DotConf.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2010 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 ADF_DotConf
#include "DotConf.h"
#endif
#ifndef ADF_ConfigurationFrame
#include "ConfigurationFrame.h"
#endif

#include <ctime>
#include <fstream>
#include <cstdlib>

using namespace ADF;
using namespace std;

DotConf::DotConf() : 
        fLog("ADF::DotConf"),
        fHeaderDef('#',false,"ADF::DotConf",""), 
        fHeader(-1,-1,"Init"),
        fListOfDotConf(),
        fLastModif(""), 
        fComment("Default")
{ 
        // to remove end of line character
        if (fComment.size() > 0) 
                if ( fComment.at(fComment.length()-1) == '\n' ) 
                        fComment.erase(fComment.size()-1);
        
        SetLastModif(); 
} 

DotConf::DotConf(const Char_t *rid, const Char_t *srid, Bool_t is_record) : 
        fLog("ADF::DotConf"), 
        fHeaderDef('#',is_record,rid,srid), 
        fHeader(-1,-1,"Init"),
        fListOfDotConf(),
        fLastModif(""), 
        fComment("Default")
{               
        // to remove end of line character
        if (fComment.size() > 0) 
                if ( fComment.at(fComment.length()-1) == '\n' ) 
                        fComment.erase(fComment.size()-1);

        SetLastModif(); 
} 

DotConf::~DotConf() 
{
}

/*
DotConf *DotConf::Clone(const char *comment)
{       
        // first creats a new agent
        DotConf *aconf = new DotConf(comment);
        if ( aconf == NULL )
                return NULL;
        
        // now copy the content of the global agent to it using Configure
        std::ostringstream o;  
        this->DoConfigure(o);
        std::string tmp;
        tmp = o.str();
        std::istringstream i(tmp);
        aconf->DoConfigure(i);
        
        return aconf;
}
 */

std::string DotConf::BeginOfRecord()
{
        std::string bor(&fHeaderDef.fSkipLine,1); bor += "////"; bor += fHeaderDef.fRID; bor += "_beg////"; 
        return bor;
}

std::string DotConf::EndOfRecord()
{
        std::string eor(&fHeaderDef.fSkipLine,1); eor += "////"; eor += fHeaderDef.fRID; eor += "_end////"; 
        return eor;
}

void DotConf::SetLastModif()
{
        time_t thetime; ::time(&thetime); fLastModif = ::ctime(&thetime);
        
        // to remove end of line character
        if (fLastModif.size() > 0) 
                if ( fLastModif.at(fLastModif.length()-1) == '\n' ) 
                        fLastModif.erase(fLastModif.size()-1);
}

void DotConf::Reset(const Char_t * /*opt*/)
{
        
}
        
Bool_t DotConf::IsBeginOfRecord(const std::string &st, Bool_t allow_init)
{       
        std::string bor = BeginOfRecord(), tmp, tmp_srid, tmp_option; Short_t version;
        Bool_t ok = false;

        if ( st.find(bor) == 0 ) {
                // look for the SRID
                tmp  = st.substr(bor.length()+1);
                tmp += " ";
                if ( tmp[0] != ' ' )
                        tmp.insert(0," ");
                // the sub record id has not been found ...
                if ( tmp.find(fHeaderDef.fSRID) == string::npos ) {
                                return false;   // ... and required ! so return false
                }
                else ok = true; // yes SRID has been found
                
                // now decode version and option
                istringstream in( tmp );
                in.clear();
                
                // check the number of values in tmp 
                Bool_t aval = false;
                Int_t nb_val = 0; 
                for (size_t i = 0; i < tmp.size(); i++) {
                        if ( tmp[i] == ' ' && aval )
                                aval = false;
                        if ( tmp[i] != ' ' && aval == false ) {
                                aval = true;
                                nb_val++;
                        }
                }
                // according to the number of value, decode tmp
                version = -1; 
                switch (nb_val) {
                        case 1:
                                in >> tmp_option; // only option
                                break;
                        case 2:
                                if ( fHeaderDef.fSRID == "" ) {
                                        in >>  version >> tmp_option; // version and option
                                }
                                else {
                                        in >> tmp_srid >> tmp_option; // SRID and option
                                }
                                break;
                        default:
                                in >> tmp_srid >> version >> tmp_option; // all
                                break;
                }
                if ( !in.good() )
                        return false; // something wrong @ reading
                
                // Option is init so call reset if set possible by the user and if everything has been read correctly
                if ( tmp_option.find("Init") != string::npos ) {
                        if ( allow_init )
                                Reset();
                        else 
                                tmp_option = "+,=="; 
                }
                // change dotconf attributes
                fHeader.fPreviousVersion = fHeader.fVersion; fHeader.fVersion = version; fHeader.fStreamOption = tmp_option;
                SetLastModif();
        }
        return ok;
}

Bool_t DotConf::IsEndOfRecord(const std::string &st)
{       
        std::string eor = EndOfRecord();
        Bool_t ok = false;
        
        if ( st.find(eor) == 0 ) 
                ok = true;
        
        return ok;
}

Bool_t DotConf::AddRecord(std::ostream &out, char t)
{
        // nothing to be added ... so ok ! 
        if ( !fHeaderDef.fWithRecord )
                return true;
        
        if ( t == 'b' ) {       
                out << BeginOfRecord()
                << " " 
                << GetSRID()
                << " " 
                << GetVersion() 
                << " " 
                << GetStreamOption() << " \n";
                
                out << "# Last modified by : " << GetLastModif() << " \n";
                out << "# Modified by : " << GetComment() << " \n";     
        }
        else {
                out << EndOfRecord() << " \n";
        }
        return out.good();
}

void DotConf::AddConf ( DotConf *aconf )
{
        fListOfDotConf.push_back(aconf);
}

Bool_t DotConf::DoConfigure (istream &in, Bool_t allow_init)
{       
        // local required
        string tmp; Bool_t is_a_record = false, do_process = false, ok_decode = true; 
        
        // to locate the log message
        fLog.SetProcessMethod("DoConfigure(istream)");
        
        // process all non commented lines if the conf file does not contain begin of records  
        if ( !fHeaderDef.fWithRecord ) 
                is_a_record = do_process = true;

        // read the file line by line   
        getline(in,tmp);
        tmp += " ";
        while ( in.good() && !in.eof() ) { // read input stream line by line
                if ( tmp[0] == fHeaderDef.fSkipLine ) {
                        // look in the comment if there is a begin of record
                        if ( fHeaderDef.fWithRecord ) {
                                // this is a start of record statement 
                                if ( IsBeginOfRecord(tmp,allow_init) )
                                        do_process = is_a_record = true;
                                
                                // this is a end of record statement for that class
                                if ( IsEndOfRecord(tmp) )
                                        do_process = false;
                        }
                        getline(in,tmp); 
                        tmp += " ";
                        continue; 
                } // this line is a comment 
                
                if (do_process)
                        ok_decode = ok_decode && ProcessLine(tmp);

                // add null character at the end since getline
                // does not store \n and it may give troubles when decoding
                getline(in,tmp);
                tmp += " ";
        }       
        
        // call it for the list of DotConf ... in case the order is not good as it is, overwrite this method
        
        std::list< DotConf * >::iterator 
                listed_item; 
        for ( listed_item = fListOfDotConf.begin() ; listed_item != fListOfDotConf.end() ; listed_item++ ) {
                in.clear();
                in.seekg (0, ios::beg);
                ok_decode = ok_decode && (*listed_item)->DoConfigure(in, allow_init);
        }       
        
        // the LogCollector may have been changed ... so wait util the end to apply collection  
        fLog << dolog; 
        //
        return ok_decode; 
}


Bool_t DotConf::DoConfigure (ostream & out)
{       
        Bool_t ok_decode = true;
        
        /* uncomment and add information in case this method is overwritten
         // add a start record
         AddRecord(out,'b');
         
         // 
         // here put what would like to add
         //     
         
         // add an end of record
         AddRecord(out,'e');
        */
        
        // now call it for the list of DotConf
        std::list< DotConf * >::iterator 
        listed_item; 
        for ( listed_item = fListOfDotConf.begin() ; listed_item != fListOfDotConf.end() ; listed_item++ ) {
                ok_decode = ok_decode && (*listed_item)->DoConfigure(out);
        }       
                
        return ok_decode;
}

Bool_t DotConf::Configure(const char *name, const char *option, Bool_t allow_init)
{
        // set reference to this method for log system
        fLog.SetProcessMethod("Configure(const char *name)");
        
        Bool_t ok; std::string opt = option;
        if ( opt == "in" ) {
                std::ifstream filein(name);
                if ( filein.is_open() == true ) { 
                        ok = DoConfigure(filein,allow_init);
                }
                else {
                        fLog << error << "Cannot open file (read mode) " << name << nline;
                        ok = false;
                }
                filein.close();
        }
        else {
                std::ofstream fileout(name);
                if ( fileout.is_open() == true ) { 
                        ok = DoConfigure(fileout);
                }
                else {
                        fLog << error << " Cannot open file (writting mode) " << name << nline;
                        ok = false;     
                }
                fileout.close();
        }
        
        fLog << dolog; return ok;
}

Bool_t DotConf::Configure(ConfigurationFrame *frame, const char *option, Bool_t allow_init)
{
        // set reference to this method for log system
        fLog.SetProcessMethod("Configure(ConfigurationFrame *name)");
        
        Bool_t ok; std::string opt = option;

        if ( opt == "in" ) {
                // load the content of the frame in the string
                frame->Read();
                // use stream facility 
                std::istringstream in;
                in.clear();
                in.str((frame->String()));
                
                ok = DoConfigure(in,allow_init);
        
        }
        else {
                // use stream facility 
                std::ostringstream out;
                ok = DoConfigure(out);
                // write the result in the conf frame
                frame->String() = out.str();
                frame->Write();
        }
                
        fLog << dolog; return ok;
}