DotConf.h

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
#define ADF_DotConf

#ifndef _ADFConfig
#include "ADFConfig.h"
#endif
#include "ADFLogMessage.h"

#include <list>

namespace ADF
{
        
class ConfigurationFrame;




class DotConf
{       
protected:
        LogMessage fLog;    

private: 
        struct HeaderDef {
                HeaderDef(Char_t skip = '#', Bool_t is_record = false, std::string rid = "", std::string srid = "", Short_t version = -1) : fSkipLine(skip), fWithRecord(is_record), fRID(rid), fSRID(srid), fVersion(version) 
                        {;}
                Char_t fSkipLine;
                Bool_t fWithRecord;
                std::string fRID;       
                std::string fSRID;
                Short_t fVersion;
        };
        HeaderDef fHeaderDef;
        
private:
        struct Header {
                Header(Short_t version, Short_t pversion, std::string streamopt = "Init") :  fVersion(version), fPreviousVersion(pversion), fStreamOption(streamopt)
                        {;}
                Short_t fVersion; 
                Short_t fPreviousVersion; 
                std::string fStreamOption;              
        };
        Header fHeader;

private:
        std::list< DotConf * > fListOfDotConf;
        
private:
        std::string fLastModif;
        std::string fComment;    
        
protected:
        std::string BeginOfRecord();
        std::string   EndOfRecord();

        Bool_t IsBeginOfRecord(const std::string &, Bool_t allow_init);
        Bool_t   IsEndOfRecord(const std::string &);    
        Bool_t AddRecord(std::ostream &, char t = 'b'); 
        
protected:
        void SetLastModif();
        void SetVersion(Short_t v)
                { fHeader.fVersion = v; }
        void SetMaxVersion(Short_t v)
                { fHeaderDef.fVersion = v; }    
        
public:

        /*
        template <class Data_t> Data_t *DoClone(Data_t *newobj)
        {
                newobj = new Data_t ();
                if ( newobj == 0x0 )
                        return 0x0;
                
                // use DotConf facilities to clone
                Bool_t ok = true;
                //
                std::ostringstream o; 
                ok = ok &&
                        this->DoConfigure(o);
                //
                // std::string tmp;
                // tmp = o.str();
                std::istringstream i(o.str());
                ok = ok &&
                        newobj->DoConfigure(i,true); //         
                
                if ( !ok )
                        { delete newobj; newobj = 0x0; }
                
                return newobj;
        }
         */
        
protected:

        virtual Bool_t ProcessLine(const std::string &) 
                { return true; }        

public:
        DotConf(); 
        DotConf(const Char_t *rid, const Char_t *srid = "", Bool_t is_record = true);
        virtual ~DotConf(); 
        
// Get/Set method
public:
        Bool_t IsWithRecord() const
                { return fHeaderDef.fWithRecord; }
        void SetWithRecord(Bool_t is_record = true)
                { fHeaderDef.fWithRecord = is_record; }
        
        void SetComment(const Char_t *comment)
                { fComment = comment ; }
        const Char_t *GetComment() const
                { return fComment.data(); }
        
        const Char_t *GetLastModif() const
                { return fLastModif.data(); }
        
        Short_t GetMaxVersion() const
                {return fHeaderDef.fVersion;}
        
        virtual void Reset(const Char_t *opt = "");
        
        virtual void SetRID(const Char_t *rid, const Char_t *srid ="") 
                { fHeaderDef.fRID = rid; fHeaderDef.fSRID = srid; }     
        virtual const Char_t *GetRID() const
                { return fHeaderDef.fRID.data(); }      
        virtual const Char_t *GetSRID() const
                { return fHeaderDef.fSRID.data(); }     
        virtual Short_t GetVersion() const
                { return fHeader.fVersion; }    
        
        virtual const Char_t *GetStreamOption() const
                { return fHeader.fStreamOption.data(); }        
        virtual void SetStreamOption(const Char_t *opt) 
                { fHeader.fStreamOption = opt; }        
        

        virtual void AddConf ( DotConf * );
        // clear conf list
        virtual void RemoveConf ( DotConf *aconf = 0x0 )
        {
                if ( aconf == 0x0 )
                        fListOfDotConf.clear();
                else
                        fListOfDotConf.remove(aconf);
        }

// Interface for any DotConf object     
public:

        virtual Bool_t DoConfigure(std::istream &, Bool_t allow_init);

        virtual Bool_t DoConfigure(std::ostream &);
        

        virtual Bool_t Configure(ConfigurationFrame *,  const char *option = "in", Bool_t allow_init = false);
        virtual Bool_t Configure(const char *name, const char *option = "in", Bool_t allow_init = true);
}; 

} // namespace ADF

#endif