HistoConverter.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005-2006 by Christophe Theisen & Olivier Stezowski     *
 *   christophe.theisen(AT)cea.fr, 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 GW_HISTOCONVERTER_H
#define GW_HISTOCONVERTER_H

#include "GwLogMessage.h"

// root's includes
#ifndef ROOT_TH1
#include <TH1.h>
#endif

#ifndef ROOT_TH2
#include <TH2.h>
#endif

#ifndef ROOT_THStack
#include <THStack.h>
#endif

#ifndef ROOT_TString
#include <TString.h>
#endif

// std's includes
#include <map>
#include <string>
#include <fstream>

// to correct a CC (solaris) bug
//      The fstream::read method does not work properly on CC solaris (at least on my machine ..)
//      Because it wasn't easy to change things that work properly on other
//      systems,  a wrapper is used and the fstream::get method which works is used instead.
//      
//      \warning if you use this wrapper, be careful that fstream::gcount does not
//      give you the correct answer .. better to use fstream::good to know if the reading was correct
//      
//      Much better to use the c or the system implementation in the futur ! 
//
/*
namespace {
class CCBug : public ifstream  
{
public:
       explicit CCBug();
        
       virtual istream &CCBug::read(char *, int);
 }; 
   
 CCBug::CCBug() : ifstream() { ; }
 
 istream & CCBug::read(char *s, int n) 
 {
        for ( int i = 0; i < n; i++ ) ifstream::get(s[i]);
        return (*this);
 }
 }
*/ 

namespace Gw {

#define MAXCYCLE 999
#ifndef ROOT_TString
#include "TString.h"
#endif

class HistoConverter 
{
private:
    static std::map <const char *, HistoConverter *> *gPrototypes; 
    static Int_t gAllocated;

public:

    enum EStatus { kGood, kFail, kZombie };
    

    enum EMode   { kVersion, kOverwrite };

    static int fVerboseLevel; // 0 for no message when writing / reading spectra
                              // 1 for message when writing / reading spectra. Default mode

protected:
    int fMode ;         // open mode: kVersion or kOverwrite
    TString fName;      // name of the histoconverter system
    
    int fStatus ;       // current status of the stream    
    TString fError;     // string to explain the last error in case the last operation failed

    char fCycle;        // character used in a versionning mode 

    TString fType;      // character used for type definition (e.g.: eg, rad, gpsi, etc...) 
    
    TString fFileExt;   // character used for file extension (e.g.: asc, spe, s, etc...) 

    bool fIsSwapping;   // true if swapping is needed to read the data
    
    TString fOptions; // option for the differents converter
  
    mutable LogMessage fLog; // log message
  
  
protected:    
    short Short(char *buf); 
    int   Int(char *buf);
    long  Long(char *buf);           
    float Float(char *buf);     

    unsigned short UShort(char *buf);     
    unsigned int   UInt(char *buf);     
    unsigned long  ULong(char *buf);       
    

    virtual void CheckDirectory(const char *name);
    
    TString CheckFileVersion(TString filename);
  
    void AddMineTypes();

           
public:
    HistoConverter();
    HistoConverter(const char *name);
    virtual ~HistoConverter();
    
    static void AddPrototype(const char *, HistoConverter *) ;
    
    std::map <const char *, HistoConverter *>*  GetMapPrototype() {return gPrototypes;} 
    
     // ! set verbose level. 0 for no I/O messages. 1 (default) for I/O messages.
     static void SetVerboseLevel(const int);
    // ! return verbose level
     static int GetVerboseLevel();
    
    int  GetMode() const { return fMode; }
    void SetMode(HistoConverter::EMode mode) { fMode = mode; }

    int  GetStatus() const { return fStatus; }
    const char *GetError() const { return fName.Data() ; }
    
   void SetError(HistoConverter::EStatus status = kGood, const char *msgerror = "");
        
    void SetCycle(char c) { fCycle = c; }
    
    void SetType(TString type) { fType = type; }
    
    void SetFileExt(TString ext) { fFileExt = ext; }
    TString GetFileExt() const { return fFileExt; }

    void SetOption(Option_t* opt, const char* mode = "reset");
    Option_t* GetOption() const {return fOptions.Data();}
    

   virtual TH1 *Get(int /*i*/);

   virtual TH1 *Get(const char */*name*/);
    

    virtual bool Read(TH1 &);  

    virtual bool Write(const TH1 &);

    virtual bool Read(TH2 &/*h*/) { return false; }     

    virtual bool Write(const TH2 &/*h*/) { return false;}
    

    virtual bool Read(THStack &/*hs*/) { return false; }
    virtual bool Write(const THStack &/*hs*/) { return false; }  
        
    virtual HistoConverter *NewDB(const char *) const;
    
    virtual const char *GetType() const { return "null" ; }
    
    virtual void ls(Option_t *) const ;

    void CheckMineTypes();  
    
    static void DrawSpectrum(const char* spectrum);

    ClassDef(HistoConverter,0); // base class to read/write histograms  
};
}
#endif