DataModelAthenaPool Namespace Reference

Classes
class	CLHEPConverters
	Register all CLHEP converters. More...
class	DataVectorConvert
	Provide backwards compatibility for reading DataVector classes. More...
class	PackedContainerConverter
	Converter from std::vector<T,ALLOC> to SG::PackedContainer<U,ALLOC>. More...
class	PointConverter
	Converter for Hep3Vector to Point3D<double>. More...

Functions
void	installPackedContainerConverters ()
	Install converters for supported instantiations.
template<class T, class ALLOC>
void	vectorMove (std::vector< T, ALLOC > &src, std::vector< T, ALLOC > &dst)
	Move from one vector to another.
template<class T, class U, class ALLOC>
void	vectorMove (std::vector< T, ALLOC > &src, std::vector< U, ALLOC > &dst)

Function Documentation

installPackedContainerConverters()

void DataModelAthenaPool::installPackedContainerConverters

(

)

Install converters for supported instantiations.

Definition at line 136 of file PackedContainerConverter.cxx.

{
#define CONVERTER(SRC, DST)                                     \
  do {                                                          \
    TConverterRegistry::Instance()->AddStreamerConverter        \
      ("vector<" #SRC ">", \
       "SG::PackedContainer<" #DST ",allocator<" #DST "> >",       \
       new PackedContainerConverter<SRC, DST> ( #SRC));         \
  } while (0)
 
#define CONVERTER1(T) CONVERTER(T,T)
 
#define CONVERTER2(T, ALLOC)                                    \
  do {                                                          \
    TConverterRegistry::Instance()->AddStreamerConverter        \
      ("vector<" #T "," #ALLOC "<" #T "> >",                    \
       "SG::PackedContainer<" #T "," #ALLOC "<" #T "> >",       \
       new PackedContainerConverter<T, T, ALLOC<T> > ( #T, #ALLOC "<" #T ">" )); \
  } while (0)
 
  
  CONVERTER1(char);
  CONVERTER1(unsigned char);
  CONVERTER1(short);
  CONVERTER1(unsigned short);
  CONVERTER1(int);
  CONVERTER1(unsigned int);
  CONVERTER1(float);
  CONVERTER1(double);
 
  CONVERTER1(std::vector<char>);
  CONVERTER1(std::vector<unsigned char>);
  CONVERTER1(std::vector<short>);
  CONVERTER1(std::vector<unsigned short>);
  CONVERTER1(std::vector<int>);
  CONVERTER1(std::vector<unsigned int>);
  CONVERTER1(std::vector<float>);
  CONVERTER1(std::vector<double>);
 
  CONVERTER1(std::vector<std::vector<char> >);
  CONVERTER1(std::vector<std::vector<unsigned char> >);
  CONVERTER1(std::vector<std::vector<short> >);
  CONVERTER1(std::vector<std::vector<unsigned short> >);
  CONVERTER1(std::vector<std::vector<int> >);
  CONVERTER1(std::vector<std::vector<unsigned int> >);
  CONVERTER1(std::vector<std::vector<float> >);
  CONVERTER1(std::vector<std::vector<double> >);
}

vectorMove() [1/2]

template<class T, class ALLOC>

void DataModelAthenaPool::vectorMove	(	std::vector< T, ALLOC > &	src,
		std::vector< T, ALLOC > &	dst )

Move from one vector to another.

Parameters

src	Source vector. Destroyed by the move.
dst	Destination vector.

If the types of src and dst are the same, then just do a move. Otherwise, copy.

Definition at line 35 of file PackedContainerConverter.cxx.

{
  dst.swap (src);
}

vectorMove() [2/2]

template<class T, class U, class ALLOC>

void DataModelAthenaPool::vectorMove	(	std::vector< T, ALLOC > &	src,
		std::vector< U, ALLOC > &	dst )

Definition at line 40 of file PackedContainerConverter.cxx.

{
  dst.assign (src.begin(), src.end());
}