usServiceTracker.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 USSERVICETRACKER_H
#define USSERVICETRACKER_H

#include <map>

#include "usServiceReference.h"
#include "usServiceTrackerCustomizer.h"
#include "usLDAPFilter.h"

US_BEGIN_NAMESPACE

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

  static TrackedType DefaultValue()
  {
    return NULL;
  }

  static void Dispose(TrackedType& t)
  {
    t = 0;
  }
};

template<class S>
struct TrackedTypeTraits<S,S*>
{
  typedef S* TrackedType;

  static bool IsValid(const TrackedType& t)
  {
    return t != NULL;
  }

  static TrackedType DefaultValue()
  {
    return NULL;
  }

  static void Dispose(TrackedType& t)
  {
    t = 0;
  }

  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 dependening 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();

  ServiceTracker(ModuleContext* context,
                 const ServiceReferenceType& reference,
                 ServiceTrackerCustomizer<S,T>* customizer = 0);

  ServiceTracker(ModuleContext* context, const std::string& clazz,
                 ServiceTrackerCustomizer<S,T>* customizer = 0);

  ServiceTracker(ModuleContext* context, const LDAPFilter& filter,
                 ServiceTrackerCustomizer<S,T>* customizer = 0);

  ServiceTracker(ModuleContext* context, ServiceTrackerCustomizer<S,T>* customizer = 0);

  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);

  void ModifiedService(const ServiceReferenceType& reference, T service);

  void RemovedService(const ServiceReferenceType& reference, T service);

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

US_END_NAMESPACE

#include "usServiceTracker.tpp"

#endif // USSERVICETRACKER_H