descriptor.h

/****************************************************************************************
                                          descriptor.h 
                                        ----------------
    copyright            : (C) 2006 Jean-Luc Perret - Pierre Mahé
    email                : jean-luc.perret@unine.ch - pierre.mahe@ensmp.fr
 ***************************************************************************************/

/****************************************************************************************
 *                                                                                      *
 *      This program is free software; you can redistribute it and/or                   *
 *      modify it under the terms of the GNU Lesser General Public                      *
 *      License as published by the Free Software Foundation; either                    *
 *      version 2.1 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               *
 *      Lesser General Public License for more details.                                 *
 *                                                                                      *
 *      You should have received a copy of the GNU Lesser General Public                *
 *      License along with this library; if not, write to the Free Software             *
 *      Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA      *
 *                                                                                      *
 ****************************************************************************************/



#ifndef DESCRIPTOR_H
#define DESCRIPTOR_H

#include<iostream>
#include<sstream>
using std::string;
using std::endl;
using std::stringstream;

#include <constant.h>
#include <cerror.h>

template <class T> class Descriptor {
public:


        Descriptor();

        Descriptor(T avalue);

        Descriptor(string aLabel, T aValue, string aUnit, string aComment);

        //~Descriptor(){}




        void setValue( T );
        
        void setLabel( string aLabel ){ label = aLabel; }
        
        void setUnit( string aUnit ){ unit = aUnit; }
        
        void setComment( string aComment){ comment = aComment; }

        void setEmpty(){ empty = true; }

        T getValue( bool silentError = false ) throw( CError );
        
        string getLabel(){ return( label ); }
        
        string getUnit(){ return( unit ); }
        
        string getComment(){ return( comment ); }

        bool isEmpty(){ return(empty); }



        string toString();
        
        string toStringShort();

        void describe();

        void describeShort();
  

private:

        string label;

        T value;

        string unit;

        string comment;

        bool empty;
 
};





template <class T>
Descriptor<T>::Descriptor(){
        setLabel( "no name" );
        setUnit( "no unit" );
        setComment( "no comment" );
        empty = true;
}

template <class T>
Descriptor<T>::Descriptor( T avalue ){
        //Descriptor();
        setLabel( "no name" );
        setUnit( "no unit" );
        setComment( "no comment" );
        empty = true;

        setValue( avalue );
}

template <class T>
Descriptor<T>::Descriptor( string aLabel, T aValue, string aUnit, string aComment ){
        setLabel( aLabel );
        setUnit( aUnit );
        setComment( aComment );
        setValue( aValue );
}


template <class T>
void Descriptor<T>::setValue( T avalue ){
        value = avalue;
        empty = false;
}

template <class T>
T Descriptor<T>::getValue( bool silentError ) throw( CError ){
        if( !isEmpty() ){
                return value;
        }else{
                // value is emtpy, so ERROR_NA exception is raised
                CError e( ERRORNA, getLabel() + " is empty" );
                if( silentError == false){
                        e.describe();
                }
                throw( e );
        }
}

template <class T>
void Descriptor<T>::describe(){
        cout << toString() << endl;
}

template <class T>
void Descriptor<T>::describeShort(){
        cout << toStringShort() << endl;
}

template <class T>
string Descriptor<T>::toString(){
        stringstream out;
        if( empty == false ){
                out << getComment() << ": " << getLabel() << " = " << getValue() << " (" << getUnit() << ") ";
        }else{
                out << getComment() << ": " << getLabel() << " = " << "NA" << " (" << getUnit() << ") ";
        }
        return( out.str() );
}

template <class T>
string Descriptor<T>::toStringShort(){
        stringstream out;
        if( empty == false ){
                out << getLabel() << " = " << getValue() << " (" << getUnit() << ") ";
        }else{
                out << getLabel() << " = " << "NA" << " (" << getUnit() << ") ";
        }
        return( out.str() );
}

#endif

---