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/StatusCode.h"
#include "GaudiKernel/System.h"
#include <ostream>
#include <type_traits>
#include <typeinfo>

#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_<std::conditional_t<std::is_base_of_v<id_<I>, inherit_from<id_<Is>...>>, interface_list<Is...>,
                                   interface_list<Is..., I>>> {};

      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> {
      };
    } // namespace detail

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

  // 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 );
      }
    };
  } // namespace iid_cast_details

  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{};
} // namespace Gaudi

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 class Status : StatusCode::code_t {
    FAILURE = 0,
    SUCCESS = 1,
    NO_INTERFACE,
    VERSMISMATCH,
    LAST_ERROR
  };

  virtual ~IInterface() = default;
};

STATUSCODE_ENUM_DECL( IInterface::Status )

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() ) );
  }
} // namespace Gaudi

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/extends.h"
#include "GaudiKernel/implements.h"

#endif // GAUDIKERNEL_IINTERFACE_H