usServiceInterface.h

Go to the documentation of this file.

/*============================================================================
 
  Library: CppMicroServices
 
  Copyright (c) German Cancer Research Center (DKFZ)
  All rights reserved.
 
  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at
 
    https://www.apache.org/licenses/LICENSE-2.0
 
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
 
============================================================================*/
 
 
#ifndef USSERVICEINTERFACE_H
#define USSERVICEINTERFACE_H
 
#include <usGlobalConfig.h>
#include <usServiceException.h>
 
#include <map>
#include <string>
#include <typeinfo>
 
US_BEGIN_NAMESPACE
std::string GetDemangledName(const std::type_info& typeInfo);
US_END_NAMESPACE
 
template<class T> std::string us_service_interface_iid()
{
  return US_PREPEND_NAMESPACE(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; }                                                                \
 
 
US_BEGIN_NAMESPACE
 
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;
}
 
US_END_NAMESPACE
 
 
#endif // USSERVICEINTERFACE_H