---

CdbBdbNTupleConversionRules.hh

Go to the documentation of this file.

#ifndef CDBBDBTABLE_NTUPLE_CONVERSION_RULES_HH
#define CDBBDBTABLE_NTUPLE_CONVERSION_RULES_HH

// File and Version Information:
//      $Id: CdbBdbNTupleConversionRules.hh,v 1.3 2005/01/19 10:10:00 gapon Exp $

#include "BdbUtil/Bdb.hh"   // to bring in Objy 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 CdbBdbNTupleConversionRules_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 CdbBdbNTupleConversionReverseRules_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++
/**
  * Accordint to Objectivity/DDL documentation the 'long' type is 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', which would confuse DDL compiler. The DDL won't be able to map
  * this type any any of known elementary persistent types of predefined width.
  *
  * SOLUTION: Map C++ 'long' into DDL 'long long', which is known to DDL as 64 bit type.
  */
template <>
struct CdbBdbNTupleConversionRules_Default<long> {

    typedef long      Transient;
    typedef long long 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 CdbBdbNTupleConversionReverseRules_Default<long long> {

    typedef long      Transient;
    typedef long long 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 CdbBdbNTupleConversionRules_Default<long>
  */
template <>
struct CdbBdbNTupleConversionRules_Default<unsigned long> {

    typedef unsigned long      Transient;
    typedef unsigned long long 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 CdbBdbNTupleConversionReverseRules_Default<unsigned long long> {

    typedef unsigned long      Transient;
    typedef unsigned long long 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 std::string type of C++
/**
  * This class will be used to map STD strings into OO strings to avoid
  * any attempts to use STD strings in the persistent schema (which would be a really
  * terrible idea given different implementation of STD strings on various compliter/library
  * platforms.
  */
template <>
struct CdbBdbNTupleConversionRules_Default< std::string > {

    typedef std::string Transient;
    typedef ooVString   Persistent;

    static const ooVString   to_persistent( const std::string& value ) { return ooVString  ( value.c_str( )); }
    static const std::string to_transient ( const ooVString&   value ) { return std::string( value.head( ));  }
};

template <>
struct CdbBdbNTupleConversionReverseRules_Default< ooVString > {

    typedef std::string Transient;
    typedef ooVString   Persistent;

    static const ooVString   to_persistent( const std::string& value ) { return ooVString  ( value.c_str( )); }
    static const std::string to_transient ( const ooVString&   value ) { return std::string( value.head( ));  }
};

/// 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 CdbBdbNTupleConversionRules_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 CdbBdbNTupleConversionRules_UseDefault {
};

#endif // CDBBDBTABLE_NTUPLE_CONVERSION_RULES_HH

---