DataHandling.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004 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_DataHandling
#define ADF_DataHandling
#define ADF_DATAHANDLING_H ADF_DataHandling

#ifndef ADF_ADFConfig
#include "ADFConfig.h"
#endif
#ifndef ADF_BufferIO
#include "BufferIO.h"
#endif

#include<iostream>
#include<string>
#include<cstdlib>

namespace ADF
{ 

const char *NamedItemTypeOf(Bool_t); 
const char *NamedItemTypeOf(UShort_t); 
const char *NamedItemTypeOf(Short_t); 
const char *NamedItemTypeOf(UInt_t); 
const char *NamedItemTypeOf(Int_t); 
const char *NamedItemTypeOf(ULong64_t);
const char *NamedItemTypeOf(Long64_t);
const char *NamedItemTypeOf(Double_t);
const char *NamedItemTypeOf(Float_t); 
const char *NamedItemTypeOf(std::string); 


class DataLink 
{
public:
        friend class GObject;
        
protected:
        virtual void *A1()
                { return 0x0; } 
        virtual void *A2()
                { return 0x0; }

public:
        DataLink() 
                {;} 
        virtual ~DataLink()
                {;}

//      virtual UShort_t IsALink(void *) 
//              { return 0u; }
                                
        virtual void Link(void *, void *) 
                {;}
        
        virtual void CopyA1_to_A2() 
                {;}
        
        virtual void CopyA2_to_A1() 
                {;}
        
        virtual void Reset() 
                {;}
        
        virtual void ResetA1() 
                {;}     
        
        virtual void ResetA2() 
                {;}     
};


template<typename Data_T> class DataLinkImp : public DataLink
{
private:
        Data_T fDefault; Data_T *fA1, *fA2;

protected:
        virtual void *A1()
                { return fA1; }
        virtual void *A2()
                { return fA2; }
public:
        DataLinkImp(Data_T d) : 
                DataLink(), fDefault(d), fA1(0x0), fA2(0x0) {;}
        virtual ~DataLinkImp() 
                { fA1 = fA2 = 0x0; }

        virtual void Link(void *a1, void *a2) 
                { fA1 = (Data_T *)a1; fA2 = (Data_T *)a2; };
        
        virtual void CopyA1_to_A2() 
                { (*fA2) = (*fA1) ;}
        virtual void CopyA2_to_A1() 
                { (*fA1) = (*fA2) ;}
        
        virtual void ResetA1() 
                { (*fA1) = fDefault; }  
        virtual void ResetA2() 
                { (*fA2) = fDefault; }
                
        virtual void Reset() 
                { (*fA2) = (*fA1) = fDefault; } 
};


class ANamedItem 
{
protected:
        std::string fName;
        std::string fType;
        
public:
        ANamedItem(const char *name, const char *type) : 
                fName(name), fType(type) {;}
        virtual ~ANamedItem() 
                {;}
        
        virtual ANamedItem *MakeAClone() const = 0;
                
//      virtual UShort_t IsLinked(DataLink *) = 0;
                
        virtual DataLink *MakeADataLink(void *) = 0;
        
        virtual ANamedItem *MakeAProxy()= 0;
        
        virtual Bool_t Set( const ANamedItem * ) = 0;
        // virtual Bool_t Set( const ANamedItem *, Bool_t check_type = true, check_name = false ) = 0;

        std::string GetName() const
                { return fName; }
        std::string GetType() const
                { return fType; }       
        
        std::string &Name() 
                { return fName; }
        std::string &Type() 
                { return fType; }
                
        Bool_t IsType(const char *type) 
                { return fType.compare(type) == 0 ; }
                        
        virtual void SetItem(BufferIO &) const 
                {;}     
        virtual void GetItem(const BufferIO &) 
                {;}
        
        virtual void Reset() 
                {;}
                
        virtual void Print(std::ostream & = std::cout) const 
                {;}
};

template<typename Data_T> class NamedItem : public ANamedItem
{
private:
        Data_T fDefault; Data_T fData;
        
public:
        NamedItem(const char *name, Data_T d = 0): 
                ANamedItem(name,"NOTYPE"),fDefault(d),fData(d) { fType = NamedItemTypeOf(fData); }
        virtual ~NamedItem() 
                {;}

        virtual ANamedItem *MakeAClone() const
        { 
                NamedItem<Data_T> *clone = new NamedItem<Data_T>(GetName().data(),GetDefault()) ;
                clone->Set(Get());
                
                return clone;
        }
        virtual Bool_t Set( const ANamedItem *item )
        {
                Bool_t ok = false;
                if ( item->GetType() == GetType() ) {
                        const NamedItem<Data_T> *t = dynamic_cast< const NamedItem<Data_T> *> (item);
                        Set( t->Get() );
                        ok = true;
                }               
                return ok;
        }
        virtual ANamedItem *MakeAProxy();
                
        virtual DataLink *MakeADataLink(void *extern_add)
        { 
                DataLinkImp<Data_T> *link = new DataLinkImp<Data_T>(fDefault); 
                if ( link ) 
                        link->Link(&fData,extern_add);
                return link;
        }
        virtual void Set(Data_T t) 
                { fData = t; }
        virtual Data_T Get() const
                { return fData; }
                
        virtual void SetDefault(Data_T t) 
                { fDefault = t; }
        virtual Data_T GetDefault() const
                { return fDefault; }
                
        virtual void SetItem(BufferIO &buf) const  
                {buf << fData;} 
        virtual void GetItem(const BufferIO &buf) 
                {buf >> fData;} 
                
        virtual void Reset() 
                { fData = fDefault; }
                
        virtual void Print(std::ostream & /*out */ = std::cout) const 
        {
//              out << " " << GetName() << " " << GetType() << " " << fData ;
//              out << " " << GetName() << " " << GetType() << " " ;            
        }
};

class AProxyNamedItem 
{
public:
        AProxyNamedItem() 
                {;}
        virtual ~AProxyNamedItem() 
                {;}
                
        virtual void SetProxy(ANamedItem * /*ritem*/) 
                {;}
};

template<typename Data_T> class ProxyNamedItem : public AProxyNamedItem, public NamedItem<Data_T>
{
private:
        NamedItem<Data_T> *fRealItem;

public:
        ProxyNamedItem(const char *name, Data_T d = 0): 
                NamedItem<Data_T>(name,d),fRealItem(0x0) { fRealItem = this; }
        virtual ~ProxyNamedItem() 
                {;}
        
        virtual void SetProxy(ANamedItem *ritem)
        { 
                fRealItem = this;
                if ( ritem == 0x0 )
                        return;
                if ( dynamic_cast< NamedItem<Data_T> *>(ritem) )
                        fRealItem = dynamic_cast< NamedItem<Data_T> *>(ritem);
        } 


        virtual ANamedItem *MakeAProxy()
                { return this; }        
        
        virtual DataLink *MakeADataLink(void *extern_add)
                { return fRealItem->MakeADataLink(extern_add); }
        
        virtual Bool_t Set( const ANamedItem *t )
                { return fRealItem->Set(t) ; }
        virtual void Set(Data_T t) 
                { fRealItem->Set(t) ; }
        virtual Data_T Get() const
                { return fRealItem->Get(); }
                
        virtual void SetDefault(Data_T t) 
                { fRealItem->SetDefault(t) ; }
        virtual Data_T GetDefault() const
                { return fRealItem->GetDefault(); }
                
        virtual void SetItem(BufferIO &buf) const  
                {fRealItem->SetItem(buf);}      
        virtual void GetItem(const BufferIO &buf) 
                {fRealItem->GetItem(buf);}      
                
        virtual void Reset() 
                { fRealItem->Reset(); } 
};

template <typename Data_T> ANamedItem *NamedItem<Data_T>::MakeAProxy()
{
        ProxyNamedItem<Data_T> *ritem 
                = new ProxyNamedItem<Data_T>(Name().data(),GetDefault());
        ritem->SetProxy(this);
        
        return ritem;
}


class Digitizer
{
private:
        Double_t fXmin, fXmax, fDeltaX;
        
        UShort_t fNBins2;
        UInt_t   fNBins4;        
        
public:
        Digitizer(Double_t xmin = 0., Double_t xmax = 1., UInt_t bins = 1u);
        virtual ~Digitizer() {;}
        
        virtual void Init(Double_t xmin = 0., Double_t xmax = 1., UInt_t bins = 1u);
        
        Double_t GetMin() const 
                { return fXmin; }
        Double_t GetMax() const 
                { return fXmax; }
        
        UShort_t GetBins2() const 
                { return fNBins2; }
        UInt_t   GetBins4() const 
                { return fNBins4; }
                

        virtual UShort_t D2Bytes(Double_t x) const {
                if ( x <= fXmin ) return 0u;  
                if ( x > fXmax ) return fNBins2; return UShort_t(fNBins2*(x-fXmin)/fDeltaX) ; 
        }
         

        virtual UInt_t D4Bytes(Double_t x) const {  
                if ( x <= fXmin ) return 0u;
                if ( x > fXmax ) return fNBins4; return UInt_t(fNBins4*(x-fXmin)/fDeltaX) ;
        }        
         

        virtual Double_t UndigitR(UInt_t i) const 
          { if ( i > fNBins4 ) return fXmax; return fXmin + (i+Double_t(::rand())/RAND_MAX) * fDeltaX / fNBins4; }
          

        virtual Double_t UndigitR(UShort_t i) const
          { if ( i > fNBins2 ) return fXmax; return fXmin + (i+Double_t(::rand())/RAND_MAX) * fDeltaX / fNBins2; }      
          

        virtual Double_t Undigit(UInt_t i) const 
          { if ( i > fNBins4 ) return fXmax; return fXmin + (i) * fDeltaX / fNBins4; }
          

        virtual Double_t Undigit(UShort_t i) const
          { if ( i > fNBins2 ) return fXmax; return fXmin + (i) * fDeltaX / fNBins2; }  
          

        virtual Double_t UndigitC(UInt_t i) const 
          { if ( i > fNBins4 ) return fXmax; return fXmin + (i+0.5) * fDeltaX / fNBins4; }
          

        virtual Double_t UndigitC(UShort_t i) const
          { if ( i > fNBins2 ) return fXmax; return fXmin + (i+0.5) * fDeltaX / fNBins2; }                
};

} // namespace ADF
#endif