Parameterlist.cc

Go to the documentation of this file.

#include <stdio.h>
#include "Parameterlist.h"
#include "parseTools.h"
#include <assert.h>
#include <algorithm>

// class Parameter
        Parameter::Parameter(   const string &name, 
                                        const string &value, 
                                        const string &comment,
                                        bool fromDefault) :     name_m(name),
                                                                        value_m(value),
                                                                        comment_m(comment), 
                                                                        bUsed_m(false),
                                                                        bDefaultValue_m(fromDefault),
                                                                        order_m(0)
        {
        }
        
        ostream &  Parameter::printParameter(ostream & os) const
        {
                os << name_m << " = " << value_m <<"; " <<  std::endl;
                return os;
        }

        ostream &  Parameter::printParameterWithComment(ostream & os) const
        {
                os << name_m << " = " << value_m <<"; -- " << comment_m << std::endl;
                return os;
        }

        ostream &  Parameter::printParameterDetailed(ostream & os) const
        {
                os << name_m << " = " << value_m <<"; -- " << comment_m << std::endl;
                os << "--order( " <<name_m << ")= " << order_m << std::endl;
                return os;
        }

        void    Parameter::setPrintOrder(unsigned short order)
        {
                order_m = order;
        }

        unsigned short  Parameter::getPrintOrder( ) const
        {
                return order_m;
        }

        void     Parameter::markUsed()
        {
                bUsed_m = true;
        }

        void    Parameter::setValue( const string &  value)
        {
                value_m = value;
        }

        string &        Parameter::getValue(  )
        {
                return value_m;
        }


        std::ostream &  operator<<(std::ostream & out, const Parameter & z)
        {  
                z.printParameter(out);
                return out;
        } 

        std::string &   Parameter::getValueAsString(  )
        {
                return value_m;
        }


std::string     Parameter::getName( )
{
        return name_m;  

}

bool    Parameter::isUsed() const
{
        return bUsed_m;
}

bool    Parameter::isDefaultValue() const
{
        return bDefaultValue_m;
}





const string Parameterlist::emptyString("");
// Konstruktion/Destruktion

        Parameterlist::Parameterlist()
        {
                parameters_m.resize(0);
                
        }
        
        
        Parameterlist::~Parameterlist()
        {
                for (size_t idx=0; idx< parameters_m.size() ; idx++)
                {
                        delete parameters_m[idx];
                }
        }



//----------------------------Get  ---------------------------------------------
        size_t          Parameterlist::getParameterCount() const
        {
                return parameters_m.size();
        }


        Parameter&              Parameterlist::getParameterRef(unsigned int idx)
        {
        
                if (idx >= parameters_m.size())
                {
                                cerr << " parameter indes " << idx ; 
                        throw (" Parameter does not exist !");
                }
                else
                        return *parameters_m[idx] ;
        }

          string &  Parameterlist::getParameterValueByName(const string &  paramName ) 
        {
                int idx = getParameterIdx(paramName);
        
                if (idx==-1)
                {
                                cerr << paramName ; 
                                throw (" Parameter does not exist !");
                }
                else
                        return parameters_m[idx]->value_m;
        }
        
        
           Parameter&   Parameterlist::getParameterRefByName(const string & paramName )
        {
                int idx =  getParameterIdx(paramName);
                if  (idx==-1)
                {
                        cerr <<  paramName  ;
                        throw (" Parameter does not exist !");
                }
                return  *(parameters_m[idx] );
        }

                string &        Parameterlist::getParameterValueByName(const char * paramName )
                {       
                        return getParameterValueByName(  string(paramName) );
                }

                Parameter &             Parameterlist::getParameterRefByName (const char * paramName )  
                {
                        return getParameterRefByName(  string(paramName) );
                }


//----------------------------Operators  ---------------------------------------------

        bool Parameterlist::paramExists(const string & paramName ) const
        {
                int pos = getParameterIdx(paramName);
        
                if ( pos == -1 )
                        return false;
                return true;
        }


        void Parameterlist::addParameter(       const string & paramname, 
                                                        const string & paramValue,      
                                                        const string & pcomment     )
        {
                string realParamName = eatWS(paramname);
                assert( realParamName.length() !=0 );
                if ( paramExists(paramname ))
                {
                        std::cerr <<"Error: multiple parameter definition (parameter " << paramname << ")" << endl;
                        assert(! paramExists(paramname ));
                }
                Parameter * tmp = new Parameter( realParamName, paramValue, pcomment );

                parameters_m.push_back (tmp );
                
                return;
        }
        
        void Parameterlist::addDefaultParameter(        const string & paramname, 
                                                        const string & paramValue,      
                                                        const string & pcomment     )
        {
                std::cerr <<"addDefaultParameter" << endl;
                std::cerr <<"paramname " <<paramname<< endl;
                if ( paramExists(paramname ))
                {
                        std::cerr <<"Error: multiple parameter definition (parameter " << paramname << ")" << endl;
                        assert(! paramExists(paramname ));
                }
                

                string realParamName = eatWS(paramname);
                assert( realParamName.length() !=0 );
                bool bDefault = true;
                Parameter * tmp = new Parameter( realParamName, paramValue, pcomment, bDefault );
                tmp->markUsed();
                parameters_m.push_back (tmp );
                
                return;
        }
        
        
        void    Parameterlist::markAsUsed(const string &  paramName)
        {
                int     index = getParameterIdx(paramName);
        
                assert( index!=-1 );
        
                if ( index!=-1 )
                        parameters_m[index]->bUsed_m=true;
        }
        
        
        
        void Parameterlist::setParameterValue(const string & paramName, const  string &paramVal)
        {
                int     index = getParameterIdx(paramName);
        
                assert( index!=-1 );
        
                if ( index!=-1 )
                        parameters_m[index]->setValue( paramVal );
        
        }
        
        
        
        
        void    Parameterlist::resetUsedStatus()
        {
                for (size_t idx=0; idx< parameters_m.size() ; idx++)
                        parameters_m[idx]->bUsed_m=false;
        }


 

//----------------------------IO private---------------------------------------------


        void Parameterlist::printUsedParameters(ostream & os) const
        {
                
                ParamListType    parameterscopy ;
                parameterscopy.resize( 0 );


                for (size_t idx=0; idx< parameters_m.size() ; idx++)
                {
                        assert( parameters_m[idx] != NULL ) ;
                        parameterscopy.push_back(  parameters_m[idx]) ;
                        //parameterscopy[idx]->printParameterDetailed(std::cerr);
                }

                std::sort(parameterscopy.begin(), parameterscopy.end() ,  Parameter::compareParameterOrder ) ;
                
                os <<   std::endl<< "----  not defined parameters (default values are used): " << std::endl;
                for (size_t idx=0; idx<parameterscopy.size() ; idx++)
                {
                        if ( parameterscopy[idx]->bUsed_m &&  parameterscopy[idx]->bDefaultValue_m )
                        {
                                os << * (parameterscopy[idx]) ; 
                        }
                }
                os <<   std::endl<< "----  used parameters: " << std::endl;
                for (size_t idx=0; idx<parameterscopy.size() ; idx++)
                {
                        if ( parameterscopy[idx]->bUsed_m && ! parameterscopy[idx]->bDefaultValue_m )
                        {
                                os << * (parameterscopy[idx]) ; 
                        }
                }
                return;
        }
        
        
        
        void Parameterlist::printNotUsedParameters(ostream & os) const
        {
                os <<   std::endl << "---- not used parameters: " << std::endl;

                for (size_t idx=0; idx<parameters_m.size() ; idx++)
                {
                        if ( ! parameters_m[idx]->bUsed_m )
                        {
                                // die nichtbenutzten Parameter werden auskommentiert, damit sie 
                                // in Macaulay beim Einlesen nicht ausgewertet werden!
                                os << "-- " << * (parameters_m[idx]) ; 
                        }
                }
                return;
        }



//----------------------------get private---------------------------------------------


        int Parameterlist::getParameterIdx(const string & paramName) const
        {
                if ( paramName.length()==0 )
                        return -1;
                else
                {
                        for (size_t idx = 0 ; idx< parameters_m.size(); idx++)
                                if ( paramName.compare(parameters_m[idx]->name_m) == 0 )
                                        return idx;
        
                        return -1; // not found
                }
        }