plugin.h

Go to the documentation of this file.

#ifndef CVMFS_UTIL_PLUGIN_H_
#define CVMFS_UTIL_PLUGIN_H_

#include <pthread.h>

#include <cassert>
#include <vector>

#include "util/atomic.h"
#include "util/concurrency.h"

#ifdef CVMFS_NAMESPACE_GUARD
namespace CVMFS_NAMESPACE_GUARD {
#endif

template <class AbstractProductT, typename ParameterT, typename InfoT>
class AbstractFactory {
 public:
  AbstractFactory() {}
  virtual ~AbstractFactory() {}

  virtual bool WillHandle(const ParameterT &param) const = 0;
  virtual AbstractProductT* Construct(const ParameterT &param) const = 0;
  virtual InfoT Introspect() const = 0;
};


template <class ConcreteProductT,
          class AbstractProductT,
          typename ParameterT,
          typename InfoT>
class AbstractFactoryImpl2 : public AbstractFactory<AbstractProductT,
                                                    ParameterT,
                                                    InfoT>
{
 public:
  inline bool WillHandle(const ParameterT &param) const {
    return ConcreteProductT::WillHandle(param);
  }
  inline AbstractProductT* Construct(const ParameterT &param) const {
    AbstractProductT* product = new ConcreteProductT(param);
    return product;
  }
};


template <class ConcreteProductT,
          class AbstractProductT,
          typename ParameterT,
          typename InfoT>
class AbstractFactoryImpl :
  public AbstractFactoryImpl2<ConcreteProductT,
                              AbstractProductT,
                              ParameterT,
                              InfoT>
{
  inline InfoT Introspect() const {
    return ConcreteProductT::GetInfo();
  }
};

template <class ConcreteProductT,
          class AbstractProductT,
          typename ParameterT>
class AbstractFactoryImpl<ConcreteProductT,
                          AbstractProductT,
                          ParameterT,
                          void> :
  public AbstractFactoryImpl2<ConcreteProductT,
                              AbstractProductT,
                              ParameterT,
                              void>
{
  inline void Introspect() const {}
};

template <class AbstractProductT, typename ParameterT, typename InfoT>
class PolymorphicConstructionImpl {
 protected:
  typedef AbstractFactory<AbstractProductT, ParameterT, InfoT> Factory;
  typedef std::vector<Factory*> RegisteredPlugins;

 public:
  virtual ~PolymorphicConstructionImpl() { }

  static AbstractProductT* Construct(const ParameterT &param) {
    LazilyRegisterPlugins();

    // select and initialize the correct plugin at runtime
    // (polymorphic construction)
    typename RegisteredPlugins::const_iterator i = registered_plugins_.begin();
    typename RegisteredPlugins::const_iterator iend = registered_plugins_.end();
    for (; i != iend; ++i) {
      if ((*i)->WillHandle(param)) {
        // create and initialize the class that claimed responsibility
        AbstractProductT *product = (*i)->Construct(param);
        if (!product->Initialize()) {
          delete product;
          continue;
        }
        return product;
      }
    }

    // no plugin found to handle the given parameter...
    return NULL;
  }

 protected:
  static void LazilyRegisterPlugins() {
    // Thread Safety Note:
    //   Double Checked Locking with atomics!
    //   Simply double checking registered_plugins_.empty() is _not_ thread safe
    //   since a second thread might find a registered_plugins_ list that is
    //   currently under construction and therefore _not_ empty but also _not_
    //   fully initialized!
    // See StackOverflow: http://stackoverflow.com/questions/8097439/lazy-initialized-caching-how-do-i-make-it-thread-safe
    if (atomic_read32(&needs_init_)) {
      MutexLockGuard m(&init_mutex_);
      if (atomic_read32(&needs_init_)) {
        AbstractProductT::RegisterPlugins();
        atomic_dec32(&needs_init_);
      }
    }

    assert(!registered_plugins_.empty());
  }

  friend class PolymorphicConstructionUnittestAdapter;

  template <class ConcreteProductT>
  static void RegisterPlugin() {
    registered_plugins_.push_back(
      new AbstractFactoryImpl<ConcreteProductT,
                              AbstractProductT,
                              ParameterT,
                              InfoT>());
  }

  virtual bool Initialize() { return true; }

 private:
  static void UnregisterAllPlugins() {
    registered_plugins_.clear();
    needs_init_ = 1;
  }

 protected:
  static RegisteredPlugins registered_plugins_;

 private:
  static atomic_int32      needs_init_;
  static pthread_mutex_t   init_mutex_;
};


template <class AbstractProductT, typename ParameterT, typename InfoT = void>
class PolymorphicConstruction :
       public PolymorphicConstructionImpl<AbstractProductT, ParameterT, InfoT> {
 private:
  typedef PolymorphicConstructionImpl<AbstractProductT, ParameterT, InfoT> T;
  typedef typename T::RegisteredPlugins RegisteredPlugins;

 public:
  typedef std::vector<InfoT> IntrospectionData;

  static IntrospectionData Introspect() {
    IntrospectionData introspection_data;
    introspection_data.reserve(T::registered_plugins_.size());
    const RegisteredPlugins &plugins = T::registered_plugins_;

    T::LazilyRegisterPlugins();
    typename RegisteredPlugins::const_iterator i    = plugins.begin();
    typename RegisteredPlugins::const_iterator iend = plugins.end();
    for (; i != iend; ++i) {
      introspection_data.push_back((*i)->Introspect());
    }

    return introspection_data;
  }
};

template <class AbstractProductT, typename ParameterT>
class PolymorphicConstruction<AbstractProductT, ParameterT, void> :
      public PolymorphicConstructionImpl<AbstractProductT, ParameterT, void> {};



template <class AbstractProductT, typename ParameterT, typename InfoT>
atomic_int32
PolymorphicConstructionImpl<AbstractProductT, ParameterT, InfoT>::
  needs_init_ = 1;

template <class AbstractProductT, typename ParameterT, typename InfoT>
pthread_mutex_t
PolymorphicConstructionImpl<AbstractProductT, ParameterT, InfoT>::init_mutex_ =
                                                      PTHREAD_MUTEX_INITIALIZER;

// init the static member registered_plugins_ inside the
// PolymorphicConstructionImpl template... whoa, what ugly code :o)
template <class AbstractProductT, typename ParameterT, typename InfoT>
typename PolymorphicConstructionImpl<AbstractProductT, ParameterT, InfoT>::
  RegisteredPlugins
PolymorphicConstructionImpl<AbstractProductT, ParameterT, InfoT>::
  registered_plugins_;


#ifdef CVMFS_NAMESPACE_GUARD
}  // namespace CVMFS_NAMESPACE_GUARD
#endif

#endif  // CVMFS_UTIL_PLUGIN_H_