In This Package:

RawBuffer.cc

Go to the documentation of this file.

#include "RawData/RawBuffer.h"
#include <string.h>
#include <cstdlib>

DayaBay::RawBuffer::RawBuffer()
  : m_buffer(0),
    m_bufferSize(0),
    m_isOwner(false)
{
  // Default constructor
}

DayaBay::RawBuffer::RawBuffer(unsigned int* buffer,
                              bool isOwner/*=false*/, 
                              unsigned int bufferSize/*=0*/)
  : m_buffer(buffer),
    m_bufferSize(bufferSize),
    m_isOwner(isOwner)
{
  // Standard constructor
}

DayaBay::RawBuffer::RawBuffer(DayaBay::RawBuffer& buffer,
                              bool adopt/*=false*/)
  : m_buffer(0),
    m_bufferSize(0),
    m_isOwner(false)
{
  // Construct from another RawBuffer
  // If adopt==true, then take over ownership of the 
  // memory buffer (if the input buffer is the current owner)
  m_buffer = buffer.buffer();
  m_isOwner = false;
  m_bufferSize = buffer.bufferSize();
  if(adopt && buffer.isOwner()){
    // Make new RawBuffer the owner of this memory
    m_isOwner = true;
    buffer.setOwner(false);
  }
}


DayaBay::RawBuffer::~RawBuffer()
{
  // Destructor
  if(m_isOwner && m_buffer) free(m_buffer);
  m_buffer=0;
  m_bufferSize=0;
  m_isOwner=false;
}

unsigned int* DayaBay::RawBuffer::buffer() const
{
  // Return the pointer to the internal memory buffer
  return m_buffer;
}

unsigned int DayaBay::RawBuffer::bufferSize() const
{
  // Return the allocated size of the internal memory buffer, if known
  return m_bufferSize;
}

bool DayaBay::RawBuffer::isOwner() const
{
  // Does this RawBuffer own this memory buffer?
  return m_isOwner;
}

void DayaBay::RawBuffer::setOwner(bool isOwner/*=true*/){
  m_isOwner = isOwner;
}

bool DayaBay::RawBuffer::isValid() const
{
  // Does this RawBuffer contain data?
  return (m_buffer != 0);
}

unsigned int* DayaBay::RawBuffer::getPointer(const unsigned int& line) const
{
  // Return a pointer to a specific line in the data block
  if(m_bufferSize>0 && line>=m_bufferSize) return 0;
  return (m_buffer + line);
}

unsigned int DayaBay::RawBuffer::getValue(const unsigned int& line,
                                          const unsigned int& firstBit/*=0*/,
                                          const unsigned int& bitLength/*=32*/)   const
{
  // Read a value from the memory buffer
  // line = line number in the memory block (line = integer length)
  // firstBit = first bit to read (max=31)
  // bitLength =  length of bits to read (max=32)
  if(bitLength>32 || firstBit>31) return 0;
  unsigned int* pointer = this->getPointer(line);
  if(!pointer) return 0;
  // Catch request for full line
  if(firstBit==0 && bitLength==32) return *pointer;
  // Prepare bit mask
  unsigned int oneBit = 0x1;
  unsigned int mask = 0;
  for(unsigned int shift=0; shift<bitLength; shift++) 
    mask += (oneBit << shift);
  // Shift value, mask, and return
  return (*pointer >> firstBit) & mask;
}

char* DayaBay::RawBuffer::getString(const unsigned int& line,
                                    const unsigned int& byteOffset/*=0*/) const
{
  // Return a char pointer to a specific byte in the data block
  // line = line number in the memory block (line = integer length)
  // byteOffset = offset if string starts at an uneven byte position (max=3)
  if(byteOffset>3) return 0;
  unsigned int* pointer = this->getPointer(line);
  if(!pointer) return 0;
  return (char*)(pointer + byteOffset);
}

---