Frame.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_Frame
#define ADF_Frame
#define ADF_FRAME_H ADF_Frame

#ifndef ADF_Key
#include "Key.h"
#endif

#ifndef ADF_FrameFactory
#include "FrameFactory.h"
#endif

#ifndef ADF_PtrStack
#include "PtrStack.h"
#endif

#include <string>
#include <cstdio>

namespace ADF
{ 

class ConfigurationFrame;


class Frame
{
public:
        friend class FrameFactory;
private:
        FactoryItem fSignature; 
        Bool_t fZombie;  
// Migration SharedFP   PF_FactoryItemChange fKeyChange;
// Migration SharedFP   PF_FactoryItemChange fFrameChange;
        
private:
        Short_t fCheckLevel;
                        
protected:
        Frame();  
        Frame(Key *);  
                
        void SetSignature(FactoryItem item)
                { fSignature = item ; }
                
protected:
        virtual Bool_t DoConfigure(std::istream &) 
                { return false ; }
        virtual Bool_t DoConfigure(std::ostream &) 
                { return false ; }
            
public:
        virtual ~Frame();
        

        virtual void SetCheckLevel(Short_t checklevel)
                { fCheckLevel = checklevel; }
                
        virtual Short_t GetCheckLevel() const
                { return fCheckLevel; } 
                        
        const FactoryItem &GetSignature() const
                { return fSignature; }
        
        virtual const BufferIO *GetRealBuffer() const = 0;      
        
        virtual Key *GetKey() = 0; 
        
        virtual const Key *GetKey() const = 0; 
                
        virtual BaseBuffer::EStatus GetFrameStatus() const = 0;  
        
        virtual void ClearFrameStatus() = 0; 
        
        virtual UInt_t GetLength() const = 0; 
        

        virtual Bool_t Link(const Char_t *, UInt_t, const char = 'b') = 0; 


        virtual Bool_t Copy(const Char_t *, UInt_t, const char = 'b') = 0; 
        

        virtual Bool_t Link(const BufferIO &/*buf*/, UInt_t /*pos*/, const char /*opt*/ = 'b') = 0; 
                        
        virtual void Unlink() = 0; 
        
        virtual Bool_t IsLinked() const = 0;    
        

        virtual Bool_t Export(BufferIO &buf) const = 0;
        

        virtual Bool_t ExportData(BufferIO &buf) const = 0; 
        
        virtual Bool_t Copy(const Frame *) = 0;
        virtual Bool_t Link(const Frame *) = 0;
        

        virtual UInt_t Read() 
                { return 0u;}
        

        virtual UInt_t Write() 
                { return 0u;}
                        

        virtual Bool_t IsComposite() const 
                { return false; }
        

        virtual UInt_t Scan() 
                { return 0u; }      
        
        virtual const Key *GetSubKey(UInt_t) const = 0;
        

        virtual UInt_t GetNbSubFrame() const 
                { return 0u; }     
                

        virtual Bool_t IsASubFrame(const Frame &) 
                { return false; }
                        

        virtual Bool_t AddSubFrame(const Frame &) 
                { return false; }
        

        virtual Bool_t LinkSubFrame(UInt_t , Frame *) 
                { return false; }       
                

        //virtual Bool_t CopySubFrame(Int_t, Frame *) { return false; }   
        

        virtual Bool_t TransfertSubFrame(const Frame & /*from_frame*/, UInt_t /*whichsub*/)
                { return false; }               
        

        virtual void Reset() = 0; 
        
        virtual void FastReset() = 0; 
                

        virtual void Dump(const Char_t *filename, Bool_t anew = false) const = 0; 
        virtual Bool_t Dump(FILE *) const = 0;
                
        virtual Bool_t Load(FILE *) = 0;  
                

        virtual void Stallion(UInt_t repetition = 4u) = 0;
                
        virtual Bool_t Configure(const char *name, const char *option);
        virtual Bool_t Configure(ConfigurationFrame *,  const char *option);    
};

class ConcreteFrame : public Frame
{           
protected:
        BufferIO *fBuffer;      // the buffer that streams in/out the content of the Frame      
        Key *fKey;              // the key to map the frame
        
protected:    
        virtual BufferIO *RealBuffer() 
                { return fBuffer; }   

private:
        // ConcreteFrame(); 
    
protected:    
        ConcreteFrame(Key *);    
    
        virtual Bool_t LinkKey(const Char_t *buf, UInt_t size)   
                { return fKey->Link(buf,size) ; } 
                
        virtual Bool_t CopyKey(const Char_t *buf, UInt_t size)   
                { return fKey->Copy(buf,size) ; }
        
        virtual Bool_t LinkFrame(const Char_t *buf, UInt_t size)   
                { return fBuffer->Link(buf,size); } 
                
        virtual Bool_t CopyFrame(const Char_t *buf, UInt_t size)   
                { return fBuffer->Copy(buf,size); }
                      
public:      
        virtual ~ConcreteFrame();
        
        virtual const BufferIO *GetRealBuffer() const 
                { return fBuffer; } 
        
        virtual Key *GetKey() 
                { return fKey; }  
        
        virtual const Key *GetKey() const 
                { return fKey; }  
                
        virtual BaseBuffer::EStatus GetFrameStatus() const 
                { return fBuffer->GetStatus(); } 
        
        virtual void ClearFrameStatus() 
                { fBuffer->SetStatus(BaseBuffer::kGood); }
        
        virtual UInt_t GetLength()  const 
                { return fKey->GetFrameLength(); }    
        

//      virtual Bool_t Link(Char_t *buf, UInt_t size) 
//      { 
//              return LinkKey(buf,size) && LinkFrame(buf+fKey->GetKeyLength(),size-fKey->GetKeyLength()); 
//      }
        virtual Bool_t Link(const Char_t *buf, UInt_t size, const char opt = 'b')
        {
                if ( opt == 'k' )
                        return LinkKey(buf,size);
                if ( opt == 'f' )
                        return LinkFrame(buf,size);     
                        
                return (LinkKey(buf,size) && LinkFrame(buf+fKey->GetKeyLength(),size-fKey->GetKeyLength())); 
        } 
//      virtual Bool_t Copy(Char_t *buf, UInt_t size)
//      {
//              return false;
//      }
        virtual Bool_t Copy(const Char_t *buf, UInt_t size, const char opt = 'b')       
        {
                if ( opt == 'k' )
                        return CopyKey(buf,size);
                if ( opt == 'f' )
                        return CopyFrame(buf,size);     
                        
                return (CopyKey(buf,size) && CopyFrame(buf+fKey->GetKeyLength(),size-fKey->GetKeyLength())); 
        }
                

//      virtual Bool_t Copy(const Char_t *buf, UInt_t size)
//      {
//              return CopyKey(buf,size) && CopyFrame(buf+fKey->GetKeyLength(),size-fKey->GetKeyLength());
//      }
        

        virtual Bool_t Link(const BufferIO &buf, UInt_t pos, const Char_t opt = 'b') 
        { 
                if ( opt == 'k' )
                        return fKey->Link(buf,pos,fKey->GetKeyLength());
                if ( opt == 'f' )
                        return fBuffer->Link(buf,pos+fKey->GetKeyLength(),fKey->GetDataLength());       
                        
                return fKey->Link(buf,pos,fKey->GetKeyLength()) 
                        && fBuffer->Link(buf,pos+fKey->GetKeyLength(),fKey->GetDataLength()); 
        } 
                        

//      virtual Bool_t Copy(BufferIO &buf, UInt_t pos) 
//              { return fKey->Copy(buf,pos,fKey->GetKeyLength()) 
//                      && fBuffer->Copy(buf,pos+fKey->GetKeyLength(),fKey->GetDataLength()); }
                
        virtual void Unlink() 
                { fKey->Unlink(); fBuffer->Unlink(); }
        
        virtual Bool_t IsLinked() const
                { return fBuffer->IsLinked() && fKey->IsLinked(); }       
        
        virtual Bool_t Copy(const Frame *);
        virtual Bool_t Link(const Frame *);
        

        virtual Bool_t Export(BufferIO &buf) const 
        { 
                Bool_t ok = fKey->Export(buf);
                UInt_t length =  fKey->GetDataLength();

//              ok = ok && buf.Import((*fBuffer),fKey->GetDataLength()) == fKey->GetDataLength();
                ok = ok && (buf.Import((*fBuffer),length) == length);
                return ok;
        }
        

        virtual Bool_t ExportData(BufferIO &buf) const
                { return BufferIO::Copy((*fBuffer),buf,fKey->GetDataLength()); }   
        
                                

        virtual Bool_t IsComposite() const 
                { return false; }
        

        virtual UInt_t Scan() 
                { return 0u; }      
        
        virtual const Key *GetSubKey(UInt_t) const 
                { return fKey; }
        

        virtual UInt_t GetNbSubFrame() const 
                { return 0u; }       
        

        virtual Bool_t AddSubFrame(const Frame &) 
                { return false; }
        

        virtual Bool_t LinkSubFrame(UInt_t , Frame *) 
                { return false; }        
                

        //virtual Bool_t CopySubFrame(Int_t, Frame *) { return false; }   
        

        virtual void Reset() 
                { fBuffer->Reset(); fBuffer->SetOffset(); fKey->SetDataLength(0u); }  
        
        virtual void FastReset() 
                { fBuffer->SetOffset(); fKey->SetDataLength(0u); } 
                

        virtual void Dump(const Char_t *filename, Bool_t anew = false) const ;  
        virtual Bool_t Dump(FILE *) const;
        
        virtual Bool_t Load(FILE *);  
                

        virtual void Stallion(UInt_t repetition = 4u);
}; 
// ConcreteFrame inline members //////////////////////////////////////////////////////


class RawFrame : public ConcreteFrame
{
public:      
        RawFrame(Key *key): ConcreteFrame(key) 
                {;}     
        virtual ~RawFrame()
                {;}     
                

        virtual UInt_t Read() 
                { return GetKey()->GetDataLength(); }
        

        virtual UInt_t Write() 
                { GetKey()->SetDataLength(GetRealBuffer()->Offset()); return GetKey()->GetDataLength(); }       
        
        virtual BufferIO &RawBuffer()
                { return (*RealBuffer()); } 
};


class SharedFP
{       
private:
        Frame *fFrame;
private:
        Bool_t fIsValid;
private:
        PF_FactoryItemChange fKeyChange;
        PF_FactoryItemChange fFrameChange;
        
public: 
        explicit SharedFP( Frame *f = 0x0 );
        virtual ~SharedFP() 
                { if (fFrame) delete fFrame ; fFrame = 0x0; }

        virtual Bool_t IsValid() const
                { return fIsValid; }
        virtual void SetValid(Bool_t validity) 
                { fIsValid = validity; }
        
        virtual Frame *SetFrame(Frame *);
        
        virtual Frame * GetFrame() const
                { return fFrame; }
        

        Bool_t IsKeyChangeable(FactoryItem item_from, FactoryItem item_to) const
                { return fKeyChange(item_from,item_to); }
        
        virtual void SetKeyChangeFunction(PF_FactoryItemChange pf)
                { fKeyChange = pf; }    
        
        const PF_FactoryItemChange &GetKeyChangeFunction() const
                { return fKeyChange; }
        

        Bool_t IsFrameChangeable(FactoryItem item_from, FactoryItem item_to) const
                { return fFrameChange(item_from,item_to); }
        
        virtual void SetFrameChangeFunction(PF_FactoryItemChange pf)
                { fFrameChange = pf; }
        
        const PF_FactoryItemChange &GetFrameChangeFunction() const
                { return fFrameChange; }        
};

} // namespace ADF
#endif