Filter.hh

Go to the documentation of this file.

//======================================================================
/*! \file Filter.hh
 *
 *  Fichier de déclaration de la classe de base Filter.
 */
//======================================================================

#ifndef FILTER_HH
#define FILTER_HH

#include "FilterBase.hh"
#include "GNamed.hh"
#include "RPointerList.hh"

#define FILTER_ID     "FILTER:   " ///< Texte identifiant un contour dans un fichier
#define FILTER_NONAME "unnamed"    ///< Texte par défaut du nom de filtre

#define FILTER_TYPE_TXT_FALSE       "FALSE"     ///< Nom du type de filtre
#define FILTER_TYPE_TXT_TRUE        "TRUE"      ///< Nom du type de filtre
#define FILTER_TYPE_TXT_NOT         "NOT"       ///< Nom du type de filtre
#define FILTER_TYPE_TXT_AND         "AND"       ///< Nom du type de filtre
#define FILTER_TYPE_TXT_OR          "OR"        ///< Nom du type de filtre
#define FILTER_TYPE_TXT_XOR         "XOR"       ///< Nom du type de filtre
#define FILTER_TYPE_TXT_MULTI_AND   "MULTI_AND" ///< Nom du type de filtre
#define FILTER_TYPE_TXT_MULTI_OR    "MULTI_OR"  ///< Nom du type de filtre
#define FILTER_TYPE_TXT_GATE        "GATE"      ///< Nom du type de filtre
#define FILTER_TYPE_TXT_CONTOUR     "CONTOUR"   ///< Nom du type de filtre
#define FILTER_TYPE_TXT_UNDEFINED   "UNDEFINED" ///< Nom du type de filtre

//======================================================================
/*! \class Filter
 *
 *  Classe générique pour le traitement des filtres. Cette classe ne
 *  définit pas un filtre, mais y fait référence par un pointeur.
 *  Les filtres eux-mêmes sont définis à partir des classes dérivées
 *  de la classe FilterBase.
 *
 *  Un filtre définit une condition sur un événement: soit par une
 *  combinaison logique de filtres, soit par des conditions sur des
 *  paramètres.
 *
 *  Un filtre est validé par la méthode Ok(), qui teste les contours
 *  où autres filtres impliqués. Cette méthode peut être longue lors
 *  de l'utilisation de filtres compliqués et/ou appliqués à de
 *  nombreux spectres.
 *  C'est pourquoi la validité d'un filtre peut être précalculée,
 *  avant l'incrémentation des spectres notemment: c'est l'intérêt
 *  des fonction GetInternalValue et SetInternalValue.
 */
class Filter: virtual public GNamed
{
//----------------------------------------------------------------------
  /*! \object_doc */
  GObject(Filter);
//----------------------------------------------------------------------

    friend class FilterList;
    friend class Spectrum;
    friend class TreeInfo;

  public:

    /// Identification des types de contours
    enum FTypes
      {
        typeFalse     = 0,    // type des filtres logiques
        typeTrue      = 1,
        typeNot       = 2,
        typeAnd       = 3,
        typeOr        = 4,
        typeXOr       = 5,
        typeMultiAnd  = 6,
        typeMultiOr   = 7,

        typeGate      = 16,   // type des filtres numériques
        typeContour   = 17,

        typeUndefined = -1
      } ;

  protected:
    FilterBase  *filter_ptr;    ///< Pointeur sur une instance de base d'un filtre

    #ifndef __MAKECINT__
    bool        *value;         ///< Valeur courante du filtre (mise à jour par Ok())
    #endif

  public:

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

    // constructeurs
    Filter ( const string & f_name = FILTER_NONAME );
    Filter ( const string & f_name, const FilterBase & f_base );
    Filter ( const string & f_name, FilterBase       * f_base );
    Filter ( const Filter & f, const string &f_name );
    Filter ( const Filter & f );

    // opérateur d'affectation
    Filter & operator = ( const Filter     & f );
    Filter & operator = ( const FilterBase & f_base );

    // destructeur
    virtual ~Filter ( );

//----------------------------------------------------------------------
//  Méthode provenant des filtres
    virtual int     Type        ( ) const;
    virtual string  TypeName    ( ) const;

    virtual bool    Ok          ( ) const;

    virtual void    Rename      ( const string & ct_name );

//----------------------------------------------------------------------
    // Ecriture du contour.
    virtual bool Write ( ostream &os ) const;
    virtual bool Write ( FILE *fptr ) const;

    // Lecture du contour.
    virtual Int_t Read ( istream      & is,   const EventManager * mgr );
    virtual Int_t Read ( FILE         * fptr, const EventManager * mgr );
    virtual Int_t Read ( const string & str,  const EventManager * mgr );

//----------------------------------------------------------------------
    const FilterBase * GetFilterBase ( ) const;

    // test si un filtre utilise un contour ou un autre filtre
    // pour vérifier qu'il peut être effacé dans les listes.
    virtual bool  UsesContour ( const RContour *ct, const bool rec = true ) const;
    virtual bool  UsesFilter  ( const Filter   *f,  const bool rec = true ) const;

  private:
    // méthodes pour ne par recalculer tous les filtres
    virtual void  SetInternalValue ( const bool b ) const;
    virtual bool  GetInternalValue ( ) const;

//----------------------------------------------------------------------
//  pour ROOT...

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


//======================================================================
//  METHODES INLINE

/*! Teste la validité d'un filtre (celà met à valeur le résultat interne). */
inline bool Filter::Ok ( ) const
  { *value = (filter_ptr != NULL) ? filter_ptr->Ok() : false; return (*value); }

/*! Retourne le type de contour. */
inline int Filter::Type ( ) const
  { return ((filter_ptr != NULL) ? filter_ptr->Type() : Filter::typeUndefined); }

/*! Retourne le type de contour, sous forme textuelle. */
inline string Filter::TypeName ( ) const
  { return ((filter_ptr != NULL) ? filter_ptr->TypeName() : "undefined"); }


/*! Retourne le pointeur de base sur le contour. */
inline const FilterBase * Filter::GetFilterBase ( ) const
  { return (filter_ptr); }

/*! Test si un filtre utilise un contour (en particulier pour savoir si le
 *  contour peut-être effacé).
 *  \param  ct    pointeur sur le contour
 *  \param  rec   indique si on doit chercher récursivement dans les filtres
 */
inline bool Filter::UsesContour ( const RContour *ct, const bool rec ) const
  { return ( (filter_ptr != NULL) ? filter_ptr->UsesContour(ct,rec) : false ); }

/*! Test si un filtre utilise un autre filtre (en particulier pour savoir
 *  si le filtre peut-être effacé).
 *  \param  f     pointeur sur le filtre
 *  \param  rec   indique si on doit chercher récursivement dans les filtres
 */
inline bool Filter::UsesFilter ( const Filter *f, const bool rec ) const
  { return ( (filter_ptr != NULL) ? filter_ptr->UsesFilter(f,rec) : false ); }

/*! Renomme un contour (cette fonction est publique, à la différence
 *  de GNamed::SetName).
 *  \param  f_name   nouveau nom du filtre
 */
inline void Filter::Rename ( const string & f_name )
  { GNamed::SetName ( f_name ); }

/*! Mise à valeur du résultat du filtre: usage interne seulement: cette
 *  méthode sert à ne pas recalculer les filtres plusieurs fois dans les
 *  incrémentations de spectres.
 *  \param  b   nouveau nom du filtre
 */
inline void Filter::SetInternalValue ( const bool b ) const
  { *value = b; }

/*! Retourne le résultat du filtre: usage interne seulement: cette
 *  méthode sert à ne pas recalculer les filtres plusieurs fois dans les
 *  incrémentations de spectres.
 */
inline bool Filter::GetInternalValue ( ) const
  { return (*value); }


//======================================================================
#endif