Data.hh

Go to the documentation of this file.

//======================================================================
/*! \file Data.hh
 *
 *  Déclaration des méthodes de la classe Data qui est une classe
 *  générique pour les type de données.
 */
//======================================================================

#ifndef DATA_HH
#define DATA_HH

// contient la définition des types
#include "EventCommon.hh"
#include "Tools.hh"

//----------------------------------------------------------------------
// résultat des conversions de données
#define   DATA_NO_CAST       0x00000000   ///<  Bits d'état d'une donnée: pas de conversion
#define   DATA_VALID_CAST    0x00000001   ///<  Bits d'état d'une donnée: conversion acceptée
#define   DATA_BAD_CAST      0x80000000   ///<  Bits d'état d'une donnée: conversion incorrecte
#define   DATA_BIT_CUT       0x80000001   ///<  Bits d'état d'une donnée: troncation de bits utilisés
#define   DATA_SIGN_FLIP     0x80000002   ///<  Bits d'état d'une donnée: changement effectif de signe
#define   DATA_UNKNOWN       0x80000004   ///<  Bits d'état d'une donnée: type de données incorrect
#define   DATA_INVALID       0x80000008   ///<  Bits d'état d'une donnée: donnée loufoque
#define   DATA_BAD           0x80000000   ///<  Bits d'état d'une donnée: donnée inutilisable
#define   DATA_NO_DATA       0xFFFFFFFF   ///<  Bits d'état d'une donnée: singleton de DataBad

//----------------------------------------------------------------------
// bits de définition des types numériques
#define   DATA_TYPE_REAL     0x00010000   ///<  Type d'une donnée: bit 16 = 1: donnée de type réel
#define   DATA_TYPE_UNSIGNED 0x00001000   ///<  Type d'une donnée: bit 12 = 1: donnée de type non signéesP
#define   DATA_TYPE_16B      0x00000001   ///<  Type d'une donnée: bits 0 = 0 et bit 1 = 1: donnée sur 16 bits
#define   DATA_TYPE_32B      0x00000002   ///<  Type d'une donnée: bits 0 = 1 et bit 1 = 0: donnée sur 32 bits
#define   DATA_TYPE_64B      0x00000003   ///<  Type d'une donnée: bits 0 = 1 et bit 1 = 1: donnée sur 64 bits

/// Bits de définition des types numériques
enum DataTypeFlags
{
  dataTypeReal     = 0x00010000,  // Type d'une donnée: bit 16 = 1: donnée de type réel
  dataTypeUnsigned = 0x00001000,  // Type d'une donnée: bit 12 = 1: donnée de type non signée  dataType16b      = 0x00000001,  // Type d'une donnée: bits 0 = 0 et bit 1 = 1: donnée sur 16 bits
  dataType32b      = 0x00000002,  // Type d'une donnée: bits 0 = 1 et bit 1 = 0: donnée sur 32 bits
  dataType64b      = 0x00000003   // Type d'une donnée: bits 0 = 1 et bit 1 = 1: donnée sur 64 bits
};

//----------------------------------------------------------------------
#define   DATA_TYPE_UNDEFINED 0                                     ///< bits pour type de donnée inconnu
#define   DATA_TYPE_U_INT2    (DATA_TYPE_UNSIGNED | DATA_TYPE_16B)  ///< bits spécifiant le type de donnée
#define   DATA_TYPE_U_INT4    (DATA_TYPE_UNSIGNED | DATA_TYPE_32B)  ///< bits spécifiant le type de donnée
#define   DATA_TYPE_U_INT8    (DATA_TYPE_UNSIGNED | DATA_TYPE_64B)  ///< bits spécifiant le type de donnée
#define   DATA_TYPE_INT2      (DATA_TYPE_16B)                       ///< bits spécifiant le type de donnée
#define   DATA_TYPE_INT4      (DATA_TYPE_32B)                       ///< bits spécifiant le type de donnée
#define   DATA_TYPE_INT8      (DATA_TYPE_64B)                       ///< bits spécifiant le type de donnée
#define   DATA_TYPE_REAL4     (DATA_TYPE_REAL | DATA_TYPE_32B)      ///< bits spécifiant le type de donnée
#define   DATA_TYPE_REAL8     (DATA_TYPE_REAL | DATA_TYPE_64B)      ///< bits spécifiant le type de donnée

/// Définition des types numériques
enum ParamDataTypes
{
  dataTypeUndefined = 0,                                  // bits pour type de donnée inconnu
  dataTypeUInt2     = (dataTypeUnsigned | dataType16b),   // bits spécifiant le type de donnée
  dataTypeUInt4     = (dataTypeUnsigned | dataType32b),   // bits spécifiant le type de donnée
  dataTypeUInt8     = (dataTypeUnsigned | dataType64b),   // bits spécifiant le type de donnée
  dataTypeInt2      = (dataType16b),                      // bits spécifiant le type de donnée
  dataTypeInt4      = (dataType32b),                      // bits spécifiant le type de donnée
  dataTypeInt8      = (dataType64b),                      // bits spécifiant le type de donnée
  dataTypeReal4     = (dataTypeReal | dataType32b),       // bits spécifiant le type de donnée
  dataTypeReal8     = (dataTypeReal | dataType64b)        // bits spécifiant le type de donnée
};

//----------------------------------------------------------------------
#define   DATA_TYPE_TXT_UNDEFINED  "???"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT2     "U*2"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT4     "U*4"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT8     "U*8"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_INT2       "I*2"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_INT4       "I*4"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_INT8       "I*8"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_REAL4      "R*4"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_REAL8      "R*8"   ///< identifiant texte du type de donnée

//----------------------------------------------------------------------
const U_Int2  DATA_UI2_MAX  =  0xFFFF;      ///< valeur maxi pour conversion d'un entier
const Int2    DATA_I2_MIN   =  -32768;      ///< valeur mini pour conversion d'un entier
const Int2    DATA_I2_MAX   =   32767;      ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI2_RMAX =  65535.;      ///< valeur mini pour conversion d'un entier
const Real8   DATA_I2_RMIN  = -32768.;      ///< valeur mini pour conversion d'un réel
const Real8   DATA_I2_RMAX  =  32767.;      ///< valeur maxi pour conversion d'un réel

const U_Int2  DATA_UI2_SIGN = (DATA_UI2_MAX-DATA_I2_MAX); ///< Bit de signe 16 bits

//----------------------------------------------------------------------
const U_Int4  DATA_UI4_MAX  =  0xFFFFFFFF;  ///< valeur maxi pour conversion d'un entier
const Int4    DATA_I4_MIN   =  0x80000000;  ///< valeur mini pour conversion d'un entier
const Int4    DATA_I4_MAX   =  0x7FFFFFFF;  ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI4_RMAX =  4294967295.; ///< valeur mini pour conversion d'un entier
const Real8   DATA_I4_RMIN  = -2147483648.; ///< valeur mini pour conversion d'un réel
const Real8   DATA_I4_RMAX  =  2147483647.; ///< valeur maxi pour conversion d'un réel

const U_Int4  DATA_UI4_SIGN = (DATA_UI4_MAX-DATA_I4_MAX);   ///< Bit de signe 32 bits
const U_Int4  DATA_UI4_HI16 = (DATA_UI4_MAX-DATA_UI2_MAX);  ///< Masque binaire 16 bits forts sur 32 bits

//----------------------------------------------------------------------
// récupéré dans les includes de root
#ifndef __MAKECINT__
const U_Int8  DATA_UI8_MAX  = kMaxULong64;              ///< valeur maxi pour conversion d'un entier
const Int8    DATA_I8_MAX   = kMaxLong64;               ///< valeur mini pour conversion d'un entier
const Int8    DATA_I8_MIN   = kMinLong64;               ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI8_RMAX = Double_t(DATA_UI8_MAX);   ///< valeur mini pour conversion d'un entier
const Real8   DATA_I8_RMAX  = Double_t(DATA_I8_MAX);    ///< valeur mini pour conversion d'un réel
const Real8   DATA_I8_RMIN  = Double_t(DATA_I8_MIN);    ///< valeur maxi pour conversion d'un réel

const U_Int8  DATA_UI8_SIGN = (DATA_UI8_MAX-DATA_I8_MAX);   ///< Bit de signe 64 bits
const U_Int8  DATA_UI8_HI16 = (DATA_UI8_MAX-DATA_UI4_MAX);  ///< Masque binaire 16 bits forts sur 32 bits
const U_Int8  DATA_UI8_HI24 = (DATA_UI8_MAX-DATA_UI2_MAX);  ///< Masque binaire 24 bits forts sur 32 bits
#endif

/* NON IMPLEMENTE !!!
#define   DATA_I8_RMIN     -9223372036854775808.
#define   DATA_I8_RMAX      9223372036854775807.
#define   DATA_I8_MIN      -9223372036854775808
#define   DATA_I8_MAX       9223372036854775807
#define   DATA_UI8_RMAX     18446744065119617025.
#define   DATA_UI8_MAX      18446744065119617025
*/

//class Param;

//======================================================================
/*! \class Data
 *
 *  Classe générique (abstraite) pour les types de données.
 *  Ce sont les classes dérivées qui peuvent être instanciées: elles
 *  ont un type de données spécifique, qui ne peut pas être modifié !
 *  \note:
 *    - Les opérateurs d'affectation de valeurs numériques sont virtuels.
 *    - Pour les comparaison, il faut effectuer un cast.
 *    - Les objets dérivés de la classe Data n'ont pas vocation à
 *      être déclarés constant, parce qu'ils peuvent être modifiés
 *      (mot d'état) lorsqu'ils sont copiés ou affectés.
 *    - Les méthodes de cast vers les types numériques sont définis
 *      une fois pour toutes par une méthode patron de la classe de
 *      base Data, par un appel aux méthodes virtuelles GetValue.
 *    - Les méthodes GetValue, SetValue et l'opérateur d'affection
 *      doivent être définis dans les classes dérivées pour l'ensemble
 *      des types de valeurs considérés.
 *
 *  Les objets de la classe Data (et de ses dérivées) gèrent automatiquement
 *  les changements de type. Dans ce cas, le mot d'état (status) rend
 *  compte des difficultés ou impossibilités de conversions.
 *
 */
class Data
{
//----------------------------------------------------------------------
  /*! \object_doc */
  GObjectV(Data);
//----------------------------------------------------------------------

  protected:

    static  u_int   len;    ///<  Longueur d'affichage
    static  u_int   prec;   ///<  Précision d'affichage
    static  char    fill;   ///<  Caractère de remplissage
    static  string  undef;  ///<  Chaîne pour l'écriture de donnée non valide

    int   status;           ///<  Indicateur de l'état des conversions de types

  public:

//----------------------------------------------------------------------
//  CONSTRUCTEUR / AFFECTATION / DESTRUCTEUR
//----------------------------------------------------------------------

    //  Constructeur
    Data ( );

    //  Constructeur de recopie
    Data ( const Data &d );

    //  Destructeur
    virtual ~Data ( );

//----------------------------------------------------------------------

  public:

    /*! Méthode qui fixe la longueur d'écriture en format texte.
     *  \param  l   longueur du format
     */
    static  inline void  SetLen  ( u_int l )
      {
        len = l;
        if (undef.length() < len)
          undef = string(len-undef.length(),' ') + undef;
      }

    /*! Méthode qui fixe la précision d'écriture en format texte.
     *  \param  p   précision du format
     */
    static  inline void  SetPrec ( u_int p ) { prec = p; }

    /*! Méthode qui fixe le caractère de remplissage en format texte.
     *  \param  c   caractère de remplissage
     */
    static  inline void  SetFill ( char c )  { fill = c; }

    /*! Méthode qui fixe la chaîne de caractères pour l'écriture
     *  d'une donnée non valide.
     *  \param  str   chaîne à écrire
     */
    static  inline void  SetFill ( const string &str )  { undef = str; }

    // retourne une donnée non valide
    static  Data & Bad();

//----------------------------------------------------------------------

    /*! Opérateur d'affectation d'une autre donnée.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Data & d ) { return (*this); }

    /*! Opérateur d'affectation d'une valeur de type entier 16 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int2 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 16 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int2 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 32 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 64 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real8 & d ) = 0;


//----------------------------------------------------------------------

    /*! Méthode virtuelle pure qui renvoit un identificateur de type
     * de données.
     */
    virtual u_int   TypeId ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant le type
     *  de données.
     */
    virtual string   Type ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant la valeur.
     */
    virtual string   String ( ) const = 0;

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données et la valeur.
     */
    inline virtual  string   Text ( ) const
    {
      return (string("(") + Type() + ") " + String());
    }

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données, la valeur et le mot d'état.
     */
    inline virtual  string   FullText ( ) const
    {
      return (Text() + " status = 0x" + GGetStringHexa((U_Int4) status));
    }

//----------------------------------------------------------------------
//  OPERATEURS DE CAST
//----------------------------------------------------------------------

    /*! Patron pour opérateur de cast vers différents types de
     *  données.
     */
    template < class T >  operator T  (void) const
      { T result; GetValue (result); return (result); }

//----------------------------------------------------------------------
    /*! Mise à valeur à l'aide d'un entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int2 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int4 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int8 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int2   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int4   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int8   &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real4  &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real8  &val ) = 0;

//----------------------------------------------------------------------

    /*! Affectation d'une variable de type entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int2 &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int4 &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int8 &val ) const = 0;

    /*! Affectation d'une variable de type entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

  dataType16b      = 0x00000001,  // Type d'une donnée: bits 0 = 0 et bit 1 = 1: donnée sur 16 bits
  dataType32b      = 0x00000002,  // Type d'une donnée: bits 0 = 1 et bit 1 = 0: donnée sur 32 bits
  dataType64b      = 0x00000003   // Type d'une donnée: bits 0 = 1 et bit 1 = 1: donnée sur 64 bits
};

//----------------------------------------------------------------------
#define   DATA_TYPE_UNDEFINED 0                                     ///< bits pour type de donnée inconnu
#define   DATA_TYPE_U_INT2    (DATA_TYPE_UNSIGNED | DATA_TYPE_16B)  ///< bits spécifiant le type de donnée]*
#define   DATA_TYPE_U_INT4    (DATA_TYPE_UNSIGNED | DATA_TYPE_32B)  ///< bits spécifiant le type de donnée4
#define   DATA_TYPE_U_INT8    (DATA_TYPE_UNSIGNED | DATA_TYPE_64B)  ///< bits spécifiant le type de donnée]*
#define   DATA_TYPE_INT2      (DATA_TYPE_16B)                       ///< bits spécifiant le type de donnée]*
#define   DATA_TYPE_INT4      (DATA_TYPE_32B)                       ///< bits spécifiant le type de donnéead5852d9e@
#define   DATA_TYPE_INT8      (DATA_TYPE_64B)                       ///< bits spécifiant le type de donnée]*
#define   DATA_TYPE_REAL4     (DATA_TYPE_REAL | DATA_TYPE_32B)      ///< bits spécifiant le type de donnée]*
#define   DATA_TYPE_REAL8     (DATA_TYPE_REAL | DATA_TYPE_64B)      ///< bits spécifiant le type de donnée4

/// Définition des types numériques
enum ParamDataTypes
{
  dataTypeUndefined = 0,                                  // bits pour type de donnée inconnu
  dataTypeUInt2     = (dataTypeUnsigned | dataType16b),   // bits spécifiant le type de donnée  dataTypeUInt4     = (dataTypeUnsigned | dataType32b),   // bits spécifiant le type de donnée
  dataTypeUInt8     = (dataTypeUnsigned | dataType64b),   // bits spécifiant le type de donnée
  dataTypeInt2      = (dataType16b),                      // bits spécifiant le type de donnée
  dataTypeInt4      = (dataType32b),                      // bits spécifiant le type de donnée
  dataTypeInt8      = (dataType64b),                      // bits spécifiant le type de donnée
  dataTypeReal4     = (dataTypeReal | dataType32b),       // bits spécifiant le type de donnée
  dataTypeReal8     = (dataTypeReal | dataType64b)        // bits spécifiant le type de donnée
};

//----------------------------------------------------------------------
#define   DATA_TYPE_TXT_UNDEFINED  "???"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT2     "U*2"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT4     "U*4"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT8     "U*8"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_INT2       "I*2"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_INT4       "I*4"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_INT8       "I*8"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_REAL4      "R*4"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_REAL8      "R*8"   ///< identifiant texte du type de donnée

//----------------------------------------------------------------------
const U_Int2  DATA_UI2_MAX  =  0xFFFF;      ///< valeur maxi pour conversion d'un entier
const Int2    DATA_I2_MIN   =  -32768;      ///< valeur mini pour conversion d'un entier
const Int2    DATA_I2_MAX   =   32767;      ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI2_RMAX =  65535.;      ///< valeur mini pour conversion d'un entier
const Real8   DATA_I2_RMIN  = -32768.;      ///< valeur mini pour conversion d'un réel
const Real8   DATA_I2_RMAX  =  32767.;      ///< valeur maxi pour conversion d'un réel

const U_Int2  DATA_UI2_SIGN = (DATA_UI2_MAX-DATA_I2_MAX); ///< Bit de signe 16 bits

//----------------------------------------------------------------------
const U_Int4  DATA_UI4_MAX  =  0xFFFFFFFF;  ///< valeur maxi pour conversion d'un entier
const Int4    DATA_I4_MIN   =  0x80000000;  ///< valeur mini pour conversion d'un entier
const Int4    DATA_I4_MAX   =  0x7FFFFFFF;  ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI4_RMAX =  4294967295.; ///< valeur mini pour conversion d'un entier
const Real8   DATA_I4_RMIN  = -2147483648.; ///< valeur mini pour conversion d'un réel
const Real8   DATA_I4_RMAX  =  2147483647.; ///< valeur maxi pour conversion d'un réel

const U_Int4  DATA_UI4_SIGN = (DATA_UI4_MAX-DATA_I4_MAX);   ///< Bit de signe 32 bits
const U_Int4  DATA_UI4_HI16 = (DATA_UI4_MAX-DATA_UI2_MAX);  ///< Masque binaire 16 bits forts sur 32 bits

//----------------------------------------------------------------------
// récupéré dans les includes de root
#ifndef __MAKECINT__
const U_Int8  DATA_UI8_MAX  = kMaxULong64;              ///< valeur maxi pour conversion d'un entier
const Int8    DATA_I8_MAX   = kMaxLong64;               ///< valeur mini pour conversion d'un entier
const Int8    DATA_I8_MIN   = kMinLong64;               ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI8_RMAX = Double_t(DATA_UI8_MAX);   ///< valeur mini pour conversion d'un entier
const Real8   DATA_I8_RMAX  = Double_t(DATA_I8_MAX);    ///< valeur mini pour conversion d'un réel
const Real8   DATA_I8_RMIN  = Double_t(DATA_I8_MIN);    ///< valeur maxi pour conversion d'un réel

const U_Int8  DATA_UI8_SIGN = (DATA_UI8_MAX-DATA_I8_MAX);   ///< Bit de signe 64 bits
const U_Int8  DATA_UI8_HI16 = (DATA_UI8_MAX-DATA_UI4_MAX);  ///< Masque binaire 16 bits forts sur 32 bits
const U_Int8  DATA_UI8_HI24 = (DATA_UI8_MAX-DATA_UI2_MAX);  ///< Masque binaire 24 bits forts sur 32 bits
#endif

/* NON IMPLEMENTE !!!
#define   DATA_I8_RMIN     -9223372036854775808.
#define   DATA_I8_RMAX      9223372036854775807.
#define   DATA_I8_MIN      -9223372036854775808
#define   DATA_I8_MAX       9223372036854775807
#define   DATA_UI8_RMAX     18446744065119617025.
#define   DATA_UI8_MAX      18446744065119617025
*/

//class Param;

//======================================================================
/*! \class Data
 *
 *  Classe générique (abstraite) pour les types de données.
 *  Ce sont les classes dérivées qui peuvent être instanciées: elles
 *  ont un type de données spécifique, qui ne peut pas être modifié !
 *  \note:
 *    - Les opérateurs d'affectation de valeurs numériques sont virtuels.
 *    - Pour les comparaison, il faut effectuer un cast.
 *    - Les objets dérivés de la classe Data n'ont pas vocation à
 *      être déclarés constant, parce qu'ils peuvent être modifiés
 *      (mot d'état) lorsqu'ils sont copiés ou affectés.
 *    - Les méthodes de cast vers les types numériques sont définis
 *      une fois pour toutes par une méthode patron de la classe de
 *      base Data, par un appel aux méthodes virtuelles GetValue.
 *    - Les méthodes GetValue, SetValue et l'opérateur d'affection
 *      doivent être définis dans les classes dérivées pour l'ensemble
 *      des types de valeurs considérés.
 *
 *  Les objets de la classe Data (et de ses dérivées) gèrent automatiquement
 *  les changements de type. Dans ce cas, le mot d'état (status) rend
 *  compte des difficultés ou impossibilités de conversions.
 *
 */
class Data
{
//----------------------------------------------------------------------
  /*! \object_doc */
  GObjectV(Data);
//----------------------------------------------------------------------

  protected:

    static  u_int   len;    ///<  Longueur d'affichage
    static  u_int   prec;   ///<  Précision d'affichage
    static  char    fill;   ///<  Caractère de remplissage
    static  string  undef;  ///<  Chaîne pour l'écriture de donnée non valide

    int   status;           ///<  Indicateur de l'état des conversions de types

  public:

//----------------------------------------------------------------------
//  CONSTRUCTEUR / AFFECTATION / DESTRUCTEUR
//----------------------------------------------------------------------

    //  Constructeur
    Data ( );

    //  Constructeur de recopie
    Data ( const Data &d );

    //  Destructeur
    virtual ~Data ( );

//----------------------------------------------------------------------

  public:

    /*! Méthode qui fixe la longueur d'écriture en format texte.
     *  \param  l   longueur du format
     */
    static  inline void  SetLen  ( u_int l )
      {
        len = l;
        if (undef.length() < len)
          undef = string(len-undef.length(),' ') + undef;
      }

    /*! Méthode qui fixe la précision d'écriture en format texte.
     *  \param  p   précision du format
     */
    static  inline void  SetPrec ( u_int p ) { prec = p; }

    /*! Méthode qui fixe le caractère de remplissage en format texte.
     *  \param  c   caractère de remplissage
     */
    static  inline void  SetFill ( char c )  { fill = c; }

    /*! Méthode qui fixe la chaîne de caractères pour l'écriture
     *  d'une donnée non valide.
     *  \param  str   chaîne à écrire
     */
    static  inline void  SetFill ( const string &str )  { undef = str; }

    // retourne une donnée non valide
    static  Data & Bad();

//----------------------------------------------------------------------

    /*! Opérateur d'affectation d'une autre donnée.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Data & d ) { return (*this); }

    /*! Opérateur d'affectation d'une valeur de type entier 16 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int2 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 16 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int2 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 32 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 64 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real8 & d ) = 0;


//----------------------------------------------------------------------

    /*! Méthode virtuelle pure qui renvoit un identificateur de type
     * de données.
     */
    virtual u_int   TypeId ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant le type
     *  de données.
     */
    virtual string   Type ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant la valeur.
     */
    virtual string   String ( ) const = 0;

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données et la valeur.
     */
    inline virtual  string   Text ( ) const
    {
      return (string("(") + Type() + ") " + String());
    }

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données, la valeur et le mot d'état.
     */
    inline virtual  string   FullText ( ) const
    {
      return (Text() + " status = 0x" + GGetStringHexa((U_Int4) status));
    }

//----------------------------------------------------------------------
//  OPERATEURS DE CAST
//----------------------------------------------------------------------

    /*! Patron pour opérateur de cast vers différents types de
     *  données.
     */
    template < class T >  operator T  (void) const
      { T result; GetValue (result); return (result); }

//----------------------------------------------------------------------
    /*! Mise à valeur à l'aide d'un entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int2 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int4 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int8 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int2   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int4   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int8   &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real4  &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real8  &val ) = 0;

//----------------------------------------------------------------------

    /*! Affectation d'une variable de type entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int2 &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int4 &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int8 &val ) const = 0;

    /*! Affectation d'une variable de type entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

  dataTypeUInt4     = (dataTypeUnsigned | dataType32b),   // bits spécifiant le type de donnée  dataTypeUInt8     = (dataTypeUnsigned | dataType64b),   // bits spécifiant le type de donnée
  dataTypeInt2      = (dataType16b),                      // bits spécifiant le type de donnée
  dataTypeInt4      = (dataType32b),                      // bits spécifiant le type de donnée
  dataTypeInt8      = (dataType64b),                      // bits spécifiant le type de donnée
  dataTypeReal4     = (dataTypeReal | dataType32b),       // bits spécifiant le type de donnée
  dataTypeReal8     = (dataTypeReal | dataType64b)        // bits spécifiant le type de donnée
};

//----------------------------------------------------------------------
#define   DATA_TYPE_TXT_UNDEFINED  "???"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT2     "U*2"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT4     "U*4"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT8     "U*8"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_INT2       "I*2"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_INT4       "I*4"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_INT8       "I*8"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_REAL4      "R*4"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_REAL8      "R*8"   ///< identifiant texte du type de donnée

//----------------------------------------------------------------------
const U_Int2  DATA_UI2_MAX  =  0xFFFF;      ///< valeur maxi pour conversion d'un entier
const Int2    DATA_I2_MIN   =  -32768;      ///< valeur mini pour conversion d'un entier
const Int2    DATA_I2_MAX   =   32767;      ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI2_RMAX =  65535.;      ///< valeur mini pour conversion d'un entier
const Real8   DATA_I2_RMIN  = -32768.;      ///< valeur mini pour conversion d'un réel
const Real8   DATA_I2_RMAX  =  32767.;      ///< valeur maxi pour conversion d'un réel

const U_Int2  DATA_UI2_SIGN = (DATA_UI2_MAX-DATA_I2_MAX); ///< Bit de signe 16 bits

//----------------------------------------------------------------------
const U_Int4  DATA_UI4_MAX  =  0xFFFFFFFF;  ///< valeur maxi pour conversion d'un entier
const Int4    DATA_I4_MIN   =  0x80000000;  ///< valeur mini pour conversion d'un entier
const Int4    DATA_I4_MAX   =  0x7FFFFFFF;  ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI4_RMAX =  4294967295.; ///< valeur mini pour conversion d'un entier
const Real8   DATA_I4_RMIN  = -2147483648.; ///< valeur mini pour conversion d'un réel
const Real8   DATA_I4_RMAX  =  2147483647.; ///< valeur maxi pour conversion d'un réel

const U_Int4  DATA_UI4_SIGN = (DATA_UI4_MAX-DATA_I4_MAX);   ///< Bit de signe 32 bits
const U_Int4  DATA_UI4_HI16 = (DATA_UI4_MAX-DATA_UI2_MAX);  ///< Masque binaire 16 bits forts sur 32 bits

//----------------------------------------------------------------------
// récupéré dans les includes de root
#ifndef __MAKECINT__
const U_Int8  DATA_UI8_MAX  = kMaxULong64;              ///< valeur maxi pour conversion d'un entier
const Int8    DATA_I8_MAX   = kMaxLong64;               ///< valeur mini pour conversion d'un entier
const Int8    DATA_I8_MIN   = kMinLong64;               ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI8_RMAX = Double_t(DATA_UI8_MAX);   ///< valeur mini pour conversion d'un entier
const Real8   DATA_I8_RMAX  = Double_t(DATA_I8_MAX);    ///< valeur mini pour conversion d'un réel
const Real8   DATA_I8_RMIN  = Double_t(DATA_I8_MIN);    ///< valeur maxi pour conversion d'un réel

const U_Int8  DATA_UI8_SIGN = (DATA_UI8_MAX-DATA_I8_MAX);   ///< Bit de signe 64 bits
const U_Int8  DATA_UI8_HI16 = (DATA_UI8_MAX-DATA_UI4_MAX);  ///< Masque binaire 16 bits forts sur 32 bits
const U_Int8  DATA_UI8_HI24 = (DATA_UI8_MAX-DATA_UI2_MAX);  ///< Masque binaire 24 bits forts sur 32 bits
#endif

/* NON IMPLEMENTE !!!
#define   DATA_I8_RMIN     -9223372036854775808.
#define   DATA_I8_RMAX      9223372036854775807.
#define   DATA_I8_MIN      -9223372036854775808
#define   DATA_I8_MAX       9223372036854775807
#define   DATA_UI8_RMAX     18446744065119617025.
#define   DATA_UI8_MAX      18446744065119617025
*/

//class Param;

//======================================================================
/*! \class Data
 *
 *  Classe générique (abstraite) pour les types de données.
 *  Ce sont les classes dérivées qui peuvent être instanciées: elles
 *  ont un type de données spécifique, qui ne peut pas être modifié !
 *  \note:
 *    - Les opérateurs d'affectation de valeurs numériques sont virtuels.
 *    - Pour les comparaison, il faut effectuer un cast.
 *    - Les objets dérivés de la classe Data n'ont pas vocation à
 *      être déclarés constant, parce qu'ils peuvent être modifiés
 *      (mot d'état) lorsqu'ils sont copiés ou affectés.
 *    - Les méthodes de cast vers les types numériques sont définis
 *      une fois pour toutes par une méthode patron de la classe de
 *      base Data, par un appel aux méthodes virtuelles GetValue.
 *    - Les méthodes GetValue, SetValue et l'opérateur d'affection
 *      doivent être définis dans les classes dérivées pour l'ensemble
 *      des types de valeurs considérés.
 *
 *  Les objets de la classe Data (et de ses dérivées) gèrent automatiquement
 *  les changements de type. Dans ce cas, le mot d'état (status) rend
 *  compte des difficultés ou impossibilités de conversions.
 *
 */
class Data
{
//----------------------------------------------------------------------
  /*! \object_doc */
  GObjectV(Data);
//----------------------------------------------------------------------

  protected:

    static  u_int   len;    ///<  Longueur d'affichage
    static  u_int   prec;   ///<  Précision d'affichage
    static  char    fill;   ///<  Caractère de remplissage
    static  string  undef;  ///<  Chaîne pour l'écriture de donnée non valide

    int   status;           ///<  Indicateur de l'état des conversions de types

  public:

//----------------------------------------------------------------------
//  CONSTRUCTEUR / AFFECTATION / DESTRUCTEUR
//----------------------------------------------------------------------

    //  Constructeur
    Data ( );

    //  Constructeur de recopie
    Data ( const Data &d );

    //  Destructeur
    virtual ~Data ( );

//----------------------------------------------------------------------

  public:

    /*! Méthode qui fixe la longueur d'écriture en format texte.
     *  \param  l   longueur du format
     */
    static  inline void  SetLen  ( u_int l )
      {
        len = l;
        if (undef.length() < len)
          undef = string(len-undef.length(),' ') + undef;
      }

    /*! Méthode qui fixe la précision d'écriture en format texte.
     *  \param  p   précision du format
     */
    static  inline void  SetPrec ( u_int p ) { prec = p; }

    /*! Méthode qui fixe le caractère de remplissage en format texte.
     *  \param  c   caractère de remplissage
     */
    static  inline void  SetFill ( char c )  { fill = c; }

    /*! Méthode qui fixe la chaîne de caractères pour l'écriture
     *  d'une donnée non valide.
     *  \param  str   chaîne à écrire
     */
    static  inline void  SetFill ( const string &str )  { undef = str; }

    // retourne une donnée non valide
    static  Data & Bad();

//----------------------------------------------------------------------

    /*! Opérateur d'affectation d'une autre donnée.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Data & d ) { return (*this); }

    /*! Opérateur d'affectation d'une valeur de type entier 16 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int2 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 16 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int2 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 32 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 64 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real8 & d ) = 0;


//----------------------------------------------------------------------

    /*! Méthode virtuelle pure qui renvoit un identificateur de type
     * de données.
     */
    virtual u_int   TypeId ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant le type
     *  de données.
     */
    virtual string   Type ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant la valeur.
     */
    virtual string   String ( ) const = 0;

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données et la valeur.
     */
    inline virtual  string   Text ( ) const
    {
      return (string("(") + Type() + ") " + String());
    }

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données, la valeur et le mot d'état.
     */
    inline virtual  string   FullText ( ) const
    {
      return (Text() + " status = 0x" + GGetStringHexa((U_Int4) status));
    }

//----------------------------------------------------------------------
//  OPERATEURS DE CAST
//----------------------------------------------------------------------

    /*! Patron pour opérateur de cast vers différents types de
     *  données.
     */
    template < class T >  operator T  (void) const
      { T result; GetValue (result); return (result); }

//----------------------------------------------------------------------
    /*! Mise à valeur à l'aide d'un entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int2 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int4 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int8 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int2   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int4   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int8   &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real4  &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real8  &val ) = 0;

//----------------------------------------------------------------------

    /*! Affectation d'une variable de type entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int2 &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int4 &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int8 &val ) const = 0;

    /*! Affectation d'une variable de type entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

  dataTypeUInt8     = (dataTypeUnsigned | dataType64b),   // bits spécifiant le type de donnée  dataTypeInt2      = (dataType16b),                      // bits spécifiant le type de donnée
  dataTypeInt4      = (dataType32b),                      // bits spécifiant le type de donnée
  dataTypeInt8      = (dataType64b),                      // bits spécifiant le type de donnée
  dataTypeReal4     = (dataTypeReal | dataType32b),       // bits spécifiant le type de donnée
  dataTypeReal8     = (dataTypeReal | dataType64b)        // bits spécifiant le type de donnée
};

//----------------------------------------------------------------------
#define   DATA_TYPE_TXT_UNDEFINED  "???"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT2     "U*2"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT4     "U*4"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT8     "U*8"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_INT2       "I*2"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_INT4       "I*4"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_INT8       "I*8"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_REAL4      "R*4"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_REAL8      "R*8"   ///< identifiant texte du type de donnée

//----------------------------------------------------------------------
const U_Int2  DATA_UI2_MAX  =  0xFFFF;      ///< valeur maxi pour conversion d'un entier
const Int2    DATA_I2_MIN   =  -32768;      ///< valeur mini pour conversion d'un entier
const Int2    DATA_I2_MAX   =   32767;      ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI2_RMAX =  65535.;      ///< valeur mini pour conversion d'un entier
const Real8   DATA_I2_RMIN  = -32768.;      ///< valeur mini pour conversion d'un réel
const Real8   DATA_I2_RMAX  =  32767.;      ///< valeur maxi pour conversion d'un réel

const U_Int2  DATA_UI2_SIGN = (DATA_UI2_MAX-DATA_I2_MAX); ///< Bit de signe 16 bits

//----------------------------------------------------------------------
const U_Int4  DATA_UI4_MAX  =  0xFFFFFFFF;  ///< valeur maxi pour conversion d'un entier
const Int4    DATA_I4_MIN   =  0x80000000;  ///< valeur mini pour conversion d'un entier
const Int4    DATA_I4_MAX   =  0x7FFFFFFF;  ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI4_RMAX =  4294967295.; ///< valeur mini pour conversion d'un entier
const Real8   DATA_I4_RMIN  = -2147483648.; ///< valeur mini pour conversion d'un réel
const Real8   DATA_I4_RMAX  =  2147483647.; ///< valeur maxi pour conversion d'un réel

const U_Int4  DATA_UI4_SIGN = (DATA_UI4_MAX-DATA_I4_MAX);   ///< Bit de signe 32 bits
const U_Int4  DATA_UI4_HI16 = (DATA_UI4_MAX-DATA_UI2_MAX);  ///< Masque binaire 16 bits forts sur 32 bits

//----------------------------------------------------------------------
// récupéré dans les includes de root
#ifndef __MAKECINT__
const U_Int8  DATA_UI8_MAX  = kMaxULong64;              ///< valeur maxi pour conversion d'un entier
const Int8    DATA_I8_MAX   = kMaxLong64;               ///< valeur mini pour conversion d'un entier
const Int8    DATA_I8_MIN   = kMinLong64;               ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI8_RMAX = Double_t(DATA_UI8_MAX);   ///< valeur mini pour conversion d'un entier
const Real8   DATA_I8_RMAX  = Double_t(DATA_I8_MAX);    ///< valeur mini pour conversion d'un réel
const Real8   DATA_I8_RMIN  = Double_t(DATA_I8_MIN);    ///< valeur maxi pour conversion d'un réel

const U_Int8  DATA_UI8_SIGN = (DATA_UI8_MAX-DATA_I8_MAX);   ///< Bit de signe 64 bits
const U_Int8  DATA_UI8_HI16 = (DATA_UI8_MAX-DATA_UI4_MAX);  ///< Masque binaire 16 bits forts sur 32 bits
const U_Int8  DATA_UI8_HI24 = (DATA_UI8_MAX-DATA_UI2_MAX);  ///< Masque binaire 24 bits forts sur 32 bits
#endif

/* NON IMPLEMENTE !!!
#define   DATA_I8_RMIN     -9223372036854775808.
#define   DATA_I8_RMAX      9223372036854775807.
#define   DATA_I8_MIN      -9223372036854775808
#define   DATA_I8_MAX       9223372036854775807
#define   DATA_UI8_RMAX     18446744065119617025.
#define   DATA_UI8_MAX      18446744065119617025
*/

//class Param;

//======================================================================
/*! \class Data
 *
 *  Classe générique (abstraite) pour les types de données.
 *  Ce sont les classes dérivées qui peuvent être instanciées: elles
 *  ont un type de données spécifique, qui ne peut pas être modifié !
 *  \note:
 *    - Les opérateurs d'affectation de valeurs numériques sont virtuels.
 *    - Pour les comparaison, il faut effectuer un cast.
 *    - Les objets dérivés de la classe Data n'ont pas vocation à
 *      être déclarés constant, parce qu'ils peuvent être modifiés
 *      (mot d'état) lorsqu'ils sont copiés ou affectés.
 *    - Les méthodes de cast vers les types numériques sont définis
 *      une fois pour toutes par une méthode patron de la classe de
 *      base Data, par un appel aux méthodes virtuelles GetValue.
 *    - Les méthodes GetValue, SetValue et l'opérateur d'affection
 *      doivent être définis dans les classes dérivées pour l'ensemble
 *      des types de valeurs considérés.
 *
 *  Les objets de la classe Data (et de ses dérivées) gèrent automatiquement
 *  les changements de type. Dans ce cas, le mot d'état (status) rend
 *  compte des difficultés ou impossibilités de conversions.
 *
 */
class Data
{
//----------------------------------------------------------------------
  /*! \object_doc */
  GObjectV(Data);
//----------------------------------------------------------------------

  protected:

    static  u_int   len;    ///<  Longueur d'affichage
    static  u_int   prec;   ///<  Précision d'affichage
    static  char    fill;   ///<  Caractère de remplissage
    static  string  undef;  ///<  Chaîne pour l'écriture de donnée non valide

    int   status;           ///<  Indicateur de l'état des conversions de types

  public:

//----------------------------------------------------------------------
//  CONSTRUCTEUR / AFFECTATION / DESTRUCTEUR
//----------------------------------------------------------------------

    //  Constructeur
    Data ( );

    //  Constructeur de recopie
    Data ( const Data &d );

    //  Destructeur
    virtual ~Data ( );

//----------------------------------------------------------------------

  public:

    /*! Méthode qui fixe la longueur d'écriture en format texte.
     *  \param  l   longueur du format
     */
    static  inline void  SetLen  ( u_int l )
      {
        len = l;
        if (undef.length() < len)
          undef = string(len-undef.length(),' ') + undef;
      }

    /*! Méthode qui fixe la précision d'écriture en format texte.
     *  \param  p   précision du format
     */
    static  inline void  SetPrec ( u_int p ) { prec = p; }

    /*! Méthode qui fixe le caractère de remplissage en format texte.
     *  \param  c   caractère de remplissage
     */
    static  inline void  SetFill ( char c )  { fill = c; }

    /*! Méthode qui fixe la chaîne de caractères pour l'écriture
     *  d'une donnée non valide.
     *  \param  str   chaîne à écrire
     */
    static  inline void  SetFill ( const string &str )  { undef = str; }

    // retourne une donnée non valide
    static  Data & Bad();

//----------------------------------------------------------------------

    /*! Opérateur d'affectation d'une autre donnée.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Data & d ) { return (*this); }

    /*! Opérateur d'affectation d'une valeur de type entier 16 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int2 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 16 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int2 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 32 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 64 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real8 & d ) = 0;


//----------------------------------------------------------------------

    /*! Méthode virtuelle pure qui renvoit un identificateur de type
     * de données.
     */
    virtual u_int   TypeId ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant le type
     *  de données.
     */
    virtual string   Type ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant la valeur.
     */
    virtual string   String ( ) const = 0;

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données et la valeur.
     */
    inline virtual  string   Text ( ) const
    {
      return (string("(") + Type() + ") " + String());
    }

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données, la valeur et le mot d'état.
     */
    inline virtual  string   FullText ( ) const
    {
      return (Text() + " status = 0x" + GGetStringHexa((U_Int4) status));
    }

//----------------------------------------------------------------------
//  OPERATEURS DE CAST
//----------------------------------------------------------------------

    /*! Patron pour opérateur de cast vers différents types de
     *  données.
     */
    template < class T >  operator T  (void) const
      { T result; GetValue (result); return (result); }

//----------------------------------------------------------------------
    /*! Mise à valeur à l'aide d'un entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int2 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int4 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int8 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int2   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int4   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int8   &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real4  &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real8  &val ) = 0;

//----------------------------------------------------------------------

    /*! Affectation d'une variable de type entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int2 &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int4 &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int8 &val ) const = 0;

    /*! Affectation d'une variable de type entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

  dataTypeInt2      = (dataType16b),                      // bits spécifiant le type de donnée  dataTypeInt4      = (dataType32b),                      // bits spécifiant le type de donnée
  dataTypeInt8      = (dataType64b),                      // bits spécifiant le type de donnée
  dataTypeReal4     = (dataTypeReal | dataType32b),       // bits spécifiant le type de donnée
  dataTypeReal8     = (dataTypeReal | dataType64b)        // bits spécifiant le type de donnée
};

//----------------------------------------------------------------------
#define   DATA_TYPE_TXT_UNDEFINED  "???"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT2     "U*2"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT4     "U*4"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT8     "U*8"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_INT2       "I*2"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_INT4       "I*4"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_INT8       "I*8"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_REAL4      "R*4"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_REAL8      "R*8"   ///< identifiant texte du type de donnée

//----------------------------------------------------------------------
const U_Int2  DATA_UI2_MAX  =  0xFFFF;      ///< valeur maxi pour conversion d'un entier
const Int2    DATA_I2_MIN   =  -32768;      ///< valeur mini pour conversion d'un entier
const Int2    DATA_I2_MAX   =   32767;      ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI2_RMAX =  65535.;      ///< valeur mini pour conversion d'un entier
const Real8   DATA_I2_RMIN  = -32768.;      ///< valeur mini pour conversion d'un réel
const Real8   DATA_I2_RMAX  =  32767.;      ///< valeur maxi pour conversion d'un réel

const U_Int2  DATA_UI2_SIGN = (DATA_UI2_MAX-DATA_I2_MAX); ///< Bit de signe 16 bits

//----------------------------------------------------------------------
const U_Int4  DATA_UI4_MAX  =  0xFFFFFFFF;  ///< valeur maxi pour conversion d'un entier
const Int4    DATA_I4_MIN   =  0x80000000;  ///< valeur mini pour conversion d'un entier
const Int4    DATA_I4_MAX   =  0x7FFFFFFF;  ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI4_RMAX =  4294967295.; ///< valeur mini pour conversion d'un entier
const Real8   DATA_I4_RMIN  = -2147483648.; ///< valeur mini pour conversion d'un réel
const Real8   DATA_I4_RMAX  =  2147483647.; ///< valeur maxi pour conversion d'un réel

const U_Int4  DATA_UI4_SIGN = (DATA_UI4_MAX-DATA_I4_MAX);   ///< Bit de signe 32 bits
const U_Int4  DATA_UI4_HI16 = (DATA_UI4_MAX-DATA_UI2_MAX);  ///< Masque binaire 16 bits forts sur 32 bits

//----------------------------------------------------------------------
// récupéré dans les includes de root
#ifndef __MAKECINT__
const U_Int8  DATA_UI8_MAX  = kMaxULong64;              ///< valeur maxi pour conversion d'un entier
const Int8    DATA_I8_MAX   = kMaxLong64;               ///< valeur mini pour conversion d'un entier
const Int8    DATA_I8_MIN   = kMinLong64;               ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI8_RMAX = Double_t(DATA_UI8_MAX);   ///< valeur mini pour conversion d'un entier
const Real8   DATA_I8_RMAX  = Double_t(DATA_I8_MAX);    ///< valeur mini pour conversion d'un réel
const Real8   DATA_I8_RMIN  = Double_t(DATA_I8_MIN);    ///< valeur maxi pour conversion d'un réel

const U_Int8  DATA_UI8_SIGN = (DATA_UI8_MAX-DATA_I8_MAX);   ///< Bit de signe 64 bits
const U_Int8  DATA_UI8_HI16 = (DATA_UI8_MAX-DATA_UI4_MAX);  ///< Masque binaire 16 bits forts sur 32 bits
const U_Int8  DATA_UI8_HI24 = (DATA_UI8_MAX-DATA_UI2_MAX);  ///< Masque binaire 24 bits forts sur 32 bits
#endif

/* NON IMPLEMENTE !!!
#define   DATA_I8_RMIN     -9223372036854775808.
#define   DATA_I8_RMAX      9223372036854775807.
#define   DATA_I8_MIN      -9223372036854775808
#define   DATA_I8_MAX       9223372036854775807
#define   DATA_UI8_RMAX     18446744065119617025.
#define   DATA_UI8_MAX      18446744065119617025
*/

//class Param;

//======================================================================
/*! \class Data
 *
 *  Classe générique (abstraite) pour les types de données.
 *  Ce sont les classes dérivées qui peuvent être instanciées: elles
 *  ont un type de données spécifique, qui ne peut pas être modifié !
 *  \note:
 *    - Les opérateurs d'affectation de valeurs numériques sont virtuels.
 *    - Pour les comparaison, il faut effectuer un cast.
 *    - Les objets dérivés de la classe Data n'ont pas vocation à
 *      être déclarés constant, parce qu'ils peuvent être modifiés
 *      (mot d'état) lorsqu'ils sont copiés ou affectés.
 *    - Les méthodes de cast vers les types numériques sont définis
 *      une fois pour toutes par une méthode patron de la classe de
 *      base Data, par un appel aux méthodes virtuelles GetValue.
 *    - Les méthodes GetValue, SetValue et l'opérateur d'affection
 *      doivent être définis dans les classes dérivées pour l'ensemble
 *      des types de valeurs considérés.
 *
 *  Les objets de la classe Data (et de ses dérivées) gèrent automatiquement
 *  les changements de type. Dans ce cas, le mot d'état (status) rend
 *  compte des difficultés ou impossibilités de conversions.
 *
 */
class Data
{
//----------------------------------------------------------------------
  /*! \object_doc */
  GObjectV(Data);
//----------------------------------------------------------------------

  protected:

    static  u_int   len;    ///<  Longueur d'affichage
    static  u_int   prec;   ///<  Précision d'affichage
    static  char    fill;   ///<  Caractère de remplissage
    static  string  undef;  ///<  Chaîne pour l'écriture de donnée non valide

    int   status;           ///<  Indicateur de l'état des conversions de types

  public:

//----------------------------------------------------------------------
//  CONSTRUCTEUR / AFFECTATION / DESTRUCTEUR
//----------------------------------------------------------------------

    //  Constructeur
    Data ( );

    //  Constructeur de recopie
    Data ( const Data &d );

    //  Destructeur
    virtual ~Data ( );

//----------------------------------------------------------------------

  public:

    /*! Méthode qui fixe la longueur d'écriture en format texte.
     *  \param  l   longueur du format
     */
    static  inline void  SetLen  ( u_int l )
      {
        len = l;
        if (undef.length() < len)
          undef = string(len-undef.length(),' ') + undef;
      }

    /*! Méthode qui fixe la précision d'écriture en format texte.
     *  \param  p   précision du format
     */
    static  inline void  SetPrec ( u_int p ) { prec = p; }

    /*! Méthode qui fixe le caractère de remplissage en format texte.
     *  \param  c   caractère de remplissage
     */
    static  inline void  SetFill ( char c )  { fill = c; }

    /*! Méthode qui fixe la chaîne de caractères pour l'écriture
     *  d'une donnée non valide.
     *  \param  str   chaîne à écrire
     */
    static  inline void  SetFill ( const string &str )  { undef = str; }

    // retourne une donnée non valide
    static  Data & Bad();

//----------------------------------------------------------------------

    /*! Opérateur d'affectation d'une autre donnée.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Data & d ) { return (*this); }

    /*! Opérateur d'affectation d'une valeur de type entier 16 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int2 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 16 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int2 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 32 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 64 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real8 & d ) = 0;


//----------------------------------------------------------------------

    /*! Méthode virtuelle pure qui renvoit un identificateur de type
     * de données.
     */
    virtual u_int   TypeId ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant le type
     *  de données.
     */
    virtual string   Type ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant la valeur.
     */
    virtual string   String ( ) const = 0;

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données et la valeur.
     */
    inline virtual  string   Text ( ) const
    {
      return (string("(") + Type() + ") " + String());
    }

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données, la valeur et le mot d'état.
     */
    inline virtual  string   FullText ( ) const
    {
      return (Text() + " status = 0x" + GGetStringHexa((U_Int4) status));
    }

//----------------------------------------------------------------------
//  OPERATEURS DE CAST
//----------------------------------------------------------------------

    /*! Patron pour opérateur de cast vers différents types de
     *  données.
     */
    template < class T >  operator T  (void) const
      { T result; GetValue (result); return (result); }

//----------------------------------------------------------------------
    /*! Mise à valeur à l'aide d'un entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int2 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int4 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int8 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int2   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int4   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int8   &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real4  &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real8  &val ) = 0;

//----------------------------------------------------------------------

    /*! Affectation d'une variable de type entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int2 &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int4 &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int8 &val ) const = 0;

    /*! Affectation d'une variable de type entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

  dataTypeInt4      = (dataType32b),                      // bits spécifiant le type de donnée  dataTypeInt8      = (dataType64b),                      // bits spécifiant le type de donnée
  dataTypeReal4     = (dataTypeReal | dataType32b),       // bits spécifiant le type de donnée
  dataTypeReal8     = (dataTypeReal | dataType64b)        // bits spécifiant le type de donnée
};

//----------------------------------------------------------------------
#define   DATA_TYPE_TXT_UNDEFINED  "???"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT2     "U*2"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT4     "U*4"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT8     "U*8"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_INT2       "I*2"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_INT4       "I*4"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_INT8       "I*8"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_REAL4      "R*4"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_REAL8      "R*8"   ///< identifiant texte du type de donnée

//----------------------------------------------------------------------
const U_Int2  DATA_UI2_MAX  =  0xFFFF;      ///< valeur maxi pour conversion d'un entier
const Int2    DATA_I2_MIN   =  -32768;      ///< valeur mini pour conversion d'un entier
const Int2    DATA_I2_MAX   =   32767;      ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI2_RMAX =  65535.;      ///< valeur mini pour conversion d'un entier
const Real8   DATA_I2_RMIN  = -32768.;      ///< valeur mini pour conversion d'un réel
const Real8   DATA_I2_RMAX  =  32767.;      ///< valeur maxi pour conversion d'un réel

const U_Int2  DATA_UI2_SIGN = (DATA_UI2_MAX-DATA_I2_MAX); ///< Bit de signe 16 bits

//----------------------------------------------------------------------
const U_Int4  DATA_UI4_MAX  =  0xFFFFFFFF;  ///< valeur maxi pour conversion d'un entier
const Int4    DATA_I4_MIN   =  0x80000000;  ///< valeur mini pour conversion d'un entier
const Int4    DATA_I4_MAX   =  0x7FFFFFFF;  ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI4_RMAX =  4294967295.; ///< valeur mini pour conversion d'un entier
const Real8   DATA_I4_RMIN  = -2147483648.; ///< valeur mini pour conversion d'un réel
const Real8   DATA_I4_RMAX  =  2147483647.; ///< valeur maxi pour conversion d'un réel

const U_Int4  DATA_UI4_SIGN = (DATA_UI4_MAX-DATA_I4_MAX);   ///< Bit de signe 32 bits
const U_Int4  DATA_UI4_HI16 = (DATA_UI4_MAX-DATA_UI2_MAX);  ///< Masque binaire 16 bits forts sur 32 bits

//----------------------------------------------------------------------
// récupéré dans les includes de root
#ifndef __MAKECINT__
const U_Int8  DATA_UI8_MAX  = kMaxULong64;              ///< valeur maxi pour conversion d'un entier
const Int8    DATA_I8_MAX   = kMaxLong64;               ///< valeur mini pour conversion d'un entier
const Int8    DATA_I8_MIN   = kMinLong64;               ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI8_RMAX = Double_t(DATA_UI8_MAX);   ///< valeur mini pour conversion d'un entier
const Real8   DATA_I8_RMAX  = Double_t(DATA_I8_MAX);    ///< valeur mini pour conversion d'un réel
const Real8   DATA_I8_RMIN  = Double_t(DATA_I8_MIN);    ///< valeur maxi pour conversion d'un réel

const U_Int8  DATA_UI8_SIGN = (DATA_UI8_MAX-DATA_I8_MAX);   ///< Bit de signe 64 bits
const U_Int8  DATA_UI8_HI16 = (DATA_UI8_MAX-DATA_UI4_MAX);  ///< Masque binaire 16 bits forts sur 32 bits
const U_Int8  DATA_UI8_HI24 = (DATA_UI8_MAX-DATA_UI2_MAX);  ///< Masque binaire 24 bits forts sur 32 bits
#endif

/* NON IMPLEMENTE !!!
#define   DATA_I8_RMIN     -9223372036854775808.
#define   DATA_I8_RMAX      9223372036854775807.
#define   DATA_I8_MIN      -9223372036854775808
#define   DATA_I8_MAX       9223372036854775807
#define   DATA_UI8_RMAX     18446744065119617025.
#define   DATA_UI8_MAX      18446744065119617025
*/

//class Param;

//======================================================================
/*! \class Data
 *
 *  Classe générique (abstraite) pour les types de données.
 *  Ce sont les classes dérivées qui peuvent être instanciées: elles
 *  ont un type de données spécifique, qui ne peut pas être modifié !
 *  \note:
 *    - Les opérateurs d'affectation de valeurs numériques sont virtuels.
 *    - Pour les comparaison, il faut effectuer un cast.
 *    - Les objets dérivés de la classe Data n'ont pas vocation à
 *      être déclarés constant, parce qu'ils peuvent être modifiés
 *      (mot d'état) lorsqu'ils sont copiés ou affectés.
 *    - Les méthodes de cast vers les types numériques sont définis
 *      une fois pour toutes par une méthode patron de la classe de
 *      base Data, par un appel aux méthodes virtuelles GetValue.
 *    - Les méthodes GetValue, SetValue et l'opérateur d'affection
 *      doivent être définis dans les classes dérivées pour l'ensemble
 *      des types de valeurs considérés.
 *
 *  Les objets de la classe Data (et de ses dérivées) gèrent automatiquement
 *  les changements de type. Dans ce cas, le mot d'état (status) rend
 *  compte des difficultés ou impossibilités de conversions.
 *
 */
class Data
{
//----------------------------------------------------------------------
  /*! \object_doc */
  GObjectV(Data);
//----------------------------------------------------------------------

  protected:

    static  u_int   len;    ///<  Longueur d'affichage
    static  u_int   prec;   ///<  Précision d'affichage
    static  char    fill;   ///<  Caractère de remplissage
    static  string  undef;  ///<  Chaîne pour l'écriture de donnée non valide

    int   status;           ///<  Indicateur de l'état des conversions de types

  public:

//----------------------------------------------------------------------
//  CONSTRUCTEUR / AFFECTATION / DESTRUCTEUR
//----------------------------------------------------------------------

    //  Constructeur
    Data ( );

    //  Constructeur de recopie
    Data ( const Data &d );

    //  Destructeur
    virtual ~Data ( );

//----------------------------------------------------------------------

  public:

    /*! Méthode qui fixe la longueur d'écriture en format texte.
     *  \param  l   longueur du format
     */
    static  inline void  SetLen  ( u_int l )
      {
        len = l;
        if (undef.length() < len)
          undef = string(len-undef.length(),' ') + undef;
      }

    /*! Méthode qui fixe la précision d'écriture en format texte.
     *  \param  p   précision du format
     */
    static  inline void  SetPrec ( u_int p ) { prec = p; }

    /*! Méthode qui fixe le caractère de remplissage en format texte.
     *  \param  c   caractère de remplissage
     */
    static  inline void  SetFill ( char c )  { fill = c; }

    /*! Méthode qui fixe la chaîne de caractères pour l'écriture
     *  d'une donnée non valide.
     *  \param  str   chaîne à écrire
     */
    static  inline void  SetFill ( const string &str )  { undef = str; }

    // retourne une donnée non valide
    static  Data & Bad();

//----------------------------------------------------------------------

    /*! Opérateur d'affectation d'une autre donnée.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Data & d ) { return (*this); }

    /*! Opérateur d'affectation d'une valeur de type entier 16 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int2 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 16 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int2 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 32 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 64 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real8 & d ) = 0;


//----------------------------------------------------------------------

    /*! Méthode virtuelle pure qui renvoit un identificateur de type
     * de données.
     */
    virtual u_int   TypeId ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant le type
     *  de données.
     */
    virtual string   Type ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant la valeur.
     */
    virtual string   String ( ) const = 0;

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données et la valeur.
     */
    inline virtual  string   Text ( ) const
    {
      return (string("(") + Type() + ") " + String());
    }

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données, la valeur et le mot d'état.
     */
    inline virtual  string   FullText ( ) const
    {
      return (Text() + " status = 0x" + GGetStringHexa((U_Int4) status));
    }

//----------------------------------------------------------------------
//  OPERATEURS DE CAST
//----------------------------------------------------------------------

    /*! Patron pour opérateur de cast vers différents types de
     *  données.
     */
    template < class T >  operator T  (void) const
      { T result; GetValue (result); return (result); }

//----------------------------------------------------------------------
    /*! Mise à valeur à l'aide d'un entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int2 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int4 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int8 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int2   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int4   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int8   &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real4  &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real8  &val ) = 0;

//----------------------------------------------------------------------

    /*! Affectation d'une variable de type entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int2 &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int4 &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int8 &val ) const = 0;

    /*! Affectation d'une variable de type entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

  dataTypeInt8      = (dataType64b),                      // bits spécifiant le type de donnée  dataTypeReal4     = (dataTypeReal | dataType32b),       // bits spécifiant le type de donnée
  dataTypeReal8     = (dataTypeReal | dataType64b)        // bits spécifiant le type de donnée
};

//----------------------------------------------------------------------
#define   DATA_TYPE_TXT_UNDEFINED  "???"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT2     "U*2"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT4     "U*4"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT8     "U*8"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_INT2       "I*2"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_INT4       "I*4"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_INT8       "I*8"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_REAL4      "R*4"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_REAL8      "R*8"   ///< identifiant texte du type de donnée

//----------------------------------------------------------------------
const U_Int2  DATA_UI2_MAX  =  0xFFFF;      ///< valeur maxi pour conversion d'un entier
const Int2    DATA_I2_MIN   =  -32768;      ///< valeur mini pour conversion d'un entier
const Int2    DATA_I2_MAX   =   32767;      ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI2_RMAX =  65535.;      ///< valeur mini pour conversion d'un entier
const Real8   DATA_I2_RMIN  = -32768.;      ///< valeur mini pour conversion d'un réel
const Real8   DATA_I2_RMAX  =  32767.;      ///< valeur maxi pour conversion d'un réel

const U_Int2  DATA_UI2_SIGN = (DATA_UI2_MAX-DATA_I2_MAX); ///< Bit de signe 16 bits

//----------------------------------------------------------------------
const U_Int4  DATA_UI4_MAX  =  0xFFFFFFFF;  ///< valeur maxi pour conversion d'un entier
const Int4    DATA_I4_MIN   =  0x80000000;  ///< valeur mini pour conversion d'un entier
const Int4    DATA_I4_MAX   =  0x7FFFFFFF;  ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI4_RMAX =  4294967295.; ///< valeur mini pour conversion d'un entier
const Real8   DATA_I4_RMIN  = -2147483648.; ///< valeur mini pour conversion d'un réel
const Real8   DATA_I4_RMAX  =  2147483647.; ///< valeur maxi pour conversion d'un réel

const U_Int4  DATA_UI4_SIGN = (DATA_UI4_MAX-DATA_I4_MAX);   ///< Bit de signe 32 bits
const U_Int4  DATA_UI4_HI16 = (DATA_UI4_MAX-DATA_UI2_MAX);  ///< Masque binaire 16 bits forts sur 32 bits

//----------------------------------------------------------------------
// récupéré dans les includes de root
#ifndef __MAKECINT__
const U_Int8  DATA_UI8_MAX  = kMaxULong64;              ///< valeur maxi pour conversion d'un entier
const Int8    DATA_I8_MAX   = kMaxLong64;               ///< valeur mini pour conversion d'un entier
const Int8    DATA_I8_MIN   = kMinLong64;               ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI8_RMAX = Double_t(DATA_UI8_MAX);   ///< valeur mini pour conversion d'un entier
const Real8   DATA_I8_RMAX  = Double_t(DATA_I8_MAX);    ///< valeur mini pour conversion d'un réel
const Real8   DATA_I8_RMIN  = Double_t(DATA_I8_MIN);    ///< valeur maxi pour conversion d'un réel

const U_Int8  DATA_UI8_SIGN = (DATA_UI8_MAX-DATA_I8_MAX);   ///< Bit de signe 64 bits
const U_Int8  DATA_UI8_HI16 = (DATA_UI8_MAX-DATA_UI4_MAX);  ///< Masque binaire 16 bits forts sur 32 bits
const U_Int8  DATA_UI8_HI24 = (DATA_UI8_MAX-DATA_UI2_MAX);  ///< Masque binaire 24 bits forts sur 32 bits
#endif

/* NON IMPLEMENTE !!!
#define   DATA_I8_RMIN     -9223372036854775808.
#define   DATA_I8_RMAX      9223372036854775807.
#define   DATA_I8_MIN      -9223372036854775808
#define   DATA_I8_MAX       9223372036854775807
#define   DATA_UI8_RMAX     18446744065119617025.
#define   DATA_UI8_MAX      18446744065119617025
*/

//class Param;

//======================================================================
/*! \class Data
 *
 *  Classe générique (abstraite) pour les types de données.
 *  Ce sont les classes dérivées qui peuvent être instanciées: elles
 *  ont un type de données spécifique, qui ne peut pas être modifié !
 *  \note:
 *    - Les opérateurs d'affectation de valeurs numériques sont virtuels.
 *    - Pour les comparaison, il faut effectuer un cast.
 *    - Les objets dérivés de la classe Data n'ont pas vocation à
 *      être déclarés constant, parce qu'ils peuvent être modifiés
 *      (mot d'état) lorsqu'ils sont copiés ou affectés.
 *    - Les méthodes de cast vers les types numériques sont définis
 *      une fois pour toutes par une méthode patron de la classe de
 *      base Data, par un appel aux méthodes virtuelles GetValue.
 *    - Les méthodes GetValue, SetValue et l'opérateur d'affection
 *      doivent être définis dans les classes dérivées pour l'ensemble
 *      des types de valeurs considérés.
 *
 *  Les objets de la classe Data (et de ses dérivées) gèrent automatiquement
 *  les changements de type. Dans ce cas, le mot d'état (status) rend
 *  compte des difficultés ou impossibilités de conversions.
 *
 */
class Data
{
//----------------------------------------------------------------------
  /*! \object_doc */
  GObjectV(Data);
//----------------------------------------------------------------------

  protected:

    static  u_int   len;    ///<  Longueur d'affichage
    static  u_int   prec;   ///<  Précision d'affichage
    static  char    fill;   ///<  Caractère de remplissage
    static  string  undef;  ///<  Chaîne pour l'écriture de donnée non valide

    int   status;           ///<  Indicateur de l'état des conversions de types

  public:

//----------------------------------------------------------------------
//  CONSTRUCTEUR / AFFECTATION / DESTRUCTEUR
//----------------------------------------------------------------------

    //  Constructeur
    Data ( );

    //  Constructeur de recopie
    Data ( const Data &d );

    //  Destructeur
    virtual ~Data ( );

//----------------------------------------------------------------------

  public:

    /*! Méthode qui fixe la longueur d'écriture en format texte.
     *  \param  l   longueur du format
     */
    static  inline void  SetLen  ( u_int l )
      {
        len = l;
        if (undef.length() < len)
          undef = string(len-undef.length(),' ') + undef;
      }

    /*! Méthode qui fixe la précision d'écriture en format texte.
     *  \param  p   précision du format
     */
    static  inline void  SetPrec ( u_int p ) { prec = p; }

    /*! Méthode qui fixe le caractère de remplissage en format texte.
     *  \param  c   caractère de remplissage
     */
    static  inline void  SetFill ( char c )  { fill = c; }

    /*! Méthode qui fixe la chaîne de caractères pour l'écriture
     *  d'une donnée non valide.
     *  \param  str   chaîne à écrire
     */
    static  inline void  SetFill ( const string &str )  { undef = str; }

    // retourne une donnée non valide
    static  Data & Bad();

//----------------------------------------------------------------------

    /*! Opérateur d'affectation d'une autre donnée.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Data & d ) { return (*this); }

    /*! Opérateur d'affectation d'une valeur de type entier 16 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int2 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 16 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int2 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 32 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 64 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real8 & d ) = 0;


//----------------------------------------------------------------------

    /*! Méthode virtuelle pure qui renvoit un identificateur de type
     * de données.
     */
    virtual u_int   TypeId ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant le type
     *  de données.
     */
    virtual string   Type ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant la valeur.
     */
    virtual string   String ( ) const = 0;

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données et la valeur.
     */
    inline virtual  string   Text ( ) const
    {
      return (string("(") + Type() + ") " + String());
    }

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données, la valeur et le mot d'état.
     */
    inline virtual  string   FullText ( ) const
    {
      return (Text() + " status = 0x" + GGetStringHexa((U_Int4) status));
    }

//----------------------------------------------------------------------
//  OPERATEURS DE CAST
//----------------------------------------------------------------------

    /*! Patron pour opérateur de cast vers différents types de
     *  données.
     */
    template < class T >  operator T  (void) const
      { T result; GetValue (result); return (result); }

//----------------------------------------------------------------------
    /*! Mise à valeur à l'aide d'un entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int2 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int4 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int8 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int2   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int4   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int8   &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real4  &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real8  &val ) = 0;

//----------------------------------------------------------------------

    /*! Affectation d'une variable de type entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int2 &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int4 &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int8 &val ) const = 0;

    /*! Affectation d'une variable de type entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

  dataTypeReal4     = (dataTypeReal | dataType32b),       // bits spécifiant le type de donnée  dataTypeReal8     = (dataTypeReal | dataType64b)        // bits spécifiant le type de donnée
};

//----------------------------------------------------------------------
#define   DATA_TYPE_TXT_UNDEFINED  "???"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT2     "U*2"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT4     "U*4"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT8     "U*8"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_INT2       "I*2"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_INT4       "I*4"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_INT8       "I*8"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_REAL4      "R*4"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_REAL8      "R*8"   ///< identifiant texte du type de donnée

//----------------------------------------------------------------------
const U_Int2  DATA_UI2_MAX  =  0xFFFF;      ///< valeur maxi pour conversion d'un entier
const Int2    DATA_I2_MIN   =  -32768;      ///< valeur mini pour conversion d'un entier
const Int2    DATA_I2_MAX   =   32767;      ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI2_RMAX =  65535.;      ///< valeur mini pour conversion d'un entier
const Real8   DATA_I2_RMIN  = -32768.;      ///< valeur mini pour conversion d'un réel
const Real8   DATA_I2_RMAX  =  32767.;      ///< valeur maxi pour conversion d'un réel

const U_Int2  DATA_UI2_SIGN = (DATA_UI2_MAX-DATA_I2_MAX); ///< Bit de signe 16 bits

//----------------------------------------------------------------------
const U_Int4  DATA_UI4_MAX  =  0xFFFFFFFF;  ///< valeur maxi pour conversion d'un entier
const Int4    DATA_I4_MIN   =  0x80000000;  ///< valeur mini pour conversion d'un entier
const Int4    DATA_I4_MAX   =  0x7FFFFFFF;  ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI4_RMAX =  4294967295.; ///< valeur mini pour conversion d'un entier
const Real8   DATA_I4_RMIN  = -2147483648.; ///< valeur mini pour conversion d'un réel
const Real8   DATA_I4_RMAX  =  2147483647.; ///< valeur maxi pour conversion d'un réel

const U_Int4  DATA_UI4_SIGN = (DATA_UI4_MAX-DATA_I4_MAX);   ///< Bit de signe 32 bits
const U_Int4  DATA_UI4_HI16 = (DATA_UI4_MAX-DATA_UI2_MAX);  ///< Masque binaire 16 bits forts sur 32 bits

//----------------------------------------------------------------------
// récupéré dans les includes de root
#ifndef __MAKECINT__
const U_Int8  DATA_UI8_MAX  = kMaxULong64;              ///< valeur maxi pour conversion d'un entier
const Int8    DATA_I8_MAX   = kMaxLong64;               ///< valeur mini pour conversion d'un entier
const Int8    DATA_I8_MIN   = kMinLong64;               ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI8_RMAX = Double_t(DATA_UI8_MAX);   ///< valeur mini pour conversion d'un entier
const Real8   DATA_I8_RMAX  = Double_t(DATA_I8_MAX);    ///< valeur mini pour conversion d'un réel
const Real8   DATA_I8_RMIN  = Double_t(DATA_I8_MIN);    ///< valeur maxi pour conversion d'un réel

const U_Int8  DATA_UI8_SIGN = (DATA_UI8_MAX-DATA_I8_MAX);   ///< Bit de signe 64 bits
const U_Int8  DATA_UI8_HI16 = (DATA_UI8_MAX-DATA_UI4_MAX);  ///< Masque binaire 16 bits forts sur 32 bits
const U_Int8  DATA_UI8_HI24 = (DATA_UI8_MAX-DATA_UI2_MAX);  ///< Masque binaire 24 bits forts sur 32 bits
#endif

/* NON IMPLEMENTE !!!
#define   DATA_I8_RMIN     -9223372036854775808.
#define   DATA_I8_RMAX      9223372036854775807.
#define   DATA_I8_MIN      -9223372036854775808
#define   DATA_I8_MAX       9223372036854775807
#define   DATA_UI8_RMAX     18446744065119617025.
#define   DATA_UI8_MAX      18446744065119617025
*/

//class Param;

//======================================================================
/*! \class Data
 *
 *  Classe générique (abstraite) pour les types de données.
 *  Ce sont les classes dérivées qui peuvent être instanciées: elles
 *  ont un type de données spécifique, qui ne peut pas être modifié !
 *  \note:
 *    - Les opérateurs d'affectation de valeurs numériques sont virtuels.
 *    - Pour les comparaison, il faut effectuer un cast.
 *    - Les objets dérivés de la classe Data n'ont pas vocation à
 *      être déclarés constant, parce qu'ils peuvent être modifiés
 *      (mot d'état) lorsqu'ils sont copiés ou affectés.
 *    - Les méthodes de cast vers les types numériques sont définis
 *      une fois pour toutes par une méthode patron de la classe de
 *      base Data, par un appel aux méthodes virtuelles GetValue.
 *    - Les méthodes GetValue, SetValue et l'opérateur d'affection
 *      doivent être définis dans les classes dérivées pour l'ensemble
 *      des types de valeurs considérés.
 *
 *  Les objets de la classe Data (et de ses dérivées) gèrent automatiquement
 *  les changements de type. Dans ce cas, le mot d'état (status) rend
 *  compte des difficultés ou impossibilités de conversions.
 *
 */
class Data
{
//----------------------------------------------------------------------
  /*! \object_doc */
  GObjectV(Data);
//----------------------------------------------------------------------

  protected:

    static  u_int   len;    ///<  Longueur d'affichage
    static  u_int   prec;   ///<  Précision d'affichage
    static  char    fill;   ///<  Caractère de remplissage
    static  string  undef;  ///<  Chaîne pour l'écriture de donnée non valide

    int   status;           ///<  Indicateur de l'état des conversions de types

  public:

//----------------------------------------------------------------------
//  CONSTRUCTEUR / AFFECTATION / DESTRUCTEUR
//----------------------------------------------------------------------

    //  Constructeur
    Data ( );

    //  Constructeur de recopie
    Data ( const Data &d );

    //  Destructeur
    virtual ~Data ( );

//----------------------------------------------------------------------

  public:

    /*! Méthode qui fixe la longueur d'écriture en format texte.
     *  \param  l   longueur du format
     */
    static  inline void  SetLen  ( u_int l )
      {
        len = l;
        if (undef.length() < len)
          undef = string(len-undef.length(),' ') + undef;
      }

    /*! Méthode qui fixe la précision d'écriture en format texte.
     *  \param  p   précision du format
     */
    static  inline void  SetPrec ( u_int p ) { prec = p; }

    /*! Méthode qui fixe le caractère de remplissage en format texte.
     *  \param  c   caractère de remplissage
     */
    static  inline void  SetFill ( char c )  { fill = c; }

    /*! Méthode qui fixe la chaîne de caractères pour l'écriture
     *  d'une donnée non valide.
     *  \param  str   chaîne à écrire
     */
    static  inline void  SetFill ( const string &str )  { undef = str; }

    // retourne une donnée non valide
    static  Data & Bad();

//----------------------------------------------------------------------

    /*! Opérateur d'affectation d'une autre donnée.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Data & d ) { return (*this); }

    /*! Opérateur d'affectation d'une valeur de type entier 16 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int2 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 16 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int2 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 32 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 64 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real8 & d ) = 0;


//----------------------------------------------------------------------

    /*! Méthode virtuelle pure qui renvoit un identificateur de type
     * de données.
     */
    virtual u_int   TypeId ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant le type
     *  de données.
     */
    virtual string   Type ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant la valeur.
     */
    virtual string   String ( ) const = 0;

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données et la valeur.
     */
    inline virtual  string   Text ( ) const
    {
      return (string("(") + Type() + ") " + String());
    }

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données, la valeur et le mot d'état.
     */
    inline virtual  string   FullText ( ) const
    {
      return (Text() + " status = 0x" + GGetStringHexa((U_Int4) status));
    }

//----------------------------------------------------------------------
//  OPERATEURS DE CAST
//----------------------------------------------------------------------

    /*! Patron pour opérateur de cast vers différents types de
     *  données.
     */
    template < class T >  operator T  (void) const
      { T result; GetValue (result); return (result); }

//----------------------------------------------------------------------
    /*! Mise à valeur à l'aide d'un entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int2 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int4 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int8 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int2   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int4   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int8   &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real4  &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real8  &val ) = 0;

//----------------------------------------------------------------------

    /*! Affectation d'une variable de type entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int2 &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int4 &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int8 &val ) const = 0;

    /*! Affectation d'une variable de type entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

  dataTypeReal8     = (dataTypeReal | dataType64b)        // bits spécifiant le type de donnée};

//----------------------------------------------------------------------
#define   DATA_TYPE_TXT_UNDEFINED  "???"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT2     "U*2"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT4     "U*4"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT8     "U*8"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_INT2       "I*2"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_INT4       "I*4"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_INT8       "I*8"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_REAL4      "R*4"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_REAL8      "R*8"   ///< identifiant texte du type de donnée

//----------------------------------------------------------------------
const U_Int2  DATA_UI2_MAX  =  0xFFFF;      ///< valeur maxi pour conversion d'un entier
const Int2    DATA_I2_MIN   =  -32768;      ///< valeur mini pour conversion d'un entier
const Int2    DATA_I2_MAX   =   32767;      ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI2_RMAX =  65535.;      ///< valeur mini pour conversion d'un entier
const Real8   DATA_I2_RMIN  = -32768.;      ///< valeur mini pour conversion d'un réel
const Real8   DATA_I2_RMAX  =  32767.;      ///< valeur maxi pour conversion d'un réel

const U_Int2  DATA_UI2_SIGN = (DATA_UI2_MAX-DATA_I2_MAX); ///< Bit de signe 16 bits

//----------------------------------------------------------------------
const U_Int4  DATA_UI4_MAX  =  0xFFFFFFFF;  ///< valeur maxi pour conversion d'un entier
const Int4    DATA_I4_MIN   =  0x80000000;  ///< valeur mini pour conversion d'un entier
const Int4    DATA_I4_MAX   =  0x7FFFFFFF;  ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI4_RMAX =  4294967295.; ///< valeur mini pour conversion d'un entier
const Real8   DATA_I4_RMIN  = -2147483648.; ///< valeur mini pour conversion d'un réel
const Real8   DATA_I4_RMAX  =  2147483647.; ///< valeur maxi pour conversion d'un réel

const U_Int4  DATA_UI4_SIGN = (DATA_UI4_MAX-DATA_I4_MAX);   ///< Bit de signe 32 bits
const U_Int4  DATA_UI4_HI16 = (DATA_UI4_MAX-DATA_UI2_MAX);  ///< Masque binaire 16 bits forts sur 32 bits

//----------------------------------------------------------------------
// récupéré dans les includes de root
#ifndef __MAKECINT__
const U_Int8  DATA_UI8_MAX  = kMaxULong64;              ///< valeur maxi pour conversion d'un entier
const Int8    DATA_I8_MAX   = kMaxLong64;               ///< valeur mini pour conversion d'un entier
const Int8    DATA_I8_MIN   = kMinLong64;               ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI8_RMAX = Double_t(DATA_UI8_MAX);   ///< valeur mini pour conversion d'un entier
const Real8   DATA_I8_RMAX  = Double_t(DATA_I8_MAX);    ///< valeur mini pour conversion d'un réel
const Real8   DATA_I8_RMIN  = Double_t(DATA_I8_MIN);    ///< valeur maxi pour conversion d'un réel

const U_Int8  DATA_UI8_SIGN = (DATA_UI8_MAX-DATA_I8_MAX);   ///< Bit de signe 64 bits
const U_Int8  DATA_UI8_HI16 = (DATA_UI8_MAX-DATA_UI4_MAX);  ///< Masque binaire 16 bits forts sur 32 bits
const U_Int8  DATA_UI8_HI24 = (DATA_UI8_MAX-DATA_UI2_MAX);  ///< Masque binaire 24 bits forts sur 32 bits
#endif

/* NON IMPLEMENTE !!!
#define   DATA_I8_RMIN     -9223372036854775808.
#define   DATA_I8_RMAX      9223372036854775807.
#define   DATA_I8_MIN      -9223372036854775808
#define   DATA_I8_MAX       9223372036854775807
#define   DATA_UI8_RMAX     18446744065119617025.
#define   DATA_UI8_MAX      18446744065119617025
*/

//class Param;

//======================================================================
/*! \class Data
 *
 *  Classe générique (abstraite) pour les types de données.
 *  Ce sont les classes dérivées qui peuvent être instanciées: elles
 *  ont un type de données spécifique, qui ne peut pas être modifié !
 *  \note:
 *    - Les opérateurs d'affectation de valeurs numériques sont virtuels.
 *    - Pour les comparaison, il faut effectuer un cast.
 *    - Les objets dérivés de la classe Data n'ont pas vocation à
 *      être déclarés constant, parce qu'ils peuvent être modifiés
 *      (mot d'état) lorsqu'ils sont copiés ou affectés.
 *    - Les méthodes de cast vers les types numériques sont définis
 *      une fois pour toutes par une méthode patron de la classe de
 *      base Data, par un appel aux méthodes virtuelles GetValue.
 *    - Les méthodes GetValue, SetValue et l'opérateur d'affection
 *      doivent être définis dans les classes dérivées pour l'ensemble
 *      des types de valeurs considérés.
 *
 *  Les objets de la classe Data (et de ses dérivées) gèrent automatiquement
 *  les changements de type. Dans ce cas, le mot d'état (status) rend
 *  compte des difficultés ou impossibilités de conversions.
 *
 */
class Data
{
//----------------------------------------------------------------------
  /*! \object_doc */
  GObjectV(Data);
//----------------------------------------------------------------------

  protected:

    static  u_int   len;    ///<  Longueur d'affichage
    static  u_int   prec;   ///<  Précision d'affichage
    static  char    fill;   ///<  Caractère de remplissage
    static  string  undef;  ///<  Chaîne pour l'écriture de donnée non valide

    int   status;           ///<  Indicateur de l'état des conversions de types

  public:

//----------------------------------------------------------------------
//  CONSTRUCTEUR / AFFECTATION / DESTRUCTEUR
//----------------------------------------------------------------------

    //  Constructeur
    Data ( );

    //  Constructeur de recopie
    Data ( const Data &d );

    //  Destructeur
    virtual ~Data ( );

//----------------------------------------------------------------------

  public:

    /*! Méthode qui fixe la longueur d'écriture en format texte.
     *  \param  l   longueur du format
     */
    static  inline void  SetLen  ( u_int l )
      {
        len = l;
        if (undef.length() < len)
          undef = string(len-undef.length(),' ') + undef;
      }

    /*! Méthode qui fixe la précision d'écriture en format texte.
     *  \param  p   précision du format
     */
    static  inline void  SetPrec ( u_int p ) { prec = p; }

    /*! Méthode qui fixe le caractère de remplissage en format texte.
     *  \param  c   caractère de remplissage
     */
    static  inline void  SetFill ( char c )  { fill = c; }

    /*! Méthode qui fixe la chaîne de caractères pour l'écriture
     *  d'une donnée non valide.
     *  \param  str   chaîne à écrire
     */
    static  inline void  SetFill ( const string &str )  { undef = str; }

    // retourne une donnée non valide
    static  Data & Bad();

//----------------------------------------------------------------------

    /*! Opérateur d'affectation d'une autre donnée.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Data & d ) { return (*this); }

    /*! Opérateur d'affectation d'une valeur de type entier 16 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int2 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 16 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int2 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 32 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 64 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real8 & d ) = 0;


//----------------------------------------------------------------------

    /*! Méthode virtuelle pure qui renvoit un identificateur de type
     * de données.
     */
    virtual u_int   TypeId ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant le type
     *  de données.
     */
    virtual string   Type ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant la valeur.
     */
    virtual string   String ( ) const = 0;

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données et la valeur.
     */
    inline virtual  string   Text ( ) const
    {
      return (string("(") + Type() + ") " + String());
    }

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données, la valeur et le mot d'état.
     */
    inline virtual  string   FullText ( ) const
    {
      return (Text() + " status = 0x" + GGetStringHexa((U_Int4) status));
    }

//----------------------------------------------------------------------
//  OPERATEURS DE CAST
//----------------------------------------------------------------------

    /*! Patron pour opérateur de cast vers différents types de
     *  données.
     */
    template < class T >  operator T  (void) const
      { T result; GetValue (result); return (result); }

//----------------------------------------------------------------------
    /*! Mise à valeur à l'aide d'un entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int2 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int4 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int8 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int2   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int4   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int8   &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real4  &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real8  &val ) = 0;

//----------------------------------------------------------------------

    /*! Affectation d'une variable de type entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int2 &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int4 &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int8 &val ) const = 0;

    /*! Affectation d'une variable de type entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

};

//----------------------------------------------------------------------
#define   DATA_TYPE_TXT_UNDEFINED  "???"   ///< identifiant texte du type de donnée
#define   DATA_TYPE_TXT_U_INT2     "U*2"   ///< identifiant texte du type de donnée5„
#define   DATA_TYPE_TXT_U_INT4     "U*4"   ///< identifiant texte du type de donnée5„
#define   DATA_TYPE_TXT_U_INT8     "U*8"   ///< identifiant texte du type de donnée5„
#define   DATA_TYPE_TXT_INT2       "I*2"   ///< identifiant texte du type de donnée5„
#define   DATA_TYPE_TXT_INT4       "I*4"   ///< identifiant texte du type de donnée5„
#define   DATA_TYPE_TXT_INT8       "I*8"   ///< identifiant texte du type de donnée5„
#define   DATA_TYPE_TXT_REAL4      "R*4"   ///< identifiant texte du type de donnée5„
#define   DATA_TYPE_TXT_REAL8      "R*8"   ///< identifiant texte du type de donnée5„

//----------------------------------------------------------------------
const U_Int2  DATA_UI2_MAX  =  0xFFFF;      ///< valeur maxi pour conversion d'un entier
const Int2    DATA_I2_MIN   =  -32768;      ///< valeur mini pour conversion d'un entier
const Int2    DATA_I2_MAX   =   32767;      ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI2_RMAX =  65535.;      ///< valeur mini pour conversion d'un entier
const Real8   DATA_I2_RMIN  = -32768.;      ///< valeur mini pour conversion d'un réel
const Real8   DATA_I2_RMAX  =  32767.;      ///< valeur maxi pour conversion d'un réel

const U_Int2  DATA_UI2_SIGN = (DATA_UI2_MAX-DATA_I2_MAX); ///< Bit de signe 16 bits

//----------------------------------------------------------------------
const U_Int4  DATA_UI4_MAX  =  0xFFFFFFFF;  ///< valeur maxi pour conversion d'un entier
const Int4    DATA_I4_MIN   =  0x80000000;  ///< valeur mini pour conversion d'un entier
const Int4    DATA_I4_MAX   =  0x7FFFFFFF;  ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI4_RMAX =  4294967295.; ///< valeur mini pour conversion d'un entier
const Real8   DATA_I4_RMIN  = -2147483648.; ///< valeur mini pour conversion d'un réel
const Real8   DATA_I4_RMAX  =  2147483647.; ///< valeur maxi pour conversion d'un réel

const U_Int4  DATA_UI4_SIGN = (DATA_UI4_MAX-DATA_I4_MAX);   ///< Bit de signe 32 bits
const U_Int4  DATA_UI4_HI16 = (DATA_UI4_MAX-DATA_UI2_MAX);  ///< Masque binaire 16 bits forts sur 32 bits

//----------------------------------------------------------------------
// récupéré dans les includes de root
#ifndef __MAKECINT__
const U_Int8  DATA_UI8_MAX  = kMaxULong64;              ///< valeur maxi pour conversion d'un entier
const Int8    DATA_I8_MAX   = kMaxLong64;               ///< valeur mini pour conversion d'un entier
const Int8    DATA_I8_MIN   = kMinLong64;               ///< valeur maxi pour conversion d'un entier
const Real8   DATA_UI8_RMAX = Double_t(DATA_UI8_MAX);   ///< valeur mini pour conversion d'un entier
const Real8   DATA_I8_RMAX  = Double_t(DATA_I8_MAX);    ///< valeur mini pour conversion d'un réel
const Real8   DATA_I8_RMIN  = Double_t(DATA_I8_MIN);    ///< valeur maxi pour conversion d'un réel

const U_Int8  DATA_UI8_SIGN = (DATA_UI8_MAX-DATA_I8_MAX);   ///< Bit de signe 64 bits
const U_Int8  DATA_UI8_HI16 = (DATA_UI8_MAX-DATA_UI4_MAX);  ///< Masque binaire 16 bits forts sur 32 bits
const U_Int8  DATA_UI8_HI24 = (DATA_UI8_MAX-DATA_UI2_MAX);  ///< Masque binaire 24 bits forts sur 32 bits
#endif

/* NON IMPLEMENTE !!!
#define   DATA_I8_RMIN     -9223372036854775808.
#define   DATA_I8_RMAX      9223372036854775807.
#define   DATA_I8_MIN      -9223372036854775808
#define   DATA_I8_MAX       9223372036854775807
#define   DATA_UI8_RMAX     18446744065119617025.
#define   DATA_UI8_MAX      18446744065119617025
*/

//class Param;

//======================================================================
/*! \class Data
 *
 *  Classe générique (abstraite) pour les types de données.
 *  Ce sont les classes dérivées qui peuvent être instanciées: elles
 *  ont un type de données spécifique, qui ne peut pas être modifié !
 *  \note:
 *    - Les opérateurs d'affectation de valeurs numériques sont virtuels.
 *    - Pour les comparaison, il faut effectuer un cast.
 *    - Les objets dérivés de la classe Data n'ont pas vocation à *      être déclarés constant, parce qu'ils peuvent être modifiés
 *      (mot d'état) lorsqu'ils sont copiés ou affectés.
 *    - Les méthodes de cast vers les types numériques sont définis
 *      une fois pour toutes par une méthode patron de la classe de
 *      base Data, par un appel aux méthodes virtuelles GetValue.
 *    - Les méthodes GetValue, SetValue et l'opérateur d'affection
 *      doivent être définis dans les classes dérivées pour l'ensemble
 *      des types de valeurs considérés.
 *
 *  Les objets de la classe Data (et de ses dérivées) gèrent automatiquement
 *  les changements de type. Dans ce cas, le mot d'état (status) rend
 *  compte des difficultés ou impossibilités de conversions.
 *
 */
class Data
{
//----------------------------------------------------------------------
  /*! \object_doc */
  GObjectV(Data);
//----------------------------------------------------------------------

  protected:

    static  u_int   len;    ///<  Longueur d'affichage
    static  u_int   prec;   ///<  Précision d'affichage
    static  char    fill;   ///<  Caractère de remplissage
    static  string  undef;  ///<  Chaîne pour l'écriture de donnée non valide

    int   status;           ///<  Indicateur de l'état des conversions de types

  public:

//----------------------------------------------------------------------
//  CONSTRUCTEUR / AFFECTATION / DESTRUCTEUR
//----------------------------------------------------------------------

    //  Constructeur
    Data ( );

    //  Constructeur de recopie
    Data ( const Data &d );

    //  Destructeur
    virtual ~Data ( );

//----------------------------------------------------------------------

  public:

    /*! Méthode qui fixe la longueur d'écriture en format texte.
     *  \param  l   longueur du format
     */
    static  inline void  SetLen  ( u_int l )
      {
        len = l;
        if (undef.length() < len)
          undef = string(len-undef.length(),' ') + undef;
      }

    /*! Méthode qui fixe la précision d'écriture en format texte.
     *  \param  p   précision du format
     */
    static  inline void  SetPrec ( u_int p ) { prec = p; }

    /*! Méthode qui fixe le caractère de remplissage en format texte.
     *  \param  c   caractère de remplissage
     */
    static  inline void  SetFill ( char c )  { fill = c; }

    /*! Méthode qui fixe la chaîne de caractères pour l'écriture
     *  d'une donnée non valide.
     *  \param  str   chaîne à écrire
     */
    static  inline void  SetFill ( const string &str )  { undef = str; }

    // retourne une donnée non valide
    static  Data & Bad();

//----------------------------------------------------------------------

    /*! Opérateur d'affectation d'une autre donnée.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Data & d ) { return (*this); }

    /*! Opérateur d'affectation d'une valeur de type entier 16 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int2 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 16 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int2 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 32 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 64 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real8 & d ) = 0;


//----------------------------------------------------------------------

    /*! Méthode virtuelle pure qui renvoit un identificateur de type
     * de données.
     */
    virtual u_int   TypeId ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant le type
     *  de données.
     */
    virtual string   Type ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant la valeur.
     */
    virtual string   String ( ) const = 0;

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données et la valeur.
     */
    inline virtual  string   Text ( ) const
    {
      return (string("(") + Type() + ") " + String());
    }

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données, la valeur et le mot d'état.
     */
    inline virtual  string   FullText ( ) const
    {
      return (Text() + " status = 0x" + GGetStringHexa((U_Int4) status));
    }

//----------------------------------------------------------------------
//  OPERATEURS DE CAST
//----------------------------------------------------------------------

    /*! Patron pour opérateur de cast vers différents types de
     *  données.
     */
    template < class T >  operator T  (void) const
      { T result; GetValue (result); return (result); }

//----------------------------------------------------------------------
    /*! Mise à valeur à l'aide d'un entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int2 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int4 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int8 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int2   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int4   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int8   &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real4  &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real8  &val ) = 0;

//----------------------------------------------------------------------

    /*! Affectation d'une variable de type entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int2 &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int4 &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int8 &val ) const = 0;

    /*! Affectation d'une variable de type entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

 *      être déclarés constant, parce qu'ils peuvent être modifiés *      (mot d'état) lorsqu'ils sont copiés ou affectés.
 *    - Les méthodes de cast vers les types numériques sont définis
 *      une fois pour toutes par une méthode patron de la classe de
 *      base Data, par un appel aux méthodes virtuelles GetValue.
 *    - Les méthodes GetValue, SetValue et l'opérateur d'affection
 *      doivent être définis dans les classes dérivées pour l'ensemble
 *      des types de valeurs considérés.
 *
 *  Les objets de la classe Data (et de ses dérivées) gèrent automatiquement
 *  les changements de type. Dans ce cas, le mot d'état (status) rend
 *  compte des difficultés ou impossibilités de conversions.
 *
 */
class Data
{
//----------------------------------------------------------------------
  /*! \object_doc */
  GObjectV(Data);
//----------------------------------------------------------------------

  protected:

    static  u_int   len;    ///<  Longueur d'affichage
    static  u_int   prec;   ///<  Précision d'affichage
    static  char    fill;   ///<  Caractère de remplissage
    static  string  undef;  ///<  Chaîne pour l'écriture de donnée non valide

    int   status;           ///<  Indicateur de l'état des conversions de types

  public:

//----------------------------------------------------------------------
//  CONSTRUCTEUR / AFFECTATION / DESTRUCTEUR
//----------------------------------------------------------------------

    //  Constructeur
    Data ( );

    //  Constructeur de recopie
    Data ( const Data &d );

    //  Destructeur
    virtual ~Data ( );

//----------------------------------------------------------------------

  public:

    /*! Méthode qui fixe la longueur d'écriture en format texte.
     *  \param  l   longueur du format
     */
    static  inline void  SetLen  ( u_int l )
      {
        len = l;
        if (undef.length() < len)
          undef = string(len-undef.length(),' ') + undef;
      }

    /*! Méthode qui fixe la précision d'écriture en format texte.
     *  \param  p   précision du format
     */
    static  inline void  SetPrec ( u_int p ) { prec = p; }

    /*! Méthode qui fixe le caractère de remplissage en format texte.
     *  \param  c   caractère de remplissage
     */
    static  inline void  SetFill ( char c )  { fill = c; }

    /*! Méthode qui fixe la chaîne de caractères pour l'écriture
     *  d'une donnée non valide.
     *  \param  str   chaîne à écrire
     */
    static  inline void  SetFill ( const string &str )  { undef = str; }

    // retourne une donnée non valide
    static  Data & Bad();

//----------------------------------------------------------------------

    /*! Opérateur d'affectation d'une autre donnée.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Data & d ) { return (*this); }

    /*! Opérateur d'affectation d'une valeur de type entier 16 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int2 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 16 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int2 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 32 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 64 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real8 & d ) = 0;


//----------------------------------------------------------------------

    /*! Méthode virtuelle pure qui renvoit un identificateur de type
     * de données.
     */
    virtual u_int   TypeId ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant le type
     *  de données.
     */
    virtual string   Type ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant la valeur.
     */
    virtual string   String ( ) const = 0;

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données et la valeur.
     */
    inline virtual  string   Text ( ) const
    {
      return (string("(") + Type() + ") " + String());
    }

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données, la valeur et le mot d'état.
     */
    inline virtual  string   FullText ( ) const
    {
      return (Text() + " status = 0x" + GGetStringHexa((U_Int4) status));
    }

//----------------------------------------------------------------------
//  OPERATEURS DE CAST
//----------------------------------------------------------------------

    /*! Patron pour opérateur de cast vers différents types de
     *  données.
     */
    template < class T >  operator T  (void) const
      { T result; GetValue (result); return (result); }

//----------------------------------------------------------------------
    /*! Mise à valeur à l'aide d'un entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int2 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int4 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int8 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int2   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int4   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int8   &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real4  &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real8  &val ) = 0;

//----------------------------------------------------------------------

    /*! Affectation d'une variable de type entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int2 &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int4 &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int8 &val ) const = 0;

    /*! Affectation d'une variable de type entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

 *      (mot d'état) lorsqu'ils sont copiés ou affectés.
 *    - Les méthodes de cast vers les types numériques sont définis
 *      une fois pour toutes par une méthode patron de la classe de
 *      base Data, par un appel aux méthodes virtuelles GetValue.
 *    - Les méthodes GetValue, SetValue et l'opérateur d'affection
 *      doivent être définis dans les classes dérivées pour l'ensemble
 *      des types de valeurs considérés.
 *
 *  Les objets de la classe Data (et de ses dérivées) gèrent automatiquement
 *  les changements de type. Dans ce cas, le mot d'état (status) rend
 *  compte des difficultés ou impossibilités de conversions.
 *
 */
class Data
{
//----------------------------------------------------------------------
  /*! \object_doc */
  GObjectV(Data);
//----------------------------------------------------------------------

  protected:

    static  u_int   len;    ///<  Longueur d'affichage
    static  u_int   prec;   ///<  Précision d'affichage
    static  char    fill;   ///<  Caractère de remplissage
    static  string  undef;  ///<  Chaîne pour l'écriture de donnée non valide

    int   status;           ///<  Indicateur de l'état des conversions de types

  public:

//----------------------------------------------------------------------
//  CONSTRUCTEUR / AFFECTATION / DESTRUCTEUR
//----------------------------------------------------------------------

    //  Constructeur
    Data ( );

    //  Constructeur de recopie
    Data ( const Data &d );

    //  Destructeur
    virtual ~Data ( );

//----------------------------------------------------------------------

  public:

    /*! Méthode qui fixe la longueur d'écriture en format texte.
     *  \param  l   longueur du format
     */
    static  inline void  SetLen  ( u_int l )
      {
        len = l;
        if (undef.length() < len)
          undef = string(len-undef.length(),' ') + undef;
      }

    /*! Méthode qui fixe la précision d'écriture en format texte.
     *  \param  p   précision du format
     */
    static  inline void  SetPrec ( u_int p ) { prec = p; }

    /*! Méthode qui fixe le caractère de remplissage en format texte.
     *  \param  c   caractère de remplissage
     */
    static  inline void  SetFill ( char c )  { fill = c; }

    /*! Méthode qui fixe la chaîne de caractères pour l'écriture
     *  d'une donnée non valide.
     *  \param  str   chaîne à écrire
     */
    static  inline void  SetFill ( const string &str )  { undef = str; }

    // retourne une donnée non valide
    static  Data & Bad();

//----------------------------------------------------------------------

    /*! Opérateur d'affectation d'une autre donnée.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Data & d ) { return (*this); }

    /*! Opérateur d'affectation d'une valeur de type entier 16 bits signé.     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int2 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 16 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int2 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 32 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 64 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real8 & d ) = 0;


//----------------------------------------------------------------------

    /*! Méthode virtuelle pure qui renvoit un identificateur de type
     * de données.
     */
    virtual u_int   TypeId ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant le type
     *  de données.
     */
    virtual string   Type ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant la valeur.
     */
    virtual string   String ( ) const = 0;

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données et la valeur.
     */
    inline virtual  string   Text ( ) const
    {
      return (string("(") + Type() + ") " + String());
    }

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données, la valeur et le mot d'état.
     */
    inline virtual  string   FullText ( ) const
    {
      return (Text() + " status = 0x" + GGetStringHexa((U_Int4) status));
    }

//----------------------------------------------------------------------
//  OPERATEURS DE CAST
//----------------------------------------------------------------------

    /*! Patron pour opérateur de cast vers différents types de
     *  données.
     */
    template < class T >  operator T  (void) const
      { T result; GetValue (result); return (result); }

//----------------------------------------------------------------------
    /*! Mise à valeur à l'aide d'un entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int2 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int4 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int8 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int2   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int4   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int8   &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real4  &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real8  &val ) = 0;

//----------------------------------------------------------------------

    /*! Affectation d'une variable de type entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int2 &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int4 &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int8 &val ) const = 0;

    /*! Affectation d'une variable de type entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int2 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 16 bits non signé.     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int2 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 32 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 64 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real8 & d ) = 0;


//----------------------------------------------------------------------

    /*! Méthode virtuelle pure qui renvoit un identificateur de type
     * de données.
     */
    virtual u_int   TypeId ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant le type
     *  de données.
     */
    virtual string   Type ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant la valeur.
     */
    virtual string   String ( ) const = 0;

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données et la valeur.
     */
    inline virtual  string   Text ( ) const
    {
      return (string("(") + Type() + ") " + String());
    }

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données, la valeur et le mot d'état.
     */
    inline virtual  string   FullText ( ) const
    {
      return (Text() + " status = 0x" + GGetStringHexa((U_Int4) status));
    }

//----------------------------------------------------------------------
//  OPERATEURS DE CAST
//----------------------------------------------------------------------

    /*! Patron pour opérateur de cast vers différents types de
     *  données.
     */
    template < class T >  operator T  (void) const
      { T result; GetValue (result); return (result); }

//----------------------------------------------------------------------
    /*! Mise à valeur à l'aide d'un entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int2 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int4 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int8 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int2   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int4   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int8   &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real4  &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real8  &val ) = 0;

//----------------------------------------------------------------------

    /*! Affectation d'une variable de type entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int2 &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int4 &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int8 &val ) const = 0;

    /*! Affectation d'une variable de type entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int2 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits signé.     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 32 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 64 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real8 & d ) = 0;


//----------------------------------------------------------------------

    /*! Méthode virtuelle pure qui renvoit un identificateur de type
     * de données.
     */
    virtual u_int   TypeId ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant le type
     *  de données.
     */
    virtual string   Type ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant la valeur.
     */
    virtual string   String ( ) const = 0;

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données et la valeur.
     */
    inline virtual  string   Text ( ) const
    {
      return (string("(") + Type() + ") " + String());
    }

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données, la valeur et le mot d'état.
     */
    inline virtual  string   FullText ( ) const
    {
      return (Text() + " status = 0x" + GGetStringHexa((U_Int4) status));
    }

//----------------------------------------------------------------------
//  OPERATEURS DE CAST
//----------------------------------------------------------------------

    /*! Patron pour opérateur de cast vers différents types de
     *  données.
     */
    template < class T >  operator T  (void) const
      { T result; GetValue (result); return (result); }

//----------------------------------------------------------------------
    /*! Mise à valeur à l'aide d'un entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int2 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int4 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int8 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int2   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int4   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int8   &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real4  &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real8  &val ) = 0;

//----------------------------------------------------------------------

    /*! Affectation d'une variable de type entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int2 &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int4 &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int8 &val ) const = 0;

    /*! Affectation d'une variable de type entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 32 bits non signé.     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 32 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 64 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real8 & d ) = 0;


//----------------------------------------------------------------------

    /*! Méthode virtuelle pure qui renvoit un identificateur de type
     * de données.
     */
    virtual u_int   TypeId ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant le type
     *  de données.
     */
    virtual string   Type ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant la valeur.
     */
    virtual string   String ( ) const = 0;

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données et la valeur.
     */
    inline virtual  string   Text ( ) const
    {
      return (string("(") + Type() + ") " + String());
    }

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données, la valeur et le mot d'état.
     */
    inline virtual  string   FullText ( ) const
    {
      return (Text() + " status = 0x" + GGetStringHexa((U_Int4) status));
    }

//----------------------------------------------------------------------
//  OPERATEURS DE CAST
//----------------------------------------------------------------------

    /*! Patron pour opérateur de cast vers différents types de
     *  données.
     */
    template < class T >  operator T  (void) const
      { T result; GetValue (result); return (result); }

//----------------------------------------------------------------------
    /*! Mise à valeur à l'aide d'un entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int2 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int4 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int8 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int2   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int4   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int8   &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real4  &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real8  &val ) = 0;

//----------------------------------------------------------------------

    /*! Affectation d'une variable de type entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int2 &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int4 &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int8 &val ) const = 0;

    /*! Affectation d'une variable de type entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits signé.     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 32 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 64 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real8 & d ) = 0;


//----------------------------------------------------------------------

    /*! Méthode virtuelle pure qui renvoit un identificateur de type
     * de données.
     */
    virtual u_int   TypeId ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant le type
     *  de données.
     */
    virtual string   Type ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant la valeur.
     */
    virtual string   String ( ) const = 0;

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données et la valeur.
     */
    inline virtual  string   Text ( ) const
    {
      return (string("(") + Type() + ") " + String());
    }

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données, la valeur et le mot d'état.
     */
    inline virtual  string   FullText ( ) const
    {
      return (Text() + " status = 0x" + GGetStringHexa((U_Int4) status));
    }

//----------------------------------------------------------------------
//  OPERATEURS DE CAST
//----------------------------------------------------------------------

    /*! Patron pour opérateur de cast vers différents types de
     *  données.
     */
    template < class T >  operator T  (void) const
      { T result; GetValue (result); return (result); }

//----------------------------------------------------------------------
    /*! Mise à valeur à l'aide d'un entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int2 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int4 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int8 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int2   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int4   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int8   &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real4  &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real8  &val ) = 0;

//----------------------------------------------------------------------

    /*! Affectation d'une variable de type entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int2 &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int4 &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int8 &val ) const = 0;

    /*! Affectation d'une variable de type entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé.     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 32 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 64 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real8 & d ) = 0;


//----------------------------------------------------------------------

    /*! Méthode virtuelle pure qui renvoit un identificateur de type
     * de données.
     */
    virtual u_int   TypeId ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant le type
     *  de données.
     */
    virtual string   Type ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant la valeur.
     */
    virtual string   String ( ) const = 0;

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données et la valeur.
     */
    inline virtual  string   Text ( ) const
    {
      return (string("(") + Type() + ") " + String());
    }

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données, la valeur et le mot d'état.
     */
    inline virtual  string   FullText ( ) const
    {
      return (Text() + " status = 0x" + GGetStringHexa((U_Int4) status));
    }

//----------------------------------------------------------------------
//  OPERATEURS DE CAST
//----------------------------------------------------------------------

    /*! Patron pour opérateur de cast vers différents types de
     *  données.
     */
    template < class T >  operator T  (void) const
      { T result; GetValue (result); return (result); }

//----------------------------------------------------------------------
    /*! Mise à valeur à l'aide d'un entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int2 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int4 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int8 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int2   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int4   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int8   &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real4  &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real8  &val ) = 0;

//----------------------------------------------------------------------

    /*! Affectation d'une variable de type entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int2 &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int4 &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int8 &val ) const = 0;

    /*! Affectation d'une variable de type entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const U_Int8 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 32 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real4 & d ) = 0;

    /*! Opérateur d'affectation d'une valeur de type réel 64 bits.
     *  \param  d   donnée à affecter
     */
    virtual Data & operator = ( const Real8 & d ) = 0;


//----------------------------------------------------------------------

    /*! Méthode virtuelle pure qui renvoit un identificateur de type
     * de données.
     */
    virtual u_int   TypeId ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant le type
     *  de données.
     */
    virtual string   Type ( ) const = 0;

    /*! Méthode virtuelle pure qui renvoit une chaîne indiquant la valeur.
     */
    virtual string   String ( ) const = 0;

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données et la valeur.
     */
    inline virtual  string   Text ( ) const
    {
      return (string("(") + Type() + ") " + String());
    }

    /*! Méthode qui renvoit une chaîne indiquant le type
     *  de données, la valeur et le mot d'état.
     */
    inline virtual  string   FullText ( ) const
    {
      return (Text() + " status = 0x" + GGetStringHexa((U_Int4) status));
    }

//----------------------------------------------------------------------
//  OPERATEURS DE CAST
//----------------------------------------------------------------------

    /*! Patron pour opérateur de cast vers différents types de
     *  données.
     */
    template < class T >  operator T  (void) const
      { T result; GetValue (result); return (result); }

//----------------------------------------------------------------------
    /*! Mise à valeur à l'aide d'un entier 16 bits non signé.     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int2 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int4 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int8 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int2   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int4   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int8   &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real4  &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real8  &val ) = 0;

//----------------------------------------------------------------------

    /*! Affectation d'une variable de type entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int2 &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int4 &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int8 &val ) const = 0;

    /*! Affectation d'une variable de type entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int2 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits non signé.     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int4 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int8 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int2   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int4   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int8   &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real4  &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real8  &val ) = 0;

//----------------------------------------------------------------------

    /*! Affectation d'une variable de type entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int2 &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int4 &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int8 &val ) const = 0;

    /*! Affectation d'une variable de type entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int4 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits non signé.     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int8 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int2   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int4   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int8   &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real4  &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real8  &val ) = 0;

//----------------------------------------------------------------------

    /*! Affectation d'une variable de type entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int2 &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int4 &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int8 &val ) const = 0;

    /*! Affectation d'une variable de type entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const U_Int8 &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 16 bits signé.     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int2   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int4   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int8   &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real4  &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real8  &val ) = 0;

//----------------------------------------------------------------------

    /*! Affectation d'une variable de type entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int2 &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int4 &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int8 &val ) const = 0;

    /*! Affectation d'une variable de type entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int2   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 32 bits signé.     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int4   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int8   &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real4  &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real8  &val ) = 0;

//----------------------------------------------------------------------

    /*! Affectation d'une variable de type entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int2 &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int4 &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int8 &val ) const = 0;

    /*! Affectation d'une variable de type entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int4   &val ) = 0;

    /*! Mise à valeur à l'aide d'un entier 64 bits signé.     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int8   &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real4  &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real8  &val ) = 0;

//----------------------------------------------------------------------

    /*! Affectation d'une variable de type entier 16 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int2 &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int4 &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int8 &val ) const = 0;

    /*! Affectation d'une variable de type entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Int8   &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real4  &val ) = 0;

    /*! Mise à valeur à l'aide d'un réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  SetValue ( const Real8  &val ) = 0;

//----------------------------------------------------------------------

    /*! Affectation d'une variable de type entier 16 bits non signé.     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int2 &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int4 &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int8 &val ) const = 0;

    /*! Affectation d'une variable de type entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int2 &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits non signé.     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int4 &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits non signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int8 &val ) const = 0;

    /*! Affectation d'une variable de type entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int4 &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits non signé.     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int8 &val ) const = 0;

    /*! Affectation d'une variable de type entier 16 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( U_Int8 &val ) const = 0;

    /*! Affectation d'une variable de type entier 16 bits signé.     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int2   &val ) const = 0;

    /*! Affectation d'une variable de type entier 32 bits signé.     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int4   &val ) const = 0;

    /*! Affectation d'une variable de type entier 64 bits signé.     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné
     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Int8   &val ) const = 0;

    /*! Affectation d'une variable de type réel 32 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real4  &val ) const = 0;

    /*! Affectation d'une variable de type réel 64 bits.
     *  La valeur en retour est le statut de conversion.
     */
    virtual int  GetValue ( Real8  &val ) const = 0;


    /*! Patron pour opérateu de cast vers différents types de
     *  données qui met à jour le mot d'état (après conversion
     *  de type).
     */
    template < class T > T Value ( )
    {
      T   result;
      status = GetValue ( result );
      return (result);
    }

//----------------------------------------------------------------------
//  TEST DES CASTS
//----------------------------------------------------------------------

    /*! Méthode qui renvoit le mot d'état d'une donnée. Si le mot
     *  d'état est négatif, c'est que la dernière affectation a donné     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif

     *  lieu à une mauvaise conversion.
     */
    inline int Status() const { return (status); }

    /*! Méthode qui retourne vrai si une donnée est considérée
     *  comme utilisable.
     */
    inline bool IsValid () const
      { return ( (status & DATA_BAD) == 0 ); }

    /*! Méthode qui positionne le bit DATA_BAD du mot d'état.
     */
    inline void SetBad ()
      { status  = status | DATA_BAD; }

    // retourne une indication textuelle de l'état de conversion.
    string  CastInfo();

  public:
    friend ostream & operator << ( ostream &os, const Data &d );

//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! Définition à usage de ROOT... */
    ClassDef(Data,0);
} ;


//======================================================================
//  FONCTIONS ASSOCIEES
//======================================================================

/*! Opérateur de direction d'une donnée vers un flux de sortie.
 *  \param  os  flux de sortie
 *  \param  d donnée à écrire
 */
inline ostream & operator << ( ostream & os, const Data &d )
  { return (os << d.String()); }

//======================================================================

#endif