source: branches/removing_cpp11_features/mfileio/MMatrix.cc@ 18282

/* ======================================================================== *\
!
!   Author(s): Sebastian Mueller and Dominik Neise for the FACT Colaboration
!              2014 Nov 05
!
!   Copyright: "THE BEER-WARE LICENSE" (Revision 42):
!
!   The FACT Colaboration wrote this file. As long as you retain this notice you
!   can do whatever you want with this stuff. If we meet some day, and you think
!   this stuff is worth it, you can buy us a beer in return.
!
\* ======================================================================== */

//////////////////////////////////////////////////////////////////////////////
//
//  MMatrix
//
//  A generic container to store a matrix of floating point numbers.
//  More precise it is a vector of vectors of floating numbers.
//  The rows can have an individual number of columns.
//  The data structure fM itself is public.
// 
//  A delimiter seperated value text file parser is used to obtain the data
//  from a text file.
//
//////////////////////////////////////////////////////////////////////////////
#include "MMatrix.h"

ClassImp(MMatrix);
//------------------------------------------------------------------------------
MMatrix::MMatrix(const char *name, const char *title){
    if( name == NULL ){
        std::exception error;
        *fLog << err; 
        *fLog << "In Source: "<< __FILE__ <<" in line: "<< __LINE__ <<" ";
        *fLog << "in function: "<< __func__ <<"\n";
                *fLog << "The name string is pointing to NULL!\n";
        throw error;    
    }else{
        fName  = name;          
    }

    fTitle = title ? title : 
    "Parameter container storing a vector of vectors to hold floating numbers";
        
    initialize();
}
//------------------------------------------------------------------------------
void MMatrix::initialize() {
    fDelimiter = ',';
    fComment = '#';
    fFileName = "";
    fLineNumber = 0;
}
//------------------------------------------------------------------------------
MMatrix::~MMatrix(){ clear(); }
//------------------------------------------------------------------------------
void MMatrix::ReadFile(const TString path_to_text_file){
        // Here a text file is parsed into the internal data structure fM
        // All errors which might occur during parsing result in exceptions.
        // Right before the exception a info text is printed using the error logger.

        // the delimiter symbol must not be a white space
        if( std::isspace(fDelimiter) ){
                std::exception error;
                *fLog << err; 
        *fLog << "In Source: "<< __FILE__ <<" in line: "<< __LINE__ <<" ";
        *fLog << "in function: "<< __func__ <<"\n";
                *fLog << "The delimiter symbol must not be a white space character!\n";
        throw error;                    
        }

        // the comment symbol must not be a white space
        if( std::isspace(fComment) ){
                std::exception error;
                *fLog << err; 
        *fLog << "In Source: "<< __FILE__ <<" in line: "<< __LINE__ <<" ";
        *fLog << "in function: "<< __func__ <<"\n";
                *fLog << "The comment symbol must not be a white space character!\n";
        throw error;                    
        }

        // make sure the data Matrix fM is wiped out before new data is read.
        clear();

        std::ifstream dsv_input_file( path_to_text_file, std::ifstream::in);

        if( !dsv_input_file.is_open() ){

                // a file which can not be opened must not pass silent!
                *fLog << err; 
        *fLog << "In file: "<< __FILE__ <<" in line: "<< __LINE__ <<" ";
        *fLog << "in function: "<< __func__ <<"\n";
                *fLog << "The file: "<< path_to_text_file <<" could no be opened!\n";
                std::exception error;
        throw error;    
        }else{
                // the file does exist and is now parsed

                // only here the filename is set to ensure it is related to the actual 
                // file being parsed.
                fFileName = path_to_text_file;

                // we set the line counter to 0 because we read a new file.
                fLineNumber = 0;

                //as long as there are lines in the file:
                std::string line;
        while ( getline(dsv_input_file, line ) ){

                fLineNumber++;

                // check if the line can be ignored
                if( !is_comment(line) && !is_empty_or_has_only_white_spaces(line)){

                        std::stringstream line_stream(line);
                        std::string token;
                                
                                // create an empty row to be filled with the data chunks of 
                                // a text file line
                                std::vector< double > row;

                        //as long as there are tokens in a line:
                                while( getline(line_stream, token, fDelimiter)){

                                        // remove tailing and leading whitespaces
                                        token = remove_leading_white_spaces(token);
                                        token = remove_tailing_white_spaces(token);

                                        // parse the text chunk to a floating number and push it
                                        // back the data row
                                        row.push_back(pedantic_strtod(token));
                                }

                                // Now that a whole text file line was parsed into a data row,
                                // the row is pushed back into the data matrix.
                                fM.push_back( row );
                        }
        }
        }

        dsv_input_file.close();
}
//------------------------------------------------------------------------------
double MMatrix::pedantic_strtod(std::string text)const{
        // a pedantic string to float converter

        // since std::strtod will return 0.0 in case the text string is empty we 
        // check for this in advance.
        if(text.empty() ){
                std::exception error;
                *fLog << err; 
        *fLog << "In Source: "<< __FILE__ <<" in line: "<< __LINE__ <<" ";
        *fLog << "in function: "<< __func__ <<"\n";
                *fLog << "In file: "<< fFileName <<" in line: "<<fLineNumber<<"\n";             
                *fLog << "The given text to be converted to a flot is empty! \n";
                throw error;
        }

        // Ok the text string is not empty and might store a valid floating number.

        // This pointer to character is used to verify if std::strtod has parsed
        // the string to its end.
        char * e;
        double FloatingNumber = std::strtod(text.c_str(), &e);

        // when std::strtod parsed until the last character in the input string,
        // e is pointing to an empty string. 
        // Otherwise e is pointing to the remaining string.
        // Example:
        // OK : '65.456456'          -> e = ''
        // BAD: '65.456456   585.46' -> e = '   585.46'

        if (*e != 0) {
                std::exception error;
                *fLog << err; 
        *fLog << "In Source: "<< __FILE__ <<" in line: "<< __LINE__ <<" ";
        *fLog << "in function: "<< __func__ <<"\n";
                *fLog << "In file: "<< fFileName <<" in line: "<<fLineNumber<<"\n";     
                *fLog << "The given text: '" << text <<"' can not be converted ";
                *fLog << "to a floating point number!\n";
                throw error;
        }
        return FloatingNumber;
}
//------------------------------------------------------------------------------
void MMatrix::clear(){
        // Not sure if this is neccessary but it shall enforce the correct erasing 
        // of the data Matrix fM e.g. before a new text file is parsed in.
        for(unsigned int row=0; row<fM.size(); row++)
                fM[row].clear();

        fM.clear();
}
//------------------------------------------------------------------------------
void MMatrix::print()const{
        // A info text is printed to std::cout showing the data, 
        // the number of lines parsed in and the name of the text file parsed in.

        std::stringstream info;
        info << std::fixed << std::setprecision( 2 );
        info << " ___MMatrix."<< __func__ <<"()____________________\n";
        info << "| \n";
        for(unsigned int row=0; row<fM.size(); row++){
                info << "| "<< row <<" ";
                for(unsigned int col=0; col<fM[row].size(); col++){
                        info << "[" << fM[row][col] << "] ";
                }
                info << "\n";
        }
        info << "| . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .\n";
        info << "| file:  " << fFileName << "\n";
        info << "| lines: " << fLineNumber << "\n";     
        info << "|______________________________________________________________\n";

        std::cout << info.str();
}
//------------------------------------------------------------------------------
bool MMatrix::is_empty_or_has_only_white_spaces(std::string line)const{
        // Shall return TRUE when the text line is empty or only holding white 
        // spaces and FALSE otherwise.

        if(line.size() == 0){
                return true;
        }else{

                bool there_are_only_whitespaces = true;

                int i = 0;
                while ( line[i] ){

                    if( !isspace(line[i]) ){
                                there_are_only_whitespaces = false;
                    }
                    i++;
                }

                return there_are_only_whitespaces;
        }
}
//------------------------------------------------------------------------------
bool MMatrix::is_comment(std::string line)const{
        // TRUE -> the whole line is a comment
        // FALSE -> the line is data or something else
        // a comment line is a line of arbitrary number of white spaces followed 
        // by the fComment symbol

        if( line.empty() ){
                // an empty line is not a comment line
                return false;
        }else{
                // remove leading whitespaces
                line = remove_leading_white_spaces(line);
                if( line.empty() ){
                        // after the white spaces have been removed the line turns out to 
                        // be empty; so it is not a comment
                        return false;
                }else if( line[0] == fComment ){
                        // this is a comment line
                        return true;
                }else{
                        // there is some thing not comment like in this line
                        return false;
                }
        }
}
//------------------------------------------------------------------------------
// Both string trimmers are taken from StackOverflow
//http://stackoverflow.com/questions/216823/whats-the-best-way-to-trim-stdstring
std::string MMatrix::remove_leading_white_spaces(std::string &s)const{
        // trim from start
    s.erase(
        s.begin(), 
        std::find_if(
                s.begin(), 
                s.end(), 
                std::not1(std::ptr_fun<int, int>(std::isspace))
        )
    );
    return s;
}
//------------------------------------------------------------------------------
std::string MMatrix::remove_tailing_white_spaces(std::string &s)const{
        // trim from end
    s.erase(
        std::find_if(
                s.rbegin(),
                s.rend(),
                std::not1(std::ptr_fun<int, int>(std::isspace))
        ).base(),
        s.end()
    );
    return s;
}
//------------------------------------------------------------------------------
Int_t MMatrix::ReadEnv(const TEnv &env, TString prefix, Bool_t print){

    if (IsEnvDefined(env, prefix, "FileName", print))
    {
        TString temp_file_name = 
        GetEnvValue(env, prefix, "FileName", fFileName);

                try{// to parse the text file
                        ReadFile(temp_file_name);
                }
                catch(std::exception error){
                        // Oh oh. There was some trouble when parsing the file. This must 
                        // not be accepted.
                        return kERROR;
                }

                // The text file was correctly parsed
                return kTRUE;
    }

    /*
    *fLog << err << "In Source: "<< __FILE__ <<" in line: "<< __LINE__;
    *fLog << " in function: "<< __func__ <<"\n";
    *fLog << "There is no:'"<< prefix<<".FileName' in the config file. ";
    *fLog << "The filename is crucial because there are no default values ";
    *fLog << "to be asigned in case the input file with name filename is not ";
    *fLog << "found." << std::endl;
    */
    return kFALSE;
}