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_