PackedContainerConverter.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
 
#include "DataModelAthenaPool/PackedContainerConverter.h"
#include "AthContainers/PackedContainer.h"
#include "RootConversions/TConverterRegistry.h"
#include "TMemberStreamer.h"
#include "TClass.h"
#include "TROOT.h"
#include <vector>
#include <string>
#include <cassert>
 
 
namespace DataModelAthenaPool {
 

template <class T, class ALLOC>
void vectorMove (std::vector<T, ALLOC>& src, std::vector<T, ALLOC>& dst)
{
  dst.swap (src);
}
template <class T, class U, class ALLOC>
void vectorMove (std::vector<T, ALLOC>& src, std::vector<U, ALLOC>& dst)
{
  dst.assign (src.begin(), src.end());
}
 

template <class T, class U=T, class ALLOC=std::allocator<T> >
class PackedContainerConverter
  : public TMemberStreamer
{
public:
  PackedContainerConverter (const char* tname,
                            const char* allocName = nullptr);
 

  virtual void operator() (TBuffer& b, void* pmember, Int_t size=0);
 
 
private:
  TClass* m_cl;
};
 

template <class T, class U, class ALLOC>
PackedContainerConverter<T, U, ALLOC>::PackedContainerConverter (const char* tname,
                                                                 const char* allocName /* = nullptr*/)
{
  std::string vname = "vector<";
  vname += tname;
  if (allocName != nullptr) {
    vname += ",";
    vname += allocName;
  }
  if (vname[vname.size()-1] == '>')
    vname += ' ';
  vname += '>';
  m_cl = gROOT->GetClass (vname.c_str());
}
 

template <class T, class U, class ALLOC>
void PackedContainerConverter<T, U, ALLOC>::operator() (TBuffer& b,
                                                        void* pmember, 
                                                        Int_t size /*=0*/)
{
  // This only works for reading!
  assert (b.IsReading());
 
  // The transient object.
  SG::PackedContainer<U, ALLOC>* obj =
    reinterpret_cast<SG::PackedContainer<U, ALLOC>*> (pmember);
 
  // We'll read into this object.
  std::vector<T, ALLOC> tmp;
 
  while (size-- > 0) {
    // Read into tmp and move data to *obj.
    tmp.clear();
    m_cl->Streamer (&tmp, b);
    vectorMove (tmp, *obj);
    ++obj;
  }
}
 

void installPackedContainerConverters()
{
#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> >);
}
 
 
} // namespace DataModelAthenaPool