Analysis  version 7.0 - august 2014
DataR8.hh
Go to the documentation of this file.
1 //======================================================================
2 /*! \file DataR8.hh
3  *
4  * Déclaration des méthodes de la classe DataR8 qui définit les
5  * données de type réel 64 bits.
6  */
7 //======================================================================
8 
9 #ifndef DATA_R8_HH
10 #define DATA_R8_HH
11 
12 #include "Data.hh"
13 
14 //======================================================================
15 /*! \class DataR8
16  *
17  * Classe décrivant les données de type réel 64 bits.
18  */
19 class DataR8 : public Data
20 {
21 //----------------------------------------------------------------------
22  /*! \object_doc */
23  GObject(DataR8);
24 //----------------------------------------------------------------------
25 
26  protected:
27 
28  Real8 value; ///< Valeur numérique
29 
30  public:
31 
32 //----------------------------------------------------------------------
33 // CONSTRUCTEUR / AFFECTATION / DESTRUCTEUR
34 //----------------------------------------------------------------------
35 
36  // Constructeur
37  DataR8 ( const Real8 val = 0. );
38 
39  // Constructeur de recopie à partir d'une donnée quelconque
40  DataR8 ( const Data &d );
41 
42  // Destructeur
43  virtual ~DataR8 ( );
44 
45  /*! Opérateur d'affectation d'une autre donnée.
46  * \param d donnée à affecter
47  */
48  inline DataR8 & operator = ( const Data & d )
49  {
50  status = d.Status() | d.GetValue(value);
51  return (*this);
52  }
53 
54  /*! Opérateur d'affectation d'une valeur de type entier 16 bits signé. * \param d donnée à affecter */ inline DataR8 & operator = ( const Int2 & d ) { SetValue (d); return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 16 bits non signé. * \param d donnée à affecter */ inline DataR8 & operator = ( const U_Int2 & d ) { SetValue (d); return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 32 bits signé. * \param d donnée à affecter */ inline DataR8 & operator = ( const Int4 & d ) { SetValue (d); return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 32 bits non signé. * \param d donnée à affecter */ inline DataR8 & operator = ( const U_Int4 & d ) { SetValue (d); return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 64 bits signé. * \param d donnée à affecter */ inline DataR8 & operator = ( const Int8 & d ) { SetValue (d); return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé. * \param d donnée à affecter */ inline DataR8 & operator = ( const U_Int8 & d ) { SetValue (d); return (*this); } /*! Opérateur d'affectation d'une valeur de type réel 32 bits. * \param d donnée à affecter */ inline DataR8 & operator = ( const Real4 & d ) { SetValue (d); return (*this); } /*! Opérateur d'affectation d'une valeur de type réel 64 bits. * \param d donnée à affecter */ inline DataR8 & operator = ( const Real8 & d ) { SetValue (d); return (*this); } //---------------------------------------------------------------------- /*! Méthode qui renvoit un identificateur de type * de données. */ inline u_int TypeId ( ) const { return (DATA_TYPE_REAL8); } /*! Méthode qui renvoit une chaîne indiquant le type de données. */ inline string Type ( ) const { return (DATA_TYPE_TXT_REAL8); } /*! Méthode qui renvoit une chaîne indiquant la valeur. */ inline string String ( ) const { return (IsValid() ? GGetString(value,len,prec,fill) : 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(DataR8,0); } ; //====================================================================== #endif
55  * \param d donnée à affecter
56  */
57  inline DataR8 & operator = ( const Int2 & d )
58  { SetValue (d); return (*this); }
59 
60  /*! Opérateur d'affectation d'une valeur de type entier 16 bits non signé. * \param d donnée à affecter */ inline DataR8 & operator = ( const U_Int2 & d ) { SetValue (d); return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 32 bits signé. * \param d donnée à affecter */ inline DataR8 & operator = ( const Int4 & d ) { SetValue (d); return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 32 bits non signé. * \param d donnée à affecter */ inline DataR8 & operator = ( const U_Int4 & d ) { SetValue (d); return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 64 bits signé. * \param d donnée à affecter */ inline DataR8 & operator = ( const Int8 & d ) { SetValue (d); return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé. * \param d donnée à affecter */ inline DataR8 & operator = ( const U_Int8 & d ) { SetValue (d); return (*this); } /*! Opérateur d'affectation d'une valeur de type réel 32 bits. * \param d donnée à affecter */ inline DataR8 & operator = ( const Real4 & d ) { SetValue (d); return (*this); } /*! Opérateur d'affectation d'une valeur de type réel 64 bits. * \param d donnée à affecter */ inline DataR8 & operator = ( const Real8 & d ) { SetValue (d); return (*this); } //---------------------------------------------------------------------- /*! Méthode qui renvoit un identificateur de type * de données. */ inline u_int TypeId ( ) const { return (DATA_TYPE_REAL8); } /*! Méthode qui renvoit une chaîne indiquant le type de données. */ inline string Type ( ) const { return (DATA_TYPE_TXT_REAL8); } /*! Méthode qui renvoit une chaîne indiquant la valeur. */ inline string String ( ) const { return (IsValid() ? GGetString(value,len,prec,fill) : 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(DataR8,0); } ; //====================================================================== #endif
61  * \param d donnée à affecter
62  */
63  inline DataR8 & operator = ( const U_Int2 & d )
64  { SetValue (d); return (*this); }
65 
66  /*! Opérateur d'affectation d'une valeur de type entier 32 bits signé. * \param d donnée à affecter */ inline DataR8 & operator = ( const Int4 & d ) { SetValue (d); return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 32 bits non signé. * \param d donnée à affecter */ inline DataR8 & operator = ( const U_Int4 & d ) { SetValue (d); return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 64 bits signé. * \param d donnée à affecter */ inline DataR8 & operator = ( const Int8 & d ) { SetValue (d); return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé. * \param d donnée à affecter */ inline DataR8 & operator = ( const U_Int8 & d ) { SetValue (d); return (*this); } /*! Opérateur d'affectation d'une valeur de type réel 32 bits. * \param d donnée à affecter */ inline DataR8 & operator = ( const Real4 & d ) { SetValue (d); return (*this); } /*! Opérateur d'affectation d'une valeur de type réel 64 bits. * \param d donnée à affecter */ inline DataR8 & operator = ( const Real8 & d ) { SetValue (d); return (*this); } //---------------------------------------------------------------------- /*! Méthode qui renvoit un identificateur de type * de données. */ inline u_int TypeId ( ) const { return (DATA_TYPE_REAL8); } /*! Méthode qui renvoit une chaîne indiquant le type de données. */ inline string Type ( ) const { return (DATA_TYPE_TXT_REAL8); } /*! Méthode qui renvoit une chaîne indiquant la valeur. */ inline string String ( ) const { return (IsValid() ? GGetString(value,len,prec,fill) : 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(DataR8,0); } ; //====================================================================== #endif
67  * \param d donnée à affecter
68  */
69  inline DataR8 & operator = ( const Int4 & d )
70  { SetValue (d); return (*this); }
71 
72  /*! Opérateur d'affectation d'une valeur de type entier 32 bits non signé. * \param d donnée à affecter */ inline DataR8 & operator = ( const U_Int4 & d ) { SetValue (d); return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 64 bits signé. * \param d donnée à affecter */ inline DataR8 & operator = ( const Int8 & d ) { SetValue (d); return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé. * \param d donnée à affecter */ inline DataR8 & operator = ( const U_Int8 & d ) { SetValue (d); return (*this); } /*! Opérateur d'affectation d'une valeur de type réel 32 bits. * \param d donnée à affecter */ inline DataR8 & operator = ( const Real4 & d ) { SetValue (d); return (*this); } /*! Opérateur d'affectation d'une valeur de type réel 64 bits. * \param d donnée à affecter */ inline DataR8 & operator = ( const Real8 & d ) { SetValue (d); return (*this); } //---------------------------------------------------------------------- /*! Méthode qui renvoit un identificateur de type * de données. */ inline u_int TypeId ( ) const { return (DATA_TYPE_REAL8); } /*! Méthode qui renvoit une chaîne indiquant le type de données. */ inline string Type ( ) const { return (DATA_TYPE_TXT_REAL8); } /*! Méthode qui renvoit une chaîne indiquant la valeur. */ inline string String ( ) const { return (IsValid() ? GGetString(value,len,prec,fill) : 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(DataR8,0); } ; //====================================================================== #endif
73  * \param d donnée à affecter
74  */
75  inline DataR8 & operator = ( const U_Int4 & d )
76  { SetValue (d); return (*this); }
77 
78  /*! Opérateur d'affectation d'une valeur de type entier 64 bits signé. * \param d donnée à affecter */ inline DataR8 & operator = ( const Int8 & d ) { SetValue (d); return (*this); } /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé. * \param d donnée à affecter */ inline DataR8 & operator = ( const U_Int8 & d ) { SetValue (d); return (*this); } /*! Opérateur d'affectation d'une valeur de type réel 32 bits. * \param d donnée à affecter */ inline DataR8 & operator = ( const Real4 & d ) { SetValue (d); return (*this); } /*! Opérateur d'affectation d'une valeur de type réel 64 bits. * \param d donnée à affecter */ inline DataR8 & operator = ( const Real8 & d ) { SetValue (d); return (*this); } //---------------------------------------------------------------------- /*! Méthode qui renvoit un identificateur de type * de données. */ inline u_int TypeId ( ) const { return (DATA_TYPE_REAL8); } /*! Méthode qui renvoit une chaîne indiquant le type de données. */ inline string Type ( ) const { return (DATA_TYPE_TXT_REAL8); } /*! Méthode qui renvoit une chaîne indiquant la valeur. */ inline string String ( ) const { return (IsValid() ? GGetString(value,len,prec,fill) : 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(DataR8,0); } ; //====================================================================== #endif
79  * \param d donnée à affecter
80  */
81  inline DataR8 & operator = ( const Int8 & d )
82  { SetValue (d); return (*this); }
83 
84  /*! Opérateur d'affectation d'une valeur de type entier 64 bits non signé. * \param d donnée à affecter */ inline DataR8 & operator = ( const U_Int8 & d ) { SetValue (d); return (*this); } /*! Opérateur d'affectation d'une valeur de type réel 32 bits. * \param d donnée à affecter */ inline DataR8 & operator = ( const Real4 & d ) { SetValue (d); return (*this); } /*! Opérateur d'affectation d'une valeur de type réel 64 bits. * \param d donnée à affecter */ inline DataR8 & operator = ( const Real8 & d ) { SetValue (d); return (*this); } //---------------------------------------------------------------------- /*! Méthode qui renvoit un identificateur de type * de données. */ inline u_int TypeId ( ) const { return (DATA_TYPE_REAL8); } /*! Méthode qui renvoit une chaîne indiquant le type de données. */ inline string Type ( ) const { return (DATA_TYPE_TXT_REAL8); } /*! Méthode qui renvoit une chaîne indiquant la valeur. */ inline string String ( ) const { return (IsValid() ? GGetString(value,len,prec,fill) : 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(DataR8,0); } ; //====================================================================== #endif
85  * \param d donnée à affecter
86  */
87  inline DataR8 & operator = ( const U_Int8 & d )
88  { SetValue (d); return (*this); }
89 
90  /*! Opérateur d'affectation d'une valeur de type réel 32 bits.
91  * \param d donnée à affecter
92  */
93  inline DataR8 & operator = ( const Real4 & d )
94  { SetValue (d); return (*this); }
95 
96  /*! Opérateur d'affectation d'une valeur de type réel 64 bits.
97  * \param d donnée à affecter
98  */
99  inline DataR8 & operator = ( const Real8 & d )
100  { SetValue (d); return (*this); }
101 
102 //----------------------------------------------------------------------
103 
104  /*! Méthode qui renvoit un identificateur de type
105  * de données.
106  */
107  inline u_int TypeId ( ) const
108  { return (DATA_TYPE_REAL8); }
109 
110  /*! Méthode qui renvoit une chaîne indiquant le type de données.
111  */
112  inline string Type ( ) const
113  { return (DATA_TYPE_TXT_REAL8); }
114 
115  /*! Méthode qui renvoit une chaîne indiquant la valeur.
116  */
117  inline string String ( ) const
118  {
119  return (IsValid() ? GGetString(value,len,prec,fill) : undef);
120  }
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 // pour ROOT...
147  public:
148  /*! Définition à usage de ROOT... */
149  ClassDef(DataR8,0);
150 } ;
151 
152 //======================================================================
153 
154 #endif
Real8
double Real8
Définition du type réel 32 bits.
Definition: EventCommon.hh:68
Data::Status
int Status() const
Definition: Data.hh:410
Real4
float Real4
Définition du type réel 32 bits.
Definition: EventCommon.hh:62
DataR8::ClassDef
ClassDef(DataR8, 0)
DataR8
Definition: DataR8.hh:19
Data::fill
static char fill
Caractère de remplissage.
Definition: Data.hh:164
U_Int2
unsigned short U_Int2
Définition du type entier 16 bits non signé
Definition: EventCommon.hh:32
DataR8::GetValue
int GetValue(U_Int2 &val) const
Definition: DataR8.cpp:120
DataR8::~DataR8
virtual ~DataR8()
Definition: DataR8.cpp:33
DataR8::SetValue
int SetValue(const U_Int2 &val)
Definition: DataR8.cpp:44
Int2
short Int2
Définition du type entier 16 bits.
Definition: EventCommon.hh:26
DATA_TYPE_TXT_REAL8
#define DATA_TYPE_TXT_REAL8
identifiant texte du type de donnée
Definition: Data.hh:80
Data::IsValid
bool IsValid() const
Definition: Data.hh:415
DataR8::GObject
GObject(DataR8)
DATA_TYPE_REAL8
#define DATA_TYPE_REAL8
bits spécifiant le type de donnée
Definition: Data.hh:55
U_Int8
ULong64_t U_Int8
Définition du type entier 64 bits non signé
Definition: EventCommon.hh:56
DataR8::DataR8
DataR8(const Real8 val=0.)
Definition: DataR8.cpp:18
Data::undef
static string undef
Chaîne pour l&#39;écriture de donnée non valide.
Definition: Data.hh:165
DataR8::value
Real8 value
Valeur numérique.
Definition: DataR8.hh:28
DataR8::TypeId
u_int TypeId() const
Definition: DataR8.hh:107
DataR8::operator=
DataR8 & operator=(const Data &d)
Definition: DataR8.hh:48
Data
Definition: Data.hh:153
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
DataR8::Type
string Type() const
Definition: DataR8.hh:112
Data::prec
static u_int prec
Précision d&#39;affichage.
Definition: Data.hh:163
Data::len
static u_int len
Longueur d&#39;affichage.
Definition: Data.hh:162
Int8
Long64_t Int8
Définition du type entier 64 bits.
Definition: EventCommon.hh:50
Data::GetValue
virtual int GetValue(U_Int2 &val) const =0
Data::status
int status
Indicateur de l&#39;état des conversions de types.
Definition: Data.hh:167
DataR8::String
string String() const
Definition: DataR8.hh:117