usServiceInterface.h

Go to the documentation of this file.

/*=============================================================================

  Library: CppMicroServices

  Copyright (c) German Cancer Research Center,
    Division of Medical and Biological Informatics

  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

    http://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(NULL)
    , 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(NULL)
    , m_interface2(NULL)
    , m_interface3(NULL)
  {
    if (factory == NULL)
    {
      throw ServiceException("The service factory argument must not be NULL.");
    }
  }

  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(NULL)
    , m_interface1(static_cast<I1*>(impl))
    , m_interface2(static_cast<I2*>(impl))
  {}

  MakeInterfaceMap(ServiceFactory* factory)
    : m_factory(factory)
    , m_interface1(NULL)
    , m_interface2(NULL)
  {
    if (factory == NULL)
    {
      throw ServiceException("The service factory argument must not be NULL.");
    }
  }

  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(NULL)
    , m_interface1(static_cast<I1*>(impl))
  {}

  MakeInterfaceMap(ServiceFactory* factory)
    : m_factory(factory)
    , m_interface1(NULL)
  {
    if (factory == NULL)
    {
      throw ServiceException("The service factory argument must not be NULL.");
    }
  }

  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 NULL;
}

US_END_NAMESPACE


#endif // USSERVICEINTERFACE_H