usModuleContext.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 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>
 
namespace us {
 
typedef US_SERVICE_LISTENER_FUNCTOR ServiceListener;
typedef US_MODULE_LISTENER_FUNCTOR ModuleListener;
 
class ModuleContextPrivate;
class ServiceFactory;
 
template<class S> class ServiceObjects;
 
class MITKCPPMICROSERVICES_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;
};
 
}
 
#endif /* USMODULECONTEXT_H_ */