View.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ATHVIEWS_VIEW_H
#define ATHVIEWS_VIEW_H
 
#include "GaudiKernel/ServiceHandle.h"
 
#include "AthenaKernel/CLASS_DEF.h"
#include "AthenaKernel/IProxyDict.h"
#include "AthContainers/DataVector.h"
#include "AthLinks/ElementLink.h"
#include "SGCore/sgkey_t.h"
#include "CxxUtils/sgkey_utilities.h"
#include "SGTools/transientKey.h"
#include "StoreGate/StoreGateSvc.h"
#include "TrigSteeringEvent/TrigRoiDescriptorCollection.h"
 
#include <set>
#include <vector>
 
// Forward declarations
namespace SG {
  class DataProxy;
}
class DataObject;
 
 
namespace SG {

  class View final : public implements<IProxyDict> {
  public:
    View( const std::string& name, int index, bool allowFallThrough = true,
          const std::string& storeName = "StoreGateSvc" );
 
    View() = delete;
    virtual ~View() = default;
    View (const View&) = delete;
    View& operator= (const View&) = delete;

    size_t viewID() const {
      return m_index;
    }

    void linkParent( const IProxyDict* parent );

    const std::set< const SG::View* >& getParentLinks() const {
      return m_parents;
    }

    void setFilter( std::vector< std::string > const& inputFilter ) {
      m_fallFilter = inputFilter;
    }

    void setROI(const ElementLink<TrigRoiDescriptorCollection>& roi) {
      m_roi = roi;
    }

    const ElementLink<TrigRoiDescriptorCollection>& getROI() const {
      return m_roi;
    }

    std::string dump( const std::string& indent = "" ) const;
 


    virtual const std::string& name() const override {
      return m_name;
    }

    virtual SG::DataProxy* proxy_exact(SG::sgkey_t sgkey) const override;

    virtual SG::DataProxy* proxy(const CLID& id, const std::string& key) const override;

    virtual SG::DataProxy* proxy(const void* const pTransient) const override {
      return m_store->proxy( pTransient );
    }

    virtual std::vector<const SG::DataProxy*> proxies() const override {
      return m_store->proxies();
    }

    virtual StatusCode addToStore(CLID id, SG::DataProxy* proxy) override {
      return m_store->addToStore( id, proxy );
    }

    virtual SG::DataProxy* recordObject ( SG::DataObjectSharedPtr<DataObject> obj,
                                          const std::string& key,
                                          bool allowMods,
                                          bool returnExisting) override;

    virtual void boundHandle (IResetable* handle) override {
      return m_store->boundHandle( handle );
    }

    virtual void unboundHandle (IResetable* handle) override {
      return m_store->unboundHandle( handle );
    }

    virtual bool tryELRemap ( sgkey_t sgkey_in,   size_t index_in,
                              sgkey_t& sgkey_out, size_t& index_out) override;
 


    virtual const std::string* keyToString( IStringPool::sgkey_t key ) const override;

    virtual const std::string* keyToString( IStringPool::sgkey_t key, CLID& clid ) const override;

    virtual IStringPool::sgkey_t stringToKey( const std::string& str, CLID clid ) override {
      return m_store->stringToKey( viewKey(str), clid );
    }

    virtual void registerKey( IStringPool::sgkey_t key, const std::string& str, CLID clid ) override {
      m_store->registerKey( key, viewKey(str), clid );
    }

 
 
  private:
    SG::DataProxy* findProxy( const CLID& id, const std::string& key, bool allowFallThrough ) const;

    std::string viewKey (const std::string& key) const {
      return SG::transientKey (m_name + "_" + key);
    }
 
    ServiceHandle< StoreGateSvc > m_store;
    ElementLink<TrigRoiDescriptorCollection> m_roi;
 
    using KeyMap_t = SG::ConcurrentSGKeyMap<sgkey_t>;
    KeyMap_t m_keyMap;
 
    std::set< const SG::View* > m_parents;
    std::vector< std::string > m_fallFilter;
 
    std::string m_name;
    size_t m_index{0};
    bool m_allowFallThrough{true};
  };
}  // namespace SG
 

typedef DataVector<SG::View> ViewContainer;
 
CLASS_DEF( ViewContainer , 1160627009 , 1 )
 
#endif