Buffer.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.             *
 ***************************************************************************/

#include "Buffer.h"
#include <iostream>
 
using namespace Gws;
 
Buffer::Buffer(UInt_t s): fStatus(kBad), fEndian(Memory::kLittle), fBuffer(0), fSize(0), fCurrent(0)
{
//      if ( Memory::IsBytes(Memory::kBig) ) fEndian = Memory::kBig;
//      else fEndian = Memory::kLittle;
        
        fEndian = Memory::GetEndian(); Buffer::DoAlloc(s);
}

Buffer::~Buffer()
{
        if ( fBuffer != 0x0 ) { Memory::Delete(fBuffer); }
/*
  if ( fBuffer == 0x0 ) {
        if ( IsStatus(Buffer::kCorrupt) ) {
                std::cerr << " WARNING in Buffer::~Buffer() - the buffer has been corrupted \n " ;
        }
        if ( ! IsStatus(Buffer::kBad) ) { Memory::Delete(fBuffer); }
  } */
}
    
void Buffer::DoAlloc(UInt_t s) 
{
        // delete the previous one and allocate a new one that is fill with 0
        if ( fBuffer != 0x0 ) Memory::Delete(fBuffer); fBuffer = Memory::New(fBuffer,s+2);
        
        // cannot allocate memory 
        if ( fBuffer == 0x0 ) {  // becomes a bad buffer 
                fStatus = Buffer::kBad; fSize = 0; fCurrent = 0;                
        }
        else {
                fStatus = Buffer::kGood; fSize = s; fCurrent = 0; fBuffer[fSize] = fC1; fBuffer[fSize+1] = fC2;
        }
}

/*
void Buffer::Copy(Buffer &from, Buffer &to)
{

} */

Buffer * Buffer::New(Memory::EEndian e, UInt_t s)
{
        Buffer *b = 0x0;
        
        if ( e == Memory::GetEndian() ) { /* printf("Buffer allocated \n"); */ b = new Buffer(s); }
        else { /* printf("EndianBuffer allocated \n");*/ b = new EndianBuffer(s); }

        if ( b ) b->SetBytes(e); return b;
}

void Buffer::Reset()
{
        if ( fSize > 0 ) { Memory::Zero(fBuffer,fSize); fCurrent = 0; }
}

void Buffer::Reset(UInt_t newsize)
{
        DoAlloc(newsize);
}

UInt_t Buffer::SetOffset(UInt_t off) 
{ 
        UInt_t c = fCurrent;
        
        if ( off > fSize ) fCurrent = fSize;
        else fCurrent = off; 

        return c;
}

Bool_t Buffer::Expand(UInt_t add)
{
    Char_t *newbuf = 0x0; newbuf = Memory::New(newbuf,Size()+add+2);
        
        // cannot allocate the corresponding memory
        if ( newbuf == 0x0 ) return false; 
        
        // copy the content of the old buffer before deleting it
        ::memcpy(newbuf,fBuffer,Size()); Memory::Delete(fBuffer); fBuffer = newbuf; fSize = Size()+add; return true;
}

EndianBuffer::EndianBuffer(UInt_t s) : Buffer(s) 
{
//      printf("endian buffer allocated \n");
        if ( Memory::IsBytes(Memory::kBig) ) fEndian = Memory::kLittle;
        else fEndian = Memory::kBig;
}

EndianBuffer::~EndianBuffer() {;}