ExtensionEntry.h

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation 
//--------------------------------------------------------------------------
// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
// All rights reserved.
//
// For the licensing terms see $DD4hepINSTALL/LICENSE.
// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
//
// Author     : M.Frank
//
//==========================================================================
//
// NOTE:
//
// This is an internal include file. It should only be included to 
// instantiate code. Otherwise the BasicGrammar include file should be
// sufficient for all practical purposes.
//
//==========================================================================
#ifndef DD4HEP_EXTENSIONENTRY_H
#define DD4HEP_EXTENSIONENTRY_H
 
#include "DD4hep/Primitives.h"
 
// C/C++ include files
#include <typeinfo>
 
namespace dd4hep {
 
 
  class ExtensionEntry {
  protected:
    ExtensionEntry() = default;
    ExtensionEntry(const ExtensionEntry& copy) = default;
  public:
    virtual ~ExtensionEntry() = default;
    void invalidCall(const char* tag)  const;
    virtual void* object() const    = 0;
    virtual void* copy(void*) const = 0;
    virtual void  destruct() const  = 0;
    virtual ExtensionEntry* clone(void* arg)  const = 0;
    virtual unsigned long long int hash64()  const = 0;
  };
 
  namespace detail  {
 
 
    template <typename Q,typename T> class SimpleExtension : public ExtensionEntry  {
    protected:
      T* ptr = 0;
      mutable Q* iface = 0;  
    public:
      SimpleExtension() = delete;
      SimpleExtension(T* p) : ptr(p) { iface = dynamic_cast<Q*>(p); }
      SimpleExtension(const SimpleExtension& copy) = default;
      virtual ~SimpleExtension() = default;
      SimpleExtension& operator=(const SimpleExtension& copy) = default;
      virtual void* copy(void*) const override { invalidCall("copy"); return 0;   }
      virtual void  destruct()  const override {                                  }
      virtual void* object()    const override
      { return iface ? iface : (iface=dynamic_cast<Q*>(ptr));                     }
      virtual ExtensionEntry* clone(void*)  const  override
      { invalidCall("clone"); return 0;                                           }
      virtual unsigned long long int hash64()  const override
      {  return detail::typeHash64<Q>();                                       }
    };
      
 
    template <typename Q,typename T> class DeleteExtension : public ExtensionEntry  {
    protected:
      T* ptr = 0;
      mutable Q* iface = 0;  
    public:
      DeleteExtension() = delete;
      DeleteExtension(T* p) : ptr(p)  { iface = dynamic_cast<Q*>(p); }
      DeleteExtension(const DeleteExtension& copy) = default;
      virtual ~DeleteExtension() = default;
      DeleteExtension& operator=(const DeleteExtension& copy) = default;
      virtual void* copy(void*)  const override  { invalidCall("copy"); return 0; }
      virtual void  destruct()   const override  { delete ptr;                    }
      virtual void* object()     const override
      { return iface ? iface : (iface=dynamic_cast<Q*>(ptr));                     }
      virtual ExtensionEntry* clone(void* arg)  const  override
      {  return new DeleteExtension((T*)this->copy(arg));                         }
      virtual unsigned long long int hash64()  const override
      {  return detail::typeHash64<Q>();                                       }
    };
 
 
    template <typename Q,typename T> class CopyDeleteExtension : public ExtensionEntry  {
    protected:
      T* ptr = 0;
      mutable Q* iface = 0;  
    public:
      CopyDeleteExtension() = delete;
      CopyDeleteExtension(T* p) : ptr(p)  { iface = dynamic_cast<Q*>(p);          }
      CopyDeleteExtension(const CopyDeleteExtension& copy) = default;
      virtual ~CopyDeleteExtension() = default;
      CopyDeleteExtension& operator=(const CopyDeleteExtension& copy) = default;
      virtual void* copy(void*)  const override  { return new T(*ptr);            }
      virtual void  destruct()   const override  { delete ptr;                    }
      virtual void* object()     const override
      { return iface ? iface : (iface=dynamic_cast<Q*>(ptr));                     }
      virtual ExtensionEntry* clone(void* arg)  const  override
      {  return new CopyDeleteExtension((T*)this->copy(arg));                     }
      virtual unsigned long long int hash64()  const override
      {  return detail::typeHash64<Q>();                                       }
    };
  }     // End namespace detail
}       // End namespace dd4hep
#endif // DD4HEP_EXTENSIONENTRY_H