template <class T>
std::shared_ptr<ServiceFactory> cppmicroservices::ToFactory(const std::shared_ptr<T> &factory)

Cast the argument to a shared pointer of type ServiceFactory.

Useful when calling BundleContext::RegisterService with a service factory, for example:

std::shared_ptr<MyServiceFactory> factory = std::make_shared<MyServiceFactory>();

A shared_ptr object of type ServiceFactory
BundleContext::RegisterService(ServiceFactory* factory, const ServiceProperties& properties)
  • factory: The service factory shared_ptr object

typedef std::map<std::string, std::shared_ptr<void>> cppmicroservices::InterfaceMap

A map containing interfaces ids and their corresponding service object smart pointers.

InterfaceMap instances represent a complete service object which implements one or more service interfaces. For each implemented service interface, there is an entry in the map with the key being the service interface id and the value a smart pointer to the service interface implementation.

To create InterfaceMap instances, use the MakeInterfaceMap helper class.

This is a low-level type and should only rarely be used.

template <class T>
std::string us_service_interface_iid()

Returns a unique id for a given type.

By default, the demangled name of T is returned.

This template method may be specialized directly or by using the macro CPPMICROSERVICES_DECLARE_SERVICE_INTERFACE to return a custom id for each service interface.

A unique id for the service interface type T.
Template Parameters
  • T: The service interface type.

template <class Interface>
std::shared_ptr<Interface> cppmicroservices::ExtractInterface(const InterfaceMapConstPtr &map)

Extract a service interface pointer from a given InterfaceMap instance.

A shared pointer object of type Interface. The returned object is empty if the map does not contain an entry for the given type
  • map: a InterfaceMap instance.

std::shared_ptr<void> cppmicroservices::ExtractInterface(const InterfaceMapConstPtr &map, const std::string &interfaceId)

Extract a service interface pointer from a given InterfaceMap instance.

The service interface pointer for the service interface id or nullptr if map does not contain an entry for the given type.
ExtractInterface(const InterfaceMapConstPtr&)
  • map: a InterfaceMap instance.
  • interfaceId: The interface id string.

template <class... Interfaces>
class cppmicroservices::MakeInterfaceMap
#include <cppmicroservices/ServiceInterface.h>

Helper class for constructing InterfaceMap instances based on service implementations or service factories.

Example usage:

std::shared_ptr<MyService> service; // implementes I1 and I2
InterfaceMap im = MakeInterfaceMap<I1,I2>(service);


Public Functions

template <class Impl>
MakeInterfaceMap(const std::shared_ptr<Impl> &impl)

Constructor taking a service implementation pointer.

  • impl: A service implementation pointer, which must be castable to a all specified service interfaces.

MakeInterfaceMap(const std::shared_ptr<ServiceFactory> &factory)

Constructor taking a service factory.

  • factory: A service factory.

operator InterfaceMapPtr()
operator InterfaceMapConstPtr()
CPPMICROSERVICES_DECLARE_SERVICE_INTERFACE(_service_interface_type, _service_interface_id)

Declare a service interface id.

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 "cppmicroservices/ServiceInterface.h"

struct ISomeInterace { ... };

CPPMICROSERVICES_DECLARE_SERVICE_INTERFACE(ISomeInterface, "com.mycompany.service.ISomeInterface/1.0")

The usage of this macro is optional and the service interface id which is automatically associated with any type is usually good enough (the demangled type name). However, care must be taken if the default id is compared with a string literal hard-coding a service interface id. E.g. the default id for templated types in the STL may differ between platforms. For user-defined types and templates the ids are typically consistent, but platform specific default template arguments will lead to different ids.

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

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

#include "cppmicroservices/ServiceInterface.h"

namespace Foo
  struct ISomeInterface { ... };

CPPMICROSERVICES_DECLARE_SERVICE_INTERFACE(Foo::ISomeInterface, "com.mycompany.service.ISomeInterface/1.0")

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