usModuleContext.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 USMODULECONTEXT_H_
#define USMODULECONTEXT_H_

// TODO: Replace includes with forward directives!

#include "usListenerFunctors_p.h"
#include "usServiceInterface.h"
#include "usServiceEvent.h"
#include "usServiceRegistration.h"
#include "usServiceException.h"
#include "usModuleEvent.h"

US_BEGIN_NAMESPACE

typedef US_SERVICE_LISTENER_FUNCTOR ServiceListener;
typedef US_MODULE_LISTENER_FUNCTOR ModuleListener;

class ModuleContextPrivate;
class ServiceFactory;

template<class S> class ServiceObjects;

class US_Core_EXPORT ModuleContext
{

public:

  ~ModuleContext();

  Module* GetModule() const;

  Module* GetModule(long id) const;

  Module* GetModule(const std::string& name);

  std::vector<Module*> GetModules() const;

  ServiceRegistrationU RegisterService(const InterfaceMap& service,
                                       const ServiceProperties& properties = ServiceProperties());

  template<class S>
  ServiceRegistration<S> RegisterService(S* service, const ServiceProperties& properties = ServiceProperties())
  {
    InterfaceMap servicePointers = MakeInterfaceMap<S>(service);
    return RegisterService(servicePointers, properties);
  }

  template<class I1, class I2, class Impl>
  ServiceRegistration<I1,I2> RegisterService(Impl* impl, const ServiceProperties& properties = ServiceProperties())
  {
    InterfaceMap servicePointers = MakeInterfaceMap<I1, I2>(impl);
    return RegisterService(servicePointers, properties);
  }

  template<class I1, class I2, class I3, class Impl>
  ServiceRegistration<I1,I2,I3> RegisterService(Impl* impl, const ServiceProperties& properties = ServiceProperties())
  {
    InterfaceMap servicePointers = MakeInterfaceMap<I1, I2, I3>(impl);
    return RegisterService(servicePointers, properties);
  }

  template<class S>
  ServiceRegistration<S> RegisterService(ServiceFactory* factory, const ServiceProperties& properties = ServiceProperties())
  {
    InterfaceMap servicePointers = MakeInterfaceMap<S>(factory);
    return RegisterService(servicePointers, properties);
  }

  template<class I1, class I2>
  ServiceRegistration<I1,I2> RegisterService(ServiceFactory* factory, const ServiceProperties& properties = ServiceProperties())
  {
    InterfaceMap servicePointers = MakeInterfaceMap<I1,I2>(factory);
    return RegisterService(servicePointers, properties);
  }

  template<class I1, class I2, class I3>
  ServiceRegistration<I1,I2,I3> RegisterService(ServiceFactory* factory, const ServiceProperties& properties = ServiceProperties())
  {
    InterfaceMap servicePointers = MakeInterfaceMap<I1,I2,I3>(factory);
    return RegisterService(servicePointers, properties);
  }

  std::vector<ServiceReferenceU> GetServiceReferences(const std::string& clazz, const std::string& filter = std::string());

  template<class S>
  std::vector<ServiceReference<S> > GetServiceReferences(const std::string& filter = std::string())
  {
    std::string clazz = us_service_interface_iid<S>();
    if (clazz.empty()) throw ServiceException("The service interface class has no US_DECLARE_SERVICE_INTERFACE macro");
    typedef std::vector<ServiceReferenceU> BaseVectorT;
    BaseVectorT serviceRefs = GetServiceReferences(clazz, filter);
    std::vector<ServiceReference<S> > result;
    for(BaseVectorT::const_iterator i = serviceRefs.begin(); i != serviceRefs.end(); ++i)
    {
      result.push_back(ServiceReference<S>(*i));
    }
    return result;
  }

  ServiceReferenceU GetServiceReference(const std::string& clazz);

  template<class S>
  ServiceReference<S> GetServiceReference()
  {
    std::string clazz = us_service_interface_iid<S>();
    if (clazz.empty()) throw ServiceException("The service interface class has no US_DECLARE_SERVICE_INTERFACE macro");
    return ServiceReference<S>(GetServiceReference(clazz));
  }

  void* GetService(const ServiceReferenceBase& reference);

  InterfaceMap GetService(const ServiceReferenceU& reference);

  template<class S>
  S* GetService(const ServiceReference<S>& reference)
  {
    const ServiceReferenceBase& baseRef = reference;
    return reinterpret_cast<S*>(GetService(baseRef));
  }

  template<class S>
  ServiceObjects<S> GetServiceObjects(const ServiceReference<S>& reference)
  {
    return ServiceObjects<S>(this, reference);
  }

  bool UngetService(const ServiceReferenceBase& reference);

  void AddServiceListener(const ServiceListener& delegate,
                          const std::string& filter = std::string());
  void RemoveServiceListener(const ServiceListener& delegate);

  void AddModuleListener(const ModuleListener& delegate);
  void RemoveModuleListener(const ModuleListener& delegate);

  template<class R>
  void AddServiceListener(R* receiver, void(R::*callback)(const ServiceEvent),
                          const std::string& filter = std::string())
  {
    AddServiceListener(ServiceListenerMemberFunctor(receiver, callback),
                       static_cast<void*>(receiver), filter);
  }

  template<class R>
  void RemoveServiceListener(R* receiver, void(R::*callback)(const ServiceEvent))
  {
    RemoveServiceListener(ServiceListenerMemberFunctor(receiver, callback),
                          static_cast<void*>(receiver));
  }

  template<class R>
  void AddModuleListener(R* receiver, void(R::*callback)(const ModuleEvent))
  {
    AddModuleListener(ModuleListenerMemberFunctor(receiver, callback),
                      static_cast<void*>(receiver));
  }

  template<class R>
  void RemoveModuleListener(R* receiver, void(R::*callback)(const ModuleEvent))
  {
    RemoveModuleListener(ModuleListenerMemberFunctor(receiver, callback),
                         static_cast<void*>(receiver));
  }

  std::string GetDataFile(const std::string& filename) const;


private:

  friend class Module;
  friend class ModulePrivate;

  ModuleContext(ModulePrivate* module);

  // purposely not implemented
  ModuleContext(const ModuleContext&);
  ModuleContext& operator=(const ModuleContext&);

  void AddServiceListener(const ServiceListener& delegate, void* data,
                          const std::string& filter);
  void RemoveServiceListener(const ServiceListener& delegate, void* data);

  void AddModuleListener(const ModuleListener& delegate, void* data);
  void RemoveModuleListener(const ModuleListener& delegate, void* data);

  ModuleContextPrivate * const d;
};

US_END_NAMESPACE

#endif /* USMODULECONTEXT_H_ */