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 <type_traits>
#include <typeinfo>
#include <ostream>


#define DeclareInterfaceID(iface, major, minor)                          \
  static const InterfaceID &interfaceID() { return iid::interfaceID(); } \
  using iid = Gaudi::InterfaceId< iface , major , minor > ;              \
  using ext_iids = iid::iids

class GAUDI_API InterfaceID final {
public:
#if defined(GAUDI_V20_COMPAT) && !defined(G21_NEW_INTERFACES)
  constexpr InterfaceID( unsigned long lid ) : m_id( lid & 0xFFFF ),
                                               m_major_ver( (lid & 0xFF000000)>>24 ),
                                               m_minor_ver( (lid & 0xFF0000)>> 16 ) { }
#endif
  constexpr 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 ) { }
#if defined(GAUDI_V20_COMPAT) && !defined(G21_NEW_INTERFACES)
  constexpr operator unsigned long() const {
    return (m_major_ver << 24) + (m_minor_ver << 16) + m_id;
  }
#endif
  constexpr unsigned long id() const { return m_id; }
  constexpr unsigned long majorVersion() const { return m_major_ver; }
  constexpr unsigned long minorVersion() const { return m_minor_ver; }
  constexpr bool versionMatch( const InterfaceID& iid ) const {
    return ( id() == iid.id() &&
             majorVersion() == iid.majorVersion() &&
             minorVersion() >= iid.minorVersion() );
  }
  constexpr bool fullMatch( const InterfaceID& iid ) const {
    return ( id() == iid.id() &&
             majorVersion() == iid.majorVersion() &&
             minorVersion() == iid.minorVersion() );
  }
  constexpr bool operator == (const InterfaceID& iid ) const { return fullMatch(iid); }
  static unsigned int hash32(const char* key) {
    unsigned int hash = 0;
    for (const char* 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... I> struct interface_list { };

  namespace meta {
      // identity T -> type = T; note that id_<T> is a complete type, even if T is not
      template <typename T> struct id_
      { using type = T; };

      namespace detail
      {
          template <typename... Is>
          struct inherit_from : Is... { };

          template <typename List, typename I>
          struct append1{ };

          // interpose an id_<I> as id_<I> is a complete type, even if I is not... and we need complete
          // types to inherit from
          template <typename... Is, typename I>
          struct append1<interface_list<Is...>, I>
          : id_<typename std::conditional<std::is_base_of< id_<I>, inherit_from<id_<Is>...> >::value,
                                          interface_list<Is...>,
                                          interface_list<Is...,I> >::type> { };

          template <typename, typename>
          struct appendN { };

          template <typename State>
          struct appendN<interface_list<>, State >
          : id_<State> { };

          template <typename... Is, typename I, typename List>
          struct appendN<interface_list<I,Is...>, List>
          :      appendN<interface_list<Is...  >, typename append1<List, I>::type> { };
      }

      template <typename... Is>
      using unique_interface_list = detail::appendN<interface_list<Is...>, interface_list<>>;
  }

  // interface_list concatenation
  template <typename... I> struct interface_list_cat;

  // identity
  template <typename... I>
  struct interface_list_cat<interface_list<I...>>
  : meta::unique_interface_list< I... > { };

  // binary op
  template <typename... I1, typename... I2>
  struct interface_list_cat<interface_list<I1...>,interface_list<I2...>>
  : meta::unique_interface_list<I1...,I2...> { };

  // induction of binary op
  template <typename... I1, typename... I2, typename... Others>
  struct interface_list_cat<interface_list<I1...>,interface_list<I2...>, Others...>
  : interface_list_cat< interface_list<I1...,I2...>, Others... > { };

  // append is a special case of concatenation...
  template <typename... I> struct interface_list_append;

  template <typename... Is, typename I>
  struct interface_list_append<interface_list<Is...>,I>
  : interface_list_cat< interface_list<Is...>, interface_list<I> > { };

  // helpers for implementation of interface cast
  namespace iid_cast_details {
      template <typename I>
      constexpr void* void_cast(const I* i)
      { return const_cast<I*>(i); }

      template <typename ... Is> struct iid_cast_t;

      template <> struct iid_cast_t<> {
          template <typename P>
          constexpr void* operator()(const InterfaceID&, P*) const { return nullptr ; }
      };

      template <typename I, typename... Is> struct iid_cast_t<I,Is...> {
          template <typename P>
          inline void* operator()(const InterfaceID& tid, P* ptr) const {
            return tid.versionMatch(I::interfaceID()) ? void_cast<typename I::interface_type>(ptr)
                                                      : iid_cast_t<Is...>{}(tid,ptr);
          }
      };
  }

  template <typename... Is>
  std::vector<std::string> getInterfaceNames( Gaudi::interface_list<Is...> ) {
      return { Is::name()... };
  }

  template <typename...Is,typename P>
  inline void* iid_cast(const InterfaceID& tid, Gaudi::interface_list<Is...>, P* ptr ) {
      constexpr auto iid_cast_ = iid_cast_details::iid_cast_t<Is...>{};
      return iid_cast_(tid,ptr);
  }

  template <typename INTERFACE, unsigned long majVers, unsigned long minVers>
  struct InterfaceId final {
    using interface_type = INTERFACE;
    using iids = typename Gaudi::interface_list_append<typename interface_type::ext_iids,InterfaceId>::type ;

    static inline std::string name() { return System::typeinfoName(typeid(INTERFACE)); }
    static constexpr unsigned long majorVersion() { return majVers; }
    static constexpr unsigned long minorVersion() { return minVers; }

    static inline const std::type_info &TypeInfo() {
      return typeid(typename iids::type);
    }

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

  constexpr struct fullMatch_t { 
    template <typename IFACE1, typename IFACE2, unsigned long major1, unsigned long major2, unsigned long minor1, unsigned long minor2>
    constexpr bool operator()(InterfaceId<IFACE1,major1,minor1>, InterfaceId<IFACE2,major2,minor2>) const { return false; }
    template <typename IFACE, unsigned long major, unsigned long minor>
    constexpr bool operator()(InterfaceId<IFACE,major,minor>, InterfaceId<IFACE,major,minor>) const { return true; }
  } fullMatch{};

  constexpr struct majorMatch_t { 
    template <typename IFACE1, typename IFACE2, unsigned long major1, unsigned long major2, unsigned long minor1, unsigned long minor2>
    constexpr bool operator()(InterfaceId<IFACE1,major1,minor1>, InterfaceId<IFACE2,major2,minor2>) const { return false; }
    template <typename IFACE, unsigned long major, unsigned long minor1, unsigned long minor2>
    constexpr bool operator()(InterfaceId<IFACE,major,minor1>, InterfaceId<IFACE,major,minor2>)  const { return true; }
  } majorMatch{};

}

class GAUDI_API IInterface {
public:
  using iid = Gaudi::InterfaceId<IInterface,0,0>;

  using ext_iids = Gaudi::interface_list<iid>;

  static inline const InterfaceID &interfaceID(){
    return iid::interfaceID();
  }

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

  virtual std::vector<std::string> getInterfaceNames() const
#if defined(GAUDI_V20_COMPAT) && !defined(G21_NEW_INTERFACES)
  {return {};}
#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() = default;
};

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 = nullptr;;
  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