evBitBuffer.h

Go to the documentation of this file.

/*
 *
 * EVITA: Efficient Visualization of Terascale Datasets
 * Copyright (C) 2000-2016  Team Evita
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 * 
 * This library 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
 * Library General Public License for more details.
 * 
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 675 Mass Ave, Cambridge,
 * MA 02139, USA.
 *
 */


#ifndef __evBitBuffer_h
#define __evBitBuffer_h


#include "evFile.h"
#include "evBit.h"
#include "evVector.h"
#include "evBoundingBox.h"


class evBitBuffer : public evFile
{
public:
  evBitBuffer(void);
  virtual ~evBitBuffer(void);
  
  virtual const evString GetClassName(void) const
  {
    return(evString("evBitBuffer"));
  }
  
  QccBitBuffer *GetBitBuffer(void);
  const QccBitBuffer *GetBitBuffer(void) const;

  int Start(void);
  int End(void);
  int Flush(void);

  int Read(evBit &val);
  int Read(unsigned char &val);
  int Read(int &val);
  int Read(float &val);
  int Read(double &val);
  int Read(evVector &val);
  int Read(evAddress &val);
  int Read(evBoundingBox &bounding_box);

  int Write(const evBit val);
  int Write(const unsigned char val);
  int Write(const int val);
  int Write(const float val);
  int Write(const double val);
  int Write(const evVector &val);
  int Write(const evAddress &val);
  int Write(const evBoundingBox &bounding_box);

  int GetBitCount(void);

protected:
  
private:
  QccBitBuffer BitBuffer;

};


inline QccBitBuffer *evBitBuffer::GetBitBuffer(void)
{
  return(&this->BitBuffer);
}


inline const QccBitBuffer *evBitBuffer::GetBitBuffer(void) const
{
  return(&this->BitBuffer);
}


inline evBitBuffer::evBitBuffer(void)
{
  QccBitBufferInitialize(&(this->BitBuffer));
}


inline evBitBuffer::~evBitBuffer(void)
{
}


inline int evBitBuffer::Read(evBit &val)
{
  int bit;

  if (QccBitBufferGetBit(&this->BitBuffer,
                         &bit))
    {
      ErrorHandler.ErrorMessage("evBitBuffer::Read(): Error calling QccBitBufferGetBit()");
      return(1);
    }

  val = evBit(bit);

  return(0);
}


inline int evBitBuffer::Read(unsigned char &val)
{
  if (QccBitBufferGetChar(&this->BitBuffer,
                          &val))
    {
      ErrorHandler.ErrorMessage("evBitBuffer::Read(): Error calling QccBitBufferGetChar()");
      return(1);
    }

  return(0);
}


inline int evBitBuffer::Read(int &val)
{
  if (QccBitBufferGetInt(&this->BitBuffer,
                         &val))
    {
      ErrorHandler.ErrorMessage("evBitBuffer::Read(): Error calling QccBitBufferGetInt()");
      return(1);
    }

  return(0);
}


inline int evBitBuffer::Read(float &val)
{
  double val2;

  if (QccBitBufferGetDouble(&this->BitBuffer,
                            &val2))
    {
      ErrorHandler.ErrorMessage("evBitBuffer::Read(): Error calling QccBitBufferGetDouble()");
      return(1);
    }

  val = (float)val2;

  return(0);
}


inline int evBitBuffer::Read(double &val)
{
  if (QccBitBufferGetDouble(&this->BitBuffer,
                            &val))
    {
      ErrorHandler.ErrorMessage("evBitBuffer::Read(): Error calling QccBitBufferGetDouble()");
      return(1);
    }

  return(0);
}


inline int evBitBuffer::Read(evVector &val)
{
  for (unsigned int component = 0; component < val.Dimension(); component++)
    if (this->Read(val[component]))
      {
        ErrorHandler.ErrorMessage("evBitBuffer::Read(): Error calling evBitBuffer::Read()");
        return(1);
      }

  return(0);
}


inline int evBitBuffer::Read(evAddress &val)
{
  for (unsigned int component = 0;
       component < val.GetNumDimensions(); component++)
    {
      int val2;
      
      if (this->Read(val2))
        {
          ErrorHandler.ErrorMessage("evBitBuffer::Read(): Error calling evBitBuffer::Read()");
          return(1);
        }

      val.Set(val2, component);
    }

  return(0);
}


inline int evBitBuffer::Read(evBoundingBox &bounding_box)
{
  unsigned int num_dimensions =
    bounding_box.GetLowerBound().Dimension();

  evVector lower_bound(num_dimensions);
  evVector upper_bound(num_dimensions);

  if (this->Read(lower_bound))
    {
      ErrorHandler.ErrorMessage("evBitBuffer::Read(): Error calling evBitBuffer::Read()");
      return(1);
    }
  if (this->Read(upper_bound))
    {
      ErrorHandler.ErrorMessage("evBitBuffer::Read(): Error calling evBitBuffer::Read()");
      return(1);
    }

  bounding_box.SetBounds(lower_bound, upper_bound);

  return(0);
}


inline int evBitBuffer::Write(const evBit val)
{
  if (QccBitBufferPutBit(&this->BitBuffer,
                         val.GetBit()))
    {
      ErrorHandler.ErrorMessage("evBitBuffer::Write(): Error calling QccBitBufferPutBit()");
      return(1);
    }

  return(0);
}


inline int evBitBuffer::Write(const unsigned char val)
{
  if (QccBitBufferPutChar(&this->BitBuffer,
                          val))
    {
      ErrorHandler.ErrorMessage("evBitBuffer::Write(): Error calling QccBitBufferPutChar()");
      return(1);
    }

  return(0);
}


inline int evBitBuffer::Write(const int val)
{
  if (QccBitBufferPutInt(&this->BitBuffer,
                         val))
    {
      ErrorHandler.ErrorMessage("evBitBuffer::Write(): Error calling QccBitBufferPutInt()");
      return(1);
    }

  return(0);
}


inline int evBitBuffer::Write(const float val)
{
  if (QccBitBufferPutDouble(&this->BitBuffer,
                            (double)val))
    {
      ErrorHandler.ErrorMessage("evBitBuffer::Write(): Error calling QccBitBufferPutDouble()");
      return(1);
    }

  return(0);
}


inline int evBitBuffer::Write(const double val)
{
  if (QccBitBufferPutDouble(&this->BitBuffer,
                            val))
    {
      ErrorHandler.ErrorMessage("evBitBuffer::Write(): Error calling QccBitBufferPutDouble()");
      return(1);
    }

  return(0);
}


inline int evBitBuffer::Write(const evVector &val)
{
  for (unsigned int component = 0; component < val.Dimension(); component++)
    if (this->Write(val[component]))
      {
        ErrorHandler.ErrorMessage("evBitBuffer::Write(): Error calling evBitBuffer::Write()()");
        return(1);
      }

  return(0);
}


inline int evBitBuffer::Write(const evAddress &val)
{
  for (unsigned int component = 0;
       component < val.GetNumDimensions(); component++)
    {
      int val2 = val.Get(component);

      if (this->Write(val2))
        {
          ErrorHandler.ErrorMessage("evBitBuffer::Write(): Error calling evBitBuffer::Write()");
          return(1);
        }
    }

  return(0);
}


inline int evBitBuffer::Write(const evBoundingBox &bounding_box)
{
  if (this->Write(bounding_box.GetLowerBound()))
    {
      ErrorHandler.ErrorMessage("evBitBuffer::Write(): Error calling evBitBuffer::Write()");
      return(1);
    }
  if (this->Write(bounding_box.GetUpperBound()))
    {
      ErrorHandler.ErrorMessage("evBitBuffer::Write(): Error calling evBitBuffer::Write()");
      return(1);
    }
  return(0);
}


inline int evBitBuffer::GetBitCount(void)
{
  return(this->BitBuffer.bit_cnt);
}


#endif