IInterface.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_IINTERFACE_H
#define GAUDIKERNEL_IINTERFACE_H

// Include files
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/System.h"
#include "GaudiKernel/StatusCode.h"
#include <ostream>

#ifndef __GCCXML__
// Meta Programming Library (MPL) headers
#include <boost/mpl/set.hpp>
#include <boost/mpl/insert.hpp>
#include <boost/mpl/fold.hpp>
#include <boost/mpl/for_each.hpp>
namespace mpl = boost::mpl;
#endif

#include <typeinfo>

#ifndef __GCCXML__
#define DeclareInterfaceID(name, major, minor) \
  static const InterfaceID &interfaceID(){ return iid::interfaceID(); } \
  typedef Gaudi::InterfaceId< name , major , minor > iid; \
  typedef iid::iids::type ext_iids
#else
// GCCXML work-around
#define DeclareInterfaceID(name, major, minor) \
  static const InterfaceID &interfaceID(){ static InterfaceID xx(0UL,0UL,0UL); return xx; }
#endif

#ifndef __GCCXML__
#define DeclareInterfaceIDMultiBase(name, major, minor) \
  static const InterfaceID &interfaceID(){ return iid::interfaceID(); } \
  typedef Gaudi::InterfaceId< name , major , minor > iid
#else
// GCCXML work-around
#define DeclareInterfaceIDMultiBase(name, major, minor) \
  static const InterfaceID &interfaceID(){ static InterfaceID xx(0UL,0UL,0UL); return xx; }
#endif

class GAUDI_API InterfaceID {
public:
#if defined(GAUDI_V20_COMPAT) && !defined(G21_NEW_INTERFACES)
  InterfaceID( unsigned long lid ) : m_id( lid & 0xFFFF ),
                                     m_major_ver( (lid & 0xFF000000)>>24 ),
                                     m_minor_ver( (lid & 0xFF0000)>> 16 ) { }
#endif
  InterfaceID( unsigned long id, unsigned long major, unsigned long minor = 0)
    : m_id( id ), m_major_ver( major ), m_minor_ver( minor ) { }
  InterfaceID( const char* name, unsigned long major, unsigned long minor = 0)
    : m_id( hash32(name) ), m_major_ver( major ), m_minor_ver( minor ) { }
  ~InterfaceID() { }
#if defined(GAUDI_V20_COMPAT) && !defined(G21_NEW_INTERFACES)
  operator unsigned long() const {
    return (m_major_ver << 24) + (m_minor_ver << 16) + m_id;
  }
#endif
  unsigned long id() const { return m_id; }
  unsigned long majorVersion() const { return m_major_ver; }
  unsigned long minorVersion() const { return m_minor_ver; }
  bool versionMatch( const InterfaceID& iid ) const {
    return ( id() == iid.id() &&
             majorVersion() == iid.majorVersion() &&
             minorVersion() >= iid.minorVersion() );
  }
  bool fullMatch( const InterfaceID& iid ) const {
    return ( id() == iid.id() &&
             majorVersion() == iid.majorVersion() &&
             minorVersion() == iid.minorVersion() );
  }
  bool operator == (const InterfaceID& iid ) const { return fullMatch(iid); }
  static unsigned int hash32(const char* key) {
    unsigned int hash;
    const char* k;
    for (hash = 0, k = key; *k; k++) {
      hash += *k; hash += (hash << 10); hash ^= (hash >> 6);
    }
    hash += (hash << 3); hash ^= (hash >> 11); hash += (hash << 15);
    return hash;
  }

private:
  unsigned long m_id;
  unsigned long m_major_ver;
  unsigned long m_minor_ver;
};

namespace Gaudi {
  template <typename INTERFACE, unsigned long majVers, unsigned long minVers>
  class InterfaceId {
  public:
    typedef INTERFACE iface_type;

#ifndef __GCCXML__
    typedef mpl::insert<typename iface_type::ext_iids, InterfaceId> iids;
#endif

    static inline std::string name() { return System::typeinfoName(typeid(INTERFACE)); }

    static inline unsigned long majorVersion(){return majVers;}
    static inline unsigned long minorVersion(){return minVers;}

    static inline const std::type_info &TypeInfo() {
#ifndef __GCCXML__
      return typeid(typename iids::type);
#else
      return typeid(INTERFACE); // avoid compilation errors
#endif
    }

    static const InterfaceID& interfaceID()
    {
      static InterfaceID s_iid(name().c_str(),majVers,minVers);
      return s_iid;
    }

  };
}

class GAUDI_API IInterface {
public:
#ifndef __GCCXML__
  typedef Gaudi::InterfaceId<IInterface,0,0> iid;

  typedef mpl::set1<iid> ext_iids;
#endif

  static inline const InterfaceID &interfaceID(){
#ifndef __GCCXML__
    return iid::interfaceID();
#else
    // GCCXML work-around
    static InterfaceID xx(0UL,0UL,0UL);
    return xx;
#endif
  }

  virtual void *i_cast(const InterfaceID &) const
#if defined(GAUDI_V20_COMPAT) && !defined(G21_NEW_INTERFACES)
  {return 0;}
#else
  = 0;
#endif

  virtual std::vector<std::string> getInterfaceNames() const
#if defined(GAUDI_V20_COMPAT) && !defined(G21_NEW_INTERFACES)
  {return std::vector<std::string>();}
#else
  = 0;
#endif

  virtual unsigned long addRef() = 0;

  virtual unsigned long release() = 0;

  virtual unsigned long refCount() const
#if defined(GAUDI_V20_COMPAT) && !defined(G21_NEW_INTERFACES)
  { IInterface* ths = const_cast<IInterface*>(this);
    ths->addRef();
    return ths->release(); } // new method, so we need a default implementation for v20 compatibility
#else
  = 0;
#endif

  virtual StatusCode queryInterface(const InterfaceID &ti, void** pp) = 0;

  enum Status {
    SUCCESS = 1,
    NO_INTERFACE,
    VERSMISMATCH,
    LAST_ERROR
  };

  virtual ~IInterface() {}
};

namespace Gaudi {
  template <typename TARGET>
  TARGET* Cast(IInterface *i){
    return reinterpret_cast<TARGET*>(i->i_cast(TARGET::interfaceID()));
  }
  template <typename TARGET>
  const TARGET* Cast(const IInterface *i){
    return reinterpret_cast<const TARGET*>(i->i_cast(TARGET::interfaceID()));
  }
}

template <class I>
bool isValidInterface( I* i) {
  void* ii;
  StatusCode sc =  i->queryInterface( I::interfaceID(), &ii);
  return sc.isSuccess();
}

//#ifdef GAUDI_V20_COMPAT
inline std::ostream& operator << ( std::ostream& s, const InterfaceID& id) {
    s << "IID_" << id.id();
    return s;
}
//#endif

template <class DEST,class SRC>
inline DEST** pp_cast(SRC** ptr){
  return reinterpret_cast<DEST**>(ptr);
}

#include "GaudiKernel/extend_interfaces.h"
#include "GaudiKernel/implements.h"
#include "GaudiKernel/extends.h"

#endif  // GAUDIKERNEL_IINTERFACE_H