Measure.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004 by Olivier Stezowski                               *
 *   stezow(AT)ipnl.in2p3.fr                                                  *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
 
#ifndef Gw_Measure
#define Gw_Measure
#define GW_MEASURE_H Gw_Measure

#ifndef ROOT_Rtypes
#include <Rtypes.h>
#endif

#ifndef GW_DATA_H
#include "Data.h"
#endif


namespace Gw {

template <typename Data_T> class Measure : public Data <Data_T>
{
protected:
    Data_T fError;      // the error on this measure
    
public:
    Measure() : Data<Data_T>() { fError = 0; }
    explicit Measure(Data_T d, Data_T derr = 0) : Data<Data_T>(d) { fError = derr; }
    Measure(const Measure & data) : Data<Data_T>(data) { fError = data.fError; }
    virtual ~Measure() {;}

    virtual void Set(Data_T data) { Data<Data_T>::fValue = data; fError = 0; }
    virtual void Set(Data_T d, Data_T derr) { Data<Data_T>::fValue = d; fError = derr; }
    
    virtual void Set(const char *s) 
    {
        std::istringstream input; input.clear(); TString st = s;
        switch( InfoData::WhatIs(s) ){
                case InfoData::kKnown:
                        input.str(s); input >> Data<Data_T>::fValue >> fError;  
                        if ( input.fail() ) InfoData::SetInfo(InfoData::kUnknown);
                        else InfoData::SetInfo(InfoData::kKnown);
                        break;
                case InfoData::kUnknown:
                        InfoData::SetInfo(InfoData::kUnknown);
                        break;  
                case InfoData::kAbout:
                        st.ReplaceAll('~',' '); 
                        input.str(st.Data()); input >> Data<Data_T>::fValue >> fError;  
                        if ( input.fail() ) InfoData::SetInfo(InfoData::kUnknown);
                        else InfoData::SetInfo(InfoData::kAbout);       
                        break;                          
                case InfoData::kTentative:
                        st.ReplaceAll('(',' '); 
                        st.ReplaceAll(')',' '); 
                        input.str(st.Data()); input >> Data<Data_T>::fValue >> fError; 
                        if ( input.fail() ) InfoData::SetInfo(InfoData::kUnknown);
                        else InfoData::SetInfo(InfoData::kTentative);   
                        break;
                case InfoData::kTheo:
                        st.ReplaceAll('[',' '); 
                        st.ReplaceAll(']',' '); 
                        input.str(st.Data()); input >> Data<Data_T>::fValue >> fError; 
                        if ( input.fail() ) InfoData::SetInfo(InfoData::kUnknown);
                        else InfoData::SetInfo(InfoData::kTheo);        
                        break;
                default:
                        InfoData::SetInfo(InfoData::kUnknown);
                        break;
        }
    }     
        
    virtual Data_T GetError() const { return fError; }
    virtual void SetError(Data_T derr) { fError = derr; }
    
    virtual Data_T & operator [] (int i) { if ( i == 1 ) return fError; return Data<Data_T>::fValue; }    
    
    ClassDef(Measure,1); // A measure with an associated error
};
// inline members

/*
std::ostream & operator << (std::ostream &out, Measure<float> & m) { 
        out << m.GetValue() << "+/-" << m.GetError(); return out;
}
ostream & operator << (ostream &out, Measure<double> m) { 
        out << m.GetValue() << "~" << m.GetError(); return out;
} */

}

#endif