TObjectManager.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
 
// ROOT include(s):
#include <TBranch.h>
#include <TTree.h>
#include <TError.h>
 
// Local include(s):
#include "xAODRootAccess/tools/TObjectManager.h"
#include "xAODRootAccess/tools/THolder.h"
#include "xAODRootAccess/tools/Message.h"
 
namespace xAOD {
 
   TObjectManager::TObjectManager( ::TBranch* br, THolder* holder,
                                   ::Bool_t renewOnRead )
      : m_branch( br ), m_holder( holder ), m_entry( -1 ), m_isSet( kTRUE ),
        m_renewOnRead( renewOnRead ) {
   }
 
   TObjectManager::TObjectManager( const TObjectManager& parent )
      : TVirtualManager(), m_branch( parent.m_branch ),
        m_holder( 0 ), m_entry( parent.m_entry ),
        m_isSet( parent.m_isSet ), m_renewOnRead( parent.m_renewOnRead ) {
 
      if( parent.m_holder ) {
         m_holder = new THolder( *parent.m_holder );
      }
   }
 
   TObjectManager::~TObjectManager() {
 
      // Delete the holder object if we have one:
      if( m_holder ) {
         delete m_holder;
      }
   }
 
   TObjectManager& TObjectManager::operator=( const TObjectManager& parent ) {
 
      // Check if we need to do anything:
      if( this == &parent ) {
         return *this;
      }
 
      m_branch = parent.m_branch;
      if( m_holder ) {
         delete m_holder;
         m_holder = 0;
      }
      if( parent.m_holder ) {
         m_holder = new THolder( *parent.m_holder );
      }
      m_entry       = parent.m_entry;
      m_isSet       = parent.m_isSet;
      m_renewOnRead = parent.m_renewOnRead;
 
      return *this;
   }
 
   ::TBranch* TObjectManager::branch() {
 
      return m_branch;
   }
 
   ::TBranch** TObjectManager::branchPtr() {
 
      return &m_branch;
   }
 
   const THolder* TObjectManager::holder() const {
 
      return m_holder;
   }
 
   THolder* TObjectManager::holder() {
 
      return m_holder;
   }
 
   ::Int_t TObjectManager::getEntry( ::Int_t getall ) {
 
      // Make sure that the branch is associated to a tree 
      // as the entry to be read is retrieved from the tree
      if (!m_branch->GetTree()){
         Error("xAOD::TObjectManager::getEntry",
            XAOD_MESSAGE("Branch=%s is not associated to any tree while reading of branches within this class relies on that"),
            m_branch->GetName());
         return -1;
      }
 
      // Get the entry that should be read 
      // The entry to be read is set with TTree::LoadTree()
      // NB: for a branch from a friend tree and if the friend tree has an index built,
      // then the entry to read is found when calling the TTree::LoadTree() function 
      // that matches the major and minor values between the main tree and the friend tree 
      ::Long64_t entry = m_branch->GetTree()->GetReadEntry();
 
      if ( entry  < 0 ){
         // Raise error as it implies 
         // either that the TTree::LoadTree() function has not been called 
         // or 
         // the entry requested to be read by the user 
         // is not corresponding to any entry for the friend tree 
         Error("xAOD::TObjectManager::getEntry", 
            XAOD_MESSAGE( "Entry to read is not set for branch=%s from tree=%s. " 
            "It is either because TTree::LoadTree(entry) was not called "
            "beforehand in the TEvent class OR "
            "the entry requested to be read for the main tree is not corresponding to an event for the friend tree" ),
            m_branch->GetName(),
            m_branch->GetTree()->GetName());
         return -1;
      }
 
      // Check if anything needs to be done:
      if( entry == m_entry ) return 0;
 
      // Make sure that the branch is not in "MakeClass mode":
      if( m_branch->GetMakeClass() ) {
         m_branch->SetMakeClass( 0 );
      }
 
      // Renew the object in memory if we are in such a mode:
      if( m_renewOnRead ) {
         m_holder->renew();
      }
 
      // Load the entry.
      const ::Int_t nbytes = m_branch->GetEntry( entry, getall );
 
      // If the load was successful, remember that we loaded this entry.
      if( nbytes >= 0 ) {
         m_entry = entry;
      }
 
      // This is a tricky thing... Parts of the code try to minimise some
      // operations to only happen when an object is getting updated. But
      // it can happen that an interface or auxiliary store object doesn't
      // actually store any data itself. So TBranch::GetEntry will return 0.
      // But we still need to tell the code looking at this return value
      // that we did go to a new event. So we should never return 0 at
      // this point...
      if( nbytes ) {
         return nbytes;
      } else {
         return 1;
      }
   }
 
   const void* TObjectManager::object() const {
 
      return std::as_const(*m_holder).get();
   }
 
   void* TObjectManager::object() {
 
      return m_holder->get();
   }
 
   void TObjectManager::setObject( void* obj ) {
 
      m_holder->set( obj );
      m_isSet = kTRUE;
      return;
   }
 
   ::Bool_t TObjectManager::create() {
 
      return m_isSet;
   }
 
   ::Bool_t TObjectManager::isSet() const {
 
      return m_isSet;
   }
 
   void TObjectManager::reset() {
 
      m_isSet = kFALSE;
      return;
   }
 
} // namespace xAOD