usServiceInterface.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
 
#ifndef USSERVICEINTERFACE_H
#define USSERVICEINTERFACE_H
 
#include <usGlobalConfig.h>
#include <usServiceException.h>
 
#include <map>
#include <string>
#include <typeinfo>
 
namespace us {
 
std::string GetDemangledName(const std::type_info& typeInfo);
}
 
template<class T> std::string us_service_interface_iid()
{
  return us::GetDemangledName(typeid(T));
}
 
template<> inline std::string us_service_interface_iid<void>() { return std::string(); }
 
 
#define US_DECLARE_SERVICE_INTERFACE(_service_interface_type, _service_interface_id)               \
  template<> inline std::string us_service_interface_iid<_service_interface_type>()                \
  { return _service_interface_id; }                                                                \
 
 
namespace us {
 
class ServiceFactory;
 
template<class Interface>
struct InterfaceType {};
 
typedef std::map<std::string, void*> InterfaceMap;
 
 
template<class I>
bool InsertInterfaceType(InterfaceMap& im, I* i)
{
  if (us_service_interface_iid<I>().empty())
  {
    throw ServiceException(std::string("The interface class ") + typeid(I).name() +
                                " uses an invalid id in its US_DECLARE_SERVICE_INTERFACE macro call.");
  }
  im.insert(std::make_pair(std::string(us_service_interface_iid<I>()),
                           static_cast<void*>(static_cast<I*>(i))));
  return true;
}
 
template<>
inline bool InsertInterfaceType<void>(InterfaceMap&, void*)
{
  return false;
}
 
 
template<class I1, class I2 = void, class I3 = void>
struct MakeInterfaceMap
{
  ServiceFactory* m_factory;
  I1* m_interface1;
  I2* m_interface2;
  I3* m_interface3;
 
  template<class Impl>
  MakeInterfaceMap(Impl* impl)
    : m_factory(nullptr)
    , m_interface1(static_cast<I1*>(impl))
    , m_interface2(static_cast<I2*>(impl))
    , m_interface3(static_cast<I3*>(impl))
  {}
 
  MakeInterfaceMap(ServiceFactory* factory)
    : m_factory(factory)
    , m_interface1(nullptr)
    , m_interface2(nullptr)
    , m_interface3(nullptr)
  {
    if (factory == nullptr)
    {
      throw ServiceException("The service factory argument must not be nullptr.");
    }
  }
 
  operator InterfaceMap ()
  {
    InterfaceMap sim;
    InsertInterfaceType(sim, m_interface1);
    InsertInterfaceType(sim, m_interface2);
    InsertInterfaceType(sim, m_interface3);
 
    if (m_factory)
    {
      sim.insert(std::make_pair(std::string("org.cppmicroservices.factory"),
                                static_cast<void*>(m_factory)));
    }
 
    return sim;
  }
};
 
template<class I1, class I2>
struct MakeInterfaceMap<I1,I2,void>
{
  ServiceFactory* m_factory;
  I1* m_interface1;
  I2* m_interface2;
 
  template<class Impl>
  MakeInterfaceMap(Impl* impl)
    : m_factory(nullptr)
    , m_interface1(static_cast<I1*>(impl))
    , m_interface2(static_cast<I2*>(impl))
  {}
 
  MakeInterfaceMap(ServiceFactory* factory)
    : m_factory(factory)
    , m_interface1(nullptr)
    , m_interface2(nullptr)
  {
    if (factory == nullptr)
    {
      throw ServiceException("The service factory argument must not be nullptr.");
    }
  }
 
  operator InterfaceMap ()
  {
    InterfaceMap sim;
    InsertInterfaceType(sim, m_interface1);
    InsertInterfaceType(sim, m_interface2);
 
    if (m_factory)
    {
      sim.insert(std::make_pair(std::string("org.cppmicroservices.factory"),
                                static_cast<void*>(m_factory)));
    }
 
    return sim;
  }
};
 
template<class I1>
struct MakeInterfaceMap<I1,void,void>
{
  ServiceFactory* m_factory;
  I1* m_interface1;
 
  template<class Impl>
  MakeInterfaceMap(Impl* impl)
    : m_factory(nullptr)
    , m_interface1(static_cast<I1*>(impl))
  {}
 
  MakeInterfaceMap(ServiceFactory* factory)
    : m_factory(factory)
    , m_interface1(nullptr)
  {
    if (factory == nullptr)
    {
      throw ServiceException("The service factory argument must not be nullptr.");
    }
  }
 
  operator InterfaceMap ()
  {
    InterfaceMap sim;
    InsertInterfaceType(sim, m_interface1);
 
    if (m_factory)
    {
      sim.insert(std::make_pair(std::string("org.cppmicroservices.factory"),
                                static_cast<void*>(m_factory)));
    }
 
    return sim;
  }
};
 
template<>
struct MakeInterfaceMap<void,void,void>;
 
template<class I1>
I1* ExtractInterface(const InterfaceMap& map)
{
  InterfaceMap::const_iterator iter = map.find(us_service_interface_iid<I1>());
  if (iter != map.end())
  {
    return reinterpret_cast<I1*>(iter->second);
  }
  return nullptr;
}
 
}
 
 
#endif // USSERVICEINTERFACE_H