---

CdbRooNTupleConversionRules.hh

Go to the documentation of this file.

#ifndef CDBROOTABLE_NTUPLE_CONVERSION_RULES_HH
#define CDBROOTABLE_NTUPLE_CONVERSION_RULES_HH

// File and Version Information:
//      $Id: CdbRooNTupleConversionRules.hh,v 1.3 2005/01/13 15:04:44 gapon Exp $

#include <Rtypes.h>   // to bring in ROOT I/O data types

#include "CdbBase/CdbCommon.hh"

#include <string>

/// The default "persistent/transient" conversion rules for elements of tuples
/**
  * This pseudo-converter can be applied for any types of elements. This converter
  * is used by default when converting tuples between the transient and persistent
  * forms.
  *
  * The only template parameter of the class is a transient type of elements.
  *
  * There is also a number of specializations of the facility (see below). They'll
  * be used for types requiering nono-trivial conversion or because of lack of
  * implicit conversion supplied with the compiler or user classes.
  */
template < class T >
struct CdbRooNTupleConversionRules_Default {

    typedef T Transient;
    typedef T Persistent;

    static const Persistent& to_persistent( const Transient&  value ) { return value; }
    static const Transient&  to_transient ( const Persistent& value ) { return value; }
};

/// The default "persistent/transient" conversion rules for elements of tuples (complementary)
/**
  * This is a complementary facility whose template parameter is a persistent type of elements.
  * This class can be used to derive a persistent type for the specified persistent one,
  * when when the actual transient type is not known.
  *
  * The specializations are also available.
  */
template < class P >
struct CdbRooNTupleConversionReverseRules_Default {

    typedef P Transient;
    typedef P Persistent;

    static const Persistent& to_persistent( const Transient&  value ) { return value; }
    static const Transient&  to_transient ( const Persistent& value ) { return value; }
};

/// The specialization for platform dependent "long" type of C++
/**
  * According to ROOT I/O documentation (see the "Rtypes.h" header file) the "long" time
  * is not portable one. Foe example it translates as 32 bit integer on all platforms
  * except DEC Alpha. And it's 64 bit integer on DEC Alpha.
  *
  * In GNU C++ compiler (at least before and including 2.95.3) the 'long' is typedef-ed
  * as 'long int',
  *
  * SOLUTION: Map C++ 'long' into a portable 'Long64_t', which has 64-bits in its width.
  */
/*
 * ATTENTION: This type does not seem to be supprted by ROOT I/O.
 *
template <>
struct CdbRooNTupleConversionRules_Default<long> {

    typedef long     Transient;
    typedef Long64_t Persistent;

    static const Persistent to_persistent( const Transient&  value ) { return (Persistent)value; }
    static const Transient  to_transient ( const Persistent& value ) { return (Transient)value; }
};
template <>
struct CdbRooNTupleConversionReverseRules_Default<Long64_t> {

    typedef long     Transient;
    typedef Long64_t Persistent;

    static const Persistent to_persistent( const Transient&  value ) { return (Persistent)value; }
    static const Transient  to_transient ( const Persistent& value ) { return (Transient)value; }
};
*/

/// The specialization for platform dependent "unsigned long" type of C++
/**
  * @see class CdbRooNTupleConversionRules_Default<long>
  */
/*
 * ATTENTION: This type does not seem to be supprted by ROOT I/O.
 *
template <>
struct CdbRooNTupleConversionRules_Default<unsigned long> {

    typedef unsigned long Transient;
    typedef ULong64_t     Persistent;

    static const Persistent to_persistent( const Transient&  value ) { return (Persistent)value; }
    static const Transient  to_transient ( const Persistent& value ) { return (Transient)value; }
};
template <>
struct CdbRooNTupleConversionReverseRules_Default<ULong64_t> {

    typedef unsigned long Transient;
    typedef ULong64_t     Persistent;

    static const Persistent to_persistent( const Transient&  value ) { return (Persistent)value; }
    static const Transient  to_transient ( const Persistent& value ) { return (Transient)value; }
};
*/

/// The non-trivial "persistent/transient" converter for elements of tuples
/**
  * This converter will use type cast operator to convert values of elements.
  */
template < class T,
           class P >
struct CdbRooNTupleConversionRules_Explicit {

    typedef T Transient;
    typedef P Persistent;

    static Persistent to_persistent( const Transient&  value ) { return (Persistent)value; }
    static Transient  to_transient ( const Persistent& value ) { return (Transient)value; }
};

/// A trivial class used to turn on the default element conversion rules

class CdbRooNTupleConversionRules_UseDefault {
};

#endif // CDBROOTABLE_NTUPLE_CONVERSION_RULES_HH

---