PrintHelpers.cxx File Reference

#include <cstdint>
#include <iostream>
#include "AthContainers/AuxElement.h"
#include "AthContainers/AuxTypeRegistry.h"
#include "AthContainers/tools/AtomicConstAccessor.h"
#include "xAODCore/tools/PrintHelpers.h"

Include dependency graph for PrintHelpers.cxx:

Go to the source code of this file.

Classes
struct	PrintHelpers::VecPrintType< T >
struct	PrintHelpers::VecPrintType< char >
struct	PrintHelpers::VecPrintType< int8_t >
struct	PrintHelpers::VecPrintType< uint8_t >

Namespaces
namespace	PrintHelpers
namespace	xAOD
	ICaloAffectedTool is abstract interface for tools checking if 4 mom is in calo affected region.

Macros
#define	PRINTER(TYPE)

Functions
template<typename T, typename U>
std::ostream &	operator<< (std::ostream &out, const std::pair< T, U > &p)
template<typename T>
std::ostream &	operator<< (std::ostream &out, const std::vector< T > &vec)
	Helper operator to pretty-print the values of vectors.
std::ostream &	operator<< (std::ostream &out, const SG::AuxElement &obj)
	Operator printing the payload of an xAOD object.
void	xAOD::dump (const SG::AuxElement &obj)
	Helper function for dumping xAOD objects on the screen in PyROOT.

Macro Definition Documentation

PRINTER

#define PRINTER

(

TYPE

)

Value:

      do {                                                        \
         SG::ConstAccessor< TYPE > acc( auxid );                  \
         if( acc.isAvailable( obj ) ) {                           \
            out << acc( obj );                                    \
         }                                                        \
      } while( 0 )

Function Documentation

operator<<() [1/3]

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

operator<<() [2/3]

template<typename T, typename U>

std::ostream & operator<<	(	std::ostream &	out,
		const std::pair< T, U > &	p )

Definition at line 40 of file PrintHelpers.cxx.

                                                                     {
  out << "(";
  out << static_cast<typename PrintHelpers::VecPrintType<T>::type> (p.first);
  out << ", ";
  out << static_cast<typename PrintHelpers::VecPrintType<U>::type> (p.second);
  out << ")";
  return out;
}

operator<<() [3/3]

template<typename T>

std::ostream & operator<<	(	std::ostream &	out,
		const std::vector< T > &	vec )

Helper operator to pretty-print the values of vectors.

Definition at line 51 of file PrintHelpers.cxx.

                                                                      {
 
   out << "[";
   for( size_t i = 0; i < vec.size(); ++i ) {
      out << static_cast<typename PrintHelpers::VecPrintType<T>::type> (vec[ i ]);
      if( i < vec.size() - 1 ) {
         out << ", ";
      }
   }
   out << "]";
 
   // Return the same stream:
   return out;
}