StoreGate/StoreGate/VarHandleKeyArray.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef STOREGATE_VARHANDLEKEYARRAY_H
#define STOREGATE_VARHANDLEKEYARRAY_H 1

 
#include "GaudiKernel/DataHandle.h"
#include "GaudiKernel/IDataHandleHolder.h"
#include "StoreGate/VarHandleKey.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 void push_back(const std::string& key)=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 (const auto &e : l) {
        std::vector<Base>::emplace_back( e );
      }
    }

    template <class T = Base>
    requires T::isDecorHandleKey
    VarHandleKeyArrayCommon( VarHandleKey& contKey,
                             std::initializer_list<std::string> l )
      : m_contKey (&contKey)
    {
      for (const auto &e : l) {
        std::vector<Base>::emplace_back( contKey, e );
      }
    }    
    
    StatusCode initialize (bool used = true);

    virtual StatusCode assign(const std::vector<std::string>& vs) override;

    virtual void push_back(const std::string& key) override {
      std::vector<Base>::emplace_back( keyFromString(key) );
    }

    virtual std::string toString() const override;

    virtual std::vector<SG::VarHandleKey*> keys() const override;
    

    virtual void renounce() override { m_isRenounced = true; }
     
    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:
    template <class T = Base>
    requires T::isDecorHandleKey
    Base keyFromString (const std::string& s) const;
 

    template <class T = Base>
    requires (!T::isDecorHandleKey)
    Base keyFromString (const std::string& s) const;
    
 
    bool m_isRenounced{ false };
    IDataHandleHolder* m_owner{ nullptr };

    const VarHandleKey* m_contKey = nullptr;
 
  };
  
} // namespace SG
 
namespace std {
  ostream& operator<<(ostream& s, const SG::VarHandleKeyArray& m);
}
 
 
#include "StoreGate/VarHandleKeyArray.icc"
 
#endif