/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/AthContainers/AthContainers/AuxElement.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
// $Id: AuxElement.h 627784 2014-11-12 04:32:14Z ssnyder $
#ifndef ATHCONTAINERS_AUXELEMENTBASE_H
#define ATHCONTAINERS_AUXELEMENTBASE_H


#include "AthContainersInterfaces/IAuxElement.h"
#include "AthContainersInterfaces/IConstAuxStore.h"
#include "AthContainersInterfaces/IAuxStore.h"
#include "AthLinks/DataLink.h"
#include "AthContainers/AuxTypeRegistry.h"
#include "AthContainers/AuxVectorData.h"
#include "AthContainers/tools/AuxDataTraits.h"
#include "AthContainers/exceptions.h"
#include "AthContainers/tools/likely.h"
#include <cstddef>



namespace SG {


class AuxElementData;
class AuxElementStandaloneData;
class AuxVectorData_test;
class AuxVectorBase;
class AuxVectorBase_test;


class AuxElement
  : public SG::IAuxElement
{
public:
  AuxElement();


  AuxElement (const AuxElement& other);


  AuxElement& operator= (const AuxElement& other);


  ~AuxElement();


  SG::AuxVectorData* container();


  const SG::AuxVectorData* container() const;


  size_t index() const;


  class TypelessConstAccessor
  {
  public:
    TypelessConstAccessor (const std::string& name);


    TypelessConstAccessor (const std::type_info& ti,
                           const std::string& name);


    TypelessConstAccessor (const std::string& name,
                           const std::string& clsname);


    TypelessConstAccessor (const std::type_info& ti,
                           const std::string& name,
                           const std::string& clsname);


    const void* operator() (const AuxElement& e) const;
    

    const void* operator() (const AuxVectorData& container, size_t index) const;

    
    const void* getDataArray (const AuxVectorData& container) const;
    

    bool isAvailable (const AuxElement& e) const;


    SG::auxid_t auxid() const;


  protected:
    SG::auxid_t m_auxid;

    size_t m_eltSize;
  };


  template <class T>
  class ConstAccessor
  {
  public:
    typedef typename AuxDataTraits<T>::const_reference_type
      const_reference_type;

    typedef typename AuxDataTraits<T>::const_container_pointer_type
      const_container_pointer_type;

    ConstAccessor (const std::string& name);


    ConstAccessor (const std::string& name, const std::string& clsname);


    const_reference_type operator() (const AuxElement& e) const;
    

    const_reference_type
    operator() (const AuxVectorData& container, size_t index) const;


    const_container_pointer_type
    getDataArray (const AuxVectorData& container) const;
    

    bool isAvailable (const AuxElement& e) const;


    SG::auxid_t auxid() const;


  protected:
    SG::auxid_t m_auxid;
  };


  template <class T>
  class Accessor
    : public ConstAccessor<T>
  {
  public:
    typedef typename AuxDataTraits<T>::reference_type
     reference_type;

    typedef typename AuxDataTraits<T>::element_type
     element_type;

    typedef typename AuxDataTraits<T>::container_pointer_type
      container_pointer_type;

    using ConstAccessor<T>::operator();
    using ConstAccessor<T>::getDataArray;


    Accessor (const std::string& name);


    Accessor (const std::string& name, const std::string& clsname);


    reference_type operator() (AuxElement& e) const;


    reference_type operator() (AuxVectorData& container, size_t index) const;


    void set (AuxElement& e, const element_type& x) const;


    container_pointer_type getDataArray (AuxVectorData& container) const;


    bool isAvailableWritable (const AuxElement& e) const;
  };


  template <class T>
  class Decorator
  {
  public:
    typedef typename AuxDataTraits<T>::reference_type
     reference_type;

    typedef typename AuxDataTraits<T>::element_type
     element_type;

    typedef typename AuxDataTraits<T>::container_pointer_type
      container_pointer_type;
    typedef typename AuxDataTraits<T>::const_container_pointer_type
      const_container_pointer_type;


    Decorator (const std::string& name);


    Decorator (const std::string& name, const std::string& clsname);


    reference_type operator() (const AuxElement& e) const;


    reference_type
    operator() (const AuxVectorData& container, size_t index) const;


    void set (const AuxElement& e, const element_type& x) const;


    const_container_pointer_type getDataArray (const AuxVectorData& container) const;
    

    bool isAvailable (const AuxElement& e) const;


    bool isAvailableWritable (const AuxElement& e) const;


    SG::auxid_t auxid() const;


  private:
    SG::auxid_t m_auxid;
  };


  template <class T>
  typename AuxDataTraits<T>::reference_type
  auxdata (const std::string& name);


  template <class T>
  typename AuxDataTraits<T>::reference_type
  auxdata (const std::string& name,
           const std::string& clsname);


  template <class T>
  typename AuxDataTraits<T>::const_reference_type
  auxdata (const std::string& name) const;


  template <class T>
  typename AuxDataTraits<T>::const_reference_type
  auxdata (const std::string& name,
           const std::string& clsname) const;


  template <class T>
  typename AuxDataTraits<T>::const_reference_type
  auxdataConst (const std::string& name) const;


  template <class T>
  typename AuxDataTraits<T>::const_reference_type
  auxdataConst (const std::string& name,
                const std::string& clsname) const;


  template <class T>
  bool isAvailable (const std::string& name,
                    const std::string& clsname = "") const;


  template <class T>
  bool isAvailableWritable (const std::string& name,
                            const std::string& clsname = "") const;


  template <class T>
  bool isAvailableWritableAsDecoration (const std::string& name,
                                        const std::string& clsname = "") const;


  template <class T>
  typename AuxDataTraits<T>::reference_type
  auxdecor (const std::string& name) const;


  template <class T>
  typename AuxDataTraits<T>::reference_type
  auxdecor (const std::string& name,
            const std::string& clsname) const;


  void makePrivateStore();


  template <class U1>
  void makePrivateStore (const U1& other);


  template <class U1>
  void makePrivateStore (const U1* other);


  void releasePrivateStore();


  void setStore (const SG::IConstAuxStore* store);


  void setStore (SG::IAuxStore* store);


  void setStore (const DataLink< SG::IConstAuxStore >& store);


  void setConstStore (const SG::IConstAuxStore* store);


  void setNonConstStore (SG::IAuxStore* store);


  bool usingPrivateStore() const;


  bool usingStandaloneStore() const;


  const SG::IConstAuxStore* getConstStore() const;


  SG::IAuxStore* getStore() const;


  void clearCache();


  const SG::auxid_set_t& getAuxIDs() const;


  bool hasStore() const;


  bool hasNonConstStore() const;


  void clearDecorations() const;


private:
  friend class SG::AuxVectorBase;
  friend class SG::AuxVectorBase_test;


  AuxElement (SG::AuxVectorData* container,  size_t index);



  void releasePrivateStoreForDtor();


  void setIndex (size_t index, SG::AuxVectorData* container);


  bool setIndexPrivate (size_t index, SG::AuxVectorData* container);


  void makePrivateStore1 (const void*);


  void makePrivateStore1 (const AuxElement* other);


  AuxElementStandaloneData* setStore1 (const SG::IConstAuxStore* store);


  void clearAux();


  void copyAux (const AuxElement& other);


  bool privateDataValid() const;


  size_t m_index;

  SG::AuxVectorData* m_container;

  SG::AuxElementData* m_privateData;

  static SG::AuxElementData* s_privatePlaceholder;
};


} // namespace SG


#include "AthContainers/AuxElement.icc"


#endif // not ATHCONTAINERS_AUXELEMENTBASE_H

---