This category includes classes related to the C++ Micro Services component. More...

Namespaces
namespace	ServiceConstants

Classes
class	Module
	Represents a CppMicroServices module. More...

struct	ModuleActivator
	Customizes the starting and stopping of a CppMicroServices module. More...

class	ModuleContext
	A module's execution context within the framework. More...

class	ModuleEvent
	An event from the Micro Services framework describing a module lifecycle change. More...

class	ModuleRegistry
	Here we handle all the modules that are loaded in the framework. More...

class	ModuleResource
	Represents a resource (text file, image, etc.) embedded in a CppMicroServices module. More...

class	ModuleResourceStream
	An input stream class for ModuleResource objects. More...

class	ModuleSettings
	Query and set certain properties of the CppMicroServices library. More...

class	ModuleVersion
	Version identifier for CppMicroServices modules. More...

class	LDAPFilter
	An RFC 1960-based Filter. More...

class	ServiceEvent
	An event from the Micro Services framework describing a service lifecycle change. More...

class	ServiceException
	A service exception used to indicate that a service problem occurred. More...

class	ServiceFactory
	Allows services to provide customized service objects in the module environment. More...

class	ServiceReference
	A reference to a service. More...

class	ServiceRegistration
	A registered service. More...

class	ServiceTracker< S, T >
	The `ServiceTracker` class simplifies using services from the framework's service registry. More...

struct	ServiceTrackerCustomizer< T >
	The `ServiceTrackerCustomizer` interface allows a `ServiceTracker` to customize the service objects that are tracked. More...

Macros
#define	US_EXPORT_MODULE_ACTIVATOR(_module_libname, _activator_type)
	Export a module activator class. More...

#define	US_IMPORT_MODULE(_import_module_libname)
	Import a static module. More...

#define	US_IMPORT_MODULE_RESOURCES(_import_module_libname)
	Import a static module's resources. More...

#define	US_LOAD_IMPORTED_MODULES_INTO_MAIN(_static_modules)
	Import a list of static modules into an executable. More...

#define	US_LOAD_IMPORTED_MODULES(_module_libname, _static_modules)
	Import a list of static modules into a shared library. More...

#define	US_INITIALIZE_MODULE(_module_name, _module_libname)
	Creates initialization code for a module. More...

#define	US_INITIALIZE_EXECUTABLE(_executable_id)
	Creates initialization code for an executable. More...

#define	US_DECLARE_SERVICE_INTERFACE(_service_interface_type, _service_interface_id)
	Declare a CppMicroServices service interface. More...

Typedefs
typedef US_UNORDERED_MAP_TYPE < std::string, Any >	ServiceProperties
	A hash table with std::string as the key type and Any as the value type. More...

Functions
ModuleContext *	GetModuleContext ()
	Returns the module context of the calling module. More...

std::ostream &	operator<< (std::ostream &os, const Module &module)

std::ostream &	operator<< (std::ostream &os, Module const *module)

std::ostream &	operator<< (std::ostream &os, const ModuleResource &resource)

std::ostream &	operator<< (std::ostream &os, const ModuleVersion &v)

std::ostream &	operator<< (std::ostream &os, const LDAPFilter &filter)

template<class T >
const char *	us_service_interface_iid ()
	Returns a unique id for a given type. More...

std::ostream &	operator<< (std::ostream &os, const ServiceReference &serviceRef)

std::ostream &	operator<< (std::ostream &os, ModuleEvent::Type eventType)

std::ostream &	operator<< (std::ostream &os, const ModuleEvent &event)

std::ostream &	operator<< (std::ostream &os, const ServiceEvent::Type &type)

std::ostream &	operator<< (std::ostream &os, const ServiceEvent &event)

std::ostream &	operator<< (std::ostream &os, const ServiceException &exc)

Detailed Description

This category includes classes related to the C++ Micro Services component.

The C++ Micro Services component provides a dynamic service registry based on the service layer as specified in the OSGi R4.2 specifications.

Macro Definition Documentation

#define US_DECLARE_SERVICE_INTERFACE	(	_service_interface_type,
		_service_interface_id
	)

Declare a CppMicroServices service interface.

This macro associates the given identifier _service_interface_id (a string literal) to the interface class called _service_interface_type. The Identifier must be unique. For example:

#include <usServiceInterface.h>
struct ISomeInterace { ... };
US_DECLARE_SERVICE_INTERFACE(ISomeInterface, "com.mycompany.service.ISomeInterface/1.0")

This macro is normally used right after the class definition for _service_interface_type, in a header file.

If you want to use US_DECLARE_SERVICE_INTERFACE with interface classes declared in a namespace then you have to make sure the US_DECLARE_SERVICE_INTERFACE macro call is not inside a namespace though. For example:

#include <usServiceInterface.h>
namespace Foo
{
  struct ISomeInterface { ... };
}
US_DECLARE_SERVICE_INTERFACE(Foo::ISomeInterface, "com.mycompany.service.ISomeInterface/1.0")

Parameters

_service_interface_type	The service interface type.
_service_interface_id	A string literal representing a globally unique identifier.

#define US_EXPORT_MODULE_ACTIVATOR	(	_module_libname,
		_activator_type
	)

Export a module activator class.

Parameters

_module_libname	The physical name of the module, without prefix or suffix.
_activator_type	The fully-qualified type-name of the module activator class.

Call this macro after the definition of your module activator to make it accessible by the CppMicroServices library.

Example:

class MyActivator : public ModuleActivator
{
public:
  void Load(ModuleContext* /*context*/)
  { /* register stuff */ }
  void Unload(ModuleContext* /*context*/)
  { /* cleanup */ }
};
US_EXPORT_MODULE_ACTIVATOR(mylibname, MyActivator)

Note

If you use this macro in a source file compiled into an executable, additional requirements for the macro arguments apply:

The _module_libname argument must match the value of _module_name used in the US_INITIALIZE_MODULE macro call.

#define US_IMPORT_MODULE ( _import_module_libname )

Import a static module.

Parameters

_import_module_libname The physical name of the module to import, without prefix or suffix.

This macro imports the static module named _import_module_libname.

Inserting this macro into your application's source code will allow you to make use of a static module. Do not forget to list the imported module when calling the macro US_LOAD_IMPORTED_MODULES and to actually link the static module to the importing executable or shared library.

Example:

#include <usModuleImport.h>
US_IMPORT_MODULE(MyStaticModule)
US_LOAD_IMPORTED_MODULES(HostingModule, MyStaticModule)

See Also: US_LOAD_IMPORTED_MODULES; Static Modules

#define US_IMPORT_MODULE_RESOURCES ( _import_module_libname )

Import a static module's resources.

Parameters

_import_module_libname The physical name of the module to import, without prefix or suffix.

This macro imports the resources of the static module named _import_module_libname.

Inserting this macro into your application's source code will allow you to make use of the resources embedded in a static module. Do not forget to list the imported module when calling the macro US_LOAD_IMPORTED_MODULES and to actually link the static module to the importing executable or shared library.

See Also: US_IMPORT_MODULE; US_LOAD_IMPORTED_MODULES; Static Modules

#define US_INITIALIZE_EXECUTABLE ( _executable_id )

Creates initialization code for an executable.

Each executable which wants to register itself with the CppMicroServices library has to put a call to this macro in one of its source files. This ensures that the executable will get its own ModuleContext instance and can access the service registry.

Example call for an executable:

US_INITIALIZE_EXECUTABLE("my_executable")

This will initialize the executable for use with the CppMicroServices library, using a default auto-load directory named after the provided executable id in _executable_id.

See Also: MicroServices_AutoLoading

Remarks: If you are using CMake, consider using the provided CMake macro usFunctionGenerateExecutableInit().

Parameters

_executable_id A valid C identifier for the executable (no spaces etc.).

#define US_INITIALIZE_MODULE	(	_module_name,
		_module_libname
	)

Creates initialization code for a module.

Each module which wants to register itself with the CppMicroServices library has to put a call to this macro in one of its source files.

Example call for a module with file-name "libmylibname.so":

US_INITIALIZE_MODULE("My Service Implementation", "mylibname")

This will initialize the module for use with the CppMicroServices library, using a default auto-load directory named after the provided library name in _module_libname.

See Also: MicroServices_AutoLoading

Remarks: If you are using CMake, consider using the provided CMake macro usFunctionGenerateModuleInit().

Parameters

_module_name	A human-readable name for the module. If you use this macro in a source file for an executable, the module name must be a valid C-identifier (no spaces etc.).
_module_libname	The physical name of the module, withou prefix or suffix.

Note: If you want to create initialization code for an executable, see US_INITIALIZE_EXECUTABLE.

#define US_LOAD_IMPORTED_MODULES	(	_module_libname,
		_static_modules
	)

Import a list of static modules into a shared library.

Parameters

_module_libname	The physical name of the importing module, without prefix or suffix.
_static_modules	A space-deliminated list of physical module names, without prefix or suffix.

This macro ensures that the ModuleActivator::Load(ModuleContext*) function is called for each imported static module when the importing shared library is loaded (if the static module provides an activator). If the static module provides embedded resources and the US_IMPORT_MODULE_RESOURCES macro was called, the resources will be made available through the importing module.

There must be exactly one call of this macro in the shared library which is importing static modules.

Example:

#include <usModuleImport.h>
US_IMPORT_MODULE(MyStaticModule)
US_LOAD_IMPORTED_MODULES(HostingModule, MyStaticModule)

See Also: US_IMPORT_MODULE; US_LOAD_IMPORTED_MODULES_INTO_MAIN; Static Modules

#define US_LOAD_IMPORTED_MODULES_INTO_MAIN ( _static_modules )

Import a list of static modules into an executable.

Parameters

_static_modules A space-deliminated list of physical module names, without prefix or suffix.

This macro ensures that the ModuleActivator::Load(ModuleContext*) function is called for each imported static module when the importing executable is loaded (if the static module provides an activator). If the static module provides embedded resources and the US_IMPORT_MODULE_RESOURCES macro was called, the resources will be made available through the importing module.

There must be exactly one call of this macro in the executable which is importing static modules.

Example:

#include <usModuleImport.h>
US_IMPORT_MODULE(MyStaticModule1)
US_IMPORT_MODULE(MyStaticModule2)
US_IMPORT_MODULE_RESOURCES(MyStaticModule2)
US_LOAD_IMPORTED_MODULES_INTO_MAIN(MyStaticModule1 MyStaticModule2)

See Also: US_IMPORT_MODULE; US_LOAD_IMPORTED_MODULES; Static Modules

Typedef Documentation

typedef US_UNORDERED_MAP_TYPE<std::string, Any> ServiceProperties

A hash table with std::string as the key type and Any as the value type.

It is typically used for passing service properties to ModuleContext::RegisterService.

Function Documentation

ModuleContext* GetModuleContext ( )

Returns the module context of the calling module.

This function allows easy access to the ModuleContext instance from inside a C++ Micro Services module.

Returns: The ModuleContext of the calling module.

std::ostream& operator<<	(	std::ostream &	os,
		const ServiceException &	exc
	)

std::ostream& operator<<	(	std::ostream &	os,
		ModuleEvent::Type	eventType
	)

std::ostream& operator<<	(	std::ostream &	os,
		const ModuleEvent &	event
	)

std::ostream& operator<<	(	std::ostream &	os,
		const LDAPFilter &	filter
	)

std::ostream& operator<<	(	std::ostream &	os,
		const ServiceEvent::Type &	type
	)

std::ostream& operator<<	(	std::ostream &	os,
		const ServiceEvent &	event
	)

std::ostream& operator<<	(	std::ostream &	os,
		const ServiceReference &	serviceRef
	)

std::ostream& operator<<	(	std::ostream &	os,
		const ModuleVersion &	v
	)

std::ostream& operator<<	(	std::ostream &	os,
		const ModuleResource &	resource
	)

std::ostream& operator<<	(	std::ostream &	os,
		const Module &	module
	)

std::ostream& operator<<	(	std::ostream &	os,
		Module const *	module
	)

template<class T >

const char* us_service_interface_iid ( )

inline

Returns a unique id for a given type.

This template method is specialized in the macro US_DECLARE_SERVICE_INTERFACE to return a unique id for each service interface.

Template Parameters

T	The service interface type.

Returns: A unique id for the service interface type T.

CppMicroServices

Namespaces

Classes

Macros

Typedefs

Functions

Detailed Description

Macro Definition Documentation

Typedef Documentation

Function Documentation