service.h File Reference

Go to the source code of this file.

Data Structures
class	_service_by_guid_data_container< what >
class	comparator_service_guid
class	pfc::traits_service_ptr
class	pfc::traits_t< service_nnptr_t< T > >
class	pfc::traits_t< service_ptr_t< T > >
class	service_base
class	service_by_guid_data< what >
class	service_class_helper_t< T >
class	service_enum_t< t_interface >
class	service_factory_base
class	service_factory_base_t< B >
class	service_factory_single_ref_t< T >
class	service_factory_single_t< T >
class	service_factory_single_transparent_t< T >
class	service_factory_t< T >
class	service_factory_traits< B >
class	service_instance_array_t< T >
class	service_list_t< T, t_alloc >
class	service_nnptr_t< T >
class	service_nnptr_t< T >
class	service_obscure_refcounting< T >
class	service_ptr_base_t< T >
class	service_ptr_t< T >
class	static_api_ptr_t< t_interface >

Namespaces
	pfc

Typedefs
typedef const void *	service_class_ref
typedef service_nnptr_t< service_base >	service_nnptr
typedef service_ptr_t< service_base >	service_ptr

Functions
template<typename T >
void	__validate_service_class_helper ()
template<>
void	__validate_service_class_helper< service_base > ()
template<typename T >
static service_class_ref	_service_find_class ()
template<typename what >
static bool	_service_instantiate_helper (service_ptr_t< what > &out, service_class_ref servClass, t_size index)
void	_standard_api_create_internal (service_ptr &out, const GUID &classID)
template<typename T >
static void	_validate_service_ptr (service_ptr_t< T > const &ptr)
	PFC_DECLARE_EXCEPTION (exception_service_not_found, pfc::exception,"Service not found")
	PFC_DECLARE_EXCEPTION (exception_service_extension_not_found, pfc::exception,"Service extension not found")
	PFC_DECLARE_EXCEPTION (exception_service_duplicated, pfc::exception,"Service duplicated")
template<typename T >
static void	service_add_ref_safe (T *p_ptr) throw ()
template<typename what >
static bool	service_by_guid (service_ptr_t< what > &out, const GUID &theID)
template<typename what >
static service_ptr_t< what >	service_by_guid (const GUID &theID)
template<typename what >
static bool	service_by_guid_fallback (service_ptr_t< what > &out, const GUID &id)
template<typename what >
static void	service_by_guid_init ()
template<class T >
static bool	service_enum_create_t (service_ptr_t< T > &p_out, t_size p_index)
template<typename T >
static service_obscure_refcounting< T > *	service_obscure_refcounting_cast (T *p_source) throw ()
template<typename T >
static void	service_release_safe (T *p_ptr) throw ()
template<typename T >
void	standard_api_create_t (service_ptr_t< T > &p_out)
template<typename T >
void	standard_api_create_t (T *&p_out)
template<typename T >
service_ptr_t< T >	standard_api_create_t ()
template<typename T >
bool	static_api_test_t ()

Typedef Documentation

typedef const void* service_class_ref

Definition at line 4 of file service.h.

typedef service_nnptr_t<service_base> service_nnptr

Definition at line 370 of file service.h.

typedef service_ptr_t<service_base> service_ptr

Definition at line 369 of file service.h.

Function Documentation

template<typename T >

void __validate_service_class_helper ( )

inline

Definition at line 373 of file service.h.

                                              {
    __validate_service_class_helper<typename T::t_interface_parent>();
}

template<>

void __validate_service_class_helper< service_base > ( )

inline

Definition at line 378 of file service.h.

{}

template<typename T >

static service_class_ref _service_find_class ( )

static

Definition at line 445 of file service.h.

                                                                    {
    pfc::assert_same_type<T,typename T::t_interface_entrypoint>();
    return service_factory_base::enum_find_class(T::class_guid);
}

template<typename what >

static bool _service_instantiate_helper ( service_ptr_t< what > &  out, service_class_ref  servClass, t_size  index  )

static

Definition at line 451 of file service.h.

                                                                                                              {
    /*if (out._as_base_ptr_check()) {
        const bool state = service_factory_base::enum_create(out._as_base_ptr(), servClass, index);
        if (state) { FB2K_ASSERT_VALID_SERVICE_PTR(out); }
        return state;
    } else */{
        service_ptr temp;
        const bool state = service_factory_base::enum_create(temp, servClass, index);
        if (state) {
            out.attach( static_cast<what*>( temp.detach() ) );
            FB2K_ASSERT_VALID_SERVICE_PTR( out );
        }
        return state;
    }
}

void _standard_api_create_internal	(	service_ptr &	out,
		const GUID &	classID
	)

Definition at line 48 of file service.cpp.

                                                                            {
    service_class_ref c = service_factory_base::enum_find_class(classID);
    switch(service_factory_base::enum_get_count(c)) {
        case 0:
            throw exception_service_not_found();
        case 1:
            PFC_ASSERT_SUCCESS( service_factory_base::enum_create(out, c, 0) );
            break;
        default:
            throw exception_service_duplicated();
    }
}

template<typename T >

static void _validate_service_ptr ( service_ptr_t< T > const &  ptr )

static

Definition at line 421 of file service.h.

                                                                                     {
    PFC_ASSERT( ptr.is_valid() );
    service_ptr_t<T> test;
    PFC_ASSERT( ptr->service_query_t(test) );
}

PFC_DECLARE_EXCEPTION	(	exception_service_not_found	,
		pfc::exception	,
		"Service not found"
	)

PFC_DECLARE_EXCEPTION	(	exception_service_extension_not_found	,
		pfc::exception	,
		"Service extension not found"
	)

PFC_DECLARE_EXCEPTION	(	exception_service_duplicated	,
		pfc::exception	,
		"Service duplicated"
	)

template<typename T >

static void service_add_ref_safe ( T *  p_ptr ) throw ( )

static

Definition at line 36 of file service.h.

                                                                         {
    if (p_ptr != NULL) PFC_ASSERT_NO_EXCEPTION( p_ptr->service_add_ref() );
}

template<typename what >

static bool service_by_guid ( service_ptr_t< what > &  out, const GUID &  theID  )

static

Definition at line 738 of file service.h.

                                                                           {
    pfc::assert_same_type< what, typename what::t_interface_entrypoint >();
    service_by_guid_data<what> & data = _service_by_guid_data_container<what>::data;
    if (data.ready()) {
        //fall-thru
    } else if (core_api::is_main_thread()) {
        data.initialize();
    } else {
#ifdef _DEBUG
        FB2K_DebugLog() << "Warning: service_by_guid() used in non-main thread without initialization, using fallback";
#endif
        return service_by_guid_fallback(out,theID);
    }
    return data.create(out,theID);
}

template<typename what >

static service_ptr_t<what> service_by_guid ( const GUID &  theID )

static

Definition at line 754 of file service.h.

                                                               {
    service_ptr_t<what> temp;
    if (!service_by_guid(temp,theID)) throw exception_service_not_found();
    return temp;
}

template<typename what >

static bool service_by_guid_fallback ( service_ptr_t< what > &  out, const GUID &  id  )

static

Definition at line 677 of file service.h.

                                                                                 {
    service_enum_t<what> e;
    service_ptr_t<what> ptr;
    while(e.next(ptr)) {
        if (ptr->get_guid() == id) {out = ptr; return true;}
    }
    return false;
}

template<typename what >

static void service_by_guid_init ( )

static

Definition at line 733 of file service.h.

                                   {
    service_by_guid_data<what> & data = _service_by_guid_data_container<what>::data;
    data.initialize();
}

template<class T >

static bool service_enum_create_t ( service_ptr_t< T > &  p_out, t_size  p_index  )

static

Definition at line 433 of file service.h.

                                                                                             {
    pfc::assert_same_type<T,typename T::t_interface_entrypoint>();
    service_ptr_t<service_base> ptr;
    if (service_factory_base::enum_create(ptr,service_factory_base::enum_find_class(T::class_guid),p_index)) {
        p_out = static_cast<T*>(ptr.get_ptr());
        return true;
    } else {
        p_out.release();
        return false;
    }
}

template<typename T >

static service_obscure_refcounting<T>* service_obscure_refcounting_cast ( T *  p_source ) throw ( )

inlinestatic

Converts a service interface pointer to a pointer that obscures service counter functionality.

Definition at line 28 of file service.h.

{return static_cast<service_obscure_refcounting<T>*>(p_source);}

template<typename T >

static void service_release_safe ( T *  p_ptr ) throw ( )

static

Definition at line 31 of file service.h.

                                                                         {
    if (p_ptr != NULL) PFC_ASSERT_NO_EXCEPTION( p_ptr->service_release() );
}

template<typename T >

void standard_api_create_t ( service_ptr_t< T > &  p_out )

inline

Definition at line 492 of file service.h.

                                                                                 {
    if (pfc::is_same_type<T,typename T::t_interface_entrypoint>::value) {
        _standard_api_create_internal(p_out._as_base_ptr(), T::class_guid);
        FB2K_ASSERT_VALID_SERVICE_PTR(p_out);
    } else {
        service_ptr_t<typename T::t_interface_entrypoint> temp;
        standard_api_create_t(temp);
        if (!temp->service_query_t(p_out)) throw exception_service_extension_not_found();
    }
}

template<typename T >

void standard_api_create_t ( T *&  p_out )

inline

Definition at line 503 of file service.h.

                                                                   {
    p_out = NULL;
    standard_api_create_t( *reinterpret_cast< service_ptr_t<T> * >( & p_out ) );
}

template<typename T >

service_ptr_t<T> standard_api_create_t ( )

inline

Definition at line 508 of file service.h.

                                                                     {
    service_ptr_t<T> temp;
    standard_api_create_t(temp);
    return temp;
}

template<typename T >

bool static_api_test_t ( )

inline

Definition at line 515 of file service.h.

                                {
    typedef typename T::t_interface_entrypoint EP;
    service_class_helper_t<EP> helper;
    if (helper.get_count() != 1) return false;
    if (!pfc::is_same_type<T,EP>::value) {
        service_ptr_t<T> t;
        if (!helper.create(0)->service_query_t(t)) return false;
    }
    return true;
}