Control/xAODRootAccess/Root/Utils.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
// STL include(s):
#include <algorithm>
#include <cctype>
#include <functional>
#include <regex>
 
// ROOT include(s):
#include <TError.h>
#include <ROOT/RNTupleDescriptor.hxx>
 
// EDM include(s):
#include "AthContainers/tools/error.h"
 
// Local include(s):
#include "xAODRootAccess/tools/Message.h"
#include "xAODRootAccess/tools/Utils.h"
 
 
namespace {

   void removeDefaultTemplateParameters( std::string& name,
                                         const std::string& vectorName ) {
 
      size_t vecPos = 0;
      while( ( vecPos = name.find( vectorName + "<", vecPos ) ) !=
             std::string::npos ) {
 
         // Update the position to point at the end of the search string:
         vecPos += ( vectorName.size() + 1 );
 
         // Look for "the comma" that we should remove everything
         // after:
         int open = 0;
         size_t commaPos = std::string::npos;
         for( size_t pos = vecPos; pos < name.size(); ++pos ) {
            switch( name[ pos ] ) {
            case '<':
               ++open;
               break;
            case '>':
               --open;
               break;
            case ',':
               if( ! open ) {
                  commaPos = pos;
               }
               break;
            default:
               break;
            }
            if( commaPos != std::string::npos ) {
               break;
            }
         }
 
         // If we didn't find a comma, then let's give up:
         if( commaPos == std::string::npos ) {
            continue;
         }
 
         // If we did, then let's look for the closing '>' of the vector:
         open = 0;
         size_t closingPos = std::string::npos;
         for( size_t pos = commaPos; pos < name.size(); ++pos ) {
            switch( name[ pos ] ) {
            case '<':
               ++open;
               break;
            case '>':
               if( ! open ) {
                  closingPos = pos;
                  break;
               }
               --open;
               break;
            default:
               break;
            }
            if( closingPos != std::string::npos ) {
               break;
            }
         }
 
         // It's bad if we didn't find the closing '>'...
         if( closingPos == std::string::npos ) {
            ::Error( "removeDefaultTemplateParameters",
                     XAOD_MESSAGE( "Couldn't find closing '>' in name %s" ),
                     name.c_str() );
            return;
         }
 
         // Remove the identified part of the string:
         name.erase( commaPos, closingPos - commaPos );
      }
 
      return;
   }
 
} // private namespace
 
namespace xAOD {
 
   namespace Utils {

     SG::sgkey_t hash( const std::string& name ) {
 
         static constexpr SG::sgkey_t MASK = (~static_cast<SG::sgkey_t>(0)) >> 2;
 
         // The helper object:
         static const std::hash< std::string > helper;
         // Let the helper do the work:
         return ( static_cast< SG::sgkey_t >( helper( name ) ) & MASK );
      }

      std::string dynBranchPrefix( const std::string& key ) {
 
         // Make a copy of the key that we can modify:
         std::string result = key;
 
         // If it ends in a dot, then let's exchange that dot for
         // "Dyn.":
         if( result[ result.size() - 1 ] == '.' ) {
            result.replace( result.size() - 1, 1, "Dyn." );
         }
         // If it doesn't end in a dot, then let's just add "Dyn." at
         // the end, and be done with it:
         else {
            result += "Dyn.";
         }
 
         return result;
      }

      std::string dynFieldPrefix( const std::string& key ) {
         // Make a copy of the key that we can modify:
         std::string result = key;
 
         // If it ends in a colon, then let's exchange that colon for
         // "Dyn:":
         if( result[ result.size() - 1 ] == ':' ) {
            result.replace( result.size() - 1, 1, "Dyn:" );
         }
         // If it doesn't end in a colon, then let's just add "Dyn:" at
         // the end:
         else {
            result += "Dyn:";
         }
 
         return result;
      }

      const std::type_info& getTypeInfo( EDataType type ) {
 
         switch( type ) {
 
         case kChar_t:
         case kchar:
            return typeid( Char_t );
         case kUChar_t:
            return typeid( UChar_t );
         case kShort_t:
            return typeid( Short_t );
         case kUShort_t:
            return typeid( UShort_t );
         case kInt_t:
         case kCounter:
            return typeid( Int_t );
         case kUInt_t:
         case kBits:
         case kDataTypeAliasUnsigned_t:
            return typeid( UInt_t );
         case kLong_t:
            return typeid( Long_t );
         case kULong_t:
            return typeid( ULong_t );
         case kFloat_t:
            return typeid( Float_t );
         case kDouble_t:
            return typeid( Double_t );
         case kDouble32_t:
            return typeid( Double32_t );
         case kBool_t:
            return typeid( Bool_t );
         case kLong64_t:
            return typeid( Long64_t );
         case kULong64_t:
            return typeid( ULong64_t );
         case kFloat16_t:
            return typeid( Float16_t );
         case kCharStar:
            return typeid( char* );
         case kVoid_t:
            return typeid( void );
         default:
            ::Error( "xAOD::Utils::getTypeInfo",
                     XAOD_MESSAGE( "Unknown data type (%i) received" ),
                     static_cast< int >( type ) );
            return typeid( void );
         }
      }

#define TYPE_CHECK_INSTANTIATE(MACRO) \
   MACRO(std::int8_t)                 \
   MACRO(std::uint8_t)                \
   MACRO(std::int16_t)                \
   MACRO(std::uint16_t)               \
   MACRO(std::int32_t)                \
   MACRO(std::uint32_t)               \
   MACRO(std::int64_t)                \
   MACRO(std::uint64_t)               \
   MACRO(char)                        \
   MACRO(float)                       \
   MACRO(double)                      \
   MACRO(bool)

#define GETTYPEINFO_SPECIALIZE(TYPE) \
   if(typeName == #TYPE) {           \
      return typeid(TYPE);           \
   }
 
      const std::type_info& getTypeInfo(std::string_view typeName) {
         TYPE_CHECK_INSTANTIATE(GETTYPEINFO_SPECIALIZE)
         ::Error("xAOD::Utils::getTypeInfo",
                 XAOD_MESSAGE("Unknown data type (%s) received"),
                 typeName.data());
         return typeid(void);
      }
 
#undef GETTYPEINFO_SPECIALIZE
 
#define ISPRIMITIVETYPE_SPECIALIZE(TYPE) \
   if(typeName == #TYPE) {               \
      return true;                       \
   }
 
      bool isPrimitiveType(std::string_view typeName) {
         TYPE_CHECK_INSTANTIATE(ISPRIMITIVETYPE_SPECIALIZE)
         return false;
      }
 
#undef ISPRIMITIVETYPE_SPECIALIZE
#undef TYPE_CHECK_INSTANTIATE

      char rootType( char typeidType ) {
 
         // Do the hard-coded translation:
         switch( typeidType ) {
 
         case 'c':
            return 'B';
            break;
         case 'h':
            return 'b';
            break;
         case 's':
            return 'S';
            break;
         case 't':
            return 's';
            break;
         case 'i':
            return 'I';
            break;
         case 'j':
            return 'i';
            break;
         case 'f':
            return 'F';
            break;
         case 'd':
            return 'D';
            break;
         case 'x':
            return 'L';
            break;
         case 'y':
         case 'm': // Not sure how platform-independent this one is...
            return 'l';
            break;
         case 'b':
            return 'O';
            break;
         }
 
         // If we didn't find this type:
         Error( "xAOD::Utils::rootType",
                XAOD_MESSAGE( "Received an unknown type: %c" ), typeidType );
         return '\0';
      }

      std::string getTypeName( const std::type_info& ti ) {
 
         // Get the "raw" type name:
         std::string result = AthContainers_detail::typeinfoName( ti );
 
         // If there are no "tricky" classes in the name, then we're done
         // already:
         if( ( result.find( "DataVector<" ) == std::string::npos ) &&
             ( result.find( "std::vector<" ) == std::string::npos ) &&
             ( result.find( "std::__1::vector<") == std::string::npos ) ) {
            return result;
         }
 
         // Deal with the vector types:
         removeDefaultTemplateParameters( result, "DataVector" );
         removeDefaultTemplateParameters( result, "std::vector" );
         removeDefaultTemplateParameters( result, "std::__1::vector" );
 
         // Make sure that no ">>" parts are left in the type name:
         size_t pos = 0;
         while( ( pos = result.find( ">>" ) ) != std::string::npos ) {
            result.replace( pos, 2, "> >" );
         }
 
         // Remove all "__1" namespaces from the type name:
         while( ( pos = result.find( "__1::" ) ) != std::string::npos ) {
            result.replace( pos, 5, "" );
         }
 
         // Return the massaged name:
         return result;
      }

      std::string getFirstBranchMatch( TTree * tree,
                                        const std::string& pre ) {
         const TObjArray * pBranches = tree->GetListOfBranches();
         const std::regex pattern( ".*" + pre + ".*" );
 
         for( int i = 0, nLast = pBranches->GetLast(); i <= nLast; ++i ) {
            const std::string name = pBranches->At(i)->GetName();
 
            if( std::regex_match( name, pattern ) )
               return name;
 
         }
 
         return pre;
      }

      std::string getFieldName( const ROOT::RNTupleDescriptor& descriptor,
                                const std::string& key ) {
 
         std::string fieldName = key;
         if( fieldName.ends_with( "Aux." ) ) {
            fieldName.back() = ':';
         }
         if( descriptor.FindFieldId( fieldName ) !=
             ROOT::kInvalidDescriptorId ) {
            return fieldName;
         }
 
         // Replace the characters the same way as Athena does when writing.
         fieldName = key;
         std::replace_if( fieldName.begin(), fieldName.end(),
                          []( unsigned char c ) { return !std::isalnum( c ); },
                          '_' );
         if( fieldName.ends_with( "Aux_" ) ) {
            fieldName.back() = ':';
         }
         return fieldName;
      }
 
   }  // namespace Utils
 
}  // namespace xAOD