View.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#include "AthViews/View.h"
#include "TrigSteeringEvent/TrigRoiDescriptorCollection.h"
 
#include <stdexcept>
 

SG::View::View( std::string const& name, int index, bool allowFallThrough, std::string const& storeName ) :
  m_store( storeName, name ),
  m_keyMap(KeyMap_t::Updater_t()),
  m_name( name ),
  m_allowFallThrough( allowFallThrough )
{
  if ( index >= 0 ) {
    m_index = index;
    m_name += '_';
    m_name += std::to_string( index );
  }
}
 

void SG::View::linkParent( const IProxyDict* parent ) {
  auto castParent = dynamic_cast< const SG::View* >( parent );
  if ( castParent ) {
    m_parents.insert( castParent );
  }
  else {
    throw std::runtime_error( "Unable to link parent view that cannot be cast to SG::View" );
  }
}
 

SG::DataProxy* SG::View::recordObject ( SG::DataObjectSharedPtr<DataObject> obj,
                                        const std::string& key,
                                        bool allowMods,
                                        bool returnExisting)
{
  // Record the object under the view name
  SG::DataProxy* proxy = m_store->recordObject( obj, viewKey(key), allowMods, returnExisting );
 
  // Remember the hashed rawKey -> viewKey mapping for use in proxy_exact
  if (proxy) {
    const IStringPool::sgkey_t keyNoView = m_store->stringToKey( key, obj->clID() );
    m_keyMap.emplace(keyNoView, proxy->sgkey());
  }
 
  return proxy;
}
 

SG::DataProxy* SG::View::proxy_exact ( SG::sgkey_t sgkey ) const {
  auto itr = m_keyMap.find(sgkey);
  if (itr != m_keyMap.end()) {
    return m_store->proxy_exact( itr->second );
  }
  else return nullptr;
}
 

SG::DataProxy * SG::View::proxy( const CLID& id, const std::string& key ) const
{
  return findProxy( id, key, m_allowFallThrough );
}
 

SG::DataProxy * SG::View::findProxy( const CLID& id, const std::string& key, bool allowFallThrough ) const
{
  auto isValid = [](const SG::DataProxy* p) { return p != nullptr and p->isValid(); };
  auto localProxy = m_store->proxy( id, viewKey(key) );
  if ( isValid( localProxy ) ) {
    return localProxy;
  }
 
  for ( auto parent: m_parents ) {
    // Don't allow parents to access whole-event store independently of this view
    auto inParentProxy = parent->findProxy( id, key, false );
    if ( isValid( inParentProxy ) ) {
      return inParentProxy;
    }
  }
  
  //Look in the default store if could not find in any view - for instance for event-wise IDCs
  if ( (not isValid( localProxy )) and allowFallThrough ) {
 
    //Apply filtering
    if ( !m_fallFilter.empty() ) {
      bool filterPass = false;
 
      //Filter passes if the key contains one of the possible values
      for ( auto& entry : m_fallFilter ) {
        if ( key.find( entry ) != std::string::npos ) {
          filterPass = true;
          break;
        }
      }
 
      if ( !filterPass ) return nullptr;
    }
 
    return m_store->proxy( id, key );
  }
  return nullptr;
}
 

std::string SG::View::dump( const std::string& indent ) const
{
  // Dump view contents
  std::string ret = indent + "Dump " + name() + "\n";
  ret += indent + "[";
  for ( const SG::DataProxy* dp: proxies() ) {
    if ( dp->name().find( name() ) == 0 ) 
      ret += " " + dp->name();
  }
  ret += " ]\n";
 
  // Dump parent views
  if ( m_parents.size() ) ret += indent + "Parents:\n";
  for ( auto p : m_parents ) {
    ret += p->dump( indent + "  " );
  }
 
  // Fallthrough
  if ( indent == "" ) {
    if ( m_allowFallThrough ) {
      ret += indent + "May access main store: " + m_store->name();
    } else {
      ret += indent + "May not access main store";
    }
  }
  return ret;
}
 
 
bool SG::View::tryELRemap( sgkey_t, size_t, sgkey_t&, size_t& )
{
  throw std::runtime_error( "Not implemented: SG::View::tryELRemap" );
}
 
const std::string* SG::View::keyToString( IStringPool::sgkey_t, CLID& ) const
{
  throw std::runtime_error( "Not implemented: SG::View::keyToString" );
}
 
const std::string* SG::View::keyToString( IStringPool::sgkey_t ) const
{
  throw std::runtime_error( "Not implemented: SG::View::keyToString" );
}