StoreExplorerAlg.cpp

Go to the documentation of this file.

//  ====================================================================
//  StoreExplorerAlg.cpp
//  --------------------------------------------------------------------
//
//  Author    : Markus Frank
//
//  ====================================================================
#include "GaudiKernel/ObjectContainerBase.h"
#include "GaudiKernel/ObjectList.h"
#include "GaudiKernel/ObjectVector.h"
#include "GaudiKernel/KeyedContainer.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IDataManagerSvc.h"
#include "GaudiKernel/IOpaqueAddress.h"
#include "GaudiKernel/SmartDataPtr.h"
#include "GaudiKernel/Algorithm.h"
#include "GaudiKernel/IRegistry.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/SmartIF.h"

class StoreExplorerAlg : public Algorithm {
  long              m_print;
  double            m_frequency;
  bool              m_exploreRelations;
  long              m_printMissing;
  long              m_total = 0;
  long              m_frqPrint = 0;
  bool              m_load;
  bool              m_testAccess;
  bool              m_accessForeign;
  SmartIF<IDataProviderSvc> m_dataSvc;
  std::string       m_dataSvcName;
  std::string       m_rootName;
public:

  StoreExplorerAlg(const std::string& name, ISvcLocator* pSvcLocator)
  : Algorithm(name, pSvcLocator)
  {
    declareProperty("Load",             m_load = false);
    declareProperty("PrintEvt",         m_print = 1);
    declareProperty("PrintMissing",     m_printMissing = 0);
    declareProperty("PrintFreq",        m_frequency = 0.0);
    declareProperty("ExploreRelations", m_exploreRelations = false);
    declareProperty("DataSvc",          m_dataSvcName="EventDataSvc");
    declareProperty("TestAccess",       m_testAccess = false);
    declareProperty("AccessForeign",    m_accessForeign = false);
  }
  ~StoreExplorerAlg() override  = default;

  template <class T>
  std::string access(T* p)  {
    if ( !p )  return "Access FAILED.";
    std::string result = std::accumulate(std::begin(*p),std::end(*p),std::string{},
                                         [&](std::string s,typename T::const_reference i) {
        return s+std::to_string(p->index(i)) + ":" + std::to_string(i->clID()) + ",";
    });
    return result.substr(0, result.length()-2);
  }


  void printObj(IRegistry* pReg, std::vector<bool>& flg)    {
    auto& log = info();
    for (size_t j = 1; j < flg.size(); j++ )     {
      if ( !flg[j-1] && flg[j] ) log << "| ";
      else if ( flg[j] ) log << "  ";
      else          log << "| ";
    }
    log << "+--> " << pReg->name();
    if ( pReg->address() )  {
      log << " [Address: CLID="
          << std::showbase << std::hex << pReg->address()->clID()
          << " Type=" << (void*)pReg->address()->svcType() << "]";
    }
    else  {
      log << " [No Address]";
    }
    DataObject* p = pReg->object();
    if ( p )   {
      try  {
        std::string typ = System::typeinfoName(typeid(*p));
        if ( m_testAccess )  p->clID();
        log << "  " << typ.substr(0,32);
      }
      catch (...)  {
        log << "Access test FAILED";
      }
    }
    else    {
      log << "  (Unloaded) ";
    }
    ObjectContainerBase* base = dynamic_cast<ObjectContainerBase*>(p);
    if ( base )  {
      try   {
        int numObj = base->numberOfObjects();
        const CLID id = p->clID();
        log << " [" << numObj << "]";
        if ( m_testAccess )  {
          CLID idd = id>>16;
          switch(idd) {
            case CLID_ObjectList>>16:                /* ObjectList    */
              access((ObjectList<ContainedObject>*)base);
              break;
            case CLID_ObjectVector>>16:              /* ObjectVector  */
              access((ObjectVector<ContainedObject>*)base);
              break;
            case (CLID_ObjectVector+0x00030000)>>16: /* Keyed Map     */
              access((KeyedContainer<KeyedObject<int>,Containers::Map>*)base);
              break;
            case (CLID_ObjectVector+0x00040000)>>16: /* Keyed Hashmap */
              access((KeyedContainer<KeyedObject<int>,Containers::HashMap>*)base);
              break;
            case (CLID_ObjectVector+0x00050000)>>16: /* Keyed array   */
              access((KeyedContainer<KeyedObject<int>,Containers::Array>*)base);
              break;
          }
        }
      }
      catch (...)  {
        log << "Access test FAILED";
      }
    }
    log << endmsg;
  }

  void explore(IRegistry* pObj, std::vector<bool>& flg)    {
    printObj(pObj, flg);
    if ( pObj )    {
      auto mgr = eventSvc().as<IDataManagerSvc>();
      if ( mgr )    {
        std::vector<IRegistry*> leaves;
        StatusCode sc = mgr->objectLeaves(pObj, leaves);
        const std::string* par0 = nullptr;
        if ( pObj->address() )  par0 = pObj->address()->par();
        if ( sc.isSuccess() )  {
          for ( auto i=leaves.begin(); i != leaves.end(); i++ )   {
            const std::string& id = (*i)->identifier();
            DataObject* p = nullptr;
            if ( !m_accessForeign && (*i)->address() )  {
              if ( par0 )  {
                const std::string* par1 = (*i)->address()->par();
                if ( par1 &&  par0[0] != par1[0] )  continue;
              }
            }
            if ( m_load )  {
              sc = eventSvc()->retrieveObject(id, p);
            } else {
              sc = eventSvc()->findObject(id, p);
            }
            if ( sc.isSuccess() )  {
              if ( id != "/Event/Rec/Relations" || m_exploreRelations )   {
                flg.push_back(i+1 == leaves.end());
                explore(*i, flg);
                flg.pop_back();
              }
            } else {
              flg.push_back(i+1 == leaves.end());
              printObj(*i, flg);
              flg.pop_back();
            }
          }
        }
      }
    }
  }

  StatusCode initialize() override   {
    m_rootName.clear();
    m_dataSvc = service(m_dataSvcName,true);
    if ( !m_dataSvc )  {
        error() << "Failed to access service \""
            << m_dataSvcName << "\"." << endmsg;
        return StatusCode::FAILURE;
    }
    auto mgr = m_dataSvc.as<IDataManagerSvc>();
    if ( !mgr )  {
        error() << "Failed to retrieve IDataManagerSvc interface." << endmsg;
        return StatusCode::FAILURE;
    }
    m_rootName = mgr->rootName();
    return StatusCode::SUCCESS;
  }

  StatusCode finalize() override {
    m_dataSvc.reset();
    return StatusCode::SUCCESS;
  }

  StatusCode execute() override {
    SmartDataPtr<DataObject>   root(m_dataSvc.get(),m_rootName);
    if ( ((m_print > m_total++) || (m_frequency*m_total > m_frqPrint)) && root )    {
      if ( m_frequency*m_total > m_frqPrint )  m_frqPrint++;
      std::string store_name = "Unknown";
      IRegistry* pReg = root->registry();
      if ( pReg )  {
        auto isvc = SmartIF<IService>{pReg->dataSvc()};
        if ( isvc )  store_name = isvc->name();
      }
      info() << "========= " << m_rootName << "["
          << std::showbase << std::hex << (unsigned long) root.ptr() << std::dec
          << "@" << store_name << "]:" << endmsg;
      std::vector<bool> flg(1,true);
      explore(root->registry(), flg);
      return StatusCode::SUCCESS;
    } else if ( root )   {
      return StatusCode::SUCCESS;
    }
    error() << "Cannot retrieve \"/Event\"!" << endmsg;
    return StatusCode::FAILURE;
  }
};

DECLARE_COMPONENT(StoreExplorerAlg)