GaudiUtils Namespace Reference

Namespaces
	details

Classes
class	Allocator
class	AllocatorPool
struct	GenericHash
	Generic hash implementation (for easy migration to the new Hash class). More...
class	Hash
struct	Hash< const Gaudi::ParticleID & >
struct	Hash< const Gaudi::ParticleID >
struct	Hash< const T & >
	remove extra qualifiers: More...
struct	Hash< const T * >
	remove extra qualifiers: More...
struct	Hash< const T >
	remove extra qualifiers: More...
struct	Hash< const T(&)[N]>
	generic specialization for arrays More...
struct	Hash< Gaudi::ParticleID & >
struct	Hash< Gaudi::ParticleID >
struct	Hash< T & >
	remove extra qualifiers: More...
struct	Hash< T * >
	the partial specialization for pointers More...
struct	Hash< T(&)[N]>
	generic specialization for arrays More...
class	HashMap
class	Map
class	VectorMap

Functions
template<class T1 , class T2 >
std::ostream &	operator<< (std::ostream &s, const std::pair< T1, T2 > &p)
	Serialize an std::pair in a python like format. E.g. "(1, 2)". More...
template<class T , class ALLOC >
std::ostream &	operator<< (std::ostream &s, const std::vector< T, ALLOC > &v)
	Serialize an std::vector in a python like format. E.g. "[1, 2, 3]". More...
template<class T , std::size_t N>
std::ostream &	operator<< (std::ostream &s, const std::array< T, N > &v)
	Serialize an std::array in a python like format. E.g. "[1, 2, 3]". More...
template<class T , class ALLOC >
std::ostream &	operator<< (std::ostream &s, const std::list< T, ALLOC > &l)
	Serialize an std::list in a python like format. E.g. "[1, 2, 3]". More...
template<class T1 , class T2 , class COMP , class ALLOC >
std::ostream &	operator<< (std::ostream &s, const std::map< T1, T2, COMP, ALLOC > &m)
	Serialize an std::map in a python like format. E.g. "{a: 1, b: 2}". More...
template<class K , class T , class M >
std::ostream &	operator<< (std::ostream &s, const GaudiUtils::Map< K, T, M > &m)
	Serialize a GaudiUtils::Map in a python like format. E.g. "{a: 1, b: 2}". More...
template<class K , class T , class H , class M >
std::ostream &	operator<< (std::ostream &s, const GaudiUtils::HashMap< K, T, H, M > &m)
	Serialize a GaudiUtils::HashMap in a python like format. E.g. "{a: 1, b: 2}". More...
template<class T , class ALLOC >
std::ostream &	operator<< (std::ostream &s, const std::set< T, ALLOC > &l)
template<class T , class ALLOC >
std::ostream &	operator<< (std::ostream &s, const std::unordered_set< T, ALLOC > &l)

Function Documentation

operator<<() [1/9]

template<class K , class T , class H , class M >

std::ostream & GaudiUtils::operator<<	(	std::ostream &	s,
		const GaudiUtils::HashMap< K, T, H, M > &	m
	)

Serialize a GaudiUtils::HashMap in a python like format. E.g. "{a: 1, b: 2}".

This implementation is not efficient, but very simple.

Anyway a print-out of a hash map is not something that we do every second.

Definition at line 139 of file SerializeSTL.h.

                                                                                  {
    // Copy the hash map into a map to have it ordered by key.
    return s << GaudiUtils::Map<K, T>( m.begin(), m.end() );
  }

operator<<() [2/9]

template<class K , class T , class M >

std::ostream & GaudiUtils::operator<<	(	std::ostream &	s,
		const GaudiUtils::Map< K, T, M > &	m
	)

Serialize a GaudiUtils::Map in a python like format. E.g. "{a: 1, b: 2}".

Definition at line 131 of file SerializeSTL.h.

                                                                           {
    // Serialize the internal map.
    return s << static_cast<const M&>( m );
  }

operator<<() [3/9]

template<class T , std::size_t N>

std::ostream & GaudiUtils::operator<<	(	std::ostream &	s,
		const std::array< T, N > &	v
	)

Serialize an std::array in a python like format. E.g. "[1, 2, 3]".

Definition at line 100 of file SerializeSTL.h.

                                                                   {
    return details::ostream_joiner( s << '[', v, ", " ) << ']';
  }

operator<<() [4/9]

template<class T , class ALLOC >

std::ostream & GaudiUtils::operator<<	(	std::ostream &	s,
		const std::list< T, ALLOC > &	l
	)

Serialize an std::list in a python like format. E.g. "[1, 2, 3]".

Definition at line 105 of file SerializeSTL.h.

                                                                      {
    return details::ostream_joiner( s << '[', l, ", " ) << ']';
  }

operator<<() [5/9]

template<class T1 , class T2 , class COMP , class ALLOC >

std::ostream & GaudiUtils::operator<<	(	std::ostream &	s,
		const std::map< T1, T2, COMP, ALLOC > &	m
	)

Serialize an std::map in a python like format. E.g. "{a: 1, b: 2}".

Definition at line 122 of file SerializeSTL.h.

                                                                                {
    return details::ostream_joiner( s << "{", m, ", ",
                                    []( std::ostream& os, const std::pair<const T1, T2>& p ) -> std::ostream& {
                                      return os << p.first << ": " << p.second;
                                    } )
           << "}";
  }

operator<<() [6/9]

template<class T1 , class T2 >

std::ostream & GaudiUtils::operator<<	(	std::ostream &	s,
		const std::pair< T1, T2 > &	p
	)

Serialize an std::pair in a python like format. E.g. "(1, 2)".

Definition at line 90 of file SerializeSTL.h.

                                                                    {
    return s << '(' << p.first << ", " << p.second << ')';
  }

operator<<() [7/9]

template<class T , class ALLOC >

std::ostream& GaudiUtils::operator<<	(	std::ostream &	s,
		const std::set< T, ALLOC > &	l
	)

Definition at line 110 of file SerializeSTL.h.

                                                                     {
    return details::ostream_joiner( s << '[', l, ", " ) << ']';
  }

operator<<() [8/9]

template<class T , class ALLOC >

std::ostream& GaudiUtils::operator<<	(	std::ostream &	s,
		const std::unordered_set< T, ALLOC > &	l
	)

Definition at line 115 of file SerializeSTL.h.

                                                                               {
    auto ordered = std::set( l.begin(), l.end() ); // ensure reproducible printout
    s << ordered;
    return s;
  }

operator<<() [9/9]

template<class T , class ALLOC >

std::ostream & GaudiUtils::operator<<	(	std::ostream &	s,
		const std::vector< T, ALLOC > &	v
	)

Serialize an std::vector in a python like format. E.g. "[1, 2, 3]".

Definition at line 95 of file SerializeSTL.h.

                                                                        {
    return details::ostream_joiner( s << '[', v, ", " ) << ']';
  }