usServiceTracker.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 USSERVICETRACKER_H
#define USSERVICETRACKER_H
 
#include <map>
 
#include <usServiceReference.h>
#include <usServiceTrackerCustomizer.h>
#include <usLDAPFilter.h>
 
namespace us {
 
template<class S, class T> class TrackedService;
template<class S, class T> class ServiceTrackerPrivate;
class ModuleContext;
 
template<class T, class TTT>
struct TrackedTypeTraitsBase
{
  typedef T TrackedType;
 
  // Needed for S == void
  static TrackedType ConvertToTrackedType(const InterfaceMap&)
  {
    throw std::runtime_error("A custom ServiceTrackerCustomizer instance is required for custom tracked objects.");
    //return TTT::DefaultValue();
  }
 
  // Needed for S != void
  static TrackedType ConvertToTrackedType(void*)
  {
    throw std::runtime_error("A custom ServiceTrackerCustomizer instance is required for custom tracked objects.");
    //return TTT::DefaultValue();
  }
};
 
template<class S, class T>
struct TrackedTypeTraits;
 
template<class S, class T>
struct TrackedTypeTraits<S,T*> : public TrackedTypeTraitsBase<T*,TrackedTypeTraits<S,T*> >
{
  typedef T* TrackedType;
 
  static bool IsValid(const TrackedType& t)
  {
    return t != nullptr;
  }
 
  static TrackedType DefaultValue()
  {
    return nullptr;
  }
 
  static void Dispose(TrackedType& t)
  {
    t = nullptr;
  }
};
 
template<class S>
struct TrackedTypeTraits<S,S*>
{
  typedef S* TrackedType;
 
  static bool IsValid(const TrackedType& t)
  {
    return t != nullptr;
  }
 
  static TrackedType DefaultValue()
  {
    return nullptr;
  }
 
  static void Dispose(TrackedType& t)
  {
    t = nullptr;
  }
 
  static TrackedType ConvertToTrackedType(S* s)
  {
    return s;
  }
};
 
/*
 * This specialization is "special" because the tracked type is not
 * void* (as specified in the second template parameter) but InterfaceMap.
 * This is in line with the ModuleContext::GetService(...) overloads to
 * return either S* or InterfaceMap depending on the template parameter.
 */
template<>
struct TrackedTypeTraits<void,void*>
{
  typedef InterfaceMap TrackedType;
 
  static bool IsValid(const TrackedType& t)
  {
    return !t.empty();
  }
 
  static TrackedType DefaultValue()
  {
    return TrackedType();
  }
 
  static void Dispose(TrackedType& t)
  {
    t.clear();
  }
 
  static TrackedType ConvertToTrackedType(const InterfaceMap& im)
  {
    return im;
  }
};
 
template<class S, class TTT = TrackedTypeTraits<S,S*> >
class ServiceTracker : protected ServiceTrackerCustomizer<S,typename TTT::TrackedType>
{
public:
 
  typedef S ServiceType;
  typedef typename TTT::TrackedType T;
 
  typedef ServiceReference<S> ServiceReferenceType;
 
  typedef std::map<ServiceReference<S>,T> TrackingMap;
 
  ~ServiceTracker() override;
 
  ServiceTracker(ModuleContext* context,
                 const ServiceReferenceType& reference,
                 ServiceTrackerCustomizer<S,T>* customizer = nullptr);
 
  ServiceTracker(ModuleContext* context, const std::string& clazz,
                 ServiceTrackerCustomizer<S,T>* customizer = 0);
 
  ServiceTracker(ModuleContext* context, const LDAPFilter& filter,
                 ServiceTrackerCustomizer<S,T>* customizer = nullptr);
 
  ServiceTracker(ModuleContext* context, ServiceTrackerCustomizer<S,T>* customizer = nullptr);
 
  virtual void Open();
 
  virtual void Close();
 
  virtual T WaitForService(unsigned long timeoutMillis = 0);
 
  virtual std::vector<ServiceReferenceType> GetServiceReferences() const;
 
  virtual ServiceReferenceType GetServiceReference() const;
 
  virtual T GetService(const ServiceReferenceType& reference) const;
 
  virtual std::vector<T> GetServices() const;
 
  virtual T GetService() const;
 
  virtual void Remove(const ServiceReferenceType& reference);
 
  virtual int Size() const;
 
  virtual int GetTrackingCount() const;
 
  virtual void GetTracked(TrackingMap& tracked) const;
 
  virtual bool IsEmpty() const;
 
protected:
 
  T AddingService(const ServiceReferenceType& reference) override;
 
  void ModifiedService(const ServiceReferenceType& reference, T service) override;
 
  void RemovedService(const ServiceReferenceType& reference, T service) override;
 
private:
 
  typedef ServiceTracker<S,TTT> _ServiceTracker;
  typedef TrackedService<S,TTT> _TrackedService;
  typedef ServiceTrackerPrivate<S,TTT> _ServiceTrackerPrivate;
  typedef ServiceTrackerCustomizer<S,T> _ServiceTrackerCustomizer;
 
  friend class TrackedService<S,TTT>;
  friend class ServiceTrackerPrivate<S,TTT>;
 
  _ServiceTrackerPrivate* const d;
};
 
}
 
#include <usServiceTracker.tpp>
 
#endif // USSERVICETRACKER_H