FrameBlock.cpp

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
#include "FrameBlock.h"
#endif
#ifndef ADF_Key
#include "Key.h"
#endif

using namespace ADF;

Bool_t OneBlock::NextFrame(Key *key)
{
        if ( IsMode(ConfAgent::kWrite) || IsEoB() ) 
                return false;
                
        // try to read a key from the input buffer
        if ( !key->Link(fBuffer,fBuffer.Offset(),key->GetKeyLength()) ) 
                { SetEoB(true); return false;}

        // try to get the full frame from the input
        fFrame.SetOffset();
        if ( !fFrame.Link(fBuffer,fBuffer.Offset(),key->GetFrameLength()) ) {
                { SetEoB(true); return false;}
        }
        fBuffer.SetOffset(fBuffer.Offset()+key->GetFrameLength());
        
        return true;
}

Bool_t OneBlock::SetBlock(Char_t *buf, UInt_t size, char opt_rewind, char opt_link_or_copy, UInt_t /*which*/)
{
        /*
        if ( buf == 0x0 )
                { fBuffer.Unlink(); Rewind(GetModeIO()); return true; }
                
        // try to link, if ok, Rewind without changing the operating mode 
        Bool_t ok = fBuffer.Link(buf,size);
        if ( ok ) { 
                fBuffer.SetOffset(size); SetEoB(true);
                if ( opt_rewind == 'r' ) 
                        Rewind(GetModeIO()); 
        }
        return ok;
        */
        if ( buf == 0x0 )
                { fBuffer.Unlink(); Rewind(GetModeIO()); return true; } // back to the buffer truly owned by this
        
        // try to link, if ok, Rewind without changing the operating mode 
        Bool_t ok;
        if ( opt_link_or_copy == 'l' )
                ok = fBuffer.Link(buf,size);
        else 
                ok = fBuffer.Copy(buf,size);
        if ( ok ) { 
                fBuffer.SetOffset(size); SetEoB(true);
                if ( opt_rewind == 'r' ) 
                        Rewind(GetModeIO()); 
        }
        return ok;      
}

/*
Bool_t OneBlock::MoveBlock( FrameBlock &block, char opt_rewind, char opt_link_or_copy, UInt_t which)
{
        BufferIO *io = block.GetBufferIO();
        
        
        return false;
}
*/

Bool_t OneBlock::Reserve(UInt_t size, Bool_t switch_eob, UInt_t /*which*/)
{
        if ( IsMode(ConfAgent::kRead) || IsEoB() ) { 
                return false;
        }
        
        // check if enough place 
        Bool_t add_ok = true;
        if ( fBuffer.FreeSize() < size )
                add_ok = Expand( fBuffer.Offset() + size );
        // not enought place 
        if ( !add_ok ) {
                if ( switch_eob ) 
                        SetEoB(true);
                return false;
        }
        return true;
}
        
Bool_t OneBlock::AddFrame(const BufferIO &ext_frame, UInt_t)
{
        Bool_t ok = Reserve(ext_frame.Size());
        if ( ok ) 
                ok = BufferIO::Copy(ext_frame,fBuffer,ext_frame.Size());

        SetEoB(!ok); return ok;
}

Bool_t OneBlock::AddFrame(const Frame &frame, UInt_t)
{
        Bool_t ok = Reserve(frame.GetLength());
        if ( ok ) 
                ok = frame.Export(fBuffer); 

        SetEoB(!ok); return ok;
}

void  OneBlock::Rewind(ConfAgent::EMode mode) 
{       
        // the buffer has just been filled, so keep the current position 
        // as the effective size of the buffer
        if ( GetModeIO() == ConfAgent::kWrite && mode == ConfAgent::kRead ) {
                fBuffer.SetEffectiveSize(fBuffer.Offset());
                fBuffer.SetOffset();
        }
        else {
                fBuffer.FastReset();    
        }
        SetEoB(false); SetModeIO(mode);
}       

Bool_t ExpandableBlock::Expand(UInt_t size)
{
        // cannot expand anymore
        if ( ! fBuffer.Expand(size) ) 
                return false;

        return true;
}

FileBlock::FileBlock(UInt_t size, ConfAgent::EMode mode): 
        OneBlock(size,mode),
        fCurrentSize(0L),
        fMaxSize(kMaxUInt_t),
        fFileSnapshot(0L),
        fFile(0x0) 
{ 
}  

void FileBlock::Reset()
{
        fCurrentSize = 0u; fMaxSize = kMaxUInt_t; fFile = 0x0;
        SetEoB(false);
}

Bool_t FileBlock::NextFrame(Key *key)
{
        if ( IsMode(ConfAgent::kWrite) || fFile == 0x0 ) 
                return false;
        
        // read from the file a buffer with a length corresponding to a key
        UInt_t lengthkey = key->GetKeyLength(), lengthkeyread, lengthdata, lengthdataread;
         
        // read the key part
        fBuffer.SetOffset();
        lengthkeyread = 
                fBuffer.Import(fFile,lengthkey); 
        if ( lengthkeyread != lengthkey ) {  // cannot read anymore a key from the file
                SetEoB(true); 
                return false; 
        }
        else fCurrentSize += lengthkeyread;
                
        // link the key part to get the data length
        key->Link(fBuffer,0u,lengthkey); 
        // extract from the key the data part
        lengthdata = key->GetDataLength(); 
        // a coherent length has been found
        if ( lengthdata != 0u ) { 
                // read from file
                lengthdataread = fBuffer.Import(fFile,lengthdata);
                // test if reading ok
                if ( lengthdataread != lengthdata ) 
                                { SetEoB(true); return false; }
        } 
        else { SetEoB(true); return false; }
                
        // reading ok
        fCurrentSize += lengthdataread;
        
        // now link the content of buffer in fFrame
        fFrame.SetOffset();     
        fFrame.Link(fBuffer,0u,fBuffer.Offset());
        
        return true; // new frame properly loaded
}

Bool_t FileBlock::AddFrame(const BufferIO &ext_frame, UInt_t)
{
        Bool_t ok = Reserve(ext_frame.Size());
        if ( ok ) {
                ok = ext_frame.Export(fFile,ext_frame.Size()) ? true : false;
                if ( ok )
                        fCurrentSize += ext_frame.Size();
        }       
        SetEoB(!ok); return ok; 
}

Bool_t FileBlock::AddFrame(const Frame &frame, UInt_t)
{
        const Key *key = frame.GetKey();
        
        Bool_t ok = Reserve(frame.GetLength());
        if ( ok ) {
                ok = key->GetRealBuffer()->Export(fFile,key->GetKeyLength()) ? true : false;
                ok = ok && frame.GetRealBuffer()->Export(fFile,key->GetDataLength());
                if ( ok )
                        fCurrentSize += frame.GetLength();      
        }
        SetEoB(!ok); return ok;
}
        
Bool_t FileBlock::Reserve(UInt_t size, Bool_t switch_eob, UInt_t /*which*/)     
{ 
        if ( size <= (fMaxSize-fCurrentSize) ) 
                return true; 
        
        if ( switch_eob )
                SetEoB(true);
                
        return false; 
}
        
class NarvalBlock : public OneBlock 
{
protected:
        virtual Bool_t Expand(UInt_t);
        
public:
        // in principle just used with external buffers linked
        NarvalBlock(UInt_t size = aByte): OneBlock(size) 
                {;}  
        virtual ~NarvalBlock() 
                {;}
        
        virtual Bool_t Reserve(UInt_t, Bool_t /*switch_eob*/ = false, UInt_t /*which*/ = 0u);

};

Bool_t NarvalBlock::Reserve(UInt_t /*size*/, Bool_t /*switch_eob*/, UInt_t /*which*/)
{
        // not enought is the current block, try to expand by calling switch_output_block
//      if ( ! OneBlock::Reserve(size) ) {
//      
//      }
        return false;
}

Bool_t NarvalBlock::Expand(UInt_t)
{
        /*
        char **new_ad = new char; UInt_t new_size;
        
        void switch_output_block(fBuffer.Size(),void **output_address,UInt_t new_available_length);
        if( new_available_length < size )
                { return false ;}
        */
//      void switch_output_block(UInt_t *used_length,void **output_address,UInt_t new_available_length);
        return true;
}