ObjectMetadata.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
 
// Boost include(s):
#include <boost/tokenizer.hpp>
 
// Gaudi/Athena include(s):
#include "GaudiKernel/System.h"
#include "AthenaKernel/errorcheck.h"
 
// Local include(s):
#include "D3PDMakerUtils/ObjectMetadata.h"

namespace {


   bool isPrimitive( const std::type_info& ti ) {
 
      if( ( ti == typeid( char* ) ) ||
          ( ti == typeid( char ) ) ||
          ( ti == typeid( unsigned char ) ) ||
          ( ti == typeid( short ) ) ||
          ( ti == typeid( unsigned short ) ) ||
          ( ti == typeid( int ) ) ||
          ( ti == typeid( unsigned int ) ) ||
          ( ti == typeid( float ) ) ||
          ( ti == typeid( double ) ) ||
          ( ti == typeid( long long ) ) ||
          ( ti == typeid( unsigned long long ) ) ||
          ( ti == typeid( bool ) ) ) {
 
         return true;
      }
 
      return false;
   }
 
} // namespace
 
namespace D3PD {
 
   // Set the value of the constant(s):
   const size_t          ObjectMetadata::RANDOM_NAME_POSTFIX_LENGTH = 6;
   const char* const     ObjectMetadata::STRING_SEPARATOR           = "@";
   const unsigned int    ObjectMetadata::SERIALIZER_VERSION         = 1;
   const char* const     ObjectMetadata::Variable::STRING_SEPARATOR = "$";
 
   ObjectMetadata::ObjectMetadata()
      : m_variables(), m_name( "" ), m_prefix( "" ),
        m_container( false ) {
 
   }
 
   ObjectMetadata::ObjectMetadata( const ObjectMetadata& parent )
      : m_variables( parent.m_variables ), m_name( parent.m_name ),
        m_prefix( parent.m_prefix ), m_container( parent.m_container ) {
 
   }
 
   ObjectMetadata& ObjectMetadata::operator= ( const ObjectMetadata& parent )
   {
     if (&parent != this) {
       m_variables = parent.m_variables;
       m_name      = parent.m_name;
       m_prefix    = parent.m_prefix;
       m_container = parent.m_container;
     }
 
      return *this;
   }
 
   bool ObjectMetadata::operator== ( const ObjectMetadata& rhs ) const {
 
      return ( ( name() == rhs.name() ) && ( prefix() == rhs.prefix() ) &&
               ( container() == rhs.container() ) );
   }
 
   bool ObjectMetadata::operator< ( const ObjectMetadata& rhs ) const {
 
      if( prefix() != rhs.prefix() ) {
         return ( prefix() < rhs.prefix() );
      } else if( name() != rhs.name() ) {
         return ( name() < rhs.name() );
      } else {
         return ( container() < rhs.container() );
      }
   }

   StatusCode ObjectMetadata::addVariable( const std::string& name,
                                           const std::type_info& ti,
                                           void*& /*ptr*/,
                                           const std::string& docstring,
                                           const void* /*defval*/ ) {
 
      // Check that the variable has the correct prefix:
      if( m_prefix != "" &&
          !name.starts_with( m_prefix) )
      {
         REPORT_MESSAGE_WITH_CONTEXT( MSG::ERROR, "ObjectMetadata" )
            << "Specified variable name (" << name << ") doesn't have the "
            << "expected prefix (" << m_prefix << ")";
         return StatusCode::RECOVERABLE;
      }
 
      // Create a new variable:
      Variable var;
 
      // Remove the prefix from the variable name:
      var.setName( name.substr( m_prefix.size(), name.npos ) );
 
      // Check if it's already amongst the existing variables:
      if( m_variables.find( var ) != m_variables.end() ) {
         return StatusCode::SUCCESS;
      }
 
      // Set the type of the variable:
      var.setType( System::typeinfoName( ti.name() ) );
 
      // Set whether the variable is a primitive:
      var.setPrimitive( isPrimitive( ti ) );
 
      // Set the documentation string for the variable:
      var.setDoc( docstring );
 
      // Remember the variable:
      m_variables.insert( std::move(var) );
 
      return StatusCode::SUCCESS;
   }

   StatusCode
   ObjectMetadata::addDimensionedVariable( const std::string& /*name*/,
                                           const std::type_info& /*ti*/,
                                           void*& /*ptr*/,
                                           const std::string& /*dim*/,
                                           const std::string& /*docstring*/,
                                           const void* /*defval*/ ) {
 
      REPORT_MESSAGE_WITH_CONTEXT( MSG::FATAL, "ObjectMetadata" )
         << "addDimensionedVariable(...) not implemented";
 
      return StatusCode::FAILURE;
   }
 
   const std::string& ObjectMetadata::name() const {
 
      return m_name;
   }
 
   void ObjectMetadata::setName( const std::string& name ) {
 
      m_name = name;
      return;
   }

   std::string ObjectMetadata::metadataName ATLAS_NOT_THREAD_SAFE () const {
 
      // Variable used to give names to unnamed D3PDObject-s
      static size_t objectCounter = 0;
      std::string name = m_name;
      if (name.empty()) {
        ++objectCounter;
        name = "D3PDObject" + std::to_string( objectCounter );
      }
      return name + "_" + genSuffix (name, RANDOM_NAME_POSTFIX_LENGTH);
   }

   std::string ObjectMetadata::objectName( const std::string& metaName ) {
 
      return metaName.substr( 0, metaName.size() -
                              ( RANDOM_NAME_POSTFIX_LENGTH + 1 ) );
   }
 
   const std::string& ObjectMetadata::prefix() const {
 
      return m_prefix;
   }
 
   void ObjectMetadata::setPrefix( const std::string& prefix ) {
 
      m_prefix = prefix;
      return;
   }
 
   bool ObjectMetadata::container() const {
 
      return m_container;
   }
 
   void ObjectMetadata::setContainer( bool container ) {
 
      m_container = container;
      return;
   }

   std::string ObjectMetadata::toString() const {
 
      // Save the simple part of the information
      std::string result =
        std::to_string( SERIALIZER_VERSION ) +
         STRING_SEPARATOR + m_prefix +
         STRING_SEPARATOR + ( m_container ? "1" : "0" );
 
      // Save the serialized version of all the variables:
      std::set< Variable >::const_iterator itr = m_variables.begin();
      std::set< Variable >::const_iterator end = m_variables.end();
      for( ; itr != end; ++itr ) {
         result += STRING_SEPARATOR + itr->toString();
      }
 
      return result;
   }

   StatusCode ObjectMetadata::read( const std::string& data ) {
 
      //
      // Tokenize the string using Boost:
      //
      boost::char_separator< char > separator( STRING_SEPARATOR, "",
                                               boost::keep_empty_tokens );
      boost::tokenizer< boost::char_separator< char > > tokens( data,
                                                                separator );
      boost::tokenizer< boost::char_separator< char > >::const_iterator itr = tokens.begin();
      boost::tokenizer< boost::char_separator< char > >::const_iterator end = tokens.end();
 
      // Check that we didn't reach the last token yet:
      if( itr == end ) {
         REPORT_MESSAGE_WITH_CONTEXT( MSG::FATAL, "ObjectMetadata" )
            << "The received data can not be parsed successfully: "
            << data;
         return StatusCode::FAILURE;
      }
 
      // Check that the metadata was saved using the same version of the
      // serializer code. Later on we might want to introduce backward
      // compatibility, but for now this simple check should be enough.
      if( atoi(itr->c_str()) != SERIALIZER_VERSION ) {
         REPORT_MESSAGE_WITH_CONTEXT( MSG::FATAL, "ObjectMetadata" )
            << "Version mismatch! The metadata was saved with a different "
            << "serialization version (" << *itr << ") than the code used ("
            << SERIALIZER_VERSION << ")";
         return StatusCode::FAILURE;
      }
 
      ++itr;
 
      // Check that we didn't reach the last token yet:
      if( itr == end ) {
         REPORT_MESSAGE_WITH_CONTEXT( MSG::FATAL, "ObjectMetadata" )
            << "The received data can not be parsed successfully: "
            << data;
         return StatusCode::FAILURE;
      }
 
      // Extract the prefix from the metadata:
      m_prefix = *itr; ++itr;
 
      // Check that we didn't reach the last token yet:
      if( itr == end ) {
         REPORT_MESSAGE_WITH_CONTEXT( MSG::FATAL, "ObjectMetadata" )
            << "The received data can not be parsed successfully: "
            << data;
         return StatusCode::FAILURE;
      }
 
      // Extract whether this is a container that the variables describe:
      if( *itr == "0" ) {
         m_container = false;
      } else if( *itr == "1" ) {
         m_container = true;
      } else {
         REPORT_MESSAGE_WITH_CONTEXT( MSG::FATAL, "ObjectMetadata" )
            << "The received data can not be parsed successfully: "
            << data;
         return StatusCode::FAILURE;
      }
 
      ++itr;
 
      // Finally, let's extract all the variable metadata:
      for( ; itr != end; ++itr ) {
         Variable var;
         CHECK( var.read( *itr ) );
         m_variables.insert( std::move(var) );
      }
 
      return StatusCode::SUCCESS;
   }
 
   void ObjectMetadata::clear() {
 
      // Clear/reset all the variables:
      m_variables.clear();
      m_name = "";
      m_prefix = "";
      m_container = false;
 
      return;
   }
 
   ObjectMetadata& ObjectMetadata::operator+= ( const ObjectMetadata& obj ) {
 
      return this->merge( obj );
   }

   ObjectMetadata& ObjectMetadata::merge( const ObjectMetadata& obj ) {
 
      // Only objects with the same "name" should be merged:
      if( name() != obj.name() ) {
         REPORT_MESSAGE_WITH_CONTEXT( MSG::WARNING, "ObjectMetadata" )
            << "Can't merge object with name \"" << obj.name()
            << "\" into another object with name \"" << name() << "\"";
         return *this;
      }
 
      // Now merge all the variable definitions:
      std::set< Variable >::const_iterator itr = obj.variables().begin();
      std::set< Variable >::const_iterator end = obj.variables().end();
      for( ; itr != end; ++itr ) {
         m_variables.insert( *itr );
      }
 
      return *this;
   }

   std::string ObjectMetadata::genSuffix ATLAS_NOT_THREAD_SAFE (const std::string& name,
                                                                size_t length)
   {
 
     // Count of the number of times a given name was used,
     // in order to assign them a unique suffix.
     static std::unordered_map<std::string, size_t> namecount;
 
     const size_t count = ++namecount[name];
     std::ostringstream os;
     os << std::setw(length) << std::setprecision(length) << std::setfill('0')
        << count;
     return os.str();
   }
 
 
   ObjectMetadata::Variable::Variable()
      : m_type( "" ), m_name( "" ), m_doc( "" ), m_primitive( true ) {
 
   }
 
   const std::string& ObjectMetadata::Variable::type() const {
 
      return m_type;
   }
 
   const std::string& ObjectMetadata::Variable::name() const {
 
      return m_name;
   }
 
   const std::string& ObjectMetadata::Variable::doc() const {
 
      return m_doc;
   }
 
   bool ObjectMetadata::Variable::primitive() const {
 
      return m_primitive;
   }
 
   void ObjectMetadata::Variable::setType( const std::string& type ) {
 
      m_type = type;
      return;
   }
 
   void ObjectMetadata::Variable::setName( const std::string& name ) {
 
      m_name = name;
      return;
   }
 
   void ObjectMetadata::Variable::setDoc( const std::string& doc ) {
 
      m_doc = doc;
      return;
   }
 
   void ObjectMetadata::Variable::setPrimitive( bool primitive ) {
 
      m_primitive = primitive;
      return;
   }

   std::string ObjectMetadata::Variable::toString() const {
 
      return m_name + STRING_SEPARATOR + m_type + STRING_SEPARATOR +
         m_doc + STRING_SEPARATOR + ( m_primitive ? "1" : "0" );
   }

   StatusCode ObjectMetadata::Variable::read( const std::string& data ) {
 
      //
      // Tokenize the string using Boost:
      //
      boost::char_separator< char > separator( STRING_SEPARATOR, "",
                                               boost::keep_empty_tokens );
      boost::tokenizer< boost::char_separator< char > > tokens( data,
                                                                separator );
      boost::tokenizer< boost::char_separator< char > >::const_iterator itr = tokens.begin();
 
      // Check that we didn't reach the last token yet:
      if( itr == tokens.end() ) {
         REPORT_MESSAGE_WITH_CONTEXT( MSG::FATAL, "ObjectMetadata::Variable" )
            << "The received data can not be parsed successfully: "
            << data;
         return StatusCode::FAILURE;
      }
 
      // Extract the name of the variable:
      m_name = *itr; ++itr;
 
      // Check that we didn't reach the last token yet:
      if( itr == tokens.end() ) {
         REPORT_MESSAGE_WITH_CONTEXT( MSG::FATAL, "ObjectMetadata::Variable" )
            << "The received data can not be parsed successfully: "
            << data;
         return StatusCode::FAILURE;
      }
 
      // Extract the type of the variable:
      m_type = *itr; ++itr;
 
      // Check that we didn't reach the last token yet:
      if( itr == tokens.end() ) {
         REPORT_MESSAGE_WITH_CONTEXT( MSG::FATAL, "ObjectMetadata::Variable" )
            << "The received data can not be parsed successfully: "
            << data;
         return StatusCode::FAILURE;
      }
 
      // Extract the documentation string of the variable:
      m_doc = *itr; ++itr;
 
      // Check that we didn't reach the last token yet:
      if( itr == tokens.end() ) {
         REPORT_MESSAGE_WITH_CONTEXT( MSG::FATAL, "ObjectMetadata::Variable" )
            << "The received data can not be parsed successfully: "
            << data;
         return StatusCode::FAILURE;
      }
 
      // Extract the information of whether this variable is a primitive or not:
      if( *itr == "0" ) {
         m_primitive = false;
      } else if( *itr == "1" ) {
         m_primitive = true;
      } else {
         REPORT_MESSAGE_WITH_CONTEXT( MSG::FATAL, "ObjectMetadata::Variable" )
            << "The received data can not be parsed successfully: "
            << data;
         return StatusCode::FAILURE;
      }
 
      return StatusCode::SUCCESS;
   }
 
   bool ObjectMetadata::Variable::operator== ( const ObjectMetadata::Variable& var ) const {
 
      return ( ( name() == var.name() ) &&
               ( type() == var.type() ) );
   }
 
   bool ObjectMetadata::Variable::operator< ( const ObjectMetadata::Variable& var ) const {
 
      if( name() != var.name() ) {
         return ( name() < var.name() );
      } else {
         return ( type() < var.type() );
      }
   }
 
   const std::set< ObjectMetadata::Variable >& ObjectMetadata::variables() const {
 
      return m_variables;
   }
 
   ObjectMetadata operator+ ( const ObjectMetadata& obj1,
                              const ObjectMetadata& obj2 ) {
 
      ObjectMetadata result( obj1 );
      return result += obj2;
   }
 
} // namespace D3PD