AthToolSupport/AsgDataHandles/AsgDataHandles/VarHandleKeyArray.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ASG_DATA_HANDLES_VAR_HANDLE_KEY_ARRAY_H
#define ASG_DATA_HANDLES_VAR_HANDLE_KEY_ARRAY_H
 
#ifndef XAOD_STANDALONE
#include <StoreGate/VarHandleKeyArray.h>
#else
 
#include <AsgMessaging/StatusCode.h>
#include <vector>
#include <string>
 
namespace SG {
 
  class VarHandleKeyArray {
  public:
    VarHandleKeyArray(){};
    virtual ~VarHandleKeyArray() = default;
    // virtual StatusCode assign(const std::vector<std::string>& vs)=0;
    virtual std::string toString() const = 0;
    // virtual Gaudi::DataHandle::Mode mode() const = 0;
 
    // virtual std::vector<SG::VarHandleKey*> keys() const = 0;
 
    // virtual void renounce() = 0;
    // virtual bool renounced() const = 0;
    // virtual void declare(IDataHandleHolder*)  = 0;
 
    // virtual void setOwner( IDataHandleHolder* o ) = 0;
    // virtual const IDataHandleHolder* owner() const = 0;
    // virtual IDataHandleHolder* owner() = 0;
 
  };
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// mixin class for common functionality
//
 
  template <class Base>
  class VarHandleKeyArrayCommon : public VarHandleKeyArray, 
                                  public std::vector<Base> {
  public:
    VarHandleKeyArrayCommon() : std::vector<Base>() {};
    
    VarHandleKeyArrayCommon( const std::vector<Base>& v ):
      std::vector<Base>(v) {};
    
    VarHandleKeyArrayCommon( std::initializer_list<Base> l ):
      std::vector<Base>{l} {};
    
    VarHandleKeyArrayCommon( std::initializer_list<std::string> l ) {
      for (auto &e : l) {
        this->push_back( Base{e} );
      }
    }    
    
    StatusCode initialize (bool used = true);
 
    // /**
    //  * @brief Set the contents of the VarHandleKeyArray from a 
    //  * vector of std::strings
    //  * @param vs vector of initializer strings
    //  */
    // virtual StatusCode assign(const std::vector<std::string>& vs) override;
 
    virtual std::string toString() const override;
 
    // /**
    //  * @brief create array of all base VarHandleKeys in the Array
    //  */
    // virtual std::vector<SG::VarHandleKey*> keys() const override;
    
 
    // /**
    //  * @brief if called, handles will not be declared in the algorithm I/O
    //  */
    // virtual void renounce() override { m_isRenounced = true; }
    
    // /**
    //  * @brief query renounced state
    //  **/ 
    // virtual bool renounced() const override { return m_isRenounced; }
 
    // virtual void declare( IDataHandleHolder* ) override;
 
    // virtual void setOwner( IDataHandleHolder* o ) override { m_owner = o; }
    // virtual const IDataHandleHolder* owner() const override { return m_owner; }
    // virtual IDataHandleHolder* owner() override { return m_owner; }
 
  private:
    
    // bool m_isRenounced{ false };
    // IDataHandleHolder* m_owner{ nullptr };
 
  };
  
} // namespace SG
 
namespace std {
  ostream& operator<<(ostream& s, const SG::VarHandleKeyArray& m);
}
 
 
#include "AsgDataHandles/VarHandleKeyArray.icc"
 
#endif
 
#endif