BufferIO.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_BufferIO
#include "BufferIO.h"
#endif
 
using namespace ADF;
 
BufferIO::BufferIO(UInt_t s): 
        fStatus(BaseBuffer::kGood), 
        fEndian(BaseBuffer::kLittle), 
        fInner(0), 
        fOuter(0), 
        fRealInnerSize(0u),
        fRealOuterSize(0u),      
        fBufferIO(0), 
        fSize(0u), 
        fRealSize(0u),
        fCurrent(0u)
{       
        fEndian = BaseBuffer::SysEndian(); 
        BufferIO::AllocInner(s); 
        
        SetCurrent('i');
}

void BufferIO::SetCurrent(const char which)
{       
        char realw = which;
        
        // if outer does not exist, keep inner one
        if ( which == 'o' )
                if ( fOuter == NULL ) realw = 'i';
        
        if ( realw == 'o' ) {
                fBufferIO = fOuter;
                fSize     = fRealOuterSize; 
                fRealSize = fRealOuterSize;     
        }
        else {
                fBufferIO = fInner; 
                fSize     = fRealInnerSize; 
                fRealSize = fRealInnerSize;
        }
}
 
BufferIO::~BufferIO()
{
        if ( fInner != NULL ) 
                { BaseBuffer::Delete(fInner); }
        
        fInner = fOuter = fBufferIO = 0; 
        fCurrent = fSize = fRealSize = fRealInnerSize = fRealOuterSize = 0u;
        
        fStatus = BaseBuffer::kGood; 
}
    
void BufferIO::AllocInner(UInt_t s) 
{
        UInt_t lsize = s > 0u  ? s : 1u ; // to prevent allocation of a NULL buffer
        
        // delete the previous one and allocate a new one that is fill with 0
        if ( fInner != NULL )
                 BaseBuffer::Delete(fInner); 
        fInner = BaseBuffer::New(fInner,lsize);
        
        // cannot allocate memory ... probably to much has been asked, allocates the mimimum = 1 byte
        if ( fInner == NULL ) {   
                lsize = 1u; fInner = BaseBuffer::New(fInner,lsize);     
        }       
        fRealInnerSize = lsize;
}

BufferIO *BufferIO::New(BaseBuffer::EEndian e, UInt_t s)
{
        BufferIO *b = NULL;
        
        // allocates the right buffer depending of the system.
        if ( e == BaseBuffer::SysEndian() ) { /* printf("Buffer allocated \n"); */ b = new BufferIO(s); }
        else { /* printf("EndianBuffer allocated \n");*/ b = new EndianBufferIO(s); }

        // change endian since default is to init with the endian of the system.
        if ( b ) 
                b->SetEndian(e); 
        
        return b;
}

void BufferIO::Reset()
{
        if ( fRealSize > 0u ) 
                { BaseBuffer::Zero(fBufferIO,fRealSize); } 
        
        fCurrent = 0u; fSize = fRealSize; fStatus = BaseBuffer::kGood;
}

void BufferIO::FastReset()
{       
        fCurrent = 0u; fSize = fRealSize; fStatus = BaseBuffer::kGood;
}

UInt_t BufferIO::SetOffset(UInt_t off) const
{ 
        if ( off > fSize ) 
                fCurrent = fSize;
        else 
                fCurrent = off; 

        return fCurrent;
}

UInt_t BufferIO::SetOffset(const Char_t *off) const
{
        if ( off < fBufferIO ) 
                return BufferIO::SetOffset(0u);
        if ( off > fBufferIO+fSize ) 
                return BufferIO::SetOffset(fSize);      
                
        return BufferIO::SetOffset(UInt_t(off-fBufferIO));
}   

Bool_t BufferIO::IsAnOffset(const Char_t *off, UInt_t &pos) const
{
        if ( off < fBufferIO ) 
                return false;
        if ( off > fBufferIO+fSize )
                return false;
        
        pos = UInt_t(off - fBufferIO); return true;     
}   

UInt_t BufferIO::SetEffectiveSize(UInt_t new_size)
{
        if ( new_size < fRealSize )
                fSize = new_size;
        else 
                fSize = fRealSize;
        
        return fSize;
}

Bool_t BufferIO::Expand(UInt_t new_size)
{
        // the Real size is enought, so just change the current size
        if ( new_size <= fRealSize ) {  
                BaseBuffer::Zero(fBufferIO+fSize,new_size-fSize);
                fSize = new_size;

                return true;
        }
        
        // The current buffer is not the inner buffer, so the expand method is not applied 
        // since the outer buffer is not owned by BufferIO
        if ( fBufferIO != fInner ) 
                return false;
        
        // now the current buffer is the inner one without a size large enough
        // so allocates a new buffer
        Char_t *newbuf = NULL; newbuf = BaseBuffer::New(newbuf,new_size); 
        
        // cannot allocate the corresponding memory
        if ( newbuf == NULL ) 
                return false; 
        
        // copy the content of the old buffer before deleting the old one
        ::memcpy(newbuf,fBufferIO,Offset()); 
        //
        BaseBuffer::Delete(fInner); 
        
        // set the characterictics of the new inner and current buffer
        fInner = newbuf;
        fRealInnerSize = new_size; 
        
        SetCurrent('i');
        
        return true;
}

Bool_t BufferIO::Reserve(UInt_t add)
{
        // enough place
        if ( fCurrent + add <= fSize ) 
                return true;
        
        // enough place just by changing the size
        if ( fCurrent + add <= fRealSize ) {
                fSize = fRealSize;
                return true;
        }
        // try to expand
        return Expand(fCurrent + add);
}

Bool_t BufferIO::Link(const Char_t *extbuf, UInt_t size_ext_buf)
{
        Bool_t ok = true;
        
        if ( extbuf == NULL ) 
                return false; 

        if ( extbuf == fInner ) { // try to link again the inner
                if ( size_ext_buf < fRealInnerSize ) {
                        SetCurrent('i');
                        fCurrent = 0u; fSize = size_ext_buf; fStatus = BaseBuffer::kGood;       // the new attached buffer is ready to be processed 
                }
                else  { ok = false; }
        } 
        else { 
                fOuter = const_cast<Char_t *>(extbuf); fRealOuterSize = size_ext_buf; 
                if ( fOuter ) {
                        SetCurrent('o');
                        fCurrent = 0u; fSize = size_ext_buf; fStatus = BaseBuffer::kGood;       // the new attached buffer is ready to be processed 
                }
                else { ok = false; }    
        }// new buffer attached
        
        return ok;
}

Bool_t BufferIO::Link(const BufferIO &extbuf, UInt_t p1, UInt_t p2)
{
        if ( (p1+p2) > extbuf.Size() ) 
                return false; 
        
        return Link(extbuf.GetAddress()+p1,p2);
}

Bool_t BufferIO::Copy(const Char_t *extbuf, UInt_t size_ext_buf)
{
        // if the inner buffer is not large enought, try to expand it
        Bool_t ok = true;
        
        if ( fRealInnerSize < size_ext_buf ) { // inner is too small
        
                Char_t *newbuf 
                        = NULL;
                newbuf = BaseBuffer::New(newbuf,size_ext_buf);
                
                // can allocate the corresponding memory
                if ( newbuf != NULL ) {

                        // delete current buffer
                        BaseBuffer::Delete(fInner); 
                        
                        // set the characterictics of the new inner buffer
                        fInner = newbuf;
                        fRealInnerSize = size_ext_buf;
                }
                else ok = false;
        }
        
        if ( ok ) { // the size of the current buffer is large enought for a full copy
        
                BaseBuffer::Copy(extbuf,fInner,size_ext_buf);
                SetCurrent('i');
                SetEffectiveSize(size_ext_buf);
                
                // the new attached buffer is ready to be processed 
                fCurrent = 0u; fStatus = BaseBuffer::kGood;     
        }
        
        return ok; 
}

UInt_t  BufferIO::Import(FILE *fd, UInt_t size_ext_buf)
{
        UInt_t btoread = size_ext_buf;
        
        if ( Reserve(size_ext_buf) ) { // the size of the current buffer is large enought for a full copy
                btoread = size_ext_buf;
                btoread = (UInt_t)::fread(fBufferIO+fCurrent,1,btoread,fd); fCurrent += btoread;
        }
        else btoread = 0u;

        return btoread;
}  

UInt_t  BufferIO::Import(const Char_t *from, UInt_t size_ext_buf)
{
        UInt_t btoread = size_ext_buf;
        
        if ( Reserve(size_ext_buf) ) { // the size of the current buffer is large enought for a full copy       
                BaseBuffer::Copy(from,fBufferIO+fCurrent,btoread);
        }
        else btoread = 0u;
        
        fCurrent += btoread; return btoread;
}

UInt_t  BufferIO::Import(const BufferIO &from, UInt_t size_ext_buf)
{
        // check if the given size does not overestimate the real size of the passed buffer
        UInt_t btoread = size_ext_buf <= from.Size() ? size_ext_buf : from.Size() ;
        
        if ( Reserve(size_ext_buf) ) { // the size of the current buffer is large enought for a full copy       
                BaseBuffer::Copy(from.GetAddress(),CurrentAddress(),btoread);
        }
        else btoread = 0u;
        
        fCurrent += btoread; return btoread;    
}


/*
UInt_t BufferIO::PeakUpFast(FILE *fd, UInt_t size_ext_buf)
{
        UInt_t btoread = size_ext_buf, bread;
        Long_t fpos = ::ftell(fd);bread = ::fread(fBufferIO+fCurrent,1,btoread,fd); ::fseek(fd,fpos,SEEK_SET);

        fCurrent += bread; return bread;        
}    
*/

UInt_t  BufferIO::Export(FILE *fd, UInt_t size_buf) const
{
        // if size asked is too high, reduce it to the effective size
        UInt_t bwritten = size_buf; 
        
        if ( size_buf > Size() ) 
                bwritten = Size();

        bwritten = (UInt_t)::fwrite(fBufferIO,1,bwritten,fd); fCurrent += bwritten; return bwritten;
}  

UInt_t  BufferIO::Import(std::istream &in, UInt_t size_ext_buf)
{
        UInt_t btoread = size_ext_buf;
                
        // if the current buffer is not large enought, try to expand it
        Bool_t oksize = true;
        if ( FreeSize() < size_ext_buf ) 
                oksize = Expand(size_ext_buf-FreeSize());
        
        if ( oksize ) { // the size of the current buffer is large enought for a full copy
                btoread = size_ext_buf;
                in.read(CurrentAddress(),btoread); btoread = UInt_t(in.gcount()); fCurrent += btoread;
        }
        else btoread = 0u;

        return btoread;
}  

UInt_t BufferIO::Export(std::ostream &out, UInt_t size_buf) const
{
        UInt_t bwritten = size_buf; 
        
        if ( size_buf > Size() ) 
                bwritten = Size();

        out.write(fBufferIO,bwritten); fCurrent += bwritten; return bwritten;
}  
        
Char_t *BufferIO::Unlink()
{
        Char_t *old = fOuter; fOuter = NULL; fRealOuterSize = 0u;

        // the inner buffer is ready to be processed 
        SetCurrent('i'); 
        fCurrent = 0u; fStatus = BaseBuffer::kGood;
                
        return old;
}  

EndianBufferIO::EndianBufferIO(UInt_t s) : BufferIO(s) 
{
//      printf("endian buffer allocated \n");
        if ( BaseBuffer::IsSysEndian(BaseBuffer::kBig) ) fEndian = BaseBuffer::kLittle;
        else fEndian = BaseBuffer::kBig;
}

EndianBufferIO::~EndianBufferIO() {;}