D3PD::RootObjectMetadata Class Reference

Extension of the ObjectMetadata class for reading D3PD files. More...

#include <RootObjectMetadata.h>

Inheritance diagram for D3PD::RootObjectMetadata:

Collaboration diagram for D3PD::RootObjectMetadata:

Public Member Functions
	RootObjectMetadata ()
	Default constructor.
	RootObjectMetadata (const RootObjectMetadata &parent)
	Copy constructor.
StatusCode	addVariable (const std::string &name, const std::string &type, const std::string &docstring)
	Function adding a variable, when the exact type_info is not available.
StatusCode	checkPrefixes ()
	Remove possibly overlooked prefixes in the variable names.
virtual StatusCode	addVariable (const std::string &name, const std::type_info &ti, void *&ptr, const std::string &docstring="", const void *defval=0)
	Make the implementation from ObjectMetadata visible.
bool	operator== (const ObjectMetadata &rhs) const
	Equality operator.
bool	operator< (const ObjectMetadata &rhs) const
	Operator needed to use such objects in ordered STL containers.
template<class T>
StatusCode	addVariable (const std::string &name, T *&ptr, const std::string &docstring="")
	Make the template implementation from IAddVariable visible.
template<class T, class U>
StatusCode	addVariable (const std::string &name, T *&ptr, const std::string &docstring, const U &defval)
	Make the template implementation from IAddVariable visible.
virtual StatusCode	addDimensionedVariable (const std::string &name, const std::type_info &ti, void *&ptr, const std::string &dim, const std::string &docstring="", const void *defval=0)
	The object doesn't support dimensioned variables at the moment, like most of the D3PDMaker code doesn't.
template<class T>
StatusCode	addDimensionedVariable (const std::string &name, T *&ptr, const std::string &dim, const std::string &docstring="")
	Add a variable to the tuple.
template<class T, class U>
StatusCode	addDimensionedVariable (const std::string &name, T *&ptr, const std::string &dim, const std::string &docstring, const U &defval)
	Add a variable to the tuple.
const std::string &	name () const
	Get the name of the D3PDObject that this object describes.
void	setName (const std::string &name)
	Set the name of the D3PDObject that this object describes.
std::string metadataName	ATLAS_NOT_THREAD_SAFE () const
	Get the name for the metadata object that should be created.
const std::string &	prefix () const
	Get the prefix given to variables in this D3PDObject.
void	setPrefix (const std::string &prefix)
	Set the prefix given to variables in this D3PDObject.
bool	container () const
	Get whether the D3PDObject describes a container or not.
void	setContainer (bool container)
	Set whether the D3PDObject describes a container or not.
std::string	toString () const
	Function "serializing" the stored information into a string.
StatusCode	read (const std::string &data)
	Function "de-serializing" the stored information from a string.
void	clear ()
	Function clearing the object.
ObjectMetadata &	operator+= (const ObjectMetadata &obj)
	Operator merging the contents of two objects.
ObjectMetadata &	merge (const ObjectMetadata &obj)
	Function merging the contents of two objects.
const std::set< Variable > &	variables () const
	Function for accessing all the variables of the D3PDObject.

Static Public Member Functions
static bool	isObjectMetadata (const std::string &name)
	Function guessing if an object with a given name is object metadata.
static std::string	objectName (const std::string &metaName)
	Get the D3PDObject's name from the name of the metadata object.

Static Public Attributes
static const size_t	RANDOM_NAME_POSTFIX_LENGTH = 6
	Length of the random string appended to the object name.
static const char *const	STRING_SEPARATOR = "@"
	Character separating parts of the object's metadata.
static const unsigned int	SERIALIZER_VERSION = 1
	"Version number" of the serialized information

Protected Attributes
std::set< Variable >	m_variables
	The list of variables created by a D3PDObject.
std::string	m_name
	Name of the D3PDObject that this object describes.
std::string	m_prefix
	Prefix used by the D3PDObject.
bool	m_container
	The D3PDObject describes a container.

Private Member Functions
RootObjectMetadata &	operator= (const RootObjectMetadata &)

Static Private Member Functions
static std::string genSuffix	ATLAS_NOT_THREAD_SAFE (const std::string &name, size_t length)
	Generate a unique suffix for a metadata object name.

Detailed Description

Extension of the ObjectMetadata class for reading D3PD files.

   The base D3PD::ObjectMetadata class needs to get some extra
   features for interpreting the metadata found in D3PD ROOT files
   correctly. Instead of putting all the frunctionality into the
   base class, it is only put here.

Author

Attila Krasznahorkay Attil.nosp@m.a.Kr.nosp@m.aszna.nosp@m.hork.nosp@m.ay@ce.nosp@m.rn.c.nosp@m.h

Revision

530460

Date

2012-12-13 19:27:24 +0100 (Thu, 13 Dec 2012)

Definition at line 33 of file RootObjectMetadata.h.

Constructor & Destructor Documentation

RootObjectMetadata() [1/2]

D3PD::RootObjectMetadata::RootObjectMetadata

(

)

Default constructor.

Definition at line 20 of file RootObjectMetadata.cxx.

      : ObjectMetadata() {
 
   }

RootObjectMetadata() [2/2]

D3PD::RootObjectMetadata::RootObjectMetadata

(

const RootObjectMetadata &

parent

)

Copy constructor.

Definition at line 25 of file RootObjectMetadata.cxx.

      : ObjectMetadata( parent ) {
 
   }

Member Function Documentation

addDimensionedVariable() [1/3]

StatusCode D3PD::ObjectMetadata::addDimensionedVariable ( const std::string & name, const std::type_info & ti, void *& ptr, const std::string & dim, const std::string & docstring = "", const void * defval = 0 )

virtualinherited

The object doesn't support dimensioned variables at the moment, like most of the D3PDMaker code doesn't.

Still, we might implement something like this later on.

Implements D3PD::IAddVariable.

Definition at line 157 of file ObjectMetadata.cxx.

                                                           {
 
      REPORT_MESSAGE_WITH_CONTEXT( MSG::FATAL, "ObjectMetadata" )
         << "addDimensionedVariable(...) not implemented";
 
      return StatusCode::FAILURE;
   }

addDimensionedVariable() [2/3]

template<class T, class U>

StatusCode D3PD::IAddVariable::addDimensionedVariable ( const std::string & name, T *& ptr, const std::string & dim, const std::string & docstring, const U & defval )

inherited

Add a variable to the tuple.

Parameters

name	The name of the variable.
ptr	Pointer to the type of the variable. The pointer need not be initialized; the D3PD software will set the pointer prior to calling fill().
dim	Dimension for the variable. (Presently unimplemented!)
docstring	Documentation string for this variable.
defval	Pointer to the default value to use for this variable. Only works for basic types.

If called from the constructor, the only effect is to clear ptr.

addDimensionedVariable() [3/3]

template<class T>

StatusCode D3PD::IAddVariable::addDimensionedVariable ( const std::string & name, T *& ptr, const std::string & dim, const std::string & docstring = "" )

inherited

Add a variable to the tuple.

Parameters

name	The name of the variable.
ptr	Pointer to the type of the variable. The pointer need not be initialized; the D3PD software will set the pointer prior to calling fill().
dim	Dimension for the variable. (Presently unimplemented!)
docstring	Documentation string for this variable.

If called from the constructor, the only effect is to clear ptr.

addVariable() [1/4]

template<class T, class U>

StatusCode D3PD::IAddVariable::addVariable ( const std::string & name, T *& ptr, const std::string & docstring, const U & defval )

inherited

Make the template implementation from IAddVariable visible.

addVariable() [2/4]

template<class T>

StatusCode D3PD::IAddVariable::addVariable ( const std::string & name, T *& ptr, const std::string & docstring = "" )

inherited

Make the template implementation from IAddVariable visible.

addVariable() [3/4]

StatusCode D3PD::RootObjectMetadata::addVariable	(	const std::string &	name,
		const std::string &	type,
		const std::string &	docstring )

Function adding a variable, when the exact type_info is not available.

Definition at line 30 of file RootObjectMetadata.cxx.

                                                                            {
 
      // Check that the variable has the correct prefix:
      if( ( not m_prefix.empty() ) && ( not name.starts_with( m_prefix )) ) {
         REPORT_MESSAGE_WITH_CONTEXT( MSG::ERROR, "RootObjectMetadata" )
            << "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( type );
 
      // Set whether the variable is a primitive:
      var.setPrimitive( isPrimitive( type ) );
 
      // Set the documentation string for the variable:
      var.setDoc( docstring );
 
      // Remember the variable:
      m_variables.insert( std::move(var) );
 
      return StatusCode::SUCCESS;
   }

addVariable() [4/4]

StatusCode D3PD::ObjectMetadata::addVariable ( const std::string & name, const std::type_info & ti, void *& ptr, const std::string & docstring = "", const void * defval = 0 )

virtual

Make the implementation from ObjectMetadata visible.

Reimplemented from D3PD::ObjectMetadata.

Definition at line 59 of file ObjectMetadata.cxx.

                                                           {
 
      // 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;
   }

ATLAS_NOT_THREAD_SAFE() [1/2]

std::string metadataName D3PD::ObjectMetadata::ATLAS_NOT_THREAD_SAFE ( ) const

inherited

Get the name for the metadata object that should be created.

ATLAS_NOT_THREAD_SAFE() [2/2]

std::string genSuffix D3PD::ObjectMetadata::ATLAS_NOT_THREAD_SAFE ( const std::string & name, size_t length )

staticprivateinherited

Generate a unique suffix for a metadata object name.

Parameters

name	The metadata object name.
length	The length of the suffix to add.

We used to do this by generating a random string. However, this is very bad for regression testing, as adding or removing one variable can then change the names of all subsequent variables. Instead, we generate the suffix based on a count of the number of times we've seen a particular name.

checkPrefixes()

StatusCode D3PD::RootObjectMetadata::checkPrefixes

(

)

Remove possibly overlooked prefixes in the variable names.

By mistake some of the variable names in the D3PDs produced by AtlasPhysics-17.0.5.5.2 did not get their prefix removed when they were saved into the metadata.

(Still need to investigate why.)

This function remedies this by fixing the variable names manually.

Returns

StatusCode::SUCCESS if everything went fine

Definition at line 77 of file RootObjectMetadata.cxx.

                                                {
 
      // For simplicity's sake I don't modify the original std::set,
      // but create a new one instead. This is slightly slower, but
      // much easier. In any case, performance is not a major concern
      // in this code...
      std::set< Variable > newVariables;
 
      // Loop over the variables:
      std::set< Variable >::const_iterator itr = m_variables.begin();
      std::set< Variable >::const_iterator end = m_variables.end();
      for( ; itr != end; ++itr ) {
 
         // Check if the variable name begins with the prefix (it shouldn't):
         if( ( not m_prefix.empty() ) &&
             ( itr->name().starts_with( m_prefix )) ) {
            // Create a copy of the variable, and remove the prefix from its name:
            Variable var = *itr;
            var.setName( var.name().substr( m_prefix.size(), var.name().npos ) );
            // Insert it into the new container:
            newVariables.insert( std::move(var) );
         } else {
            // Insert the variable as it is into the new container:
            newVariables.insert( *itr );
         }
      }
 
      // Swap the two containers. (This should be a fairly quick operation...)
      m_variables.swap( newVariables );
 
      return StatusCode::SUCCESS;
   }

clear()

void D3PD::ObjectMetadata::clear ( )

inherited

Function clearing the object.

Definition at line 352 of file ObjectMetadata.cxx.

                              {
 
      // Clear/reset all the variables:
      m_variables.clear();
      m_name = "";
      m_prefix = "";
      m_container = false;
 
      return;
   }

container()

bool D3PD::ObjectMetadata::container ( ) const

inherited

Get whether the D3PDObject describes a container or not.

Definition at line 230 of file ObjectMetadata.cxx.

                                        {
 
      return m_container;
   }

isObjectMetadata()

bool D3PD::RootObjectMetadata::isObjectMetadata ( const std::string & name )

static

Function guessing if an object with a given name is object metadata.

Metadata objects are saved with a name like "Something_XXXXXX".

This function makes a very simple check whether the name given to it follows this format.

Parameters

name	The name of a metadata object

Returns

true if it appears to be an object metadata object

Definition at line 117 of file RootObjectMetadata.cxx.

                                                                    {
 
      if( ( name.size() > ( RANDOM_NAME_POSTFIX_LENGTH + 1 ) ) &&
          ( name[ name.size() - ( RANDOM_NAME_POSTFIX_LENGTH + 1 ) ] == '_' ) ) {
         return true;
      } else {
         return false;
      }
   }

merge()

ObjectMetadata & D3PD::ObjectMetadata::merge ( const ObjectMetadata & obj )

inherited

Function merging the contents of two objects.

This merging function was implemented in the anticipation that it might come in handy later on.

But no guarantees...

Parameters

obj	The object that should be merged with this one

Returns

A reference to the current object

Definition at line 375 of file ObjectMetadata.cxx.

                                                                    {
 
      // 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;
   }

name()

const std::string & D3PD::ObjectMetadata::name ( ) const

inherited

Get the name of the D3PDObject that this object describes.

Definition at line 170 of file ObjectMetadata.cxx.

                                               {
 
      return m_name;
   }

objectName()

std::string D3PD::ObjectMetadata::objectName ( const std::string & metaName )

staticinherited

Get the D3PDObject's name from the name of the metadata object.

This function should be used by the client code to "decode" the name of the original D3PDObject from the name of the metadata object.

This way the client code doesn't have to know how this class works internally.

Parameters

metaName

The name of the metadata object in the D3PD file

Returns

The name of the original D3PDObject that the metadata object describes

Definition at line 213 of file ObjectMetadata.cxx.

                                                                   {
 
      return metaName.substr( 0, metaName.size() -
                              ( RANDOM_NAME_POSTFIX_LENGTH + 1 ) );
   }

operator+=()

ObjectMetadata & D3PD::ObjectMetadata::operator+= ( const ObjectMetadata & obj )

inherited

Operator merging the contents of two objects.

Definition at line 363 of file ObjectMetadata.cxx.

                                                                          {
 
      return this->merge( obj );
   }

operator<()

bool D3PD::ObjectMetadata::operator< ( const ObjectMetadata & rhs ) const

inherited

Operator needed to use such objects in ordered STL containers.

Definition at line 91 of file ObjectMetadata.cxx.

                                                                    {
 
      if( prefix() != rhs.prefix() ) {
         return ( prefix() < rhs.prefix() );
      } else if( name() != rhs.name() ) {
         return ( name() < rhs.name() );
      } else {
         return ( container() < rhs.container() );
      }
   }

operator=()

RootObjectMetadata & D3PD::RootObjectMetadata::operator= ( const RootObjectMetadata & )

private

operator==()

bool D3PD::ObjectMetadata::operator== ( const ObjectMetadata & rhs ) const

inherited

Equality operator.

Definition at line 85 of file ObjectMetadata.cxx.

                                                                     {
 
      return ( ( name() == rhs.name() ) && ( prefix() == rhs.prefix() ) &&
               ( container() == rhs.container() ) );
   }

prefix()

const std::string & D3PD::ObjectMetadata::prefix ( ) const

inherited

Get the prefix given to variables in this D3PDObject.

Definition at line 219 of file ObjectMetadata.cxx.

                                                 {
 
      return m_prefix;
   }

read()

StatusCode D3PD::ObjectMetadata::read ( const std::string & data )

inherited

Function "de-serializing" the stored information from a string.

This function can be used to read in information from a serialized form.

Note that the function doesn't clear the contents of the object. So it can be used to merge information from multiple metadata objects / files.

Parameters

data	The string that should be decoded

Returns

StatusCode::SUCCESS if the operation was successful, StatusCode::FAILURE otherwise

Definition at line 276 of file ObjectMetadata.cxx.

                                                          {
 
      //
      // 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;
   }

setContainer()

void D3PD::ObjectMetadata::setContainer ( bool container )

inherited

Set whether the D3PDObject describes a container or not.

Definition at line 235 of file ObjectMetadata.cxx.

                                                     {
 
      m_container = container;
      return;
   }

setName()

void D3PD::ObjectMetadata::setName ( const std::string & name )

inherited

Set the name of the D3PDObject that this object describes.

Definition at line 175 of file ObjectMetadata.cxx.

                                                       {
 
      m_name = name;
      return;
   }

setPrefix()

void D3PD::ObjectMetadata::setPrefix ( const std::string & prefix )

inherited

Set the prefix given to variables in this D3PDObject.

Definition at line 224 of file ObjectMetadata.cxx.

                                                           {
 
      m_prefix = prefix;
      return;
   }

toString()

std::string D3PD::ObjectMetadata::toString ( ) const

inherited

Function "serializing" the stored information into a string.

This function translates the contents of the entire object into a single string.

The different parts of the configuration string are separated by "@" character. (So variable names and variable descriptions can't have this character in them.)

Returns

The configuration of this object "serialized" into a string

Definition at line 249 of file ObjectMetadata.cxx.

                                            {
 
      // 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;
   }

variables()

const std::set< ObjectMetadata::Variable > & D3PD::ObjectMetadata::variables ( ) const

inherited

Function for accessing all the variables of the D3PDObject.

Definition at line 577 of file ObjectMetadata.cxx.

                                                                           {
 
      return m_variables;
   }

Member Data Documentation

m_container

bool D3PD::ObjectMetadata::m_container

protectedinherited

The D3PDObject describes a container.

Definition at line 175 of file ObjectMetadata.h.

m_name

std::string D3PD::ObjectMetadata::m_name

protectedinherited

Name of the D3PDObject that this object describes.

Definition at line 173 of file ObjectMetadata.h.

m_prefix

std::string D3PD::ObjectMetadata::m_prefix

protectedinherited

Prefix used by the D3PDObject.

Definition at line 174 of file ObjectMetadata.h.

m_variables

std::set< Variable > D3PD::ObjectMetadata::m_variables

protectedinherited

The list of variables created by a D3PDObject.

Definition at line 172 of file ObjectMetadata.h.

RANDOM_NAME_POSTFIX_LENGTH

const size_t D3PD::ObjectMetadata::RANDOM_NAME_POSTFIX_LENGTH = 6

staticinherited

Length of the random string appended to the object name.

Definition at line 109 of file ObjectMetadata.h.

SERIALIZER_VERSION

const unsigned int D3PD::ObjectMetadata::SERIALIZER_VERSION = 1

staticinherited

"Version number" of the serialized information

While I don't plan to change this class any time soon, we should be able to clearly decide later on if the format of the metadata serialization changed, which version was used to write the metadata found in a given file.

Definition at line 119 of file ObjectMetadata.h.

STRING_SEPARATOR

const char *const D3PD::ObjectMetadata::STRING_SEPARATOR = "@"

staticinherited

Character separating parts of the object's metadata.

Definition at line 111 of file ObjectMetadata.h.

---

The documentation for this class was generated from the following files:

• RootObjectMetadata.h
• RootObjectMetadata.cxx