Buffer.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 GWS_BUFFER_H
#define GWS_BUFFER_H

#ifndef GWS_MEMORY_H
#include "Memory.h"
#endif

#include <iostream>
using namespace std;

namespace Gws {


class Buffer : protected Memory
{
public:
    enum EStatus { kBad = BIT(1), kGood = BIT(2), kEoB = BIT(3), kFail = BIT(4), kCorrupt = BIT(5) } ;

private:
    static const Char_t fC1 = 'E', fC2 = 'B';
    
protected:    
    Int_t       fStatus;
    Int_t       fEndian;
    
    Char_t *    fBuffer;
    UInt_t      fSize;
    UInt_t      fCurrent;
    
    void DoAlloc(UInt_t);
  
public:

    explicit Buffer(UInt_t s = 32 * KBYTE);
    virtual ~Buffer();
    

    // static void Copy(const Buffer &, Buffer &, Int_t);

    static Buffer * New(Memory::EEndian e, UInt_t s = 32 * KBYTE);

    bool IsStatus(Buffer::EStatus);
    void SetStatus(Buffer::EStatus);
    
    bool IsBytes(Memory::EEndian) const;
    void SetBytes(Memory::EEndian);
    

    Char_t *GetBuffer();
    UInt_t Size() const;
    UInt_t FreeSize() const;   
    UInt_t Offset() const;
    

    UInt_t SetOffset(UInt_t off = 0);
    

    virtual void Reset(); 
    virtual void Reset(UInt_t); 
    
    

    virtual Bool_t Expand(UInt_t);
    
    
    virtual Buffer &operator << (Char_t);
    virtual Buffer &operator << (UChar_t);
    virtual Buffer &operator << (Short_t);
    virtual Buffer &operator << (UShort_t);
    virtual Buffer &operator << (Int_t);
    virtual Buffer &operator << (UInt_t);
    virtual Buffer &operator << (Float_t);
    virtual Buffer &operator << (Double_t);    
//    virtual Buffer &operator << (long);
//    virtual Buffer &operator << (unsigned long);
    
    virtual Buffer &operator>> (Char_t &);
    virtual Buffer &operator>> (UChar_t &);
    virtual Buffer &operator>> (Short_t &);
    virtual Buffer &operator>> (UShort_t &);
    virtual Buffer &operator>> (Int_t &);
    virtual Buffer &operator>> (UInt_t &);
    virtual Buffer &operator>> (Float_t &);
    virtual Buffer &operator>> (Double_t &); 
//    virtual Buffer &operator>> (long &);
//    virtual Buffer &operator>> (unsigned long &);
};
// inline Buffer members
inline bool Buffer::IsStatus(Buffer::EStatus s) { 
        if ( s == Buffer::kCorrupt )
                if ( fBuffer[fSize] != fC1 && fBuffer[fSize+1] != fC2 )  fStatus |= Buffer::kCorrupt;
        return fStatus & s; 
}
inline void Buffer::SetStatus(Buffer::EStatus s) { fStatus = s; }
inline bool Buffer::IsBytes(Memory::EEndian e) const { return fEndian == e; }
inline void Buffer::SetBytes(Memory::EEndian e)  { fEndian = e; }
inline Char_t * Buffer::GetBuffer() { return fBuffer ; }
inline UInt_t Buffer::Size() const { return fSize; }
inline UInt_t Buffer::Offset() const { return fCurrent ; }
inline UInt_t Buffer::FreeSize() const { return fSize - fCurrent; }       
inline Buffer &Buffer::operator << (Char_t data) { 
        if (FreeSize()>=sizeof(Char_t)) { ::memcpy((fBuffer+fCurrent),&data,sizeof(Char_t)); fCurrent += sizeof(Char_t); }
        else fStatus = Buffer::kFail ;
        return (*this);
}
inline Buffer &Buffer::operator << (UChar_t data){ 
        if (FreeSize()>=sizeof(Char_t)) { ::memcpy((fBuffer+fCurrent),&data,sizeof(UChar_t)); fCurrent += sizeof(Char_t); }
        else fStatus = Buffer::kFail ;  
        return (*this);
}
inline Buffer &Buffer::operator << (Short_t data) {
        if (FreeSize()>=sizeof(Short_t)) { ::memcpy((fBuffer+fCurrent),&data,sizeof(Short_t)); fCurrent += sizeof(Short_t); }
        else fStatus = Buffer::kFail ;
        return (*this);
}
inline Buffer &Buffer::operator << (UShort_t data){
        if (FreeSize()>=sizeof(Short_t)) { ::memcpy((fBuffer+fCurrent),&data,sizeof(UShort_t)); fCurrent += sizeof(UShort_t); }
        else fStatus = Buffer::kFail ;
        return (*this); 
}
inline Buffer &Buffer::operator << (Int_t data) {
        if (FreeSize()>=sizeof(Int_t)) { ::memcpy((fBuffer+fCurrent),&data,sizeof(Int_t)); fCurrent += sizeof(Int_t); }
        else fStatus = Buffer::kFail ;
        return (*this);
}
inline Buffer &Buffer::operator << (UInt_t data){
        if (FreeSize()>=sizeof(Int_t)) { ::memcpy((fBuffer+fCurrent),&data,sizeof(UInt_t)); fCurrent += sizeof(UInt_t); }
        else fStatus = Buffer::kFail ;
        return (*this); 
}
inline Buffer &Buffer::operator << (Float_t data) { 
        if (FreeSize()>=sizeof(Float_t)) { ::memcpy((fBuffer+fCurrent),&data,sizeof(Float_t)); fCurrent += sizeof(Float_t); }
        else fStatus = Buffer::kFail ;
        return (*this); 
}
inline Buffer &Buffer::operator << (Double_t data) {
        if (FreeSize()>=sizeof(Double_t)) { ::memcpy((fBuffer+fCurrent),&data,sizeof(Double_t));fCurrent += sizeof(Double_t); }
        else fStatus = Buffer::kFail ;
        return (*this); 
}
/*
inline Buffer &Buffer::operator << (long data){ 
        if (FreeSize()>=sizeof(long)) { Memory::Copy((Char_t*)&data,(fBuffer+fCurrent),sizeof(long));fCurrent += sizeof(long); }
        else fStatus = Buffer::kFail ;
        return (*this); 
}
inline Buffer &Buffer::operator << (unsigned long data) {
        if (FreeSize()>=sizeof(long)) { Memory::Copy((Char_t*)&data,(fBuffer+fCurrent),sizeof(long));fCurrent += sizeof(long); }
        else fStatus = Buffer::kFail ;// inline Buffer members
        return (*this);
}*/

inline Buffer &Buffer::operator >> (Char_t &data){
        if (FreeSize()>=sizeof(Char_t)) { ::memcpy(&data,fBuffer+fCurrent,sizeof(Char_t));fCurrent += sizeof(Char_t); }
        else fStatus = Buffer::kFail ;  
        return (*this); 
}
inline Buffer &Buffer::operator >> (UChar_t &data){
        if (FreeSize()>=sizeof(Char_t)) { ::memcpy(&data,fBuffer+fCurrent,sizeof(UChar_t));fCurrent += sizeof(UChar_t); }
        else fStatus = Buffer::kFail ;  
        return (*this); 
}
inline Buffer &Buffer::operator >> (Short_t &data){
        if (FreeSize()>=sizeof(Short_t)) { ::memcpy(&data,fBuffer+fCurrent,sizeof(Short_t));fCurrent += sizeof(Short_t); }
        else fStatus = Buffer::kFail ;  
        return (*this); 
}
inline Buffer &Buffer::operator >> (UShort_t &data){
        if (FreeSize()>=sizeof(Short_t)) { ::memcpy(&data,fBuffer+fCurrent,sizeof(UShort_t));fCurrent += sizeof(UShort_t); }
        else fStatus = Buffer::kFail ;  
        return (*this); 
}
inline Buffer & Buffer::operator >> (Int_t &data){
        if (FreeSize()>=sizeof(Int_t)) { ::memcpy(&data,fBuffer+fCurrent,sizeof(Int_t));fCurrent += sizeof(Int_t); }
        else fStatus = Buffer::kFail ;  
        return (*this) ;
}
inline Buffer &Buffer::operator >> (UInt_t &data){
        if (FreeSize()>=sizeof(Int_t)) { ::memcpy(&data,fBuffer+fCurrent,sizeof(UInt_t));fCurrent += sizeof(UInt_t); }
        else fStatus = Buffer::kFail ;  
        return (*this); 
}
inline Buffer &Buffer::operator >> (Float_t &data){
        if (FreeSize()>=sizeof(Float_t)) { ::memcpy(&data,fBuffer+fCurrent,sizeof(Float_t));fCurrent += sizeof(Float_t); }
        else fStatus = Buffer::kFail ;  
        return (*this); 
}
inline Buffer &Buffer::operator >> (Double_t &data){
        if (FreeSize()>=sizeof(Double_t)) { ::memcpy(&data,fBuffer+fCurrent,sizeof(Double_t));fCurrent += sizeof(Double_t); }
        else fStatus = Buffer::kFail ;  
        return (*this); 
}

// inline Buffer members //////////////////////////


class EndianBuffer : public Buffer
{  
public:
    EndianBuffer(UInt_t s = 32 * KBYTE);
    virtual ~EndianBuffer();

    virtual Buffer &operator << (Char_t) ;
    virtual Buffer &operator << (UChar_t);
    virtual Buffer &operator << (Short_t);
    virtual Buffer &operator << (UShort_t);
    virtual Buffer &operator << (Int_t);
    virtual Buffer &operator << (UInt_t);
    virtual Buffer &operator << (Float_t);
    virtual Buffer &operator << (Double_t); 
//    virtual Buffer &operator << (long);
//     virtual Buffer &operator << (unsigned long);   

    virtual Buffer &operator >> (Char_t &);
    virtual Buffer &operator >> (UChar_t &);    
    virtual Buffer &operator >> (Short_t &);
    virtual Buffer &operator >> (UShort_t &);
    virtual Buffer &operator >> (Int_t &);
    virtual Buffer &operator >> (UInt_t &);
    virtual Buffer &operator >> (Float_t &);
    virtual Buffer &operator >> (Double_t &);
//     virtual Buffer &operator >> (long &);
//     virtual Buffer &operator >> (unsigned long &);
};
// inline EndianBuffer members
inline Buffer &EndianBuffer::operator << (Char_t data)  { return Buffer::operator << (data) ;}
inline Buffer &EndianBuffer::operator << (UChar_t data) { return Buffer::operator << (data); }    
inline Buffer &EndianBuffer::operator << (Short_t data) {
        if (FreeSize()>=sizeof(Short_t)) { Memory::Swap(data,fBuffer+fCurrent);fCurrent += sizeof(Short_t); }
        else fStatus = Buffer::kFail ;
        return (*this);
}
inline Buffer &EndianBuffer::operator << (UShort_t data){
        if (FreeSize()>=sizeof(Short_t)) { Memory::Swap(data,fBuffer+fCurrent); fCurrent += sizeof(Short_t); }
        else fStatus = Buffer::kFail ;
        return (*this); 
}
inline Buffer &EndianBuffer::operator << (Int_t data) {
        if (FreeSize()>=sizeof(Int_t)) { Memory::Swap(data,fBuffer+fCurrent);fCurrent += sizeof(Int_t); }
        else fStatus = Buffer::kFail ;
        return (*this);
}
inline Buffer &EndianBuffer::operator << (UInt_t data){
        if (FreeSize()>=sizeof(Int_t)) { Memory::Swap(data,fBuffer+fCurrent);fCurrent += sizeof(Int_t); }
        else fStatus = Buffer::kFail ;
        return (*this); 
}

inline Buffer &EndianBuffer::operator << (Float_t data) { 
        if (FreeSize()>=sizeof(Float_t)) { Memory::Swap(data,fBuffer+fCurrent); fCurrent += sizeof(Float_t); }
        else fStatus = Buffer::kFail ;
        return (*this); 
}
inline Buffer &EndianBuffer::operator << (Double_t data) {
        if (FreeSize()>=sizeof(Double_t)){  Memory::Swap(data,fBuffer+fCurrent);fCurrent += sizeof(Double_t); }
        else fStatus = Buffer::kFail ;
        return (*this); 
}
/*
inline Buffer &EndianBuffer::operator << (long data){ 
        if (FreeSize()>=sizeof(long)) { Memory::Swap(data,fBuffer+fCurrent);fCurrent += sizeof(long); }
        else fStatus = Buffer::kFail ;
        return (*this); 
}
inline Buffer &EndianBuffer::operator << (unsigned long data) {
        if (FreeSize()>=sizeof(long)){  Memory::Swap(data,fBuffer+fCurrent);fCurrent += sizeof(long); }
        else fStatus = Buffer::kFail ;
        return (*this);
}
*/
inline Buffer &EndianBuffer::operator >> (Char_t &data)  { return Buffer::operator >> (data) ;}
inline Buffer &EndianBuffer::operator >> (UChar_t &data) { return Buffer::operator >> (data); }    
inline Buffer &EndianBuffer::operator >> (Short_t &data){
        if (FreeSize()>=sizeof(Short_t)){ Memory::Swap(fBuffer+fCurrent,data); fCurrent += sizeof(Short_t); }
        else fStatus = Buffer::kFail ;  
        return (*this); 
}
inline Buffer &EndianBuffer::operator >> (UShort_t &data){
        if (FreeSize()>=sizeof(Short_t)){  Memory::Swap(fBuffer+fCurrent,data);fCurrent += sizeof(Short_t); }
        else fStatus = Buffer::kFail ;  
        return (*this); 
}
inline Buffer &EndianBuffer::operator >> (Int_t &data){
        if (FreeSize()>=sizeof(Int_t)){ Memory::Swap(fBuffer+fCurrent,data);  fCurrent += sizeof(Int_t); }
        else fStatus = Buffer::kFail ;  
        return (*this); 
}
inline Buffer &EndianBuffer::operator >> (UInt_t &data){
        if (FreeSize()>=sizeof(Int_t)){  Memory::Swap(fBuffer+fCurrent,data);fCurrent += sizeof(Int_t); }
        else fStatus = Buffer::kFail ;  
        return (*this); 
}
/*
inline Buffer &EndianBuffer::operator >> (long &data){
        if (FreeSize()>=sizeof(long)){  Memory::Swap(fBuffer+fCurrent,data); fCurrent += sizeof(long); }
        else fStatus = Buffer::kFail ;  
        return (*this); 
}
inline Buffer &EndianBuffer::operator >> (unsigned long &data){
        if (FreeSize()>=sizeof(long)){  Memory::Swap(fBuffer+fCurrent,data); fCurrent += sizeof(long); }
        else fStatus = Buffer::kFail ;  
        return (*this); 
}
*/
inline Buffer &EndianBuffer::operator >> (Float_t &data){
        if (FreeSize()>=sizeof(Float_t)){  Memory::Swap(fBuffer+fCurrent,data); fCurrent += sizeof(Float_t); }
        else fStatus = Buffer::kFail ;  
        return (*this); 
}
inline Buffer &EndianBuffer::operator >> (Double_t &data){
        if (FreeSize()>=sizeof(Double_t)){  Memory::Swap(fBuffer+fCurrent,data); fCurrent += sizeof(Double_t); }
        else fStatus = Buffer::kFail ;  
        return (*this); 
}
}; // gws

#endif