Geant4Handle.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 DDG4_GEANT4HANDLE_H
#define DDG4_GEANT4HANDLE_H
 
#include <DD4hep/ComponentProperties.h>
#include <DD4hep/Detector.h>
 
#include <string>
#include <memory>
 
namespace dd4hep {
 
  namespace sim {
 
    class Geant4Kernel;
    class Geant4Action;
 
 
    template <typename TYPE> class Geant4Handle {
    protected:
      void checked_assign(TYPE* p);
      TYPE* null()  { return nullptr; }
    public:
      mutable TYPE* value  {nullptr};
      explicit Geant4Handle() = default;
      Geant4Handle(TYPE* typ);
      template <typename T> Geant4Handle(T* typ) : value(0) {
        checked_assign(dynamic_cast<TYPE*>(typ));
      }
      Geant4Handle(const Geant4Handle& handle);
      Geant4Handle(Geant4Handle&& handle);
      Geant4Handle(Geant4Kernel&, const char* type_name, bool shared=false);
      Geant4Handle(Geant4Kernel&, const std::string& type_name, bool shared=false);
      Geant4Handle(Geant4Kernel& ctxt, const std::string& type_name, const std::string& detector, bool shared=false);
      ~Geant4Handle();
      Property& operator[](const std::string& property_name) const;
      Geant4Handle& operator=(const Geant4Handle& handle);
      Geant4Handle& operator=(Geant4Handle&& handle);
      Geant4Handle& operator=(TYPE* ptr);
      bool operator!() const;
      Geant4Action* action() const;
      TYPE* operator->() const;
      operator TYPE*() const;
      TYPE* get() const;
      TYPE* release();
    };
 
 
    class KernelHandle {
    public:
      mutable Geant4Kernel* value {nullptr};
      explicit KernelHandle();
      explicit KernelHandle(Geant4Kernel* k);
      KernelHandle(const KernelHandle& k) : value(k.value) {}
      ~KernelHandle()                  {               }
      operator Geant4Kernel*() const   { return value; }
      Geant4Kernel* get() const        { return value; }
      Geant4Kernel* operator->() const { return value; }
      KernelHandle worker();
      void destroy();
    };
 
  }    // End namespace sim
}      // End namespace dd4hep
 
#endif // DDG4_GEANT4HANDLE_H