PrintHelpers.h File Reference

#include <iosfwd>

Include dependency graph for PrintHelpers.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Namespaces
	SG
	Forward declaration.
	xAOD
	ICaloAffectedTool is abstract interface for tools checking if 4 mom is in calo affected region.

Functions
std::ostream &	operator<< (std::ostream &out, const SG::AuxElement &obj)
	Operator printing the payload of an xAOD object. More...
void	xAOD::dump (const SG::AuxElement &obj)
	Helper function for dumping xAOD objects on the screen in PyROOT. More...

Function Documentation

operator<<()

std::ostream& operator<<	(	std::ostream &	out,
		const SG::AuxElement &	obj
	)

Operator printing the payload of an xAOD object.

This function can be used to quickly get an idea about the payload held by any type of xAOD object. It prints the type and name of each auxiliary variable associated with the object. And for some simple types (primitives and some vectors of primitives) it even prints the values of these variables.

Parameters

out	The stream to write the information to
obj	The object to write the information about

Returns

The same stream object that was given to the function

Helper macro to make the code slightly shorter

Definition at line 66 of file PrintHelpers.cxx.

                                                                    {
 
   // Start off with some basic information:
   out << "SG::AuxElement\n";
   out << "   ";
   if( obj.usingStandaloneStore() ) {
      out << "using standalone store\n";
   } else if( obj.usingPrivateStore() ) {
      out << "using private store\n";
   } else if( obj.container() ) {
      out << "in container\n";
   } else {
      // If there's no auxiliary store, bail now:
      out << "standalone object, without auxiliary store";
      return out;
   }
 
   // If the container doesn't have an auxiliary store, bail now:
   if( ! obj.container()->getConstStore() ) {
      return out;
   }
 
   out << "   Variables:";
 
   // Get a convenience pointer to the aux type registry:
   SG::AuxTypeRegistry& reg = SG::AuxTypeRegistry::instance();
 
   // Get the auxiliary IDs of the object:
   const SG::auxid_set_t& auxids =
      ( obj.container()->getConstStore() ?
        obj.container()->getConstStore()->getAuxIDs() :
        obj.getConstStore()->getAuxIDs() );
 
   // Sort auxids to get predictable ordering.
   std::vector<SG::auxid_t> auxids_v (auxids.begin(), auxids.end());
   std::sort (auxids_v.begin(), auxids_v.end());
 
   for( SG::auxid_t auxid : auxids_v ) {
 
      out << "\n    - type: " << reg.getTypeName( auxid )
          << ", \tname: \"" << reg.getName( auxid );
      out << "\", \tvalue: ";
 
#define PRINTER( TYPE )                                           \
      do {                                                        \
         SG::ConstAccessor< TYPE > acc( auxid );                  \
         if( acc.isAvailable( obj ) ) {                           \
            out << acc( obj );                                    \
         }                                                        \
      } while( 0 )
 
      // The type of the variable:
      const std::type_info* ti = reg.getType( auxid );
      if( reg.getFlags( auxid ) & SG::AuxVarFlags::Atomic ) {
        if( *ti == typeid( unsigned int ) ) {
          SG::AtomicConstAccessor<unsigned int> acc( reg.getName( auxid ) );
          if ( acc.isAvailable( obj )) {
            out << acc (obj);
          }
        }
        else {
          out << "(Unsupported atomic type)\n";
        }
      } else if( *ti == typeid( int8_t ) ) {
         SG::ConstAccessor< int8_t > acc( auxid );
         if( acc.isAvailable( obj ) ) {
           out << static_cast< int >( acc( obj ) );
         }
      } else if( *ti == typeid( uint8_t ) ) {
         SG::ConstAccessor< uint8_t > acc( auxid );
         if( acc.isAvailable( obj ) ) {
           out << static_cast< int >( acc( obj ) );
         }
      } else if( *ti == typeid( int16_t ) ) {
         PRINTER( int16_t );
      } else if( *ti == typeid( uint16_t ) ) {
         PRINTER( uint16_t );
      } else if( *ti == typeid( int32_t ) ) {
         PRINTER( int32_t );
      } else if( *ti == typeid( uint32_t ) ) {
         PRINTER( uint32_t );
      } else if( *ti == typeid( int64_t ) ) {
         PRINTER( int64_t );
      } else if( *ti == typeid( uint64_t ) ) {
         PRINTER( uint64_t );
      } else if( *ti == typeid( long ) ) {
         PRINTER( long );
      } else if( *ti == typeid( unsigned long ) ) {
         PRINTER( unsigned long );
      } else if( *ti == typeid( unsigned long long ) ) {
         PRINTER( unsigned long long );
      } else if( *ti == typeid( float ) ) {
         PRINTER( float );
      } else if( *ti == typeid( double ) ) {
         PRINTER( double );
      } else if( *ti == typeid( std::vector< float > ) ) {
         PRINTER( std::vector< float > );
      } else if( *ti == typeid( std::vector< double > ) ) {
         PRINTER( std::vector< double > );
      } else if( *ti == typeid( std::vector< char > ) ) {
         PRINTER( std::vector< char > );
      } else if( *ti == typeid( std::vector< int8_t > ) ) {
         PRINTER( std::vector< int8_t > );
      } else if( *ti == typeid( std::vector< uint8_t > ) ) {
         PRINTER( std::vector< uint8_t > );
      } else if( *ti == typeid( std::vector< int16_t > ) ) {
         PRINTER( std::vector< int16_t > );
      } else if( *ti == typeid( std::vector< uint16_t > ) ) {
         PRINTER( std::vector< uint16_t > );
      } else if( *ti == typeid( std::vector< int32_t > ) ) {
         PRINTER( std::vector< int32_t > );
      } else if( *ti == typeid( std::vector< uint32_t > ) ) {
         PRINTER( std::vector< uint32_t > );
      } else if( *ti == typeid( std::vector< int64_t > ) ) {
         PRINTER( std::vector< int64_t > );
      } else if( *ti == typeid( std::vector< uint64_t > ) ) {
         PRINTER( std::vector< uint64_t > );
      } else if( *ti == typeid( std::vector< std::string > ) ) {
         PRINTER( std::vector< std::string > );
      } else if( *ti == typeid( std::vector< std::pair<std::string, std::string> > ) ) {
         using Stringpair_t = std::pair<std::string, std::string>;
         PRINTER( std::vector< Stringpair_t > );
      } else {
         out << "N/A";
      }
 
// Get rid of the temporary macro...
#undef PRINTER
   }
 
   // Return the same stream:
   return out;
}