Analysis  version 7.0 - august 2014
ParamSingle.hh
Go to the documentation of this file.
1 //======================================================================
2 /*! \file ParamSingle.hh
3  *
4  * Déclaration des méthodes de la classe ParamSingle qui décrit
5  * les paramètres simples d'un événement.
6  */
7 //======================================================================
8 
9 
10 #ifndef PARAM_SINGLE_HH
11 #define PARAM_SINGLE_HH
12 
13 #include "Param.hh"
14 
15 //======================================================================
16 /*! \class ParamSingle
17  *
18  * C'est une classe qui décrit les paramètres simples d'un événement.
19  */
20 
21 class ParamSingle : public Param
22 {
23 //----------------------------------------------------------------------
24  /*! \object_doc */
25  GObject(ParamSingle);
26 //----------------------------------------------------------------------
27 
28  protected:
29  Data *data_ptr; ///< Pointeur sur la donnée associée au paramètre
30 
31  public:
32 
33 //----------------------------------------------------------------------
34 // CONSTRUCTEUR / AFFECTATION /DESTRUCTEUR
35 //----------------------------------------------------------------------
36 
37  // Constructeur: le nom de paramètre doit être spécifié. ParamSingle ( const string &par_name = PARAM_NONAME ); // Constructeur à partir d'un nom et d'une donnée. ParamSingle ( const string &par_name, const Data &d ); // Constructeur de recopie. ParamSingle ( const ParamSingle &par ); // Opérateur d'affectation ParamSingle & operator = ( const ParamSingle &par ); // Destructeur virtual ~ParamSingle (); //---------------------------------------------------------------------- // AFFECTATION //---------------------------------------------------------------------- /*! Opérateur d'affectation d'une donnée. * \param d donnée à affecter */ inline Param & operator = ( const Data &d ) { *data_ptr = d; return ( *this ); } /*! Opérateur d'affectation d'un entier 16 bits signé. * \param val valeur à affecter */ inline Param & operator = ( const Int2 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un entier 16 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int2 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un entier 32 bits signé. * \param val valeur à affecter */ inline Param & operator = ( const Int4 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un entier 32 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int4 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un entier 64 bits signé. * \param val valeur à affecter */ inline Param & operator = ( const Int8 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un entier 64 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int8 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un réel 32 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real4 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un réel 64 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real8 val ) { *data_ptr = val; return ( *this ); } //---------------------------------------------------------------------- // CAST //---------------------------------------------------------------------- #ifndef __MAKECINT__ /*! Opérateur de cast une donnée générique.*/ inline operator Data & () const { return ( *data_ptr ); } #endif /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int2 () const { return ( (Int2) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int2 () const { return ( (U_Int2) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int4 () const { return ( (Int4) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int4 () const { return ( (U_Int4) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 64 bits signé.*/ inline operator Int8 () const { return ( (Int8) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 64 bits non signé.*/ inline operator U_Int8 () const { return ( (U_Int8) *data_ptr ); } /*! Opérateur de cast une donnée de type réel 32 bits.*/ inline operator Real4 () const { return ( (Real4) *data_ptr ); } /*! Opérateur de cast une donnée de type réel 64 bits.*/ inline operator Real8 () const { return ( (Real8) *data_ptr ); } //---------------------------------------------------------------------- // //---------------------------------------------------------------------- /*! Retourne l'identificateur de type de paramètre.*/ inline u_int TypeId() const { return (typeSingle); } /*! Retourne le type de paramètre.*/ inline string Type() const { return ("single"); } /*! Retourne chaîne de caractères avec le paramètre et son type. */ inline string InfoString() const { return (Name() + " = " + Type() + " (" + data_ptr->Type() + ")"); } //{ return (Name() + " = " + Type() + " (" + Get().Type() + ")"); } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante. */ inline string ValueString() const { return ( Name() + " = " + Get().Text() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante avec son mot d'état. */ inline string ValueFullString() const { return ( Name() + " = " + Get().FullText() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et l'ensemble des données (dans le cas d'un paramètre single, * il n'y a qu'une valeur). */ inline string DataString() const { return (ValueString()); } //---------------------------------------------------------------------- /*! Retourne chaîne de caractères avec de donnée.*/ inline string GetDataType() const { return (Get().Type()); } /*! Retourne l'identifiant du type de donnée.*/ inline u_int GetDataTypeId() const { return (Get().TypeId()); } //---------------------------------------------------------------------- /*! Remise à zéro du paramètre. */ inline void Reset() { *data_ptr = *def_value_ptr; (*data_ptr).SetBad(); status = 0; } /*! Retourne le nombre de données. Cette méthode n'a pas d'intérêt * pour la classe ParamSingle, mais elle sert pour les classes * dérivées de Param à valeurs multiples. */ inline u_int Dimension() const { return (1); } /*! Retourne une donnée. */ inline const Data & Get( ) const { return (*data_ptr); } // Opérateur []: renvoie la valeur de rand donnée. Data & operator [] (u_int index) const; //---------------------------------------------------------------------- /*! Positionne le paramètre sur sa première donnée. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours vrai. */ inline bool First() const { return (true); } /*! Positionne le paramètre sur sa dernière donnée. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours vrai. */ inline bool Last() const { return (true); } /*! Positionne le paramètre sur la dernière suivante. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours faux. */ inline bool Next() const { return (false); } /*! Positionne le paramètre sur la dernière précédente. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours faux. */ inline bool Previous() const { return (false); } //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(ParamSingle,0); } ; //====================================================================== #endif
38  ParamSingle ( const string &par_name = PARAM_NONAME );
39 
40  // Constructeur à partir d'un nom et d'une donnée.
41  ParamSingle ( const string &par_name, const Data &d );
42 
43  // Constructeur de recopie.
44  ParamSingle ( const ParamSingle &par );
45 
46  // Opérateur d'affectation
47  ParamSingle & operator = ( const ParamSingle &par );
48 
49  // Destructeur
50  virtual ~ParamSingle ();
51 
52 
53 //----------------------------------------------------------------------
54 // AFFECTATION
55 //----------------------------------------------------------------------
56 
57  /*! Opérateur d'affectation d'une donnée.
58  * \param d donnée à affecter
59  */
60  inline Param & operator = ( const Data &d )
61  { *data_ptr = d; return ( *this ); }
62 
63  /*! Opérateur d'affectation d'un entier 16 bits signé. * \param val valeur à affecter */ inline Param & operator = ( const Int2 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un entier 16 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int2 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un entier 32 bits signé. * \param val valeur à affecter */ inline Param & operator = ( const Int4 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un entier 32 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int4 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un entier 64 bits signé. * \param val valeur à affecter */ inline Param & operator = ( const Int8 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un entier 64 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int8 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un réel 32 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real4 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un réel 64 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real8 val ) { *data_ptr = val; return ( *this ); } //---------------------------------------------------------------------- // CAST //---------------------------------------------------------------------- #ifndef __MAKECINT__ /*! Opérateur de cast une donnée générique.*/ inline operator Data & () const { return ( *data_ptr ); } #endif /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int2 () const { return ( (Int2) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int2 () const { return ( (U_Int2) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int4 () const { return ( (Int4) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int4 () const { return ( (U_Int4) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 64 bits signé.*/ inline operator Int8 () const { return ( (Int8) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 64 bits non signé.*/ inline operator U_Int8 () const { return ( (U_Int8) *data_ptr ); } /*! Opérateur de cast une donnée de type réel 32 bits.*/ inline operator Real4 () const { return ( (Real4) *data_ptr ); } /*! Opérateur de cast une donnée de type réel 64 bits.*/ inline operator Real8 () const { return ( (Real8) *data_ptr ); } //---------------------------------------------------------------------- // //---------------------------------------------------------------------- /*! Retourne l'identificateur de type de paramètre.*/ inline u_int TypeId() const { return (typeSingle); } /*! Retourne le type de paramètre.*/ inline string Type() const { return ("single"); } /*! Retourne chaîne de caractères avec le paramètre et son type. */ inline string InfoString() const { return (Name() + " = " + Type() + " (" + data_ptr->Type() + ")"); } //{ return (Name() + " = " + Type() + " (" + Get().Type() + ")"); } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante. */ inline string ValueString() const { return ( Name() + " = " + Get().Text() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante avec son mot d'état. */ inline string ValueFullString() const { return ( Name() + " = " + Get().FullText() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et l'ensemble des données (dans le cas d'un paramètre single, * il n'y a qu'une valeur). */ inline string DataString() const { return (ValueString()); } //---------------------------------------------------------------------- /*! Retourne chaîne de caractères avec de donnée.*/ inline string GetDataType() const { return (Get().Type()); } /*! Retourne l'identifiant du type de donnée.*/ inline u_int GetDataTypeId() const { return (Get().TypeId()); } //---------------------------------------------------------------------- /*! Remise à zéro du paramètre. */ inline void Reset() { *data_ptr = *def_value_ptr; (*data_ptr).SetBad(); status = 0; } /*! Retourne le nombre de données. Cette méthode n'a pas d'intérêt * pour la classe ParamSingle, mais elle sert pour les classes * dérivées de Param à valeurs multiples. */ inline u_int Dimension() const { return (1); } /*! Retourne une donnée. */ inline const Data & Get( ) const { return (*data_ptr); } // Opérateur []: renvoie la valeur de rand donnée. Data & operator [] (u_int index) const; //---------------------------------------------------------------------- /*! Positionne le paramètre sur sa première donnée. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours vrai. */ inline bool First() const { return (true); } /*! Positionne le paramètre sur sa dernière donnée. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours vrai. */ inline bool Last() const { return (true); } /*! Positionne le paramètre sur la dernière suivante. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours faux. */ inline bool Next() const { return (false); } /*! Positionne le paramètre sur la dernière précédente. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours faux. */ inline bool Previous() const { return (false); } //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(ParamSingle,0); } ; //====================================================================== #endif
64  * \param val valeur à affecter
65  */
66  inline Param & operator = ( const Int2 val )
67  { *data_ptr = val; return ( *this ); }
68 
69  /*! Opérateur d'affectation d'un entier 16 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int2 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un entier 32 bits signé. * \param val valeur à affecter */ inline Param & operator = ( const Int4 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un entier 32 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int4 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un entier 64 bits signé. * \param val valeur à affecter */ inline Param & operator = ( const Int8 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un entier 64 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int8 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un réel 32 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real4 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un réel 64 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real8 val ) { *data_ptr = val; return ( *this ); } //---------------------------------------------------------------------- // CAST //---------------------------------------------------------------------- #ifndef __MAKECINT__ /*! Opérateur de cast une donnée générique.*/ inline operator Data & () const { return ( *data_ptr ); } #endif /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int2 () const { return ( (Int2) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int2 () const { return ( (U_Int2) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int4 () const { return ( (Int4) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int4 () const { return ( (U_Int4) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 64 bits signé.*/ inline operator Int8 () const { return ( (Int8) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 64 bits non signé.*/ inline operator U_Int8 () const { return ( (U_Int8) *data_ptr ); } /*! Opérateur de cast une donnée de type réel 32 bits.*/ inline operator Real4 () const { return ( (Real4) *data_ptr ); } /*! Opérateur de cast une donnée de type réel 64 bits.*/ inline operator Real8 () const { return ( (Real8) *data_ptr ); } //---------------------------------------------------------------------- // //---------------------------------------------------------------------- /*! Retourne l'identificateur de type de paramètre.*/ inline u_int TypeId() const { return (typeSingle); } /*! Retourne le type de paramètre.*/ inline string Type() const { return ("single"); } /*! Retourne chaîne de caractères avec le paramètre et son type. */ inline string InfoString() const { return (Name() + " = " + Type() + " (" + data_ptr->Type() + ")"); } //{ return (Name() + " = " + Type() + " (" + Get().Type() + ")"); } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante. */ inline string ValueString() const { return ( Name() + " = " + Get().Text() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante avec son mot d'état. */ inline string ValueFullString() const { return ( Name() + " = " + Get().FullText() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et l'ensemble des données (dans le cas d'un paramètre single, * il n'y a qu'une valeur). */ inline string DataString() const { return (ValueString()); } //---------------------------------------------------------------------- /*! Retourne chaîne de caractères avec de donnée.*/ inline string GetDataType() const { return (Get().Type()); } /*! Retourne l'identifiant du type de donnée.*/ inline u_int GetDataTypeId() const { return (Get().TypeId()); } //---------------------------------------------------------------------- /*! Remise à zéro du paramètre. */ inline void Reset() { *data_ptr = *def_value_ptr; (*data_ptr).SetBad(); status = 0; } /*! Retourne le nombre de données. Cette méthode n'a pas d'intérêt * pour la classe ParamSingle, mais elle sert pour les classes * dérivées de Param à valeurs multiples. */ inline u_int Dimension() const { return (1); } /*! Retourne une donnée. */ inline const Data & Get( ) const { return (*data_ptr); } // Opérateur []: renvoie la valeur de rand donnée. Data & operator [] (u_int index) const; //---------------------------------------------------------------------- /*! Positionne le paramètre sur sa première donnée. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours vrai. */ inline bool First() const { return (true); } /*! Positionne le paramètre sur sa dernière donnée. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours vrai. */ inline bool Last() const { return (true); } /*! Positionne le paramètre sur la dernière suivante. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours faux. */ inline bool Next() const { return (false); } /*! Positionne le paramètre sur la dernière précédente. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours faux. */ inline bool Previous() const { return (false); } //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(ParamSingle,0); } ; //====================================================================== #endif
70  * \param val valeur à affecter
71  */
72  inline Param & operator = ( const U_Int2 val )
73  { *data_ptr = val; return ( *this ); }
74 
75  /*! Opérateur d'affectation d'un entier 32 bits signé. * \param val valeur à affecter */ inline Param & operator = ( const Int4 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un entier 32 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int4 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un entier 64 bits signé. * \param val valeur à affecter */ inline Param & operator = ( const Int8 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un entier 64 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int8 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un réel 32 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real4 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un réel 64 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real8 val ) { *data_ptr = val; return ( *this ); } //---------------------------------------------------------------------- // CAST //---------------------------------------------------------------------- #ifndef __MAKECINT__ /*! Opérateur de cast une donnée générique.*/ inline operator Data & () const { return ( *data_ptr ); } #endif /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int2 () const { return ( (Int2) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int2 () const { return ( (U_Int2) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int4 () const { return ( (Int4) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int4 () const { return ( (U_Int4) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 64 bits signé.*/ inline operator Int8 () const { return ( (Int8) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 64 bits non signé.*/ inline operator U_Int8 () const { return ( (U_Int8) *data_ptr ); } /*! Opérateur de cast une donnée de type réel 32 bits.*/ inline operator Real4 () const { return ( (Real4) *data_ptr ); } /*! Opérateur de cast une donnée de type réel 64 bits.*/ inline operator Real8 () const { return ( (Real8) *data_ptr ); } //---------------------------------------------------------------------- // //---------------------------------------------------------------------- /*! Retourne l'identificateur de type de paramètre.*/ inline u_int TypeId() const { return (typeSingle); } /*! Retourne le type de paramètre.*/ inline string Type() const { return ("single"); } /*! Retourne chaîne de caractères avec le paramètre et son type. */ inline string InfoString() const { return (Name() + " = " + Type() + " (" + data_ptr->Type() + ")"); } //{ return (Name() + " = " + Type() + " (" + Get().Type() + ")"); } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante. */ inline string ValueString() const { return ( Name() + " = " + Get().Text() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante avec son mot d'état. */ inline string ValueFullString() const { return ( Name() + " = " + Get().FullText() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et l'ensemble des données (dans le cas d'un paramètre single, * il n'y a qu'une valeur). */ inline string DataString() const { return (ValueString()); } //---------------------------------------------------------------------- /*! Retourne chaîne de caractères avec de donnée.*/ inline string GetDataType() const { return (Get().Type()); } /*! Retourne l'identifiant du type de donnée.*/ inline u_int GetDataTypeId() const { return (Get().TypeId()); } //---------------------------------------------------------------------- /*! Remise à zéro du paramètre. */ inline void Reset() { *data_ptr = *def_value_ptr; (*data_ptr).SetBad(); status = 0; } /*! Retourne le nombre de données. Cette méthode n'a pas d'intérêt * pour la classe ParamSingle, mais elle sert pour les classes * dérivées de Param à valeurs multiples. */ inline u_int Dimension() const { return (1); } /*! Retourne une donnée. */ inline const Data & Get( ) const { return (*data_ptr); } // Opérateur []: renvoie la valeur de rand donnée. Data & operator [] (u_int index) const; //---------------------------------------------------------------------- /*! Positionne le paramètre sur sa première donnée. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours vrai. */ inline bool First() const { return (true); } /*! Positionne le paramètre sur sa dernière donnée. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours vrai. */ inline bool Last() const { return (true); } /*! Positionne le paramètre sur la dernière suivante. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours faux. */ inline bool Next() const { return (false); } /*! Positionne le paramètre sur la dernière précédente. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours faux. */ inline bool Previous() const { return (false); } //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(ParamSingle,0); } ; //====================================================================== #endif
76  * \param val valeur à affecter
77  */
78  inline Param & operator = ( const Int4 val )
79  { *data_ptr = val; return ( *this ); }
80 
81  /*! Opérateur d'affectation d'un entier 32 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int4 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un entier 64 bits signé. * \param val valeur à affecter */ inline Param & operator = ( const Int8 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un entier 64 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int8 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un réel 32 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real4 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un réel 64 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real8 val ) { *data_ptr = val; return ( *this ); } //---------------------------------------------------------------------- // CAST //---------------------------------------------------------------------- #ifndef __MAKECINT__ /*! Opérateur de cast une donnée générique.*/ inline operator Data & () const { return ( *data_ptr ); } #endif /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int2 () const { return ( (Int2) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int2 () const { return ( (U_Int2) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int4 () const { return ( (Int4) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int4 () const { return ( (U_Int4) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 64 bits signé.*/ inline operator Int8 () const { return ( (Int8) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 64 bits non signé.*/ inline operator U_Int8 () const { return ( (U_Int8) *data_ptr ); } /*! Opérateur de cast une donnée de type réel 32 bits.*/ inline operator Real4 () const { return ( (Real4) *data_ptr ); } /*! Opérateur de cast une donnée de type réel 64 bits.*/ inline operator Real8 () const { return ( (Real8) *data_ptr ); } //---------------------------------------------------------------------- // //---------------------------------------------------------------------- /*! Retourne l'identificateur de type de paramètre.*/ inline u_int TypeId() const { return (typeSingle); } /*! Retourne le type de paramètre.*/ inline string Type() const { return ("single"); } /*! Retourne chaîne de caractères avec le paramètre et son type. */ inline string InfoString() const { return (Name() + " = " + Type() + " (" + data_ptr->Type() + ")"); } //{ return (Name() + " = " + Type() + " (" + Get().Type() + ")"); } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante. */ inline string ValueString() const { return ( Name() + " = " + Get().Text() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante avec son mot d'état. */ inline string ValueFullString() const { return ( Name() + " = " + Get().FullText() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et l'ensemble des données (dans le cas d'un paramètre single, * il n'y a qu'une valeur). */ inline string DataString() const { return (ValueString()); } //---------------------------------------------------------------------- /*! Retourne chaîne de caractères avec de donnée.*/ inline string GetDataType() const { return (Get().Type()); } /*! Retourne l'identifiant du type de donnée.*/ inline u_int GetDataTypeId() const { return (Get().TypeId()); } //---------------------------------------------------------------------- /*! Remise à zéro du paramètre. */ inline void Reset() { *data_ptr = *def_value_ptr; (*data_ptr).SetBad(); status = 0; } /*! Retourne le nombre de données. Cette méthode n'a pas d'intérêt * pour la classe ParamSingle, mais elle sert pour les classes * dérivées de Param à valeurs multiples. */ inline u_int Dimension() const { return (1); } /*! Retourne une donnée. */ inline const Data & Get( ) const { return (*data_ptr); } // Opérateur []: renvoie la valeur de rand donnée. Data & operator [] (u_int index) const; //---------------------------------------------------------------------- /*! Positionne le paramètre sur sa première donnée. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours vrai. */ inline bool First() const { return (true); } /*! Positionne le paramètre sur sa dernière donnée. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours vrai. */ inline bool Last() const { return (true); } /*! Positionne le paramètre sur la dernière suivante. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours faux. */ inline bool Next() const { return (false); } /*! Positionne le paramètre sur la dernière précédente. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours faux. */ inline bool Previous() const { return (false); } //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(ParamSingle,0); } ; //====================================================================== #endif
82  * \param val valeur à affecter
83  */
84  inline Param & operator = ( const U_Int4 val )
85  { *data_ptr = val; return ( *this ); }
86 
87  /*! Opérateur d'affectation d'un entier 64 bits signé. * \param val valeur à affecter */ inline Param & operator = ( const Int8 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un entier 64 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int8 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un réel 32 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real4 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un réel 64 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real8 val ) { *data_ptr = val; return ( *this ); } //---------------------------------------------------------------------- // CAST //---------------------------------------------------------------------- #ifndef __MAKECINT__ /*! Opérateur de cast une donnée générique.*/ inline operator Data & () const { return ( *data_ptr ); } #endif /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int2 () const { return ( (Int2) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int2 () const { return ( (U_Int2) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int4 () const { return ( (Int4) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int4 () const { return ( (U_Int4) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 64 bits signé.*/ inline operator Int8 () const { return ( (Int8) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 64 bits non signé.*/ inline operator U_Int8 () const { return ( (U_Int8) *data_ptr ); } /*! Opérateur de cast une donnée de type réel 32 bits.*/ inline operator Real4 () const { return ( (Real4) *data_ptr ); } /*! Opérateur de cast une donnée de type réel 64 bits.*/ inline operator Real8 () const { return ( (Real8) *data_ptr ); } //---------------------------------------------------------------------- // //---------------------------------------------------------------------- /*! Retourne l'identificateur de type de paramètre.*/ inline u_int TypeId() const { return (typeSingle); } /*! Retourne le type de paramètre.*/ inline string Type() const { return ("single"); } /*! Retourne chaîne de caractères avec le paramètre et son type. */ inline string InfoString() const { return (Name() + " = " + Type() + " (" + data_ptr->Type() + ")"); } //{ return (Name() + " = " + Type() + " (" + Get().Type() + ")"); } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante. */ inline string ValueString() const { return ( Name() + " = " + Get().Text() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante avec son mot d'état. */ inline string ValueFullString() const { return ( Name() + " = " + Get().FullText() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et l'ensemble des données (dans le cas d'un paramètre single, * il n'y a qu'une valeur). */ inline string DataString() const { return (ValueString()); } //---------------------------------------------------------------------- /*! Retourne chaîne de caractères avec de donnée.*/ inline string GetDataType() const { return (Get().Type()); } /*! Retourne l'identifiant du type de donnée.*/ inline u_int GetDataTypeId() const { return (Get().TypeId()); } //---------------------------------------------------------------------- /*! Remise à zéro du paramètre. */ inline void Reset() { *data_ptr = *def_value_ptr; (*data_ptr).SetBad(); status = 0; } /*! Retourne le nombre de données. Cette méthode n'a pas d'intérêt * pour la classe ParamSingle, mais elle sert pour les classes * dérivées de Param à valeurs multiples. */ inline u_int Dimension() const { return (1); } /*! Retourne une donnée. */ inline const Data & Get( ) const { return (*data_ptr); } // Opérateur []: renvoie la valeur de rand donnée. Data & operator [] (u_int index) const; //---------------------------------------------------------------------- /*! Positionne le paramètre sur sa première donnée. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours vrai. */ inline bool First() const { return (true); } /*! Positionne le paramètre sur sa dernière donnée. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours vrai. */ inline bool Last() const { return (true); } /*! Positionne le paramètre sur la dernière suivante. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours faux. */ inline bool Next() const { return (false); } /*! Positionne le paramètre sur la dernière précédente. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours faux. */ inline bool Previous() const { return (false); } //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(ParamSingle,0); } ; //====================================================================== #endif
88  * \param val valeur à affecter
89  */
90  inline Param & operator = ( const Int8 val )
91  { *data_ptr = val; return ( *this ); }
92 
93  /*! Opérateur d'affectation d'un entier 64 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int8 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un réel 32 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real4 val ) { *data_ptr = val; return ( *this ); } /*! Opérateur d'affectation d'un réel 64 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real8 val ) { *data_ptr = val; return ( *this ); } //---------------------------------------------------------------------- // CAST //---------------------------------------------------------------------- #ifndef __MAKECINT__ /*! Opérateur de cast une donnée générique.*/ inline operator Data & () const { return ( *data_ptr ); } #endif /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int2 () const { return ( (Int2) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int2 () const { return ( (U_Int2) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int4 () const { return ( (Int4) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int4 () const { return ( (U_Int4) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 64 bits signé.*/ inline operator Int8 () const { return ( (Int8) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 64 bits non signé.*/ inline operator U_Int8 () const { return ( (U_Int8) *data_ptr ); } /*! Opérateur de cast une donnée de type réel 32 bits.*/ inline operator Real4 () const { return ( (Real4) *data_ptr ); } /*! Opérateur de cast une donnée de type réel 64 bits.*/ inline operator Real8 () const { return ( (Real8) *data_ptr ); } //---------------------------------------------------------------------- // //---------------------------------------------------------------------- /*! Retourne l'identificateur de type de paramètre.*/ inline u_int TypeId() const { return (typeSingle); } /*! Retourne le type de paramètre.*/ inline string Type() const { return ("single"); } /*! Retourne chaîne de caractères avec le paramètre et son type. */ inline string InfoString() const { return (Name() + " = " + Type() + " (" + data_ptr->Type() + ")"); } //{ return (Name() + " = " + Type() + " (" + Get().Type() + ")"); } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante. */ inline string ValueString() const { return ( Name() + " = " + Get().Text() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante avec son mot d'état. */ inline string ValueFullString() const { return ( Name() + " = " + Get().FullText() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et l'ensemble des données (dans le cas d'un paramètre single, * il n'y a qu'une valeur). */ inline string DataString() const { return (ValueString()); } //---------------------------------------------------------------------- /*! Retourne chaîne de caractères avec de donnée.*/ inline string GetDataType() const { return (Get().Type()); } /*! Retourne l'identifiant du type de donnée.*/ inline u_int GetDataTypeId() const { return (Get().TypeId()); } //---------------------------------------------------------------------- /*! Remise à zéro du paramètre. */ inline void Reset() { *data_ptr = *def_value_ptr; (*data_ptr).SetBad(); status = 0; } /*! Retourne le nombre de données. Cette méthode n'a pas d'intérêt * pour la classe ParamSingle, mais elle sert pour les classes * dérivées de Param à valeurs multiples. */ inline u_int Dimension() const { return (1); } /*! Retourne une donnée. */ inline const Data & Get( ) const { return (*data_ptr); } // Opérateur []: renvoie la valeur de rand donnée. Data & operator [] (u_int index) const; //---------------------------------------------------------------------- /*! Positionne le paramètre sur sa première donnée. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours vrai. */ inline bool First() const { return (true); } /*! Positionne le paramètre sur sa dernière donnée. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours vrai. */ inline bool Last() const { return (true); } /*! Positionne le paramètre sur la dernière suivante. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours faux. */ inline bool Next() const { return (false); } /*! Positionne le paramètre sur la dernière précédente. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours faux. */ inline bool Previous() const { return (false); } //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(ParamSingle,0); } ; //====================================================================== #endif
94  * \param val valeur à affecter
95  */
96  inline Param & operator = ( const U_Int8 val )
97  { *data_ptr = val; return ( *this ); }
98 
99  /*! Opérateur d'affectation d'un réel 32 bits.
100  * \param val valeur à affecter
101  */
102  inline Param & operator = ( const Real4 val )
103  { *data_ptr = val; return ( *this ); }
104 
105  /*! Opérateur d'affectation d'un réel 64 bits.
106  * \param val valeur à affecter
107  */
108  inline Param & operator = ( const Real8 val )
109  { *data_ptr = val; return ( *this ); }
110 
111 
112 //----------------------------------------------------------------------
113 // CAST
114 //----------------------------------------------------------------------
115 
116 #ifndef __MAKECINT__
117  /*! Opérateur de cast une donnée générique.*/
118  inline operator Data & () const
119  { return ( *data_ptr ); }
120 #endif
121 
122  /*! Opérateur de cast une donnée de type entier 32 bits signé./ inline operator Int2 () const { return ( (Int2) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int2 () const { return ( (U_Int2) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int4 () const { return ( (Int4) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int4 () const { return ( (U_Int4) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 64 bits signé.*/ inline operator Int8 () const { return ( (Int8) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 64 bits non signé.*/ inline operator U_Int8 () const { return ( (U_Int8) *data_ptr ); } /*! Opérateur de cast une donnée de type réel 32 bits.*/ inline operator Real4 () const { return ( (Real4) *data_ptr ); } /*! Opérateur de cast une donnée de type réel 64 bits.*/ inline operator Real8 () const { return ( (Real8) *data_ptr ); } //---------------------------------------------------------------------- // //---------------------------------------------------------------------- /*! Retourne l'identificateur de type de paramètre.*/ inline u_int TypeId() const { return (typeSingle); } /*! Retourne le type de paramètre.*/ inline string Type() const { return ("single"); } /*! Retourne chaîne de caractères avec le paramètre et son type. */ inline string InfoString() const { return (Name() + " = " + Type() + " (" + data_ptr->Type() + ")"); } //{ return (Name() + " = " + Type() + " (" + Get().Type() + ")"); } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante. */ inline string ValueString() const { return ( Name() + " = " + Get().Text() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante avec son mot d'état. */ inline string ValueFullString() const { return ( Name() + " = " + Get().FullText() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et l'ensemble des données (dans le cas d'un paramètre single, * il n'y a qu'une valeur). */ inline string DataString() const { return (ValueString()); } //---------------------------------------------------------------------- /*! Retourne chaîne de caractères avec de donnée.*/ inline string GetDataType() const { return (Get().Type()); } /*! Retourne l'identifiant du type de donnée.*/ inline u_int GetDataTypeId() const { return (Get().TypeId()); } //---------------------------------------------------------------------- /*! Remise à zéro du paramètre. */ inline void Reset() { *data_ptr = *def_value_ptr; (*data_ptr).SetBad(); status = 0; } /*! Retourne le nombre de données. Cette méthode n'a pas d'intérêt * pour la classe ParamSingle, mais elle sert pour les classes * dérivées de Param à valeurs multiples. */ inline u_int Dimension() const { return (1); } /*! Retourne une donnée. */ inline const Data & Get( ) const { return (*data_ptr); } // Opérateur []: renvoie la valeur de rand donnée. Data & operator [] (u_int index) const; //---------------------------------------------------------------------- /*! Positionne le paramètre sur sa première donnée. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours vrai. */ inline bool First() const { return (true); } /*! Positionne le paramètre sur sa dernière donnée. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours vrai. */ inline bool Last() const { return (true); } /*! Positionne le paramètre sur la dernière suivante. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours faux. */ inline bool Next() const { return (false); } /*! Positionne le paramètre sur la dernière précédente. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours faux. */ inline bool Previous() const { return (false); } //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(ParamSingle,0); } ; //====================================================================== #endif */
123  inline operator Int2 () const
124  { return ( (Int2) *data_ptr ); }
125 
126  /*! Opérateur de cast une donnée de type entier 32 bits non signé./ inline operator U_Int2 () const { return ( (U_Int2) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int4 () const { return ( (Int4) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int4 () const { return ( (U_Int4) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 64 bits signé.*/ inline operator Int8 () const { return ( (Int8) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 64 bits non signé.*/ inline operator U_Int8 () const { return ( (U_Int8) *data_ptr ); } /*! Opérateur de cast une donnée de type réel 32 bits.*/ inline operator Real4 () const { return ( (Real4) *data_ptr ); } /*! Opérateur de cast une donnée de type réel 64 bits.*/ inline operator Real8 () const { return ( (Real8) *data_ptr ); } //---------------------------------------------------------------------- // //---------------------------------------------------------------------- /*! Retourne l'identificateur de type de paramètre.*/ inline u_int TypeId() const { return (typeSingle); } /*! Retourne le type de paramètre.*/ inline string Type() const { return ("single"); } /*! Retourne chaîne de caractères avec le paramètre et son type. */ inline string InfoString() const { return (Name() + " = " + Type() + " (" + data_ptr->Type() + ")"); } //{ return (Name() + " = " + Type() + " (" + Get().Type() + ")"); } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante. */ inline string ValueString() const { return ( Name() + " = " + Get().Text() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante avec son mot d'état. */ inline string ValueFullString() const { return ( Name() + " = " + Get().FullText() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et l'ensemble des données (dans le cas d'un paramètre single, * il n'y a qu'une valeur). */ inline string DataString() const { return (ValueString()); } //---------------------------------------------------------------------- /*! Retourne chaîne de caractères avec de donnée.*/ inline string GetDataType() const { return (Get().Type()); } /*! Retourne l'identifiant du type de donnée.*/ inline u_int GetDataTypeId() const { return (Get().TypeId()); } //---------------------------------------------------------------------- /*! Remise à zéro du paramètre. */ inline void Reset() { *data_ptr = *def_value_ptr; (*data_ptr).SetBad(); status = 0; } /*! Retourne le nombre de données. Cette méthode n'a pas d'intérêt * pour la classe ParamSingle, mais elle sert pour les classes * dérivées de Param à valeurs multiples. */ inline u_int Dimension() const { return (1); } /*! Retourne une donnée. */ inline const Data & Get( ) const { return (*data_ptr); } // Opérateur []: renvoie la valeur de rand donnée. Data & operator [] (u_int index) const; //---------------------------------------------------------------------- /*! Positionne le paramètre sur sa première donnée. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours vrai. */ inline bool First() const { return (true); } /*! Positionne le paramètre sur sa dernière donnée. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours vrai. */ inline bool Last() const { return (true); } /*! Positionne le paramètre sur la dernière suivante. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours faux. */ inline bool Next() const { return (false); } /*! Positionne le paramètre sur la dernière précédente. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours faux. */ inline bool Previous() const { return (false); } //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(ParamSingle,0); } ; //====================================================================== #endif */
127  inline operator U_Int2 () const
128  { return ( (U_Int2) *data_ptr ); }
129 
130  /*! Opérateur de cast une donnée de type entier 32 bits signé./ inline operator Int4 () const { return ( (Int4) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int4 () const { return ( (U_Int4) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 64 bits signé.*/ inline operator Int8 () const { return ( (Int8) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 64 bits non signé.*/ inline operator U_Int8 () const { return ( (U_Int8) *data_ptr ); } /*! Opérateur de cast une donnée de type réel 32 bits.*/ inline operator Real4 () const { return ( (Real4) *data_ptr ); } /*! Opérateur de cast une donnée de type réel 64 bits.*/ inline operator Real8 () const { return ( (Real8) *data_ptr ); } //---------------------------------------------------------------------- // //---------------------------------------------------------------------- /*! Retourne l'identificateur de type de paramètre.*/ inline u_int TypeId() const { return (typeSingle); } /*! Retourne le type de paramètre.*/ inline string Type() const { return ("single"); } /*! Retourne chaîne de caractères avec le paramètre et son type. */ inline string InfoString() const { return (Name() + " = " + Type() + " (" + data_ptr->Type() + ")"); } //{ return (Name() + " = " + Type() + " (" + Get().Type() + ")"); } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante. */ inline string ValueString() const { return ( Name() + " = " + Get().Text() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante avec son mot d'état. */ inline string ValueFullString() const { return ( Name() + " = " + Get().FullText() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et l'ensemble des données (dans le cas d'un paramètre single, * il n'y a qu'une valeur). */ inline string DataString() const { return (ValueString()); } //---------------------------------------------------------------------- /*! Retourne chaîne de caractères avec de donnée.*/ inline string GetDataType() const { return (Get().Type()); } /*! Retourne l'identifiant du type de donnée.*/ inline u_int GetDataTypeId() const { return (Get().TypeId()); } //---------------------------------------------------------------------- /*! Remise à zéro du paramètre. */ inline void Reset() { *data_ptr = *def_value_ptr; (*data_ptr).SetBad(); status = 0; } /*! Retourne le nombre de données. Cette méthode n'a pas d'intérêt * pour la classe ParamSingle, mais elle sert pour les classes * dérivées de Param à valeurs multiples. */ inline u_int Dimension() const { return (1); } /*! Retourne une donnée. */ inline const Data & Get( ) const { return (*data_ptr); } // Opérateur []: renvoie la valeur de rand donnée. Data & operator [] (u_int index) const; //---------------------------------------------------------------------- /*! Positionne le paramètre sur sa première donnée. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours vrai. */ inline bool First() const { return (true); } /*! Positionne le paramètre sur sa dernière donnée. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours vrai. */ inline bool Last() const { return (true); } /*! Positionne le paramètre sur la dernière suivante. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours faux. */ inline bool Next() const { return (false); } /*! Positionne le paramètre sur la dernière précédente. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours faux. */ inline bool Previous() const { return (false); } //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(ParamSingle,0); } ; //====================================================================== #endif */
131  inline operator Int4 () const
132  { return ( (Int4) *data_ptr ); }
133 
134  /*! Opérateur de cast une donnée de type entier 32 bits non signé./ inline operator U_Int4 () const { return ( (U_Int4) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 64 bits signé.*/ inline operator Int8 () const { return ( (Int8) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 64 bits non signé.*/ inline operator U_Int8 () const { return ( (U_Int8) *data_ptr ); } /*! Opérateur de cast une donnée de type réel 32 bits.*/ inline operator Real4 () const { return ( (Real4) *data_ptr ); } /*! Opérateur de cast une donnée de type réel 64 bits.*/ inline operator Real8 () const { return ( (Real8) *data_ptr ); } //---------------------------------------------------------------------- // //---------------------------------------------------------------------- /*! Retourne l'identificateur de type de paramètre.*/ inline u_int TypeId() const { return (typeSingle); } /*! Retourne le type de paramètre.*/ inline string Type() const { return ("single"); } /*! Retourne chaîne de caractères avec le paramètre et son type. */ inline string InfoString() const { return (Name() + " = " + Type() + " (" + data_ptr->Type() + ")"); } //{ return (Name() + " = " + Type() + " (" + Get().Type() + ")"); } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante. */ inline string ValueString() const { return ( Name() + " = " + Get().Text() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante avec son mot d'état. */ inline string ValueFullString() const { return ( Name() + " = " + Get().FullText() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et l'ensemble des données (dans le cas d'un paramètre single, * il n'y a qu'une valeur). */ inline string DataString() const { return (ValueString()); } //---------------------------------------------------------------------- /*! Retourne chaîne de caractères avec de donnée.*/ inline string GetDataType() const { return (Get().Type()); } /*! Retourne l'identifiant du type de donnée.*/ inline u_int GetDataTypeId() const { return (Get().TypeId()); } //---------------------------------------------------------------------- /*! Remise à zéro du paramètre. */ inline void Reset() { *data_ptr = *def_value_ptr; (*data_ptr).SetBad(); status = 0; } /*! Retourne le nombre de données. Cette méthode n'a pas d'intérêt * pour la classe ParamSingle, mais elle sert pour les classes * dérivées de Param à valeurs multiples. */ inline u_int Dimension() const { return (1); } /*! Retourne une donnée. */ inline const Data & Get( ) const { return (*data_ptr); } // Opérateur []: renvoie la valeur de rand donnée. Data & operator [] (u_int index) const; //---------------------------------------------------------------------- /*! Positionne le paramètre sur sa première donnée. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours vrai. */ inline bool First() const { return (true); } /*! Positionne le paramètre sur sa dernière donnée. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours vrai. */ inline bool Last() const { return (true); } /*! Positionne le paramètre sur la dernière suivante. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours faux. */ inline bool Next() const { return (false); } /*! Positionne le paramètre sur la dernière précédente. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours faux. */ inline bool Previous() const { return (false); } //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(ParamSingle,0); } ; //====================================================================== #endif */
135  inline operator U_Int4 () const
136  { return ( (U_Int4) *data_ptr ); }
137 
138  /*! Opérateur de cast une donnée de type entier 64 bits signé./ inline operator Int8 () const { return ( (Int8) *data_ptr ); } /*! Opérateur de cast une donnée de type entier 64 bits non signé.*/ inline operator U_Int8 () const { return ( (U_Int8) *data_ptr ); } /*! Opérateur de cast une donnée de type réel 32 bits.*/ inline operator Real4 () const { return ( (Real4) *data_ptr ); } /*! Opérateur de cast une donnée de type réel 64 bits.*/ inline operator Real8 () const { return ( (Real8) *data_ptr ); } //---------------------------------------------------------------------- // //---------------------------------------------------------------------- /*! Retourne l'identificateur de type de paramètre.*/ inline u_int TypeId() const { return (typeSingle); } /*! Retourne le type de paramètre.*/ inline string Type() const { return ("single"); } /*! Retourne chaîne de caractères avec le paramètre et son type. */ inline string InfoString() const { return (Name() + " = " + Type() + " (" + data_ptr->Type() + ")"); } //{ return (Name() + " = " + Type() + " (" + Get().Type() + ")"); } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante. */ inline string ValueString() const { return ( Name() + " = " + Get().Text() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante avec son mot d'état. */ inline string ValueFullString() const { return ( Name() + " = " + Get().FullText() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et l'ensemble des données (dans le cas d'un paramètre single, * il n'y a qu'une valeur). */ inline string DataString() const { return (ValueString()); } //---------------------------------------------------------------------- /*! Retourne chaîne de caractères avec de donnée.*/ inline string GetDataType() const { return (Get().Type()); } /*! Retourne l'identifiant du type de donnée.*/ inline u_int GetDataTypeId() const { return (Get().TypeId()); } //---------------------------------------------------------------------- /*! Remise à zéro du paramètre. */ inline void Reset() { *data_ptr = *def_value_ptr; (*data_ptr).SetBad(); status = 0; } /*! Retourne le nombre de données. Cette méthode n'a pas d'intérêt * pour la classe ParamSingle, mais elle sert pour les classes * dérivées de Param à valeurs multiples. */ inline u_int Dimension() const { return (1); } /*! Retourne une donnée. */ inline const Data & Get( ) const { return (*data_ptr); } // Opérateur []: renvoie la valeur de rand donnée. Data & operator [] (u_int index) const; //---------------------------------------------------------------------- /*! Positionne le paramètre sur sa première donnée. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours vrai. */ inline bool First() const { return (true); } /*! Positionne le paramètre sur sa dernière donnée. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours vrai. */ inline bool Last() const { return (true); } /*! Positionne le paramètre sur la dernière suivante. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours faux. */ inline bool Next() const { return (false); } /*! Positionne le paramètre sur la dernière précédente. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours faux. */ inline bool Previous() const { return (false); } //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(ParamSingle,0); } ; //====================================================================== #endif */
139  inline operator Int8 () const
140  { return ( (Int8) *data_ptr ); }
141 
142  /*! Opérateur de cast une donnée de type entier 64 bits non signé./ inline operator U_Int8 () const { return ( (U_Int8) *data_ptr ); } /*! Opérateur de cast une donnée de type réel 32 bits.*/ inline operator Real4 () const { return ( (Real4) *data_ptr ); } /*! Opérateur de cast une donnée de type réel 64 bits.*/ inline operator Real8 () const { return ( (Real8) *data_ptr ); } //---------------------------------------------------------------------- // //---------------------------------------------------------------------- /*! Retourne l'identificateur de type de paramètre.*/ inline u_int TypeId() const { return (typeSingle); } /*! Retourne le type de paramètre.*/ inline string Type() const { return ("single"); } /*! Retourne chaîne de caractères avec le paramètre et son type. */ inline string InfoString() const { return (Name() + " = " + Type() + " (" + data_ptr->Type() + ")"); } //{ return (Name() + " = " + Type() + " (" + Get().Type() + ")"); } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante. */ inline string ValueString() const { return ( Name() + " = " + Get().Text() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante avec son mot d'état. */ inline string ValueFullString() const { return ( Name() + " = " + Get().FullText() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et l'ensemble des données (dans le cas d'un paramètre single, * il n'y a qu'une valeur). */ inline string DataString() const { return (ValueString()); } //---------------------------------------------------------------------- /*! Retourne chaîne de caractères avec de donnée.*/ inline string GetDataType() const { return (Get().Type()); } /*! Retourne l'identifiant du type de donnée.*/ inline u_int GetDataTypeId() const { return (Get().TypeId()); } //---------------------------------------------------------------------- /*! Remise à zéro du paramètre. */ inline void Reset() { *data_ptr = *def_value_ptr; (*data_ptr).SetBad(); status = 0; } /*! Retourne le nombre de données. Cette méthode n'a pas d'intérêt * pour la classe ParamSingle, mais elle sert pour les classes * dérivées de Param à valeurs multiples. */ inline u_int Dimension() const { return (1); } /*! Retourne une donnée. */ inline const Data & Get( ) const { return (*data_ptr); } // Opérateur []: renvoie la valeur de rand donnée. Data & operator [] (u_int index) const; //---------------------------------------------------------------------- /*! Positionne le paramètre sur sa première donnée. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours vrai. */ inline bool First() const { return (true); } /*! Positionne le paramètre sur sa dernière donnée. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours vrai. */ inline bool Last() const { return (true); } /*! Positionne le paramètre sur la dernière suivante. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours faux. */ inline bool Next() const { return (false); } /*! Positionne le paramètre sur la dernière précédente. * Dans le cas d'un paramètre de type ParamSingle, cette méthode * retourne toujours faux. */ inline bool Previous() const { return (false); } //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(ParamSingle,0); } ; //====================================================================== #endif */
143  inline operator U_Int8 () const
144  { return ( (U_Int8) *data_ptr ); }
145 
146  /*! Opérateur de cast une donnée de type réel 32 bits.*/
147  inline operator Real4 () const
148  { return ( (Real4) *data_ptr ); }
149 
150  /*! Opérateur de cast une donnée de type réel 64 bits.*/
151  inline operator Real8 () const
152  { return ( (Real8) *data_ptr ); }
153 
154 
155 //----------------------------------------------------------------------
156 //
157 //----------------------------------------------------------------------
158 
159  /*! Retourne l'identificateur de type de paramètre.*/
160  inline u_int TypeId() const { return (typeSingle); }
161 
162  /*! Retourne le type de paramètre.*/
163  inline string Type() const { return ("single"); }
164 
165  /*! Retourne chaîne de caractères avec le paramètre et son type.
166  */
167  inline string InfoString() const
168  { return (Name() + " = " + Type() + " (" + data_ptr->Type() + ")"); }
169  //{ return (Name() + " = " + Type() + " (" + Get().Type() + ")"); }
170 
171  /*! Retourne chaîne de caractères avec le paramètre et son type
172  * et la valeur courante.
173  */
174  inline string ValueString() const
175  { return ( Name() + " = " + Get().Text() ) ; }
176 
177  /*! Retourne chaîne de caractères avec le paramètre et son type
178  * et la valeur courante avec son mot d'état.
179  */
180  inline string ValueFullString() const
181  { return ( Name() + " = " + Get().FullText() ) ; }
182 
183  /*! Retourne chaîne de caractères avec le paramètre et son type
184  * et l'ensemble des données (dans le cas d'un paramètre single,
185  * il n'y a qu'une valeur).
186  */
187  inline string DataString() const
188  { return (ValueString()); }
189 
190 //----------------------------------------------------------------------
191 
192  /*! Retourne chaîne de caractères avec de donnée.*/
193  inline string GetDataType() const
194  { return (Get().Type()); }
195 
196  /*! Retourne l'identifiant du type de donnée.*/
197  inline u_int GetDataTypeId() const
198  { return (Get().TypeId()); }
199 
200 //----------------------------------------------------------------------
201  /*! Remise à zéro du paramètre.
202  */
203  inline void Reset()
204  { *data_ptr = *def_value_ptr; (*data_ptr).SetBad(); status = 0; }
205 
206  /*! Retourne le nombre de données. Cette méthode n'a pas d'intérêt
207  * pour la classe ParamSingle, mais elle sert pour les classes
208  * dérivées de Param à valeurs multiples.
209  */
210  inline u_int Dimension() const
211  { return (1); }
212 
213  /*! Retourne une donnée.
214  */
215  inline const Data & Get( ) const
216  { return (*data_ptr); }
217 
218  // Opérateur []: renvoie la valeur de rand donnée.
219  Data & operator [] (u_int index) const;
220 
221 //----------------------------------------------------------------------
222 
223  /*! Positionne le paramètre sur sa première donnée.
224  * Dans le cas d'un paramètre de type ParamSingle, cette méthode
225  * retourne toujours vrai.
226  */
227  inline bool First() const
228  { return (true); }
229 
230  /*! Positionne le paramètre sur sa dernière donnée.
231  * Dans le cas d'un paramètre de type ParamSingle, cette méthode
232  * retourne toujours vrai.
233  */
234  inline bool Last() const
235  { return (true); }
236 
237  /*! Positionne le paramètre sur la dernière suivante.
238  * Dans le cas d'un paramètre de type ParamSingle, cette méthode
239  * retourne toujours faux.
240  */
241  inline bool Next() const
242  { return (false); }
243 
244  /*! Positionne le paramètre sur la dernière précédente.
245  * Dans le cas d'un paramètre de type ParamSingle, cette méthode
246  * retourne toujours faux.
247  */
248  inline bool Previous() const
249  { return (false); }
250 
251 
252 //----------------------------------------------------------------------
253 // pour ROOT...
254  public:
255  /*! Définition à usage de ROOT... */
256  ClassDef(ParamSingle,0);
257 } ;
258 
259 
260 //======================================================================
261 
262 #endif
ParamSingle::~ParamSingle
virtual ~ParamSingle()
Definition: ParamSingle.cpp:67
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
ParamSingle::GetDataTypeId
u_int GetDataTypeId() const
Definition: ParamSingle.hh:197
ParamSingle::ValueString
string ValueString() const
Definition: ParamSingle.hh:174
Data::SetBad
void SetBad()
Definition: Data.hh:420
ParamSingle::operator=
ParamSingle & operator=(const ParamSingle &par)
Definition: ParamSingle.cpp:50
ParamSingle::TypeId
u_int TypeId() const
Definition: ParamSingle.hh:160
PARAM_NONAME
#define PARAM_NONAME
Nom de paramètre non spécifié
Definition: Param.hh:17
U_Int2
unsigned short U_Int2
Définition du type entier 16 bits non signé
Definition: EventCommon.hh:32
ParamSingle::InfoString
string InfoString() const
Definition: ParamSingle.hh:167
ParamSingle::First
bool First() const
Definition: ParamSingle.hh:227
Data::Type
virtual string Type() const =0
ParamSingle::Dimension
u_int Dimension() const
Definition: ParamSingle.hh:210
ParamSingle::operator[]
Data & operator[](u_int index) const
Definition: ParamSingle.cpp:82
Int2
short Int2
Définition du type entier 16 bits.
Definition: EventCommon.hh:26
ParamSingle::ClassDef
ClassDef(ParamSingle, 0)
ParamSingle::data_ptr
Data * data_ptr
Pointeur sur la donnée associée au paramètre.
Definition: ParamSingle.hh:29
ParamSingle::Next
bool Next() const
Definition: ParamSingle.hh:241
ParamSingle::ParamSingle
ParamSingle(const string &par_name="unnamed")
Definition: ParamSingle.cpp:22
Param
Definition: Param.hh:83
U_Int8
ULong64_t U_Int8
Définition du type entier 64 bits non signé
Definition: EventCommon.hh:56
ParamSingle::GetDataType
string GetDataType() const
Definition: ParamSingle.hh:193
ParamSingle::ValueFullString
string ValueFullString() const
Definition: ParamSingle.hh:180
ParamSingle::GObject
GObject(ParamSingle)
ParamSingle::Type
string Type() const
Definition: ParamSingle.hh:163
ParamSingle::Get
const Data & Get() const
Definition: ParamSingle.hh:215
ParamSingle
Definition: ParamSingle.hh:21
ParamSingle::Last
bool Last() const
Definition: ParamSingle.hh:234
Data
Definition: Data.hh:153
ParamSingle::DataString
string DataString() const
Definition: ParamSingle.hh:187
Int4
int Int4
Définition du type entier 32 bits.
Definition: EventCommon.hh:38
ParamSingle::Reset
void Reset()
Definition: ParamSingle.hh:203
U_Int4
unsigned int U_Int4
Définition du type entier 32 bits non signé
Definition: EventCommon.hh:44
Param::status
u_int status
Mot d&#39;état du paramètre (non implémenté)
Definition: Param.hh:100
Int8
Long64_t Int8
Définition du type entier 64 bits.
Definition: EventCommon.hh:50
ParamSingle::Previous
bool Previous() const
Definition: ParamSingle.hh:248
Param::def_value_ptr
Data * def_value_ptr
Pointeur sur la valeur par défaut du paramètre.
Definition: Param.hh:102