Analysis  version 7.0 - august 2014
ParamArray.hh
Go to the documentation of this file.
1 //======================================================================
2 /*! \file ParamArray.hh
3  *
4  * Déclaration des méthodes de la classe ParamArray qui décrit
5  * les paramètres de type tableau de longueur fixe d'un événement.
6  */
7 //======================================================================
8 
9 
10 #ifndef PARAM_ARRAY_HH
11 #define PARAM_ARRAY_HH
12 
13 #include "Param.hh"
14 
15 //======================================================================
16 /*! \class ParamArray
17  *
18  * C'est une classe qui décrit les paramètres de type tableau
19  * de données de longueur fixe d'un événement. Les données sont
20  * alors toutes du même type.
21  *
22  * Lorsqu'une valeur est écrite par un accès autre que l'opérateur
23  * [], un curseur est incrémenté. Ainsi, chaque fois qu'une affectation
24  * est opérée, c'est la donnée suivante qui est affectée.
25  *
26  * En ce qui concerne la lecture, ce curseur n'est pas modifié, mais les
27  * méthode First(), Last(), Next() et Previous() permettent de se
28  * déplacer dans les valeurs (en plus de l'opérateur []).
29  *
30  * \note
31  * Ce qui est alloué, c'est un tableau de pointeurs de type (Data *)
32  * et non un tableau de données, parce que les données ont des
33  * tailles variables, et qu'une fois considéré comme un tableau de
34  * Data, le compilateur considère que chaque élément a la taille
35  * d'un objet Data !
36  */
37 
38 class ParamArray : public Param
39 {
40 //----------------------------------------------------------------------
41  /*! \object_doc */
42  GObject(ParamArray);
43 //----------------------------------------------------------------------
44 
45  protected:
46 #ifndef __MAKECINT__
47  u_int size; ///< Taille du tableau (nombre de données)
48  u_int *cursor; ///< Position actuelle (c'est un pointeur pour pouvoir être modifié même dans une instance constante)
49  Data **array_ptr; ///< Pointeur sur la table de données associée au paramètre
50 #endif
51 
52  public:
53 
54 //----------------------------------------------------------------------
55 // CONSTRUCTEUR / AFFECTATION /DESTRUCTEUR
56 //----------------------------------------------------------------------
57 
58  // Constructeur: le nom de paramètre doit être spécifié. ParamArray ( const string &par_name = PARAM_NONAME, const u_int s = 2 ); // Constructeur à partir d'un nom et d'une donnée. ParamArray ( const string &par_name, const u_int s, const Data &d ); // Constructeur de recopie. ParamArray ( const ParamArray &par ); // Opérateur d'affectation ParamArray & operator = ( const ParamArray &par ); // Destructeur virtual ~ParamArray (); //---------------------------------------------------------------------- // AFFECTATION //---------------------------------------------------------------------- /*! Opérateur d'affectation d'une donnée. * \param d donnée à affecter */ inline Param & operator = ( const Data &d ) { return ( _SetData (d) ); } /*! Opérateur d'affectation d'un entier 16 bits signé. * \param val valeur à affecter */ inline Param & operator = ( const Int2 val ) { return ( _SetData (DataI2(val)) ); } /*! Opérateur d'affectation d'un entier 16 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int2 val ) { return ( _SetData (DataUI2(val)) ); } /*! Opérateur d'affectation d'un entier 32 bits signé. * \param val valeur à affecter */ inline Param & operator = ( const Int4 val ) { return ( _SetData (DataI4(val)) ); } /*! Opérateur d'affectation d'un entier 32 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int4 val ) { return ( _SetData (DataUI4(val)) ); } /*! Opérateur d'affectation d'un entier 64 bits signé. * \param val valeur à affecter */ inline Param & operator = ( const Int8 val ) { return ( _SetData (DataI8(val)) ); } /*! Opérateur d'affectation d'un entier 64 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int8 val ) { return ( _SetData (DataUI8(val)) ); } /*! Opérateur d'affectation d'un réel 32 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real4 val ) { return ( _SetData (DataR4(val)) ); } /*! Opérateur d'affectation d'un réel 64 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real8 val ) { return ( _SetData (DataR8(val)) ); } //---------------------------------------------------------------------- // CAST //---------------------------------------------------------------------- #ifndef __MAKECINT__ /*! Opérateur de cast une donnée générique.*/ inline operator Data & () const { return ( *array_ptr[*cursor] ); } #endif /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int2 () const { return ( (Int2) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int2 () const { return ( (U_Int2) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int4 () const { return ( (Int4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int4 () const { return ( (U_Int4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 64 bits signé.*/ inline operator Int8 () const { return ( (Int8) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 64 bits non signé.*/ inline operator U_Int8 () const { return ( (U_Int8) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type réel 32 bits.*/ inline operator Real4 () const { return ( (Real4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type réel 64 bits.*/ inline operator Real8 () const { return ( (Real8) *array_ptr[*cursor] ); } //---------------------------------------------------------------------- // //---------------------------------------------------------------------- /*! Retourne l'identificateur de type de paramètre.*/ inline u_int TypeId() const { return (typeArray); } /*! Retourne le type de paramètre.*/ inline string Type() const { return ("array"); } /*! Retourne chaîne de caractères avec le paramètre et son type. */ inline string InfoString() const { return (Name() + " = " + Type() + "[" + GGetString(size) + "] (" + array_ptr[0]->Type() + ")"); } //{ return (Name() + " = " + Type() + "[" + GGetString(size) // + "] (" + Get().Type() + ")"); } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante. * Le curseur est passé à la donnée suivante du tableau. */ inline string ValueString() const { return ( Name() + " [" + GGetString((*cursor)+1) + "/" + GGetString(size) + "] = " + Get().Text() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante avec son mot d'état. * Le curseur est passé à la donnée suivante du tableau. */ inline string ValueFullString() const { return ( Name() + " [" + GGetString((*cursor)+1) + "/" + GGetString(size) + "] = " + Get().FullText() ) ; } // Retourne chaîne de caractères avec le paramètre et son type // et l'ensemble des données. string DataString() const; //---------------------------------------------------------------------- /*! Retourne chaîne de caractères avec de donnée.*/ inline string GetDataType() const { return (array_ptr[0]->Type()); } /*! Retourne l'identifiant du type de donnée.*/ inline u_int GetDataTypeId() const { return (array_ptr[0]->TypeId()); } //---------------------------------------------------------------------- // Remise à zéro du paramètre. void Reset(); /*! Retourne le nombre de données, c'est à dire la dimension du * tableau de données. */ inline u_int Dimension() const { return (size); } /*! Retourne la donnée correspondant au curseur. */ inline const Data & Get( ) const { return (*array_ptr[*cursor]); } // Opérateur []: renvoie la valeur de rand donnée. Data & operator [] (u_int index) const; //---------------------------------------------------------------------- /*! Retourne la position actuelle du curseur dans le tableau. */ inline u_int GetCursor() const { return (*cursor); } /*! Positionne le paramètre sur sa première donnée. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne toujours vrai. */ inline bool First() const { (*cursor) = 0; return (true); } /*! Positionne le paramètre sur sa dernière donnée. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne toujours vrai. */ inline bool Last() const { (*cursor) = size; return (true); } /*! Positionne le paramètre sur la dernière suivante. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne vrai le paramètre n'est pas déjà positionné sur la * dernière valeur. */ inline bool Next() const { if ((*cursor) < (size-1)) { (*cursor)++; return (true); } else return (false); } /*! Positionne le paramètre sur la dernière précédente. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne vrai le paramètre n'est pas déjà positionné sur la * première valeur. */ inline bool Previous() const { if ((*cursor) > 0) { (*cursor)--; return (true); } else return (false); } //---------------------------------------------------------------------- // METHODES PROTEGEES //---------------------------------------------------------------------- protected: // Alloue un nouveau tableau de données initialisées Data **_AllocArray ( const u_int s, const Data &d ) ; /*! Affecte une valeur à la donnée courante (indiquée par le * curseur). Un message d'alerte est généré si * la taille du tableau est dépassée. * Cette méthode est appelée dans le cas des surcharges de l'opérateur * d'affectation pour les différents types de données. * \param d donnée à affecter */ inline Param & _SetData ( const Data &d ) { if ((*cursor) < size) { *array_ptr[(*cursor)++] = d; } else GLogWarning ( "ParamArray: affectation at " + GGetString((*cursor)) + " over array size ignored"); return ( *this ); } //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(ParamArray,0); } ; //====================================================================== #endif
59  ParamArray ( const string &par_name = PARAM_NONAME, const u_int s = 2 );
60 
61  // Constructeur à partir d'un nom et d'une donnée.
62  ParamArray ( const string &par_name, const u_int s, const Data &d );
63 
64  // Constructeur de recopie.
65  ParamArray ( const ParamArray &par );
66 
67  // Opérateur d'affectation
68  ParamArray & operator = ( const ParamArray &par );
69 
70  // Destructeur
71  virtual ~ParamArray ();
72 
73 
74 //----------------------------------------------------------------------
75 // AFFECTATION
76 //----------------------------------------------------------------------
77 
78  /*! Opérateur d'affectation d'une donnée.
79  * \param d donnée à affecter
80  */
81  inline Param & operator = ( const Data &d )
82  { return ( _SetData (d) ); }
83 
84  /*! Opérateur d'affectation d'un entier 16 bits signé. * \param val valeur à affecter */ inline Param & operator = ( const Int2 val ) { return ( _SetData (DataI2(val)) ); } /*! Opérateur d'affectation d'un entier 16 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int2 val ) { return ( _SetData (DataUI2(val)) ); } /*! Opérateur d'affectation d'un entier 32 bits signé. * \param val valeur à affecter */ inline Param & operator = ( const Int4 val ) { return ( _SetData (DataI4(val)) ); } /*! Opérateur d'affectation d'un entier 32 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int4 val ) { return ( _SetData (DataUI4(val)) ); } /*! Opérateur d'affectation d'un entier 64 bits signé. * \param val valeur à affecter */ inline Param & operator = ( const Int8 val ) { return ( _SetData (DataI8(val)) ); } /*! Opérateur d'affectation d'un entier 64 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int8 val ) { return ( _SetData (DataUI8(val)) ); } /*! Opérateur d'affectation d'un réel 32 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real4 val ) { return ( _SetData (DataR4(val)) ); } /*! Opérateur d'affectation d'un réel 64 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real8 val ) { return ( _SetData (DataR8(val)) ); } //---------------------------------------------------------------------- // CAST //---------------------------------------------------------------------- #ifndef __MAKECINT__ /*! Opérateur de cast une donnée générique.*/ inline operator Data & () const { return ( *array_ptr[*cursor] ); } #endif /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int2 () const { return ( (Int2) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int2 () const { return ( (U_Int2) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int4 () const { return ( (Int4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int4 () const { return ( (U_Int4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 64 bits signé.*/ inline operator Int8 () const { return ( (Int8) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 64 bits non signé.*/ inline operator U_Int8 () const { return ( (U_Int8) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type réel 32 bits.*/ inline operator Real4 () const { return ( (Real4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type réel 64 bits.*/ inline operator Real8 () const { return ( (Real8) *array_ptr[*cursor] ); } //---------------------------------------------------------------------- // //---------------------------------------------------------------------- /*! Retourne l'identificateur de type de paramètre.*/ inline u_int TypeId() const { return (typeArray); } /*! Retourne le type de paramètre.*/ inline string Type() const { return ("array"); } /*! Retourne chaîne de caractères avec le paramètre et son type. */ inline string InfoString() const { return (Name() + " = " + Type() + "[" + GGetString(size) + "] (" + array_ptr[0]->Type() + ")"); } //{ return (Name() + " = " + Type() + "[" + GGetString(size) // + "] (" + Get().Type() + ")"); } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante. * Le curseur est passé à la donnée suivante du tableau. */ inline string ValueString() const { return ( Name() + " [" + GGetString((*cursor)+1) + "/" + GGetString(size) + "] = " + Get().Text() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante avec son mot d'état. * Le curseur est passé à la donnée suivante du tableau. */ inline string ValueFullString() const { return ( Name() + " [" + GGetString((*cursor)+1) + "/" + GGetString(size) + "] = " + Get().FullText() ) ; } // Retourne chaîne de caractères avec le paramètre et son type // et l'ensemble des données. string DataString() const; //---------------------------------------------------------------------- /*! Retourne chaîne de caractères avec de donnée.*/ inline string GetDataType() const { return (array_ptr[0]->Type()); } /*! Retourne l'identifiant du type de donnée.*/ inline u_int GetDataTypeId() const { return (array_ptr[0]->TypeId()); } //---------------------------------------------------------------------- // Remise à zéro du paramètre. void Reset(); /*! Retourne le nombre de données, c'est à dire la dimension du * tableau de données. */ inline u_int Dimension() const { return (size); } /*! Retourne la donnée correspondant au curseur. */ inline const Data & Get( ) const { return (*array_ptr[*cursor]); } // Opérateur []: renvoie la valeur de rand donnée. Data & operator [] (u_int index) const; //---------------------------------------------------------------------- /*! Retourne la position actuelle du curseur dans le tableau. */ inline u_int GetCursor() const { return (*cursor); } /*! Positionne le paramètre sur sa première donnée. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne toujours vrai. */ inline bool First() const { (*cursor) = 0; return (true); } /*! Positionne le paramètre sur sa dernière donnée. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne toujours vrai. */ inline bool Last() const { (*cursor) = size; return (true); } /*! Positionne le paramètre sur la dernière suivante. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne vrai le paramètre n'est pas déjà positionné sur la * dernière valeur. */ inline bool Next() const { if ((*cursor) < (size-1)) { (*cursor)++; return (true); } else return (false); } /*! Positionne le paramètre sur la dernière précédente. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne vrai le paramètre n'est pas déjà positionné sur la * première valeur. */ inline bool Previous() const { if ((*cursor) > 0) { (*cursor)--; return (true); } else return (false); } //---------------------------------------------------------------------- // METHODES PROTEGEES //---------------------------------------------------------------------- protected: // Alloue un nouveau tableau de données initialisées Data **_AllocArray ( const u_int s, const Data &d ) ; /*! Affecte une valeur à la donnée courante (indiquée par le * curseur). Un message d'alerte est généré si * la taille du tableau est dépassée. * Cette méthode est appelée dans le cas des surcharges de l'opérateur * d'affectation pour les différents types de données. * \param d donnée à affecter */ inline Param & _SetData ( const Data &d ) { if ((*cursor) < size) { *array_ptr[(*cursor)++] = d; } else GLogWarning ( "ParamArray: affectation at " + GGetString((*cursor)) + " over array size ignored"); return ( *this ); } //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(ParamArray,0); } ; //====================================================================== #endif
85  * \param val valeur à affecter
86  */
87  inline Param & operator = ( const Int2 val )
88  { return ( _SetData (DataI2(val)) ); }
89 
90  /*! Opérateur d'affectation d'un entier 16 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int2 val ) { return ( _SetData (DataUI2(val)) ); } /*! Opérateur d'affectation d'un entier 32 bits signé. * \param val valeur à affecter */ inline Param & operator = ( const Int4 val ) { return ( _SetData (DataI4(val)) ); } /*! Opérateur d'affectation d'un entier 32 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int4 val ) { return ( _SetData (DataUI4(val)) ); } /*! Opérateur d'affectation d'un entier 64 bits signé. * \param val valeur à affecter */ inline Param & operator = ( const Int8 val ) { return ( _SetData (DataI8(val)) ); } /*! Opérateur d'affectation d'un entier 64 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int8 val ) { return ( _SetData (DataUI8(val)) ); } /*! Opérateur d'affectation d'un réel 32 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real4 val ) { return ( _SetData (DataR4(val)) ); } /*! Opérateur d'affectation d'un réel 64 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real8 val ) { return ( _SetData (DataR8(val)) ); } //---------------------------------------------------------------------- // CAST //---------------------------------------------------------------------- #ifndef __MAKECINT__ /*! Opérateur de cast une donnée générique.*/ inline operator Data & () const { return ( *array_ptr[*cursor] ); } #endif /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int2 () const { return ( (Int2) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int2 () const { return ( (U_Int2) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int4 () const { return ( (Int4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int4 () const { return ( (U_Int4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 64 bits signé.*/ inline operator Int8 () const { return ( (Int8) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 64 bits non signé.*/ inline operator U_Int8 () const { return ( (U_Int8) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type réel 32 bits.*/ inline operator Real4 () const { return ( (Real4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type réel 64 bits.*/ inline operator Real8 () const { return ( (Real8) *array_ptr[*cursor] ); } //---------------------------------------------------------------------- // //---------------------------------------------------------------------- /*! Retourne l'identificateur de type de paramètre.*/ inline u_int TypeId() const { return (typeArray); } /*! Retourne le type de paramètre.*/ inline string Type() const { return ("array"); } /*! Retourne chaîne de caractères avec le paramètre et son type. */ inline string InfoString() const { return (Name() + " = " + Type() + "[" + GGetString(size) + "] (" + array_ptr[0]->Type() + ")"); } //{ return (Name() + " = " + Type() + "[" + GGetString(size) // + "] (" + Get().Type() + ")"); } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante. * Le curseur est passé à la donnée suivante du tableau. */ inline string ValueString() const { return ( Name() + " [" + GGetString((*cursor)+1) + "/" + GGetString(size) + "] = " + Get().Text() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante avec son mot d'état. * Le curseur est passé à la donnée suivante du tableau. */ inline string ValueFullString() const { return ( Name() + " [" + GGetString((*cursor)+1) + "/" + GGetString(size) + "] = " + Get().FullText() ) ; } // Retourne chaîne de caractères avec le paramètre et son type // et l'ensemble des données. string DataString() const; //---------------------------------------------------------------------- /*! Retourne chaîne de caractères avec de donnée.*/ inline string GetDataType() const { return (array_ptr[0]->Type()); } /*! Retourne l'identifiant du type de donnée.*/ inline u_int GetDataTypeId() const { return (array_ptr[0]->TypeId()); } //---------------------------------------------------------------------- // Remise à zéro du paramètre. void Reset(); /*! Retourne le nombre de données, c'est à dire la dimension du * tableau de données. */ inline u_int Dimension() const { return (size); } /*! Retourne la donnée correspondant au curseur. */ inline const Data & Get( ) const { return (*array_ptr[*cursor]); } // Opérateur []: renvoie la valeur de rand donnée. Data & operator [] (u_int index) const; //---------------------------------------------------------------------- /*! Retourne la position actuelle du curseur dans le tableau. */ inline u_int GetCursor() const { return (*cursor); } /*! Positionne le paramètre sur sa première donnée. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne toujours vrai. */ inline bool First() const { (*cursor) = 0; return (true); } /*! Positionne le paramètre sur sa dernière donnée. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne toujours vrai. */ inline bool Last() const { (*cursor) = size; return (true); } /*! Positionne le paramètre sur la dernière suivante. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne vrai le paramètre n'est pas déjà positionné sur la * dernière valeur. */ inline bool Next() const { if ((*cursor) < (size-1)) { (*cursor)++; return (true); } else return (false); } /*! Positionne le paramètre sur la dernière précédente. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne vrai le paramètre n'est pas déjà positionné sur la * première valeur. */ inline bool Previous() const { if ((*cursor) > 0) { (*cursor)--; return (true); } else return (false); } //---------------------------------------------------------------------- // METHODES PROTEGEES //---------------------------------------------------------------------- protected: // Alloue un nouveau tableau de données initialisées Data **_AllocArray ( const u_int s, const Data &d ) ; /*! Affecte une valeur à la donnée courante (indiquée par le * curseur). Un message d'alerte est généré si * la taille du tableau est dépassée. * Cette méthode est appelée dans le cas des surcharges de l'opérateur * d'affectation pour les différents types de données. * \param d donnée à affecter */ inline Param & _SetData ( const Data &d ) { if ((*cursor) < size) { *array_ptr[(*cursor)++] = d; } else GLogWarning ( "ParamArray: affectation at " + GGetString((*cursor)) + " over array size ignored"); return ( *this ); } //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(ParamArray,0); } ; //====================================================================== #endif
91  * \param val valeur à affecter
92  */
93  inline Param & operator = ( const U_Int2 val )
94  { return ( _SetData (DataUI2(val)) ); }
95 
96  /*! Opérateur d'affectation d'un entier 32 bits signé. * \param val valeur à affecter */ inline Param & operator = ( const Int4 val ) { return ( _SetData (DataI4(val)) ); } /*! Opérateur d'affectation d'un entier 32 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int4 val ) { return ( _SetData (DataUI4(val)) ); } /*! Opérateur d'affectation d'un entier 64 bits signé. * \param val valeur à affecter */ inline Param & operator = ( const Int8 val ) { return ( _SetData (DataI8(val)) ); } /*! Opérateur d'affectation d'un entier 64 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int8 val ) { return ( _SetData (DataUI8(val)) ); } /*! Opérateur d'affectation d'un réel 32 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real4 val ) { return ( _SetData (DataR4(val)) ); } /*! Opérateur d'affectation d'un réel 64 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real8 val ) { return ( _SetData (DataR8(val)) ); } //---------------------------------------------------------------------- // CAST //---------------------------------------------------------------------- #ifndef __MAKECINT__ /*! Opérateur de cast une donnée générique.*/ inline operator Data & () const { return ( *array_ptr[*cursor] ); } #endif /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int2 () const { return ( (Int2) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int2 () const { return ( (U_Int2) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int4 () const { return ( (Int4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int4 () const { return ( (U_Int4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 64 bits signé.*/ inline operator Int8 () const { return ( (Int8) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 64 bits non signé.*/ inline operator U_Int8 () const { return ( (U_Int8) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type réel 32 bits.*/ inline operator Real4 () const { return ( (Real4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type réel 64 bits.*/ inline operator Real8 () const { return ( (Real8) *array_ptr[*cursor] ); } //---------------------------------------------------------------------- // //---------------------------------------------------------------------- /*! Retourne l'identificateur de type de paramètre.*/ inline u_int TypeId() const { return (typeArray); } /*! Retourne le type de paramètre.*/ inline string Type() const { return ("array"); } /*! Retourne chaîne de caractères avec le paramètre et son type. */ inline string InfoString() const { return (Name() + " = " + Type() + "[" + GGetString(size) + "] (" + array_ptr[0]->Type() + ")"); } //{ return (Name() + " = " + Type() + "[" + GGetString(size) // + "] (" + Get().Type() + ")"); } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante. * Le curseur est passé à la donnée suivante du tableau. */ inline string ValueString() const { return ( Name() + " [" + GGetString((*cursor)+1) + "/" + GGetString(size) + "] = " + Get().Text() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante avec son mot d'état. * Le curseur est passé à la donnée suivante du tableau. */ inline string ValueFullString() const { return ( Name() + " [" + GGetString((*cursor)+1) + "/" + GGetString(size) + "] = " + Get().FullText() ) ; } // Retourne chaîne de caractères avec le paramètre et son type // et l'ensemble des données. string DataString() const; //---------------------------------------------------------------------- /*! Retourne chaîne de caractères avec de donnée.*/ inline string GetDataType() const { return (array_ptr[0]->Type()); } /*! Retourne l'identifiant du type de donnée.*/ inline u_int GetDataTypeId() const { return (array_ptr[0]->TypeId()); } //---------------------------------------------------------------------- // Remise à zéro du paramètre. void Reset(); /*! Retourne le nombre de données, c'est à dire la dimension du * tableau de données. */ inline u_int Dimension() const { return (size); } /*! Retourne la donnée correspondant au curseur. */ inline const Data & Get( ) const { return (*array_ptr[*cursor]); } // Opérateur []: renvoie la valeur de rand donnée. Data & operator [] (u_int index) const; //---------------------------------------------------------------------- /*! Retourne la position actuelle du curseur dans le tableau. */ inline u_int GetCursor() const { return (*cursor); } /*! Positionne le paramètre sur sa première donnée. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne toujours vrai. */ inline bool First() const { (*cursor) = 0; return (true); } /*! Positionne le paramètre sur sa dernière donnée. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne toujours vrai. */ inline bool Last() const { (*cursor) = size; return (true); } /*! Positionne le paramètre sur la dernière suivante. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne vrai le paramètre n'est pas déjà positionné sur la * dernière valeur. */ inline bool Next() const { if ((*cursor) < (size-1)) { (*cursor)++; return (true); } else return (false); } /*! Positionne le paramètre sur la dernière précédente. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne vrai le paramètre n'est pas déjà positionné sur la * première valeur. */ inline bool Previous() const { if ((*cursor) > 0) { (*cursor)--; return (true); } else return (false); } //---------------------------------------------------------------------- // METHODES PROTEGEES //---------------------------------------------------------------------- protected: // Alloue un nouveau tableau de données initialisées Data **_AllocArray ( const u_int s, const Data &d ) ; /*! Affecte une valeur à la donnée courante (indiquée par le * curseur). Un message d'alerte est généré si * la taille du tableau est dépassée. * Cette méthode est appelée dans le cas des surcharges de l'opérateur * d'affectation pour les différents types de données. * \param d donnée à affecter */ inline Param & _SetData ( const Data &d ) { if ((*cursor) < size) { *array_ptr[(*cursor)++] = d; } else GLogWarning ( "ParamArray: affectation at " + GGetString((*cursor)) + " over array size ignored"); return ( *this ); } //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(ParamArray,0); } ; //====================================================================== #endif
97  * \param val valeur à affecter
98  */
99  inline Param & operator = ( const Int4 val )
100  { return ( _SetData (DataI4(val)) ); }
101 
102  /*! Opérateur d'affectation d'un entier 32 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int4 val ) { return ( _SetData (DataUI4(val)) ); } /*! Opérateur d'affectation d'un entier 64 bits signé. * \param val valeur à affecter */ inline Param & operator = ( const Int8 val ) { return ( _SetData (DataI8(val)) ); } /*! Opérateur d'affectation d'un entier 64 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int8 val ) { return ( _SetData (DataUI8(val)) ); } /*! Opérateur d'affectation d'un réel 32 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real4 val ) { return ( _SetData (DataR4(val)) ); } /*! Opérateur d'affectation d'un réel 64 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real8 val ) { return ( _SetData (DataR8(val)) ); } //---------------------------------------------------------------------- // CAST //---------------------------------------------------------------------- #ifndef __MAKECINT__ /*! Opérateur de cast une donnée générique.*/ inline operator Data & () const { return ( *array_ptr[*cursor] ); } #endif /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int2 () const { return ( (Int2) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int2 () const { return ( (U_Int2) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int4 () const { return ( (Int4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int4 () const { return ( (U_Int4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 64 bits signé.*/ inline operator Int8 () const { return ( (Int8) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 64 bits non signé.*/ inline operator U_Int8 () const { return ( (U_Int8) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type réel 32 bits.*/ inline operator Real4 () const { return ( (Real4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type réel 64 bits.*/ inline operator Real8 () const { return ( (Real8) *array_ptr[*cursor] ); } //---------------------------------------------------------------------- // //---------------------------------------------------------------------- /*! Retourne l'identificateur de type de paramètre.*/ inline u_int TypeId() const { return (typeArray); } /*! Retourne le type de paramètre.*/ inline string Type() const { return ("array"); } /*! Retourne chaîne de caractères avec le paramètre et son type. */ inline string InfoString() const { return (Name() + " = " + Type() + "[" + GGetString(size) + "] (" + array_ptr[0]->Type() + ")"); } //{ return (Name() + " = " + Type() + "[" + GGetString(size) // + "] (" + Get().Type() + ")"); } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante. * Le curseur est passé à la donnée suivante du tableau. */ inline string ValueString() const { return ( Name() + " [" + GGetString((*cursor)+1) + "/" + GGetString(size) + "] = " + Get().Text() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante avec son mot d'état. * Le curseur est passé à la donnée suivante du tableau. */ inline string ValueFullString() const { return ( Name() + " [" + GGetString((*cursor)+1) + "/" + GGetString(size) + "] = " + Get().FullText() ) ; } // Retourne chaîne de caractères avec le paramètre et son type // et l'ensemble des données. string DataString() const; //---------------------------------------------------------------------- /*! Retourne chaîne de caractères avec de donnée.*/ inline string GetDataType() const { return (array_ptr[0]->Type()); } /*! Retourne l'identifiant du type de donnée.*/ inline u_int GetDataTypeId() const { return (array_ptr[0]->TypeId()); } //---------------------------------------------------------------------- // Remise à zéro du paramètre. void Reset(); /*! Retourne le nombre de données, c'est à dire la dimension du * tableau de données. */ inline u_int Dimension() const { return (size); } /*! Retourne la donnée correspondant au curseur. */ inline const Data & Get( ) const { return (*array_ptr[*cursor]); } // Opérateur []: renvoie la valeur de rand donnée. Data & operator [] (u_int index) const; //---------------------------------------------------------------------- /*! Retourne la position actuelle du curseur dans le tableau. */ inline u_int GetCursor() const { return (*cursor); } /*! Positionne le paramètre sur sa première donnée. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne toujours vrai. */ inline bool First() const { (*cursor) = 0; return (true); } /*! Positionne le paramètre sur sa dernière donnée. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne toujours vrai. */ inline bool Last() const { (*cursor) = size; return (true); } /*! Positionne le paramètre sur la dernière suivante. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne vrai le paramètre n'est pas déjà positionné sur la * dernière valeur. */ inline bool Next() const { if ((*cursor) < (size-1)) { (*cursor)++; return (true); } else return (false); } /*! Positionne le paramètre sur la dernière précédente. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne vrai le paramètre n'est pas déjà positionné sur la * première valeur. */ inline bool Previous() const { if ((*cursor) > 0) { (*cursor)--; return (true); } else return (false); } //---------------------------------------------------------------------- // METHODES PROTEGEES //---------------------------------------------------------------------- protected: // Alloue un nouveau tableau de données initialisées Data **_AllocArray ( const u_int s, const Data &d ) ; /*! Affecte une valeur à la donnée courante (indiquée par le * curseur). Un message d'alerte est généré si * la taille du tableau est dépassée. * Cette méthode est appelée dans le cas des surcharges de l'opérateur * d'affectation pour les différents types de données. * \param d donnée à affecter */ inline Param & _SetData ( const Data &d ) { if ((*cursor) < size) { *array_ptr[(*cursor)++] = d; } else GLogWarning ( "ParamArray: affectation at " + GGetString((*cursor)) + " over array size ignored"); return ( *this ); } //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(ParamArray,0); } ; //====================================================================== #endif
103  * \param val valeur à affecter
104  */
105  inline Param & operator = ( const U_Int4 val )
106  { return ( _SetData (DataUI4(val)) ); }
107 
108  /*! Opérateur d'affectation d'un entier 64 bits signé. * \param val valeur à affecter */ inline Param & operator = ( const Int8 val ) { return ( _SetData (DataI8(val)) ); } /*! Opérateur d'affectation d'un entier 64 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int8 val ) { return ( _SetData (DataUI8(val)) ); } /*! Opérateur d'affectation d'un réel 32 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real4 val ) { return ( _SetData (DataR4(val)) ); } /*! Opérateur d'affectation d'un réel 64 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real8 val ) { return ( _SetData (DataR8(val)) ); } //---------------------------------------------------------------------- // CAST //---------------------------------------------------------------------- #ifndef __MAKECINT__ /*! Opérateur de cast une donnée générique.*/ inline operator Data & () const { return ( *array_ptr[*cursor] ); } #endif /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int2 () const { return ( (Int2) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int2 () const { return ( (U_Int2) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int4 () const { return ( (Int4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int4 () const { return ( (U_Int4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 64 bits signé.*/ inline operator Int8 () const { return ( (Int8) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 64 bits non signé.*/ inline operator U_Int8 () const { return ( (U_Int8) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type réel 32 bits.*/ inline operator Real4 () const { return ( (Real4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type réel 64 bits.*/ inline operator Real8 () const { return ( (Real8) *array_ptr[*cursor] ); } //---------------------------------------------------------------------- // //---------------------------------------------------------------------- /*! Retourne l'identificateur de type de paramètre.*/ inline u_int TypeId() const { return (typeArray); } /*! Retourne le type de paramètre.*/ inline string Type() const { return ("array"); } /*! Retourne chaîne de caractères avec le paramètre et son type. */ inline string InfoString() const { return (Name() + " = " + Type() + "[" + GGetString(size) + "] (" + array_ptr[0]->Type() + ")"); } //{ return (Name() + " = " + Type() + "[" + GGetString(size) // + "] (" + Get().Type() + ")"); } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante. * Le curseur est passé à la donnée suivante du tableau. */ inline string ValueString() const { return ( Name() + " [" + GGetString((*cursor)+1) + "/" + GGetString(size) + "] = " + Get().Text() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante avec son mot d'état. * Le curseur est passé à la donnée suivante du tableau. */ inline string ValueFullString() const { return ( Name() + " [" + GGetString((*cursor)+1) + "/" + GGetString(size) + "] = " + Get().FullText() ) ; } // Retourne chaîne de caractères avec le paramètre et son type // et l'ensemble des données. string DataString() const; //---------------------------------------------------------------------- /*! Retourne chaîne de caractères avec de donnée.*/ inline string GetDataType() const { return (array_ptr[0]->Type()); } /*! Retourne l'identifiant du type de donnée.*/ inline u_int GetDataTypeId() const { return (array_ptr[0]->TypeId()); } //---------------------------------------------------------------------- // Remise à zéro du paramètre. void Reset(); /*! Retourne le nombre de données, c'est à dire la dimension du * tableau de données. */ inline u_int Dimension() const { return (size); } /*! Retourne la donnée correspondant au curseur. */ inline const Data & Get( ) const { return (*array_ptr[*cursor]); } // Opérateur []: renvoie la valeur de rand donnée. Data & operator [] (u_int index) const; //---------------------------------------------------------------------- /*! Retourne la position actuelle du curseur dans le tableau. */ inline u_int GetCursor() const { return (*cursor); } /*! Positionne le paramètre sur sa première donnée. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne toujours vrai. */ inline bool First() const { (*cursor) = 0; return (true); } /*! Positionne le paramètre sur sa dernière donnée. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne toujours vrai. */ inline bool Last() const { (*cursor) = size; return (true); } /*! Positionne le paramètre sur la dernière suivante. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne vrai le paramètre n'est pas déjà positionné sur la * dernière valeur. */ inline bool Next() const { if ((*cursor) < (size-1)) { (*cursor)++; return (true); } else return (false); } /*! Positionne le paramètre sur la dernière précédente. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne vrai le paramètre n'est pas déjà positionné sur la * première valeur. */ inline bool Previous() const { if ((*cursor) > 0) { (*cursor)--; return (true); } else return (false); } //---------------------------------------------------------------------- // METHODES PROTEGEES //---------------------------------------------------------------------- protected: // Alloue un nouveau tableau de données initialisées Data **_AllocArray ( const u_int s, const Data &d ) ; /*! Affecte une valeur à la donnée courante (indiquée par le * curseur). Un message d'alerte est généré si * la taille du tableau est dépassée. * Cette méthode est appelée dans le cas des surcharges de l'opérateur * d'affectation pour les différents types de données. * \param d donnée à affecter */ inline Param & _SetData ( const Data &d ) { if ((*cursor) < size) { *array_ptr[(*cursor)++] = d; } else GLogWarning ( "ParamArray: affectation at " + GGetString((*cursor)) + " over array size ignored"); return ( *this ); } //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(ParamArray,0); } ; //====================================================================== #endif
109  * \param val valeur à affecter
110  */
111  inline Param & operator = ( const Int8 val )
112  { return ( _SetData (DataI8(val)) ); }
113 
114  /*! Opérateur d'affectation d'un entier 64 bits non signé. * \param val valeur à affecter */ inline Param & operator = ( const U_Int8 val ) { return ( _SetData (DataUI8(val)) ); } /*! Opérateur d'affectation d'un réel 32 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real4 val ) { return ( _SetData (DataR4(val)) ); } /*! Opérateur d'affectation d'un réel 64 bits. * \param val valeur à affecter */ inline Param & operator = ( const Real8 val ) { return ( _SetData (DataR8(val)) ); } //---------------------------------------------------------------------- // CAST //---------------------------------------------------------------------- #ifndef __MAKECINT__ /*! Opérateur de cast une donnée générique.*/ inline operator Data & () const { return ( *array_ptr[*cursor] ); } #endif /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int2 () const { return ( (Int2) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int2 () const { return ( (U_Int2) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int4 () const { return ( (Int4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int4 () const { return ( (U_Int4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 64 bits signé.*/ inline operator Int8 () const { return ( (Int8) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 64 bits non signé.*/ inline operator U_Int8 () const { return ( (U_Int8) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type réel 32 bits.*/ inline operator Real4 () const { return ( (Real4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type réel 64 bits.*/ inline operator Real8 () const { return ( (Real8) *array_ptr[*cursor] ); } //---------------------------------------------------------------------- // //---------------------------------------------------------------------- /*! Retourne l'identificateur de type de paramètre.*/ inline u_int TypeId() const { return (typeArray); } /*! Retourne le type de paramètre.*/ inline string Type() const { return ("array"); } /*! Retourne chaîne de caractères avec le paramètre et son type. */ inline string InfoString() const { return (Name() + " = " + Type() + "[" + GGetString(size) + "] (" + array_ptr[0]->Type() + ")"); } //{ return (Name() + " = " + Type() + "[" + GGetString(size) // + "] (" + Get().Type() + ")"); } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante. * Le curseur est passé à la donnée suivante du tableau. */ inline string ValueString() const { return ( Name() + " [" + GGetString((*cursor)+1) + "/" + GGetString(size) + "] = " + Get().Text() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante avec son mot d'état. * Le curseur est passé à la donnée suivante du tableau. */ inline string ValueFullString() const { return ( Name() + " [" + GGetString((*cursor)+1) + "/" + GGetString(size) + "] = " + Get().FullText() ) ; } // Retourne chaîne de caractères avec le paramètre et son type // et l'ensemble des données. string DataString() const; //---------------------------------------------------------------------- /*! Retourne chaîne de caractères avec de donnée.*/ inline string GetDataType() const { return (array_ptr[0]->Type()); } /*! Retourne l'identifiant du type de donnée.*/ inline u_int GetDataTypeId() const { return (array_ptr[0]->TypeId()); } //---------------------------------------------------------------------- // Remise à zéro du paramètre. void Reset(); /*! Retourne le nombre de données, c'est à dire la dimension du * tableau de données. */ inline u_int Dimension() const { return (size); } /*! Retourne la donnée correspondant au curseur. */ inline const Data & Get( ) const { return (*array_ptr[*cursor]); } // Opérateur []: renvoie la valeur de rand donnée. Data & operator [] (u_int index) const; //---------------------------------------------------------------------- /*! Retourne la position actuelle du curseur dans le tableau. */ inline u_int GetCursor() const { return (*cursor); } /*! Positionne le paramètre sur sa première donnée. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne toujours vrai. */ inline bool First() const { (*cursor) = 0; return (true); } /*! Positionne le paramètre sur sa dernière donnée. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne toujours vrai. */ inline bool Last() const { (*cursor) = size; return (true); } /*! Positionne le paramètre sur la dernière suivante. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne vrai le paramètre n'est pas déjà positionné sur la * dernière valeur. */ inline bool Next() const { if ((*cursor) < (size-1)) { (*cursor)++; return (true); } else return (false); } /*! Positionne le paramètre sur la dernière précédente. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne vrai le paramètre n'est pas déjà positionné sur la * première valeur. */ inline bool Previous() const { if ((*cursor) > 0) { (*cursor)--; return (true); } else return (false); } //---------------------------------------------------------------------- // METHODES PROTEGEES //---------------------------------------------------------------------- protected: // Alloue un nouveau tableau de données initialisées Data **_AllocArray ( const u_int s, const Data &d ) ; /*! Affecte une valeur à la donnée courante (indiquée par le * curseur). Un message d'alerte est généré si * la taille du tableau est dépassée. * Cette méthode est appelée dans le cas des surcharges de l'opérateur * d'affectation pour les différents types de données. * \param d donnée à affecter */ inline Param & _SetData ( const Data &d ) { if ((*cursor) < size) { *array_ptr[(*cursor)++] = d; } else GLogWarning ( "ParamArray: affectation at " + GGetString((*cursor)) + " over array size ignored"); return ( *this ); } //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(ParamArray,0); } ; //====================================================================== #endif
115  * \param val valeur à affecter
116  */
117  inline Param & operator = ( const U_Int8 val )
118  { return ( _SetData (DataUI8(val)) ); }
119 
120  /*! Opérateur d'affectation d'un réel 32 bits.
121  * \param val valeur à affecter
122  */
123  inline Param & operator = ( const Real4 val )
124  { return ( _SetData (DataR4(val)) ); }
125 
126  /*! Opérateur d'affectation d'un réel 64 bits.
127  * \param val valeur à affecter
128  */
129  inline Param & operator = ( const Real8 val )
130  { return ( _SetData (DataR8(val)) ); }
131 
132 
133 //----------------------------------------------------------------------
134 // CAST
135 //----------------------------------------------------------------------
136 
137 #ifndef __MAKECINT__
138  /*! Opérateur de cast une donnée générique.*/
139  inline operator Data & () const
140  { return ( *array_ptr[*cursor] ); }
141 #endif
142 
143  /*! Opérateur de cast une donnée de type entier 32 bits signé./ inline operator Int2 () const { return ( (Int2) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int2 () const { return ( (U_Int2) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int4 () const { return ( (Int4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int4 () const { return ( (U_Int4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 64 bits signé.*/ inline operator Int8 () const { return ( (Int8) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 64 bits non signé.*/ inline operator U_Int8 () const { return ( (U_Int8) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type réel 32 bits.*/ inline operator Real4 () const { return ( (Real4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type réel 64 bits.*/ inline operator Real8 () const { return ( (Real8) *array_ptr[*cursor] ); } //---------------------------------------------------------------------- // //---------------------------------------------------------------------- /*! Retourne l'identificateur de type de paramètre.*/ inline u_int TypeId() const { return (typeArray); } /*! Retourne le type de paramètre.*/ inline string Type() const { return ("array"); } /*! Retourne chaîne de caractères avec le paramètre et son type. */ inline string InfoString() const { return (Name() + " = " + Type() + "[" + GGetString(size) + "] (" + array_ptr[0]->Type() + ")"); } //{ return (Name() + " = " + Type() + "[" + GGetString(size) // + "] (" + Get().Type() + ")"); } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante. * Le curseur est passé à la donnée suivante du tableau. */ inline string ValueString() const { return ( Name() + " [" + GGetString((*cursor)+1) + "/" + GGetString(size) + "] = " + Get().Text() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante avec son mot d'état. * Le curseur est passé à la donnée suivante du tableau. */ inline string ValueFullString() const { return ( Name() + " [" + GGetString((*cursor)+1) + "/" + GGetString(size) + "] = " + Get().FullText() ) ; } // Retourne chaîne de caractères avec le paramètre et son type // et l'ensemble des données. string DataString() const; //---------------------------------------------------------------------- /*! Retourne chaîne de caractères avec de donnée.*/ inline string GetDataType() const { return (array_ptr[0]->Type()); } /*! Retourne l'identifiant du type de donnée.*/ inline u_int GetDataTypeId() const { return (array_ptr[0]->TypeId()); } //---------------------------------------------------------------------- // Remise à zéro du paramètre. void Reset(); /*! Retourne le nombre de données, c'est à dire la dimension du * tableau de données. */ inline u_int Dimension() const { return (size); } /*! Retourne la donnée correspondant au curseur. */ inline const Data & Get( ) const { return (*array_ptr[*cursor]); } // Opérateur []: renvoie la valeur de rand donnée. Data & operator [] (u_int index) const; //---------------------------------------------------------------------- /*! Retourne la position actuelle du curseur dans le tableau. */ inline u_int GetCursor() const { return (*cursor); } /*! Positionne le paramètre sur sa première donnée. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne toujours vrai. */ inline bool First() const { (*cursor) = 0; return (true); } /*! Positionne le paramètre sur sa dernière donnée. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne toujours vrai. */ inline bool Last() const { (*cursor) = size; return (true); } /*! Positionne le paramètre sur la dernière suivante. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne vrai le paramètre n'est pas déjà positionné sur la * dernière valeur. */ inline bool Next() const { if ((*cursor) < (size-1)) { (*cursor)++; return (true); } else return (false); } /*! Positionne le paramètre sur la dernière précédente. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne vrai le paramètre n'est pas déjà positionné sur la * première valeur. */ inline bool Previous() const { if ((*cursor) > 0) { (*cursor)--; return (true); } else return (false); } //---------------------------------------------------------------------- // METHODES PROTEGEES //---------------------------------------------------------------------- protected: // Alloue un nouveau tableau de données initialisées Data **_AllocArray ( const u_int s, const Data &d ) ; /*! Affecte une valeur à la donnée courante (indiquée par le * curseur). Un message d'alerte est généré si * la taille du tableau est dépassée. * Cette méthode est appelée dans le cas des surcharges de l'opérateur * d'affectation pour les différents types de données. * \param d donnée à affecter */ inline Param & _SetData ( const Data &d ) { if ((*cursor) < size) { *array_ptr[(*cursor)++] = d; } else GLogWarning ( "ParamArray: affectation at " + GGetString((*cursor)) + " over array size ignored"); return ( *this ); } //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(ParamArray,0); } ; //====================================================================== #endif */
144  inline operator Int2 () const
145  { return ( (Int2) *array_ptr[*cursor] ); }
146 
147  /*! Opérateur de cast une donnée de type entier 32 bits non signé./ inline operator U_Int2 () const { return ( (U_Int2) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 32 bits signé.*/ inline operator Int4 () const { return ( (Int4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int4 () const { return ( (U_Int4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 64 bits signé.*/ inline operator Int8 () const { return ( (Int8) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 64 bits non signé.*/ inline operator U_Int8 () const { return ( (U_Int8) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type réel 32 bits.*/ inline operator Real4 () const { return ( (Real4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type réel 64 bits.*/ inline operator Real8 () const { return ( (Real8) *array_ptr[*cursor] ); } //---------------------------------------------------------------------- // //---------------------------------------------------------------------- /*! Retourne l'identificateur de type de paramètre.*/ inline u_int TypeId() const { return (typeArray); } /*! Retourne le type de paramètre.*/ inline string Type() const { return ("array"); } /*! Retourne chaîne de caractères avec le paramètre et son type. */ inline string InfoString() const { return (Name() + " = " + Type() + "[" + GGetString(size) + "] (" + array_ptr[0]->Type() + ")"); } //{ return (Name() + " = " + Type() + "[" + GGetString(size) // + "] (" + Get().Type() + ")"); } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante. * Le curseur est passé à la donnée suivante du tableau. */ inline string ValueString() const { return ( Name() + " [" + GGetString((*cursor)+1) + "/" + GGetString(size) + "] = " + Get().Text() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante avec son mot d'état. * Le curseur est passé à la donnée suivante du tableau. */ inline string ValueFullString() const { return ( Name() + " [" + GGetString((*cursor)+1) + "/" + GGetString(size) + "] = " + Get().FullText() ) ; } // Retourne chaîne de caractères avec le paramètre et son type // et l'ensemble des données. string DataString() const; //---------------------------------------------------------------------- /*! Retourne chaîne de caractères avec de donnée.*/ inline string GetDataType() const { return (array_ptr[0]->Type()); } /*! Retourne l'identifiant du type de donnée.*/ inline u_int GetDataTypeId() const { return (array_ptr[0]->TypeId()); } //---------------------------------------------------------------------- // Remise à zéro du paramètre. void Reset(); /*! Retourne le nombre de données, c'est à dire la dimension du * tableau de données. */ inline u_int Dimension() const { return (size); } /*! Retourne la donnée correspondant au curseur. */ inline const Data & Get( ) const { return (*array_ptr[*cursor]); } // Opérateur []: renvoie la valeur de rand donnée. Data & operator [] (u_int index) const; //---------------------------------------------------------------------- /*! Retourne la position actuelle du curseur dans le tableau. */ inline u_int GetCursor() const { return (*cursor); } /*! Positionne le paramètre sur sa première donnée. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne toujours vrai. */ inline bool First() const { (*cursor) = 0; return (true); } /*! Positionne le paramètre sur sa dernière donnée. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne toujours vrai. */ inline bool Last() const { (*cursor) = size; return (true); } /*! Positionne le paramètre sur la dernière suivante. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne vrai le paramètre n'est pas déjà positionné sur la * dernière valeur. */ inline bool Next() const { if ((*cursor) < (size-1)) { (*cursor)++; return (true); } else return (false); } /*! Positionne le paramètre sur la dernière précédente. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne vrai le paramètre n'est pas déjà positionné sur la * première valeur. */ inline bool Previous() const { if ((*cursor) > 0) { (*cursor)--; return (true); } else return (false); } //---------------------------------------------------------------------- // METHODES PROTEGEES //---------------------------------------------------------------------- protected: // Alloue un nouveau tableau de données initialisées Data **_AllocArray ( const u_int s, const Data &d ) ; /*! Affecte une valeur à la donnée courante (indiquée par le * curseur). Un message d'alerte est généré si * la taille du tableau est dépassée. * Cette méthode est appelée dans le cas des surcharges de l'opérateur * d'affectation pour les différents types de données. * \param d donnée à affecter */ inline Param & _SetData ( const Data &d ) { if ((*cursor) < size) { *array_ptr[(*cursor)++] = d; } else GLogWarning ( "ParamArray: affectation at " + GGetString((*cursor)) + " over array size ignored"); return ( *this ); } //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(ParamArray,0); } ; //====================================================================== #endif */
148  inline operator U_Int2 () const
149  { return ( (U_Int2) *array_ptr[*cursor] ); }
150 
151  /*! Opérateur de cast une donnée de type entier 32 bits signé./ inline operator Int4 () const { return ( (Int4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 32 bits non signé.*/ inline operator U_Int4 () const { return ( (U_Int4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 64 bits signé.*/ inline operator Int8 () const { return ( (Int8) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 64 bits non signé.*/ inline operator U_Int8 () const { return ( (U_Int8) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type réel 32 bits.*/ inline operator Real4 () const { return ( (Real4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type réel 64 bits.*/ inline operator Real8 () const { return ( (Real8) *array_ptr[*cursor] ); } //---------------------------------------------------------------------- // //---------------------------------------------------------------------- /*! Retourne l'identificateur de type de paramètre.*/ inline u_int TypeId() const { return (typeArray); } /*! Retourne le type de paramètre.*/ inline string Type() const { return ("array"); } /*! Retourne chaîne de caractères avec le paramètre et son type. */ inline string InfoString() const { return (Name() + " = " + Type() + "[" + GGetString(size) + "] (" + array_ptr[0]->Type() + ")"); } //{ return (Name() + " = " + Type() + "[" + GGetString(size) // + "] (" + Get().Type() + ")"); } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante. * Le curseur est passé à la donnée suivante du tableau. */ inline string ValueString() const { return ( Name() + " [" + GGetString((*cursor)+1) + "/" + GGetString(size) + "] = " + Get().Text() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante avec son mot d'état. * Le curseur est passé à la donnée suivante du tableau. */ inline string ValueFullString() const { return ( Name() + " [" + GGetString((*cursor)+1) + "/" + GGetString(size) + "] = " + Get().FullText() ) ; } // Retourne chaîne de caractères avec le paramètre et son type // et l'ensemble des données. string DataString() const; //---------------------------------------------------------------------- /*! Retourne chaîne de caractères avec de donnée.*/ inline string GetDataType() const { return (array_ptr[0]->Type()); } /*! Retourne l'identifiant du type de donnée.*/ inline u_int GetDataTypeId() const { return (array_ptr[0]->TypeId()); } //---------------------------------------------------------------------- // Remise à zéro du paramètre. void Reset(); /*! Retourne le nombre de données, c'est à dire la dimension du * tableau de données. */ inline u_int Dimension() const { return (size); } /*! Retourne la donnée correspondant au curseur. */ inline const Data & Get( ) const { return (*array_ptr[*cursor]); } // Opérateur []: renvoie la valeur de rand donnée. Data & operator [] (u_int index) const; //---------------------------------------------------------------------- /*! Retourne la position actuelle du curseur dans le tableau. */ inline u_int GetCursor() const { return (*cursor); } /*! Positionne le paramètre sur sa première donnée. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne toujours vrai. */ inline bool First() const { (*cursor) = 0; return (true); } /*! Positionne le paramètre sur sa dernière donnée. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne toujours vrai. */ inline bool Last() const { (*cursor) = size; return (true); } /*! Positionne le paramètre sur la dernière suivante. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne vrai le paramètre n'est pas déjà positionné sur la * dernière valeur. */ inline bool Next() const { if ((*cursor) < (size-1)) { (*cursor)++; return (true); } else return (false); } /*! Positionne le paramètre sur la dernière précédente. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne vrai le paramètre n'est pas déjà positionné sur la * première valeur. */ inline bool Previous() const { if ((*cursor) > 0) { (*cursor)--; return (true); } else return (false); } //---------------------------------------------------------------------- // METHODES PROTEGEES //---------------------------------------------------------------------- protected: // Alloue un nouveau tableau de données initialisées Data **_AllocArray ( const u_int s, const Data &d ) ; /*! Affecte une valeur à la donnée courante (indiquée par le * curseur). Un message d'alerte est généré si * la taille du tableau est dépassée. * Cette méthode est appelée dans le cas des surcharges de l'opérateur * d'affectation pour les différents types de données. * \param d donnée à affecter */ inline Param & _SetData ( const Data &d ) { if ((*cursor) < size) { *array_ptr[(*cursor)++] = d; } else GLogWarning ( "ParamArray: affectation at " + GGetString((*cursor)) + " over array size ignored"); return ( *this ); } //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(ParamArray,0); } ; //====================================================================== #endif */
152  inline operator Int4 () const
153  { return ( (Int4) *array_ptr[*cursor] ); }
154 
155  /*! Opérateur de cast une donnée de type entier 32 bits non signé./ inline operator U_Int4 () const { return ( (U_Int4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 64 bits signé.*/ inline operator Int8 () const { return ( (Int8) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 64 bits non signé.*/ inline operator U_Int8 () const { return ( (U_Int8) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type réel 32 bits.*/ inline operator Real4 () const { return ( (Real4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type réel 64 bits.*/ inline operator Real8 () const { return ( (Real8) *array_ptr[*cursor] ); } //---------------------------------------------------------------------- // //---------------------------------------------------------------------- /*! Retourne l'identificateur de type de paramètre.*/ inline u_int TypeId() const { return (typeArray); } /*! Retourne le type de paramètre.*/ inline string Type() const { return ("array"); } /*! Retourne chaîne de caractères avec le paramètre et son type. */ inline string InfoString() const { return (Name() + " = " + Type() + "[" + GGetString(size) + "] (" + array_ptr[0]->Type() + ")"); } //{ return (Name() + " = " + Type() + "[" + GGetString(size) // + "] (" + Get().Type() + ")"); } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante. * Le curseur est passé à la donnée suivante du tableau. */ inline string ValueString() const { return ( Name() + " [" + GGetString((*cursor)+1) + "/" + GGetString(size) + "] = " + Get().Text() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante avec son mot d'état. * Le curseur est passé à la donnée suivante du tableau. */ inline string ValueFullString() const { return ( Name() + " [" + GGetString((*cursor)+1) + "/" + GGetString(size) + "] = " + Get().FullText() ) ; } // Retourne chaîne de caractères avec le paramètre et son type // et l'ensemble des données. string DataString() const; //---------------------------------------------------------------------- /*! Retourne chaîne de caractères avec de donnée.*/ inline string GetDataType() const { return (array_ptr[0]->Type()); } /*! Retourne l'identifiant du type de donnée.*/ inline u_int GetDataTypeId() const { return (array_ptr[0]->TypeId()); } //---------------------------------------------------------------------- // Remise à zéro du paramètre. void Reset(); /*! Retourne le nombre de données, c'est à dire la dimension du * tableau de données. */ inline u_int Dimension() const { return (size); } /*! Retourne la donnée correspondant au curseur. */ inline const Data & Get( ) const { return (*array_ptr[*cursor]); } // Opérateur []: renvoie la valeur de rand donnée. Data & operator [] (u_int index) const; //---------------------------------------------------------------------- /*! Retourne la position actuelle du curseur dans le tableau. */ inline u_int GetCursor() const { return (*cursor); } /*! Positionne le paramètre sur sa première donnée. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne toujours vrai. */ inline bool First() const { (*cursor) = 0; return (true); } /*! Positionne le paramètre sur sa dernière donnée. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne toujours vrai. */ inline bool Last() const { (*cursor) = size; return (true); } /*! Positionne le paramètre sur la dernière suivante. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne vrai le paramètre n'est pas déjà positionné sur la * dernière valeur. */ inline bool Next() const { if ((*cursor) < (size-1)) { (*cursor)++; return (true); } else return (false); } /*! Positionne le paramètre sur la dernière précédente. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne vrai le paramètre n'est pas déjà positionné sur la * première valeur. */ inline bool Previous() const { if ((*cursor) > 0) { (*cursor)--; return (true); } else return (false); } //---------------------------------------------------------------------- // METHODES PROTEGEES //---------------------------------------------------------------------- protected: // Alloue un nouveau tableau de données initialisées Data **_AllocArray ( const u_int s, const Data &d ) ; /*! Affecte une valeur à la donnée courante (indiquée par le * curseur). Un message d'alerte est généré si * la taille du tableau est dépassée. * Cette méthode est appelée dans le cas des surcharges de l'opérateur * d'affectation pour les différents types de données. * \param d donnée à affecter */ inline Param & _SetData ( const Data &d ) { if ((*cursor) < size) { *array_ptr[(*cursor)++] = d; } else GLogWarning ( "ParamArray: affectation at " + GGetString((*cursor)) + " over array size ignored"); return ( *this ); } //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(ParamArray,0); } ; //====================================================================== #endif */
156  inline operator U_Int4 () const
157  { return ( (U_Int4) *array_ptr[*cursor] ); }
158 
159  /*! Opérateur de cast une donnée de type entier 64 bits signé./ inline operator Int8 () const { return ( (Int8) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type entier 64 bits non signé.*/ inline operator U_Int8 () const { return ( (U_Int8) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type réel 32 bits.*/ inline operator Real4 () const { return ( (Real4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type réel 64 bits.*/ inline operator Real8 () const { return ( (Real8) *array_ptr[*cursor] ); } //---------------------------------------------------------------------- // //---------------------------------------------------------------------- /*! Retourne l'identificateur de type de paramètre.*/ inline u_int TypeId() const { return (typeArray); } /*! Retourne le type de paramètre.*/ inline string Type() const { return ("array"); } /*! Retourne chaîne de caractères avec le paramètre et son type. */ inline string InfoString() const { return (Name() + " = " + Type() + "[" + GGetString(size) + "] (" + array_ptr[0]->Type() + ")"); } //{ return (Name() + " = " + Type() + "[" + GGetString(size) // + "] (" + Get().Type() + ")"); } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante. * Le curseur est passé à la donnée suivante du tableau. */ inline string ValueString() const { return ( Name() + " [" + GGetString((*cursor)+1) + "/" + GGetString(size) + "] = " + Get().Text() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante avec son mot d'état. * Le curseur est passé à la donnée suivante du tableau. */ inline string ValueFullString() const { return ( Name() + " [" + GGetString((*cursor)+1) + "/" + GGetString(size) + "] = " + Get().FullText() ) ; } // Retourne chaîne de caractères avec le paramètre et son type // et l'ensemble des données. string DataString() const; //---------------------------------------------------------------------- /*! Retourne chaîne de caractères avec de donnée.*/ inline string GetDataType() const { return (array_ptr[0]->Type()); } /*! Retourne l'identifiant du type de donnée.*/ inline u_int GetDataTypeId() const { return (array_ptr[0]->TypeId()); } //---------------------------------------------------------------------- // Remise à zéro du paramètre. void Reset(); /*! Retourne le nombre de données, c'est à dire la dimension du * tableau de données. */ inline u_int Dimension() const { return (size); } /*! Retourne la donnée correspondant au curseur. */ inline const Data & Get( ) const { return (*array_ptr[*cursor]); } // Opérateur []: renvoie la valeur de rand donnée. Data & operator [] (u_int index) const; //---------------------------------------------------------------------- /*! Retourne la position actuelle du curseur dans le tableau. */ inline u_int GetCursor() const { return (*cursor); } /*! Positionne le paramètre sur sa première donnée. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne toujours vrai. */ inline bool First() const { (*cursor) = 0; return (true); } /*! Positionne le paramètre sur sa dernière donnée. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne toujours vrai. */ inline bool Last() const { (*cursor) = size; return (true); } /*! Positionne le paramètre sur la dernière suivante. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne vrai le paramètre n'est pas déjà positionné sur la * dernière valeur. */ inline bool Next() const { if ((*cursor) < (size-1)) { (*cursor)++; return (true); } else return (false); } /*! Positionne le paramètre sur la dernière précédente. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne vrai le paramètre n'est pas déjà positionné sur la * première valeur. */ inline bool Previous() const { if ((*cursor) > 0) { (*cursor)--; return (true); } else return (false); } //---------------------------------------------------------------------- // METHODES PROTEGEES //---------------------------------------------------------------------- protected: // Alloue un nouveau tableau de données initialisées Data **_AllocArray ( const u_int s, const Data &d ) ; /*! Affecte une valeur à la donnée courante (indiquée par le * curseur). Un message d'alerte est généré si * la taille du tableau est dépassée. * Cette méthode est appelée dans le cas des surcharges de l'opérateur * d'affectation pour les différents types de données. * \param d donnée à affecter */ inline Param & _SetData ( const Data &d ) { if ((*cursor) < size) { *array_ptr[(*cursor)++] = d; } else GLogWarning ( "ParamArray: affectation at " + GGetString((*cursor)) + " over array size ignored"); return ( *this ); } //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(ParamArray,0); } ; //====================================================================== #endif */
160  inline operator Int8 () const
161  { return ( (Int8) *array_ptr[*cursor] ); }
162 
163  /*! Opérateur de cast une donnée de type entier 64 bits non signé./ inline operator U_Int8 () const { return ( (U_Int8) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type réel 32 bits.*/ inline operator Real4 () const { return ( (Real4) *array_ptr[*cursor] ); } /*! Opérateur de cast une donnée de type réel 64 bits.*/ inline operator Real8 () const { return ( (Real8) *array_ptr[*cursor] ); } //---------------------------------------------------------------------- // //---------------------------------------------------------------------- /*! Retourne l'identificateur de type de paramètre.*/ inline u_int TypeId() const { return (typeArray); } /*! Retourne le type de paramètre.*/ inline string Type() const { return ("array"); } /*! Retourne chaîne de caractères avec le paramètre et son type. */ inline string InfoString() const { return (Name() + " = " + Type() + "[" + GGetString(size) + "] (" + array_ptr[0]->Type() + ")"); } //{ return (Name() + " = " + Type() + "[" + GGetString(size) // + "] (" + Get().Type() + ")"); } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante. * Le curseur est passé à la donnée suivante du tableau. */ inline string ValueString() const { return ( Name() + " [" + GGetString((*cursor)+1) + "/" + GGetString(size) + "] = " + Get().Text() ) ; } /*! Retourne chaîne de caractères avec le paramètre et son type * et la valeur courante avec son mot d'état. * Le curseur est passé à la donnée suivante du tableau. */ inline string ValueFullString() const { return ( Name() + " [" + GGetString((*cursor)+1) + "/" + GGetString(size) + "] = " + Get().FullText() ) ; } // Retourne chaîne de caractères avec le paramètre et son type // et l'ensemble des données. string DataString() const; //---------------------------------------------------------------------- /*! Retourne chaîne de caractères avec de donnée.*/ inline string GetDataType() const { return (array_ptr[0]->Type()); } /*! Retourne l'identifiant du type de donnée.*/ inline u_int GetDataTypeId() const { return (array_ptr[0]->TypeId()); } //---------------------------------------------------------------------- // Remise à zéro du paramètre. void Reset(); /*! Retourne le nombre de données, c'est à dire la dimension du * tableau de données. */ inline u_int Dimension() const { return (size); } /*! Retourne la donnée correspondant au curseur. */ inline const Data & Get( ) const { return (*array_ptr[*cursor]); } // Opérateur []: renvoie la valeur de rand donnée. Data & operator [] (u_int index) const; //---------------------------------------------------------------------- /*! Retourne la position actuelle du curseur dans le tableau. */ inline u_int GetCursor() const { return (*cursor); } /*! Positionne le paramètre sur sa première donnée. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne toujours vrai. */ inline bool First() const { (*cursor) = 0; return (true); } /*! Positionne le paramètre sur sa dernière donnée. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne toujours vrai. */ inline bool Last() const { (*cursor) = size; return (true); } /*! Positionne le paramètre sur la dernière suivante. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne vrai le paramètre n'est pas déjà positionné sur la * dernière valeur. */ inline bool Next() const { if ((*cursor) < (size-1)) { (*cursor)++; return (true); } else return (false); } /*! Positionne le paramètre sur la dernière précédente. * Dans le cas d'un paramètre de type ParamArray, cette méthode * retourne vrai le paramètre n'est pas déjà positionné sur la * première valeur. */ inline bool Previous() const { if ((*cursor) > 0) { (*cursor)--; return (true); } else return (false); } //---------------------------------------------------------------------- // METHODES PROTEGEES //---------------------------------------------------------------------- protected: // Alloue un nouveau tableau de données initialisées Data **_AllocArray ( const u_int s, const Data &d ) ; /*! Affecte une valeur à la donnée courante (indiquée par le * curseur). Un message d'alerte est généré si * la taille du tableau est dépassée. * Cette méthode est appelée dans le cas des surcharges de l'opérateur * d'affectation pour les différents types de données. * \param d donnée à affecter */ inline Param & _SetData ( const Data &d ) { if ((*cursor) < size) { *array_ptr[(*cursor)++] = d; } else GLogWarning ( "ParamArray: affectation at " + GGetString((*cursor)) + " over array size ignored"); return ( *this ); } //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(ParamArray,0); } ; //====================================================================== #endif */
164  inline operator U_Int8 () const
165  { return ( (U_Int8) *array_ptr[*cursor] ); }
166 
167  /*! Opérateur de cast une donnée de type réel 32 bits.*/
168  inline operator Real4 () const
169  { return ( (Real4) *array_ptr[*cursor] ); }
170 
171  /*! Opérateur de cast une donnée de type réel 64 bits.*/
172  inline operator Real8 () const
173  { return ( (Real8) *array_ptr[*cursor] ); }
174 
175 
176 //----------------------------------------------------------------------
177 //
178 //----------------------------------------------------------------------
179 
180  /*! Retourne l'identificateur de type de paramètre.*/
181  inline u_int TypeId() const { return (typeArray); }
182 
183  /*! Retourne le type de paramètre.*/
184  inline string Type() const { return ("array"); }
185 
186  /*! Retourne chaîne de caractères avec le paramètre et son type.
187  */
188  inline string InfoString() const
189  { return (Name() + " = " + Type() + "[" + GGetString(size)
190  + "] (" + array_ptr[0]->Type() + ")"); }
191  //{ return (Name() + " = " + Type() + "[" + GGetString(size)
192  // + "] (" + Get().Type() + ")"); }
193 
194  /*! Retourne chaîne de caractères avec le paramètre et son type
195  * et la valeur courante.
196  * Le curseur est passé à la donnée suivante du tableau.
197  */
198  inline string ValueString() const
199  { return ( Name() + " [" + GGetString((*cursor)+1)
200  + "/" + GGetString(size)
201  + "] = " + Get().Text() ) ; }
202 
203  /*! Retourne chaîne de caractères avec le paramètre et son type
204  * et la valeur courante avec son mot d'état.
205  * Le curseur est passé à la donnée suivante du tableau.
206  */
207  inline string ValueFullString() const
208  { return ( Name() + " [" + GGetString((*cursor)+1)
209  + "/" + GGetString(size)
210  + "] = " + Get().FullText() ) ; }
211 
212  // Retourne chaîne de caractères avec le paramètre et son type
213  // et l'ensemble des données.
214  string DataString() const;
215 
216 //----------------------------------------------------------------------
217 
218  /*! Retourne chaîne de caractères avec de donnée.*/
219  inline string GetDataType() const
220  { return (array_ptr[0]->Type()); }
221 
222  /*! Retourne l'identifiant du type de donnée.*/
223  inline u_int GetDataTypeId() const
224  { return (array_ptr[0]->TypeId()); }
225 
226 //----------------------------------------------------------------------
227  // Remise à zéro du paramètre.
228  void Reset();
229 
230  /*! Retourne le nombre de données, c'est à dire la dimension du
231  * tableau de données.
232  */
233  inline u_int Dimension() const
234  { return (size); }
235 
236  /*! Retourne la donnée correspondant au curseur.
237  */
238  inline const Data & Get( ) const
239  { return (*array_ptr[*cursor]); }
240 
241  // Opérateur []: renvoie la valeur de rand donnée.
242  Data & operator [] (u_int index) const;
243 
244 //----------------------------------------------------------------------
245 
246  /*! Retourne la position actuelle du curseur dans le tableau.
247  */
248  inline u_int GetCursor() const
249  { return (*cursor); }
250 
251  /*! Positionne le paramètre sur sa première donnée.
252  * Dans le cas d'un paramètre de type ParamArray, cette méthode
253  * retourne toujours vrai.
254  */
255  inline bool First() const
256  { (*cursor) = 0; return (true); }
257 
258  /*! Positionne le paramètre sur sa dernière donnée.
259  * Dans le cas d'un paramètre de type ParamArray, cette méthode
260  * retourne toujours vrai.
261  */
262  inline bool Last() const
263  { (*cursor) = size; return (true); }
264 
265  /*! Positionne le paramètre sur la dernière suivante.
266  * Dans le cas d'un paramètre de type ParamArray, cette méthode
267  * retourne vrai le paramètre n'est pas déjà positionné sur la
268  * dernière valeur.
269  */
270  inline bool Next() const
271  {
272  if ((*cursor) < (size-1))
273  {
274  (*cursor)++;
275  return (true);
276  }
277  else
278  return (false);
279  }
280 
281  /*! Positionne le paramètre sur la dernière précédente.
282  * Dans le cas d'un paramètre de type ParamArray, cette méthode
283  * retourne vrai le paramètre n'est pas déjà positionné sur la
284  * première valeur.
285  */
286  inline bool Previous() const
287  {
288  if ((*cursor) > 0)
289  {
290  (*cursor)--;
291  return (true);
292  }
293  else
294  return (false);
295  }
296 
297 //----------------------------------------------------------------------
298 // METHODES PROTEGEES
299 //----------------------------------------------------------------------
300 
301  protected:
302 
303  // Alloue un nouveau tableau de données initialisées
304  Data **_AllocArray ( const u_int s, const Data &d ) ;
305 
306  /*! Affecte une valeur à la donnée courante (indiquée par le
307  * curseur). Un message d'alerte est généré si
308  * la taille du tableau est dépassée.
309  * Cette méthode est appelée dans le cas des surcharges de l'opérateur
310  * d'affectation pour les différents types de données.
311  * \param d donnée à affecter
312  */
313  inline Param & _SetData ( const Data &d )
314  {
315  if ((*cursor) < size)
316  {
317  *array_ptr[(*cursor)++] = d;
318  }
319  else
320  GLogWarning ( "ParamArray: affectation at " + GGetString((*cursor)) + " over array size ignored");
321  return ( *this );
322  }
323 
324 
325 //----------------------------------------------------------------------
326 // pour ROOT...
327  public:
328  /*! Définition à usage de ROOT... */
329  ClassDef(ParamArray,0);
330 } ;
331 
332 
333 //======================================================================
334 
335 #endif
ParamArray::GetCursor
u_int GetCursor() const
Definition: ParamArray.hh:248
ParamArray::GObject
GObject(ParamArray)
Real8
double Real8
Définition du type réel 32 bits.
Definition: EventCommon.hh:68
ParamArray::Get
const Data & Get() const
Definition: ParamArray.hh:238
Real4
float Real4
Définition du type réel 32 bits.
Definition: EventCommon.hh:62
ParamArray::First
bool First() const
Definition: ParamArray.hh:255
ParamArray::operator=
ParamArray & operator=(const ParamArray &par)
Definition: ParamArray.cpp:81
ParamArray::DataString
string DataString() const
Definition: ParamArray.cpp:160
ParamArray::Next
bool Next() const
Definition: ParamArray.hh:270
DataR8
Definition: DataR8.hh:19
ParamArray::cursor
u_int * cursor
Position actuelle (c&#39;est un pointeur pour pouvoir être modifié même dans une instance constante) ...
Definition: ParamArray.hh:48
ParamArray::Previous
bool Previous() const
Definition: ParamArray.hh:286
DataUI2
Definition: DataUI2.hh:19
DataI8
Definition: DataI8.hh:19
ParamArray::ParamArray
ParamArray(const string &par_name="unnamed", const u_int s=2)
Definition: ParamArray.cpp:23
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
ParamArray::GetDataType
string GetDataType() const
Definition: ParamArray.hh:219
DataR4
Definition: DataR4.hh:19
ParamArray
Definition: ParamArray.hh:38
ParamArray::Reset
void Reset()
Definition: ParamArray.cpp:120
ParamArray::TypeId
u_int TypeId() const
Definition: ParamArray.hh:181
ParamArray::~ParamArray
virtual ~ParamArray()
Definition: ParamArray.cpp:104
DataI4
Definition: DataI4.hh:19
DataUI8
Definition: DataUI8.hh:19
DataI2
Definition: DataI2.hh:19
Int2
short Int2
Définition du type entier 16 bits.
Definition: EventCommon.hh:26
ParamArray::ValueFullString
string ValueFullString() const
Definition: ParamArray.hh:207
ParamArray::size
u_int size
Taille du tableau (nombre de données)
Definition: ParamArray.hh:47
ParamArray::_SetData
Param & _SetData(const Data &d)
Definition: ParamArray.hh:313
DataUI4
Definition: DataUI4.hh:19
Param
Definition: Param.hh:83
U_Int8
ULong64_t U_Int8
Définition du type entier 64 bits non signé
Definition: EventCommon.hh:56
ParamArray::Last
bool Last() const
Definition: ParamArray.hh:262
ParamArray::Dimension
u_int Dimension() const
Definition: ParamArray.hh:233
ParamArray::ClassDef
ClassDef(ParamArray, 0)
ParamArray::_AllocArray
Data ** _AllocArray(const u_int s, const Data &d)
Definition: ParamArray.cpp:180
Data
Definition: Data.hh:153
Int4
int Int4
Définition du type entier 32 bits.
Definition: EventCommon.hh:38
ParamArray::Type
string Type() const
Definition: ParamArray.hh:184
ParamArray::GetDataTypeId
u_int GetDataTypeId() const
Definition: ParamArray.hh:223
U_Int4
unsigned int U_Int4
Définition du type entier 32 bits non signé
Definition: EventCommon.hh:44
ParamArray::operator[]
Data & operator[](u_int index) const
Definition: ParamArray.cpp:141
Int8
Long64_t Int8
Définition du type entier 64 bits.
Definition: EventCommon.hh:50
ParamArray::ValueString
string ValueString() const
Definition: ParamArray.hh:198
ParamArray::InfoString
string InfoString() const
Definition: ParamArray.hh:188
ParamArray::array_ptr
Data ** array_ptr
Pointeur sur la table de données associée au paramètre.
Definition: ParamArray.hh:49