implements.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_IMPLEMENTS_H
#define GAUDIKERNEL_IMPLEMENTS_H

#include "GaudiKernel/IInterface.h"

#ifndef __GCCXML__
template <typename THIS>
struct GAUDI_LOCAL check_cast {
  const std::type_info &target;
  void *&ptr;
  const THIS *instance;
  check_cast(const THIS *_instance, const std::type_info &_tid, void * &_ptr):
    target(_tid),
    ptr(_ptr),
    instance(_instance){}

  template <typename IID>
  inline void operator() (IID) {
    if ((!ptr) && (typeid(typename IID::iids::type) == target)) {
      ptr = const_cast<void*>(reinterpret_cast<const void*>(static_cast<const typename IID::iface_type*>(instance)));
    }
  }

};

template <typename THIS>
struct GAUDI_LOCAL interfaceMatch {
  const InterfaceID &target;
  void *&ptr;
  THIS *instance;
  interfaceMatch(THIS *_instance, const InterfaceID &_tid, void * &_ptr):
    target(_tid),
    ptr(_ptr),
    instance(_instance){}

  template <typename IID>
  inline void operator() (IID) {
    if ((!ptr) && target.versionMatch(IID::interfaceID())) {
      ptr = reinterpret_cast<void*>(static_cast<typename IID::iface_type*>(instance));
    }
  }
};

struct GAUDI_LOCAL AppendInterfaceName {
  std::vector<std::string> &v;
  AppendInterfaceName(std::vector<std::string> &_v): v(_v) {}

  template <typename IID>
  inline void operator() (IID) { v.push_back(IID::name()); }
};

#endif

#define _refcounting_implementation_ \
public: \
 \
  virtual unsigned long addRef() { return ++m_refCount; } \
 \
  virtual unsigned long release() { \
    /* Avoid to decrement 0 */ \
    const unsigned long count = (m_refCount) ? --m_refCount : m_refCount; \
    if(count == 0) delete this; \
    return count; \
  } \
 \
  virtual unsigned long refCount() const { return m_refCount; } \
protected: \
 \
  unsigned long m_refCount; \
private:

#ifndef __GCCXML__
#define _helper_common_implementation_(N) \
  public: \
 \
  virtual void *i_cast(const std::type_info &tid) const { \
    void *ptr = 0; \
    check_cast<implements##N> caster(this,tid,ptr); \
    mpl::for_each<interfaces>(caster); \
    return ptr; \
  } \
 \
  virtual StatusCode queryInterface(const InterfaceID &ti, void** pp){ \
    if (!pp) return StatusCode::FAILURE; \
    *pp = 0; \
    interfaceMatch<implements##N> matcher(this,ti,*pp); \
    mpl::for_each<interfaces>(matcher); \
    if (!*pp) { /* cast failed */ \
      return StatusCode::FAILURE; \
    } \
    this->addRef(); \
    return StatusCode::SUCCESS; \
  } \
 \
  virtual std::vector<std::string> getInterfaceNames() const { \
    std::vector<std::string> v; /* temporary storage */ \
    AppendInterfaceName appender(v); \
    mpl::for_each<interfaces>(appender); \
    return v; \
  } \
 \
  implements##N():m_refCount(0) {} \
 \
  virtual ~implements##N() {} \
  _refcounting_implementation_
#else
#define _helper_common_implementation_(N) \
  public: \
 \
  virtual void *i_cast(const std::type_info &tid) const { \
    return 0; \
  } \
 \
  virtual StatusCode queryInterface(const InterfaceID &ti, void** pp){ \
    if (!pp) return StatusCode::FAILURE; \
    *pp = 0; \
    return StatusCode::SUCCESS; \
  } \
 \
  virtual std::vector<std::string> getInterfaceNames() const { \
    std::vector<std::string> v; /* temporary storage */ \
    return v; \
  } \
 \
  implements##N():m_refCount(0) {} \
 \
  virtual ~implements##N() {} \
  _refcounting_implementation_
#endif

template <typename I1>
struct GAUDI_API implements1: virtual public extend_interfaces1<I1> {
  typedef implements1 base_class;
  typedef extend_interfaces1<I1> extend_interfaces_base;
#ifndef __GCCXML__
  typedef typename extend_interfaces_base::ext_iids interfaces;
#endif

  _helper_common_implementation_(1)
};

template <typename I1, typename I2>
struct GAUDI_API implements2: virtual public extend_interfaces2<I1,I2> {
  typedef implements2 base_class;
  typedef extend_interfaces2<I1,I2> extend_interfaces_base;
#ifndef __GCCXML__
  typedef typename extend_interfaces_base::ext_iids interfaces;
#endif

  _helper_common_implementation_(2)
};

template <typename I1, typename I2, typename I3>
struct GAUDI_API implements3: virtual public extend_interfaces3<I1,I2,I3> {
  typedef implements3 base_class;
  typedef extend_interfaces3<I1,I2,I3> extend_interfaces_base;
#ifndef __GCCXML__
  typedef typename extend_interfaces_base::ext_iids interfaces;
#endif

  _helper_common_implementation_(3)
};

template <typename I1, typename I2, typename I3, typename I4>
struct GAUDI_API implements4: virtual public extend_interfaces4<I1,I2,I3,I4> {
  typedef implements4 base_class;
  typedef extend_interfaces4<I1,I2,I3,I4> extend_interfaces_base;
#ifndef __GCCXML__
  typedef typename extend_interfaces_base::ext_iids interfaces;
#endif

  _helper_common_implementation_(4)
};

// Undefine helper macros
#undef _refcounting_implementation_
#undef _helper_common_implementation_

#endif /* GAUDIKERNEL_IMPLEMENTS_H_ */