FrameBlock.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_FrameBlock
#define ADF_FrameBlock

#ifndef ADF_ConfAgent
#include "ConfAgent.h"
#endif
#ifndef ADF_Frame
#include "Frame.h"
#endif

namespace ADF
{ 
        
        class Key;
        

        class FrameBlock 
        {
        private:
                ConfAgent::EMode fMode;
        private:        

                Bool_t fEoB; 
        private:        
                // std::string fName;
        private:
                void *fOwner;   
                
        protected:

                virtual Bool_t Expand(UInt_t) = 0;
                
        public:
                FrameBlock(ConfAgent::EMode mode = ConfAgent::kRead): 
                fMode(mode), 
                fEoB(false),
                /* fName("AFrameBlock"), */
                fOwner(0x0)
                {;}  
                virtual ~FrameBlock() 
                {;}
                
                ConfAgent::EMode GetModeIO() const 
                { return fMode; }
                virtual void SetModeIO(ConfAgent::EMode mode) 
                { fMode = mode; }
                Bool_t IsMode(ConfAgent::EMode mode) const 
                { return fMode == mode; }
                
                Bool_t IsEoB() const
                { return fEoB; }
                
                void SetEoB(Bool_t b)
                { fEoB = b; }
                
                /*
                 virtual void SetName(std::string name)
                 {
                 fName = name;
                 }
                 virtual std::string GetName() const 
                 {
                 return fName;
                 }
                 */
                virtual void *SetOwner(void * owner = 0x0)
                {
                        void *current = fOwner; fOwner = owner; return current;
                }
                virtual Bool_t IsOwner(void * owner = 0x0) const
                {
                        return fOwner == owner;
                }       
                
                virtual BufferIO *GetBufferIO(UInt_t which = 0u) = 0;
                // virtual const BufferIO *GetBufferIO(UInt_t which = 0u) = 0;
                

                virtual Bool_t NextFrame(Key *) = 0; 
                

                virtual BufferIO &GetFrame(UInt_t which = 0u) = 0; 
                

                virtual Bool_t Reserve(UInt_t, Bool_t /*switch_eob*/ = false, UInt_t /*which*/ = 0u) 
                { return false; }
                
                virtual Long64_t GetSize(UInt_t = 0u) const
                { return 0; }   
                virtual Long64_t GetMaxSize(UInt_t = 0u) const
                { return 0; }                   
                virtual Long64_t GetOffset(UInt_t = 0u) const
                { return 0; }
                

                virtual Bool_t AddFrame(const BufferIO &, UInt_t = 0u) 
                { return false; }
                
                virtual Bool_t AddFrame(const Frame &, UInt_t = 0u)
                { return false; }       
                

                virtual void  Rewind(ConfAgent::EMode mode = ConfAgent::kRead) = 0;
                
                virtual void Snapshot() 
                {;}
                virtual void BackToSnapshot() 
                {;}     
                
                virtual UInt_t NumberOfChannels() const = 0; 
                

                virtual Bool_t SetBlock(Char_t * /*buf */ = 0x0, UInt_t /*size*/ = 0u, char /*opt_rewind*/ = 'r', char /*opt_link_or_copy*/ = 'l', UInt_t /*which*/ = 0u) = 0;  
                
                //virtual Bool_t MoveBlock( FrameBlock &, char /*opt_rewind*/ = 'r', char /*opt_link_or_copy*/ = 'l', UInt_t /*which*/ = 0u)
                //      { return false; }       
                
        };
        

        class OneBlock : public FrameBlock 
        {               
        protected:
                UInt_t fLastSnapshot;
                

                BufferIO fBuffer;
                BufferIO fFrame;
                
        protected:

                virtual Bool_t Expand(UInt_t) 
                { return false ; }
                
        public:
                OneBlock(UInt_t size = aMByte, ConfAgent::EMode mode = ConfAgent::kRead): FrameBlock(mode), fLastSnapshot(0u), fBuffer(size), fFrame()
                {;}  
                virtual ~OneBlock() 
                {;}
                
                virtual Long64_t GetSize(UInt_t = 0u) const
                { 
                        if (GetModeIO()==ConfAgent::kRead) {
                                return fBuffer.Size();
                        }
                        else return fBuffer.Offset(); 
                }
                virtual Long64_t GetMaxSize(UInt_t = 0u) const
                { 
                        return fBuffer.Size(); 
                }
                
                virtual Long64_t GetOffset(UInt_t = 0u) const
                { 
                        return fBuffer.Offset(); 
                }
                
                virtual BufferIO *GetBufferIO(UInt_t /*which*/ = 0u)
                { return &fBuffer; }
                

                virtual Bool_t NextFrame(Key *); 
                

                virtual BufferIO &GetFrame(UInt_t = 0u) 
                { return fFrame; } 
                
                virtual Bool_t Reserve(UInt_t, Bool_t /*switch_eob*/ = false, UInt_t /*which*/ = 0u);
                
                virtual void Snapshot() 
                { fLastSnapshot = fBuffer.Offset(); }
                virtual void BackToSnapshot() 
                { fBuffer.SetOffset(fLastSnapshot); }   
                

                virtual Bool_t AddFrame(const BufferIO &, UInt_t i = 0u);
                virtual Bool_t AddFrame(const Frame &, UInt_t i = 0u);
                

                virtual void  Rewind(ConfAgent::EMode mode = ConfAgent::kRead); 
                
                virtual UInt_t NumberOfChannels() const 
                { return 1u; }
                

                virtual Bool_t SetBlock(Char_t * /*buf*/ = 0x0, UInt_t /*size*/ = 0u, char /*opt_rewind*/ = 'r', char /*opt_link_or_copy*/ = 'l', UInt_t /*which*/ = 0u);       
                
                // virtual Bool_t MoveBlock( FrameBlock &, char /*opt_rewind*/ = 'r', char /*opt_link_or_copy*/ = 'l', UInt_t /*which*/ = 0u);          
                // 
                /*
                 virtual void View()
                 {
                 UInt_t off; 
                 
            fBuffer.Offset();
                 fBuffer.SetOffset();   
                 
                 UInt_t length, message;
                 fBuffer >> length >> message;
                 std::cout << std::dec  
            << length 
            << " 0x" 
            << std::hex
            << message << std::dec << std::endl;
                 
                 fBuffer.SetOffset(off);        
                 }
                 */
        };
        

        class NullBlock : public OneBlock 
        {
        protected:
                virtual Bool_t Expand(UInt_t) 
                { return true ; }
                
        public:
                NullBlock(ConfAgent::EMode mode = ConfAgent::kRead): OneBlock(aByte,mode)
                { ; }  
                virtual ~NullBlock() {;}
                
                virtual Bool_t NextFrame(Key *) 
                { return false; }
                virtual BufferIO &GetFrame(UInt_t = 0u)
                { fFrame.SetEffectiveSize(0u); return fFrame; } 
                
                virtual Bool_t Reserve(UInt_t, Bool_t /*switch_eob*/ = false, UInt_t /*which*/ = 0u)
                { return true; }
                
                virtual Bool_t AddFrame(const BufferIO &, UInt_t = 0u)
                { return true; }
                virtual Bool_t AddFrame(const Frame &, UInt_t = 0u)
                { return true; }        
        };
        

        class ExpandableBlock : public OneBlock 
        {
        protected:
                virtual Bool_t Expand(UInt_t);
                
        public:
                ExpandableBlock(UInt_t size = aMByte, ConfAgent::EMode mode = ConfAgent::kRead): OneBlock(size,mode)
                {;}  
                virtual ~ExpandableBlock() 
                {;}
        };
        

        class FileBlock : public OneBlock
        {
        private:
                Long64_t fCurrentSize;  
                Long64_t fMaxSize;
                
                Long64_t fFileSnapshot;
                
        private:
                FILE *fFile;
                
        protected:
                void Reset();
                
        public:
                FileBlock(UInt_t size = aMByte, ConfAgent::EMode mode = ConfAgent::kRead);   
                virtual ~FileBlock() 
                {;}
                
                virtual Long64_t GetSize(UInt_t = 0u) const
                {
                        if (GetModeIO()==ConfAgent::kRead) {
                                return fMaxSize;
                        }
                        else return fCurrentSize; 
                        
                }
                virtual Long64_t GetMaxSize(UInt_t = 0u) const
                { 
                        return fMaxSize; 
                }
                
                virtual Long64_t GetOffset(UInt_t = 0u) const
                { 
                        return fCurrentSize; 
                }       
                
                virtual void SetFile(FILE *file, Long64_t max_size = kMaxUInt_t)
                { 
                        Reset(); 
                        if (GetModeIO()==ConfAgent::kRead) { // reading mode, take the value from the file 
#if  !defined(_MSC_VER)
                                // keep current position 
                                Long64_t c = ::ftell(file);
                                // now get the end of file
                                ::fseek(file, 0L, SEEK_END);
                                fMaxSize = ::ftell(file);
                                // back to current position                     
                                ::fseek(file, c, SEEK_SET);
#else
                                // WINDOWS, where the use of 64 bits is not automatic as in LINUX 
                                // keep current position
                                Long64_t c = _ftelli64(file);
                                // now get the end of file
                                _fseeki64(file, __int64(0), SEEK_END);
                                fMaxSize = _ftelli64(file);
                                // back to current position                     
                                _fseeki64(file, c, SEEK_SET);
#endif
                        }
                        else fMaxSize = max_size; 
                        fFile = file; 
                }
                
                virtual Bool_t Reserve(UInt_t, Bool_t /*switch_eob*/ = false, UInt_t /*which*/ = 0u);
                

                virtual Bool_t NextFrame(Key *);
                
                virtual void Snapshot() 
                { 
                        fFileSnapshot = fCurrentSize; 
                }
                virtual void BackToSnapshot() 
                { 
                        if ( fFile ) 
#if !defined(_MSC_VER)
                                ::fseek(fFile,fFileSnapshot,SEEK_SET); 
#else
                        _fseeki64(fFile,fFileSnapshot,SEEK_SET); 
#endif
                        fCurrentSize = fFileSnapshot; 
                }       
                
                virtual void  Rewind(ConfAgent::EMode = ConfAgent::kRead) 
                { 
                        fCurrentSize = 0u; 
                        if ( fFile ) 
                                ::fseek(fFile,0u,SEEK_SET); 
                }
                
                virtual Bool_t SetBlock(Char_t * /*buf*/= 0x0, UInt_t/*size*/= 0u, char /*opt_rewind*/ = 'r', char /*opt_link_or_copy*/ = 'l', UInt_t/*which*/ = 0u)    
                { return false; }
                
                virtual Bool_t AddFrame(const BufferIO &, UInt_t i = 0u);
                virtual Bool_t AddFrame(const Frame &, UInt_t i = 0u);
        };
        
} // namespace ADF
#endif