OpaqueData.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
//
//==========================================================================
#ifndef DD4HEP_OPAQUEDATA_H
#define DD4HEP_OPAQUEDATA_H
 
// Framework include files
#include <DD4hep/Grammar.h>
 
// C/C++ include files
#include <typeinfo>
#include <vector>
#include <string>
 
namespace dd4hep {
 
  // Forward declarations
  class BasicGrammar;
 
 
  class OpaqueData   {
  private:
  protected:
    OpaqueData() = default;
    virtual ~OpaqueData() = default;
    OpaqueData(const OpaqueData& copy) = default;
    OpaqueData& operator=(const OpaqueData& copy) = default;
 
  public:
    const BasicGrammar* grammar = 0;  
 
  protected:
    void* pointer = 0;                
 
  public:
    bool fromString(const std::string& rep);
    std::string str()  const;
    const std::type_info& typeInfo() const;
    const std::string& dataType() const;
    const void* ptr()  const {  return pointer;      }
    bool is_bound()  const   {  return 0 != pointer; }
    template <typename T> T& get();
    template <typename T> const T& get() const;
    template <typename T> T& as();
    template <typename T> const T& as() const;
  };
 
  
 
  class OpaqueDataBlock : public OpaqueData   {
 
  public:
    constexpr static const size_t BUFFER_SIZE = 40;
 
  protected:
 
    unsigned char data[BUFFER_SIZE];
 
  public:
    enum _DataTypes  {
      PLAIN_DATA  =  1<<0,
      ALLOC_DATA  =  1<<1,
      STACK_DATA  =  1<<2,
      BOUND_DATA  =  1<<3,
      EXTERN_DATA =  1<<4
    };
    unsigned int type;
 
  public:
    OpaqueDataBlock();
    template <typename OBJECT> OpaqueDataBlock(OBJECT&& data);
    OpaqueDataBlock(const OpaqueDataBlock& copy);
    ~OpaqueDataBlock();
    OpaqueDataBlock& operator=(const OpaqueDataBlock& copy);
    void* ptr()  const {  return pointer;      }
    void* bind(const BasicGrammar* grammar);
    void* bind(void* ptr, size_t len, const BasicGrammar* grammar);
    void bindExtern(void* ptr, const BasicGrammar* grammar);
    template <typename T, typename... Args> T& construct(Args... args);
    template <typename T> T& bind();
    template <typename T> T& bind(void* ptr, size_t len);
    template <typename T> T& bind(const std::string& value);
    template <typename T> T& bind(void* ptr, size_t len, const std::string& value);
    template <typename T> T& bind(T&& data);
    template <typename T> void bindExtern(T* ptr);
  };
 
  template <typename T> inline T& OpaqueData::get() {
    if (!grammar || !grammar->equals(typeid(T))) { throw std::bad_cast(); }
    return *(T*)pointer;
  }
 
  template <typename T> inline const T& OpaqueData::get() const {
    if (!grammar || !grammar->equals(typeid(T))) { throw std::bad_cast(); }
    return *(T*)pointer;
  }
 
  template <typename T> inline T& OpaqueData::as() {
    if ( grammar )   {
      T* obj = (T*)(grammar->cast().apply_dynCast(Cast::instance<T>(), this->pointer));
      if ( obj ) return *obj;
    }
    throw std::bad_cast();
  }
 
  template <typename T> inline const T& OpaqueData::as() const {
    if ( grammar )   {
      const T* obj = (const T*)(grammar->cast().apply_dynCast(Cast::instance<T>(), this->pointer));
      if ( obj ) return *obj;
    }
    throw std::bad_cast();
  }
 
  template <typename OBJECT> OpaqueDataBlock::OpaqueDataBlock(OBJECT&& obj)    {
    this->bind(&BasicGrammar::instance<OBJECT>());
    new(this->pointer) OBJECT(std::move(obj));
  }
 
  template <typename T, typename... Args> inline T& OpaqueDataBlock::construct(Args... args)   {
    this->bind(&BasicGrammar::instance<T>());
    return *(new(this->pointer) T(std::forward<Args>(args)...));
  }
 
  template <typename T> inline T& OpaqueDataBlock::bind()  {
    this->bind(&BasicGrammar::instance<T>());
    return *(new(this->pointer) T());
  }
 
  template <typename T> inline T& OpaqueDataBlock::bind(T&& obj)   {
    this->bind(&BasicGrammar::instance<T>());
    new(this->pointer) T(std::move(obj));
  }
 
  template <typename T> inline T& OpaqueDataBlock::bind(void* ptr, size_t len)  {
    this->bind(ptr,len,&BasicGrammar::instance<T>());
    return *(new(this->pointer) T());
  }
 
  template <typename T> inline T& OpaqueDataBlock::bind(const std::string& value)   {
    T& ret = this->bind<T>();
    if ( !value.empty() && !this->fromString(value) )  {
      throw std::runtime_error("OpaqueDataBlock::set> Failed to bind type "+
                               typeName(typeid(T))+" to condition data block.");
    }
    return ret;
  }
 
  template <typename T> inline T& OpaqueDataBlock::bind(void* ptr, size_t len, const std::string& value)   {
    T& ret = this->bind<T>(ptr, len);
    if ( !value.empty() && !this->fromString(value) )  {
      throw std::runtime_error("OpaqueDataBlock::set> Failed to bind type "+
                               typeName(typeid(T))+" to condition data block.");
    }
    return ret;
  }
  template <typename T> inline void OpaqueDataBlock::bindExtern(T* ptr)    {
    bindExtern(ptr, &BasicGrammar::instance<T>());
  }
 
}      /* End namespace dd4hep */
#endif // DD4HEP_OPAQUEDATA_H