Analysis  version 7.0 - august 2014
DataBad.hh
Go to the documentation of this file.
1 //======================================================================
2 /*! \file DataBad.hh
3  *
4  * Déclaration des méthodes de la classe DataBad qui sert à définir
5  * un singleton dérivé de Data pour une donnée non valide.
6  */
7 //======================================================================
8 
9 #ifndef DATA_BAD_HH
10 #define DATA_BAD_HH
11 
12 #include "Data.hh"
13 
14 //======================================================================
15 /*! \class DataBad
16  *
17  * Classe décrivant les données non valides.
18  */
19 class DataBad : public Data
20 {
21 //----------------------------------------------------------------------
22  /*! \object_doc */
23  GObject(DataBad);
24 //----------------------------------------------------------------------
25 
26  protected:
27 
28  public:
29  static DataBad & GetInstance();
30 
31 //----------------------------------------------------------------------
32 // CONSTRUCTEUR / AFFECTATION / DESTRUCTEUR
33 //----------------------------------------------------------------------
34 
35  private:
36  // Constructeur
37  DataBad ( );
38 
39  // Constructeur de recopie à partir d'une donnée quelconque
40  DataBad ( const Data &d );
41 
42  /*! Opérateur d'affectation d'une autre donnée.
43  * \param d donnée à affecter
44  */
45  inline DataBad & operator = ( const Data & d )
46  {
47  status = 0xFFFFFFFF;
48  return (*this);
49  }
50 
51  public:
52 
53  // Destructeur
54  virtual ~DataBad ( );
55 
56  /*! Opérateur d'affectation d'une valeur de type entier 16 bits signé. * \param d donnée à affecter */ inline DataBad & operator = ( const Int2 & d ) { return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 16 bits non signé. * \param d donnée à affecter */ inline DataBad & operator = ( const U_Int2 & d ) { return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 32 bits signé. * \param d donnée à affecter */ inline DataBad & operator = ( const Int4 & d ) { return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 32 bits non signé. * \param d donnée à affecter */ inline DataBad & operator = ( const U_Int4 & d ) { return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 64 bits signé. * \param d donnée à affecter */ inline DataBad & operator = ( const Int8 & d ) { return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé. * \param d donnée à affecter */ inline DataBad & operator = ( const U_Int8 & d ) { return (*this); } /*! Opérateur d'affectation d'une valeur de type réel 32 bits. * \param d donnée à affecter */ inline DataBad & operator = ( const Real4 & d ) { return (*this); } /*! Opérateur d'affectation d'une valeur de type réel 64 bits. * \param d donnée à affecter */ inline DataBad & operator = ( const Real8 & d ) { return (*this); } //---------------------------------------------------------------------- /*! Méthode qui renvoit un identificateur de type * de données. */ inline u_int TypeId ( ) const { return (DATA_TYPE_UNDEFINED); } /*! Méthode qui renvoit une chaîne indiquant le type de données. */ inline string Type ( ) const { return (DATA_TYPE_TXT_UNDEFINED); } /*! Méthode qui renvoit une chaîne indiquant la valeur. */ inline string String ( ) const { return (undef); } //---------------------------------------------------------------------- // Méthodes d'affectation de valeurs //---------------------------------------------------------------------- int SetValue ( const U_Int2 &val ); int SetValue ( const U_Int4 &val ); int SetValue ( const U_Int8 &val ); int SetValue ( const Int2 &val ); int SetValue ( const Int4 &val ); int SetValue ( const Int8 &val ); int SetValue ( const Real4 &val ); int SetValue ( const Real8 &val ); int GetValue ( U_Int2 &val ) const; int GetValue ( U_Int4 &val ) const; int GetValue ( U_Int8 &val ) const; int GetValue ( Int2 &val ) const; int GetValue ( Int4 &val ) const; int GetValue ( Int8 &val ) const; int GetValue ( Real4 &val ) const; int GetValue ( Real8 &val ) const; //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(DataBad,0); } ; //====================================================================== // METHODES INLINE //====================================================================== //---------------------------------------------------------------------- // Méthodes d'affectation de valeurs /*! Mise à valeur à l'aide d'un entier 16 bits non signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const U_Int2 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 16 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int2 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 32 bits non signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const U_Int4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 32 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 64 bits non signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const U_Int8 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 64 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int8 &val ) { return (status); } /*! Mise à valeur à l'aide d'un réel 32 bits. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Real4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un réel 64 bits. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Real8 &val ) { return (status); } //---------------------------------------------------------------------- // Méthodes de répurération de valeur /*! Affectation de la valeur à une variable de type entier 16 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int2 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 16 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int2 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type réel 32 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real4 &val ) const { val = 0.; return (status); } /*! Affectation de la valeur à une variable de type réel 64 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real8 &val ) const { val = 0.; return (status); } //====================================================================== /*! Définition de l'instance unique (singleton) de la classe DataBad. */ extern DataBad & bad_data; //====================================================================== #endif
57  * \param d donnée à affecter
58  */
59  inline DataBad & operator = ( const Int2 & d )
60  { return (*this); }
61 
62  /*! Opérateur d'affectation d'une valeur de type entier 16 bits non signé. * \param d donnée à affecter */ inline DataBad & operator = ( const U_Int2 & d ) { return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 32 bits signé. * \param d donnée à affecter */ inline DataBad & operator = ( const Int4 & d ) { return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 32 bits non signé. * \param d donnée à affecter */ inline DataBad & operator = ( const U_Int4 & d ) { return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 64 bits signé. * \param d donnée à affecter */ inline DataBad & operator = ( const Int8 & d ) { return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé. * \param d donnée à affecter */ inline DataBad & operator = ( const U_Int8 & d ) { return (*this); } /*! Opérateur d'affectation d'une valeur de type réel 32 bits. * \param d donnée à affecter */ inline DataBad & operator = ( const Real4 & d ) { return (*this); } /*! Opérateur d'affectation d'une valeur de type réel 64 bits. * \param d donnée à affecter */ inline DataBad & operator = ( const Real8 & d ) { return (*this); } //---------------------------------------------------------------------- /*! Méthode qui renvoit un identificateur de type * de données. */ inline u_int TypeId ( ) const { return (DATA_TYPE_UNDEFINED); } /*! Méthode qui renvoit une chaîne indiquant le type de données. */ inline string Type ( ) const { return (DATA_TYPE_TXT_UNDEFINED); } /*! Méthode qui renvoit une chaîne indiquant la valeur. */ inline string String ( ) const { return (undef); } //---------------------------------------------------------------------- // Méthodes d'affectation de valeurs //---------------------------------------------------------------------- int SetValue ( const U_Int2 &val ); int SetValue ( const U_Int4 &val ); int SetValue ( const U_Int8 &val ); int SetValue ( const Int2 &val ); int SetValue ( const Int4 &val ); int SetValue ( const Int8 &val ); int SetValue ( const Real4 &val ); int SetValue ( const Real8 &val ); int GetValue ( U_Int2 &val ) const; int GetValue ( U_Int4 &val ) const; int GetValue ( U_Int8 &val ) const; int GetValue ( Int2 &val ) const; int GetValue ( Int4 &val ) const; int GetValue ( Int8 &val ) const; int GetValue ( Real4 &val ) const; int GetValue ( Real8 &val ) const; //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(DataBad,0); } ; //====================================================================== // METHODES INLINE //====================================================================== //---------------------------------------------------------------------- // Méthodes d'affectation de valeurs /*! Mise à valeur à l'aide d'un entier 16 bits non signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const U_Int2 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 16 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int2 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 32 bits non signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const U_Int4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 32 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 64 bits non signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const U_Int8 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 64 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int8 &val ) { return (status); } /*! Mise à valeur à l'aide d'un réel 32 bits. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Real4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un réel 64 bits. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Real8 &val ) { return (status); } //---------------------------------------------------------------------- // Méthodes de répurération de valeur /*! Affectation de la valeur à une variable de type entier 16 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int2 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 16 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int2 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type réel 32 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real4 &val ) const { val = 0.; return (status); } /*! Affectation de la valeur à une variable de type réel 64 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real8 &val ) const { val = 0.; return (status); } //====================================================================== /*! Définition de l'instance unique (singleton) de la classe DataBad. */ extern DataBad & bad_data; //====================================================================== #endif
63  * \param d donnée à affecter
64  */
65  inline DataBad & operator = ( const U_Int2 & d )
66  { return (*this); }
67 
68  /*! Opérateur d'affectation d'une valeur de type entier 32 bits signé. * \param d donnée à affecter */ inline DataBad & operator = ( const Int4 & d ) { return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 32 bits non signé. * \param d donnée à affecter */ inline DataBad & operator = ( const U_Int4 & d ) { return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 64 bits signé. * \param d donnée à affecter */ inline DataBad & operator = ( const Int8 & d ) { return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé. * \param d donnée à affecter */ inline DataBad & operator = ( const U_Int8 & d ) { return (*this); } /*! Opérateur d'affectation d'une valeur de type réel 32 bits. * \param d donnée à affecter */ inline DataBad & operator = ( const Real4 & d ) { return (*this); } /*! Opérateur d'affectation d'une valeur de type réel 64 bits. * \param d donnée à affecter */ inline DataBad & operator = ( const Real8 & d ) { return (*this); } //---------------------------------------------------------------------- /*! Méthode qui renvoit un identificateur de type * de données. */ inline u_int TypeId ( ) const { return (DATA_TYPE_UNDEFINED); } /*! Méthode qui renvoit une chaîne indiquant le type de données. */ inline string Type ( ) const { return (DATA_TYPE_TXT_UNDEFINED); } /*! Méthode qui renvoit une chaîne indiquant la valeur. */ inline string String ( ) const { return (undef); } //---------------------------------------------------------------------- // Méthodes d'affectation de valeurs //---------------------------------------------------------------------- int SetValue ( const U_Int2 &val ); int SetValue ( const U_Int4 &val ); int SetValue ( const U_Int8 &val ); int SetValue ( const Int2 &val ); int SetValue ( const Int4 &val ); int SetValue ( const Int8 &val ); int SetValue ( const Real4 &val ); int SetValue ( const Real8 &val ); int GetValue ( U_Int2 &val ) const; int GetValue ( U_Int4 &val ) const; int GetValue ( U_Int8 &val ) const; int GetValue ( Int2 &val ) const; int GetValue ( Int4 &val ) const; int GetValue ( Int8 &val ) const; int GetValue ( Real4 &val ) const; int GetValue ( Real8 &val ) const; //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(DataBad,0); } ; //====================================================================== // METHODES INLINE //====================================================================== //---------------------------------------------------------------------- // Méthodes d'affectation de valeurs /*! Mise à valeur à l'aide d'un entier 16 bits non signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const U_Int2 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 16 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int2 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 32 bits non signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const U_Int4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 32 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 64 bits non signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const U_Int8 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 64 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int8 &val ) { return (status); } /*! Mise à valeur à l'aide d'un réel 32 bits. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Real4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un réel 64 bits. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Real8 &val ) { return (status); } //---------------------------------------------------------------------- // Méthodes de répurération de valeur /*! Affectation de la valeur à une variable de type entier 16 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int2 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 16 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int2 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type réel 32 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real4 &val ) const { val = 0.; return (status); } /*! Affectation de la valeur à une variable de type réel 64 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real8 &val ) const { val = 0.; return (status); } //====================================================================== /*! Définition de l'instance unique (singleton) de la classe DataBad. */ extern DataBad & bad_data; //====================================================================== #endif
69  * \param d donnée à affecter
70  */
71  inline DataBad & operator = ( const Int4 & d )
72  { return (*this); }
73 
74  /*! Opérateur d'affectation d'une valeur de type entier 32 bits non signé. * \param d donnée à affecter */ inline DataBad & operator = ( const U_Int4 & d ) { return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 64 bits signé. * \param d donnée à affecter */ inline DataBad & operator = ( const Int8 & d ) { return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé. * \param d donnée à affecter */ inline DataBad & operator = ( const U_Int8 & d ) { return (*this); } /*! Opérateur d'affectation d'une valeur de type réel 32 bits. * \param d donnée à affecter */ inline DataBad & operator = ( const Real4 & d ) { return (*this); } /*! Opérateur d'affectation d'une valeur de type réel 64 bits. * \param d donnée à affecter */ inline DataBad & operator = ( const Real8 & d ) { return (*this); } //---------------------------------------------------------------------- /*! Méthode qui renvoit un identificateur de type * de données. */ inline u_int TypeId ( ) const { return (DATA_TYPE_UNDEFINED); } /*! Méthode qui renvoit une chaîne indiquant le type de données. */ inline string Type ( ) const { return (DATA_TYPE_TXT_UNDEFINED); } /*! Méthode qui renvoit une chaîne indiquant la valeur. */ inline string String ( ) const { return (undef); } //---------------------------------------------------------------------- // Méthodes d'affectation de valeurs //---------------------------------------------------------------------- int SetValue ( const U_Int2 &val ); int SetValue ( const U_Int4 &val ); int SetValue ( const U_Int8 &val ); int SetValue ( const Int2 &val ); int SetValue ( const Int4 &val ); int SetValue ( const Int8 &val ); int SetValue ( const Real4 &val ); int SetValue ( const Real8 &val ); int GetValue ( U_Int2 &val ) const; int GetValue ( U_Int4 &val ) const; int GetValue ( U_Int8 &val ) const; int GetValue ( Int2 &val ) const; int GetValue ( Int4 &val ) const; int GetValue ( Int8 &val ) const; int GetValue ( Real4 &val ) const; int GetValue ( Real8 &val ) const; //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(DataBad,0); } ; //====================================================================== // METHODES INLINE //====================================================================== //---------------------------------------------------------------------- // Méthodes d'affectation de valeurs /*! Mise à valeur à l'aide d'un entier 16 bits non signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const U_Int2 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 16 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int2 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 32 bits non signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const U_Int4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 32 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 64 bits non signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const U_Int8 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 64 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int8 &val ) { return (status); } /*! Mise à valeur à l'aide d'un réel 32 bits. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Real4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un réel 64 bits. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Real8 &val ) { return (status); } //---------------------------------------------------------------------- // Méthodes de répurération de valeur /*! Affectation de la valeur à une variable de type entier 16 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int2 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 16 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int2 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type réel 32 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real4 &val ) const { val = 0.; return (status); } /*! Affectation de la valeur à une variable de type réel 64 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real8 &val ) const { val = 0.; return (status); } //====================================================================== /*! Définition de l'instance unique (singleton) de la classe DataBad. */ extern DataBad & bad_data; //====================================================================== #endif
75  * \param d donnée à affecter
76  */
77  inline DataBad & operator = ( const U_Int4 & d )
78  { return (*this); }
79 
80  /*! Opérateur d'affectation d'une valeur de type entier 64 bits signé. * \param d donnée à affecter */ inline DataBad & operator = ( const Int8 & d ) { return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé. * \param d donnée à affecter */ inline DataBad & operator = ( const U_Int8 & d ) { return (*this); } /*! Opérateur d'affectation d'une valeur de type réel 32 bits. * \param d donnée à affecter */ inline DataBad & operator = ( const Real4 & d ) { return (*this); } /*! Opérateur d'affectation d'une valeur de type réel 64 bits. * \param d donnée à affecter */ inline DataBad & operator = ( const Real8 & d ) { return (*this); } //---------------------------------------------------------------------- /*! Méthode qui renvoit un identificateur de type * de données. */ inline u_int TypeId ( ) const { return (DATA_TYPE_UNDEFINED); } /*! Méthode qui renvoit une chaîne indiquant le type de données. */ inline string Type ( ) const { return (DATA_TYPE_TXT_UNDEFINED); } /*! Méthode qui renvoit une chaîne indiquant la valeur. */ inline string String ( ) const { return (undef); } //---------------------------------------------------------------------- // Méthodes d'affectation de valeurs //---------------------------------------------------------------------- int SetValue ( const U_Int2 &val ); int SetValue ( const U_Int4 &val ); int SetValue ( const U_Int8 &val ); int SetValue ( const Int2 &val ); int SetValue ( const Int4 &val ); int SetValue ( const Int8 &val ); int SetValue ( const Real4 &val ); int SetValue ( const Real8 &val ); int GetValue ( U_Int2 &val ) const; int GetValue ( U_Int4 &val ) const; int GetValue ( U_Int8 &val ) const; int GetValue ( Int2 &val ) const; int GetValue ( Int4 &val ) const; int GetValue ( Int8 &val ) const; int GetValue ( Real4 &val ) const; int GetValue ( Real8 &val ) const; //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(DataBad,0); } ; //====================================================================== // METHODES INLINE //====================================================================== //---------------------------------------------------------------------- // Méthodes d'affectation de valeurs /*! Mise à valeur à l'aide d'un entier 16 bits non signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const U_Int2 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 16 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int2 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 32 bits non signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const U_Int4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 32 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 64 bits non signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const U_Int8 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 64 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int8 &val ) { return (status); } /*! Mise à valeur à l'aide d'un réel 32 bits. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Real4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un réel 64 bits. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Real8 &val ) { return (status); } //---------------------------------------------------------------------- // Méthodes de répurération de valeur /*! Affectation de la valeur à une variable de type entier 16 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int2 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 16 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int2 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type réel 32 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real4 &val ) const { val = 0.; return (status); } /*! Affectation de la valeur à une variable de type réel 64 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real8 &val ) const { val = 0.; return (status); } //====================================================================== /*! Définition de l'instance unique (singleton) de la classe DataBad. */ extern DataBad & bad_data; //====================================================================== #endif
81  * \param d donnée à affecter
82  */
83  inline DataBad & operator = ( const Int8 & d )
84  { return (*this); }
85 
86  /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé. * \param d donnée à affecter */ inline DataBad & operator = ( const U_Int8 & d ) { return (*this); } /*! Opérateur d'affectation d'une valeur de type réel 32 bits. * \param d donnée à affecter */ inline DataBad & operator = ( const Real4 & d ) { return (*this); } /*! Opérateur d'affectation d'une valeur de type réel 64 bits. * \param d donnée à affecter */ inline DataBad & operator = ( const Real8 & d ) { return (*this); } //---------------------------------------------------------------------- /*! Méthode qui renvoit un identificateur de type * de données. */ inline u_int TypeId ( ) const { return (DATA_TYPE_UNDEFINED); } /*! Méthode qui renvoit une chaîne indiquant le type de données. */ inline string Type ( ) const { return (DATA_TYPE_TXT_UNDEFINED); } /*! Méthode qui renvoit une chaîne indiquant la valeur. */ inline string String ( ) const { return (undef); } //---------------------------------------------------------------------- // Méthodes d'affectation de valeurs //---------------------------------------------------------------------- int SetValue ( const U_Int2 &val ); int SetValue ( const U_Int4 &val ); int SetValue ( const U_Int8 &val ); int SetValue ( const Int2 &val ); int SetValue ( const Int4 &val ); int SetValue ( const Int8 &val ); int SetValue ( const Real4 &val ); int SetValue ( const Real8 &val ); int GetValue ( U_Int2 &val ) const; int GetValue ( U_Int4 &val ) const; int GetValue ( U_Int8 &val ) const; int GetValue ( Int2 &val ) const; int GetValue ( Int4 &val ) const; int GetValue ( Int8 &val ) const; int GetValue ( Real4 &val ) const; int GetValue ( Real8 &val ) const; //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(DataBad,0); } ; //====================================================================== // METHODES INLINE //====================================================================== //---------------------------------------------------------------------- // Méthodes d'affectation de valeurs /*! Mise à valeur à l'aide d'un entier 16 bits non signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const U_Int2 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 16 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int2 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 32 bits non signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const U_Int4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 32 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 64 bits non signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const U_Int8 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 64 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int8 &val ) { return (status); } /*! Mise à valeur à l'aide d'un réel 32 bits. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Real4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un réel 64 bits. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Real8 &val ) { return (status); } //---------------------------------------------------------------------- // Méthodes de répurération de valeur /*! Affectation de la valeur à une variable de type entier 16 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int2 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 16 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int2 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type réel 32 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real4 &val ) const { val = 0.; return (status); } /*! Affectation de la valeur à une variable de type réel 64 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real8 &val ) const { val = 0.; return (status); } //====================================================================== /*! Définition de l'instance unique (singleton) de la classe DataBad. */ extern DataBad & bad_data; //====================================================================== #endif
87  * \param d donnée à affecter
88  */
89  inline DataBad & operator = ( const U_Int8 & d )
90  { return (*this); }
91 
92  /*! Opérateur d'affectation d'une valeur de type réel 32 bits.
93  * \param d donnée à affecter
94  */
95  inline DataBad & operator = ( const Real4 & d )
96  { return (*this); }
97 
98  /*! Opérateur d'affectation d'une valeur de type réel 64 bits.
99  * \param d donnée à affecter
100  */
101  inline DataBad & operator = ( const Real8 & d )
102  { return (*this); }
103 
104 //----------------------------------------------------------------------
105 
106  /*! Méthode qui renvoit un identificateur de type
107  * de données.
108  */
109  inline u_int TypeId ( ) const
110  { return (DATA_TYPE_UNDEFINED); }
111 
112  /*! Méthode qui renvoit une chaîne indiquant le type de données.
113  */
114  inline string Type ( ) const
115  { return (DATA_TYPE_TXT_UNDEFINED); }
116 
117  /*! Méthode qui renvoit une chaîne indiquant la valeur.
118  */
119  inline string String ( ) const
120  { return (undef); }
121 
122 
123 //----------------------------------------------------------------------
124 // Méthodes d'affectation de valeurs
125 //----------------------------------------------------------------------
126 
127  int SetValue ( const U_Int2 &val );
128  int SetValue ( const U_Int4 &val );
129  int SetValue ( const U_Int8 &val );
130  int SetValue ( const Int2 &val );
131  int SetValue ( const Int4 &val );
132  int SetValue ( const Int8 &val );
133  int SetValue ( const Real4 &val );
134  int SetValue ( const Real8 &val );
135 
136  int GetValue ( U_Int2 &val ) const;
137  int GetValue ( U_Int4 &val ) const;
138  int GetValue ( U_Int8 &val ) const;
139  int GetValue ( Int2 &val ) const;
140  int GetValue ( Int4 &val ) const;
141  int GetValue ( Int8 &val ) const;
142  int GetValue ( Real4 &val ) const;
143  int GetValue ( Real8 &val ) const;
144 
145 
146 //----------------------------------------------------------------------
147 // pour ROOT...
148  public:
149  /*! Définition à usage de ROOT... */
150  ClassDef(DataBad,0);
151 } ;
152 
153 
154 //======================================================================
155 // METHODES INLINE
156 //======================================================================
157 
158 //----------------------------------------------------------------------
159 // Méthodes d'affectation de valeurs
160 
161 /*! Mise à valeur à l'aide d'un entier 16 bits non signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const U_Int2 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 16 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int2 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 32 bits non signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const U_Int4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 32 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 64 bits non signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const U_Int8 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 64 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int8 &val ) { return (status); } /*! Mise à valeur à l'aide d'un réel 32 bits. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Real4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un réel 64 bits. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Real8 &val ) { return (status); } //---------------------------------------------------------------------- // Méthodes de répurération de valeur /*! Affectation de la valeur à une variable de type entier 16 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int2 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 16 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int2 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type réel 32 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real4 &val ) const { val = 0.; return (status); } /*! Affectation de la valeur à une variable de type réel 64 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real8 &val ) const { val = 0.; return (status); } //====================================================================== /*! Définition de l'instance unique (singleton) de la classe DataBad. */ extern DataBad & bad_data; //====================================================================== #endif
162  * \param val valeur à affecter
163  */
164 inline int DataBad::SetValue ( const U_Int2 &val )
165  { return (status); }
166 
167 /*! Mise à valeur à l'aide d'un entier 16 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int2 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 32 bits non signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const U_Int4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 32 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 64 bits non signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const U_Int8 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 64 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int8 &val ) { return (status); } /*! Mise à valeur à l'aide d'un réel 32 bits. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Real4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un réel 64 bits. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Real8 &val ) { return (status); } //---------------------------------------------------------------------- // Méthodes de répurération de valeur /*! Affectation de la valeur à une variable de type entier 16 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int2 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 16 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int2 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type réel 32 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real4 &val ) const { val = 0.; return (status); } /*! Affectation de la valeur à une variable de type réel 64 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real8 &val ) const { val = 0.; return (status); } //====================================================================== /*! Définition de l'instance unique (singleton) de la classe DataBad. */ extern DataBad & bad_data; //====================================================================== #endif
168  * \param val valeur à affecter
169  */
170 inline int DataBad::SetValue ( const Int2 &val )
171  { return (status); }
172 
173 /*! Mise à valeur à l'aide d'un entier 32 bits non signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const U_Int4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 32 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 64 bits non signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const U_Int8 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 64 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int8 &val ) { return (status); } /*! Mise à valeur à l'aide d'un réel 32 bits. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Real4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un réel 64 bits. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Real8 &val ) { return (status); } //---------------------------------------------------------------------- // Méthodes de répurération de valeur /*! Affectation de la valeur à une variable de type entier 16 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int2 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 16 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int2 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type réel 32 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real4 &val ) const { val = 0.; return (status); } /*! Affectation de la valeur à une variable de type réel 64 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real8 &val ) const { val = 0.; return (status); } //====================================================================== /*! Définition de l'instance unique (singleton) de la classe DataBad. */ extern DataBad & bad_data; //====================================================================== #endif
174  * \param val valeur à affecter
175  */
176 inline int DataBad::SetValue ( const U_Int4 &val )
177  { return (status); }
178 
179 /*! Mise à valeur à l'aide d'un entier 32 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 64 bits non signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const U_Int8 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 64 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int8 &val ) { return (status); } /*! Mise à valeur à l'aide d'un réel 32 bits. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Real4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un réel 64 bits. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Real8 &val ) { return (status); } //---------------------------------------------------------------------- // Méthodes de répurération de valeur /*! Affectation de la valeur à une variable de type entier 16 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int2 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 16 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int2 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type réel 32 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real4 &val ) const { val = 0.; return (status); } /*! Affectation de la valeur à une variable de type réel 64 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real8 &val ) const { val = 0.; return (status); } //====================================================================== /*! Définition de l'instance unique (singleton) de la classe DataBad. */ extern DataBad & bad_data; //====================================================================== #endif
180  * \param val valeur à affecter
181  */
182 inline int DataBad::SetValue ( const Int4 &val )
183  { return (status); }
184 
185 /*! Mise à valeur à l'aide d'un entier 64 bits non signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const U_Int8 &val ) { return (status); } /*! Mise à valeur à l'aide d'un entier 64 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int8 &val ) { return (status); } /*! Mise à valeur à l'aide d'un réel 32 bits. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Real4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un réel 64 bits. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Real8 &val ) { return (status); } //---------------------------------------------------------------------- // Méthodes de répurération de valeur /*! Affectation de la valeur à une variable de type entier 16 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int2 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 16 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int2 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type réel 32 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real4 &val ) const { val = 0.; return (status); } /*! Affectation de la valeur à une variable de type réel 64 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real8 &val ) const { val = 0.; return (status); } //====================================================================== /*! Définition de l'instance unique (singleton) de la classe DataBad. */ extern DataBad & bad_data; //====================================================================== #endif
186  * \param val valeur à affecter
187  */
188 inline int DataBad::SetValue ( const U_Int8 &val )
189  { return (status); }
190 
191 /*! Mise à valeur à l'aide d'un entier 64 bits signé. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Int8 &val ) { return (status); } /*! Mise à valeur à l'aide d'un réel 32 bits. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Real4 &val ) { return (status); } /*! Mise à valeur à l'aide d'un réel 64 bits. * \param val valeur à affecter */ inline int DataBad::SetValue ( const Real8 &val ) { return (status); } //---------------------------------------------------------------------- // Méthodes de répurération de valeur /*! Affectation de la valeur à une variable de type entier 16 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int2 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 16 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int2 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type réel 32 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real4 &val ) const { val = 0.; return (status); } /*! Affectation de la valeur à une variable de type réel 64 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real8 &val ) const { val = 0.; return (status); } //====================================================================== /*! Définition de l'instance unique (singleton) de la classe DataBad. */ extern DataBad & bad_data; //====================================================================== #endif
192  * \param val valeur à affecter
193  */
194 inline int DataBad::SetValue ( const Int8 &val )
195  { return (status); }
196 
197 /*! Mise à valeur à l'aide d'un réel 32 bits.
198  * \param val valeur à affecter
199  */
200 inline int DataBad::SetValue ( const Real4 &val )
201  { return (status); }
202 
203 /*! Mise à valeur à l'aide d'un réel 64 bits.
204  * \param val valeur à affecter
205  */
206 inline int DataBad::SetValue ( const Real8 &val )
207  { return (status); }
208 
209 //----------------------------------------------------------------------
210 // Méthodes de répurération de valeur
211 
212 
213 /*! Affectation de la valeur à une variable de type entier 16 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int2 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 16 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int2 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type réel 32 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real4 &val ) const { val = 0.; return (status); } /*! Affectation de la valeur à une variable de type réel 64 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real8 &val ) const { val = 0.; return (status); } //====================================================================== /*! Définition de l'instance unique (singleton) de la classe DataBad. */ extern DataBad & bad_data; //====================================================================== #endif
214  * \param val variable à affectée (par référence)
215  */
216 inline int DataBad::GetValue ( U_Int2 &val ) const
217  { val = 0; return (status); }
218 
219 /*! Affectation de la valeur à une variable de type entier 16 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int2 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type réel 32 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real4 &val ) const { val = 0.; return (status); } /*! Affectation de la valeur à une variable de type réel 64 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real8 &val ) const { val = 0.; return (status); } //====================================================================== /*! Définition de l'instance unique (singleton) de la classe DataBad. */ extern DataBad & bad_data; //====================================================================== #endif
220  * \param val variable à affectée (par référence)
221  */
222 inline int DataBad::GetValue ( Int2 &val ) const
223  { val = 0; return (status); }
224 
225 /*! Affectation de la valeur à une variable de type entier 32 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 32 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type réel 32 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real4 &val ) const { val = 0.; return (status); } /*! Affectation de la valeur à une variable de type réel 64 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real8 &val ) const { val = 0.; return (status); } //====================================================================== /*! Définition de l'instance unique (singleton) de la classe DataBad. */ extern DataBad & bad_data; //====================================================================== #endif
226  * \param val variable à affectée (par référence)
227  */
228 inline int DataBad::GetValue ( U_Int4 &val ) const
229  { val = 0; return (status); }
230 
231 /*! Affectation de la valeur à une variable de type entier 32 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int4 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type réel 32 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real4 &val ) const { val = 0.; return (status); } /*! Affectation de la valeur à une variable de type réel 64 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real8 &val ) const { val = 0.; return (status); } //====================================================================== /*! Définition de l'instance unique (singleton) de la classe DataBad. */ extern DataBad & bad_data; //====================================================================== #endif
232  * \param val variable à affectée (par référence)
233  */
234 inline int DataBad::GetValue ( Int4 &val ) const
235  { val = 0; return (status); }
236 
237 /*! Affectation de la valeur à une variable de type entier 64 bits non signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( U_Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type entier 64 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type réel 32 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real4 &val ) const { val = 0.; return (status); } /*! Affectation de la valeur à une variable de type réel 64 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real8 &val ) const { val = 0.; return (status); } //====================================================================== /*! Définition de l'instance unique (singleton) de la classe DataBad. */ extern DataBad & bad_data; //====================================================================== #endif
238  * \param val variable à affectée (par référence)
239  */
240 inline int DataBad::GetValue ( U_Int8 &val ) const
241  { val = 0; return (status); }
242 
243 /*! Affectation de la valeur à une variable de type entier 64 bits signé. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Int8 &val ) const { val = 0; return (status); } /*! Affectation de la valeur à une variable de type réel 32 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real4 &val ) const { val = 0.; return (status); } /*! Affectation de la valeur à une variable de type réel 64 bits. * \param val variable à affectée (par référence) */ inline int DataBad::GetValue ( Real8 &val ) const { val = 0.; return (status); } //====================================================================== /*! Définition de l'instance unique (singleton) de la classe DataBad. */ extern DataBad & bad_data; //====================================================================== #endif
244  * \param val variable à affectée (par référence)
245  */
246 inline int DataBad::GetValue ( Int8 &val ) const
247  { val = 0; return (status); }
248 
249 /*! Affectation de la valeur à une variable de type réel 32 bits.
250  * \param val variable à affectée (par référence)
251  */
252 inline int DataBad::GetValue ( Real4 &val ) const
253  { val = 0.; return (status); }
254 
255 /*! Affectation de la valeur à une variable de type réel 64 bits.
256  * \param val variable à affectée (par référence)
257  */
258 inline int DataBad::GetValue ( Real8 &val ) const
259  { val = 0.; return (status); }
260 
261 //======================================================================
262 
263 /*! Définition de l'instance unique (singleton) de la classe DataBad.
264  */
265 extern DataBad & bad_data;
266 
267 //======================================================================
268 
269 #endif
Real8
double Real8
Définition du type réel 32 bits.
Definition: EventCommon.hh:68
Real4
float Real4
Définition du type réel 32 bits.
Definition: EventCommon.hh:62
DataBad::DataBad
DataBad()
Definition: DataBad.cpp:20
DataBad::GetValue
int GetValue(U_Int2 &val) const
Definition: DataBad.hh:216
bad_data
DataBad & bad_data
Definition: DataBad.cpp:51
DataBad::String
string String() const
Definition: DataBad.hh:119
DataBad::GetInstance
static DataBad & GetInstance()
Definition: DataBad.cpp:41
U_Int2
unsigned short U_Int2
Définition du type entier 16 bits non signé
Definition: EventCommon.hh:32
DataBad::SetValue
int SetValue(const U_Int2 &val)
Definition: DataBad.hh:164
DATA_TYPE_TXT_UNDEFINED
#define DATA_TYPE_TXT_UNDEFINED
identifiant texte du type de donnée
Definition: Data.hh:72
DataBad::ClassDef
ClassDef(DataBad, 0)
Int2
short Int2
Définition du type entier 16 bits.
Definition: EventCommon.hh:26
DataBad::~DataBad
virtual ~DataBad()
Definition: DataBad.cpp:31
U_Int8
ULong64_t U_Int8
Définition du type entier 64 bits non signé
Definition: EventCommon.hh:56
DataBad
Definition: DataBad.hh:19
Data::undef
static string undef
Chaîne pour l'écriture de donnée non valide.
Definition: Data.hh:165
DataBad::GObject
GObject(DataBad)
DataBad::TypeId
u_int TypeId() const
Definition: DataBad.hh:109
Data
Definition: Data.hh:153
DataBad::operator=
DataBad & operator=(const Data &d)
Definition: DataBad.hh:45
DATA_TYPE_UNDEFINED
#define DATA_TYPE_UNDEFINED
bits pour type de donnée inconnu
Definition: Data.hh:47
Int4
int Int4
Définition du type entier 32 bits.
Definition: EventCommon.hh:38
U_Int4
unsigned int U_Int4
Définition du type entier 32 bits non signé
Definition: EventCommon.hh:44
Int8
Long64_t Int8
Définition du type entier 64 bits.
Definition: EventCommon.hh:50
DataBad::Type
string Type() const
Definition: DataBad.hh:114
Data::status
int status
Indicateur de l'état des conversions de types.
Definition: Data.hh:167