MCFmpBase.h

Go to the documentation of this file.

// MCFmpBase.h
//////////////////////////////////////////////////////////////////////
//          (c) Copyright 2001-2002 Brown Deer Technology, LLC.
//                        All rights reserved.
//////////////////////////////////////////////////////////////////////

#ifndef MCFMPBASE_H
#define MCFMPBASE_H

#ifdef USE_STD
#include <vector>
using namespace std;
#else
#include <vector.h>
#endif

#include "utility.h"

class MCFmpBase 
{
   public:

      MCFmpBase( 
         const int bplen_mpsizeb, const int bplen_coef,
         const int bplen_n, const int bplen_a
      );
      MCFmpBase( 
         const int bplen_mpsizeb, const int bplen_coef, 
         const int bplen_n
      );
      virtual ~MCFmpBase();

      virtual void set( 
         const int bplen_mpsizeb, const int bplen_coef, 
         const int bplen_n, const int bplen_a
      );
      virtual void set( 
         const int bplen_mpsizeb, const int bplen_coef, 
         const int bplen_n
      );
      virtual void set( const char mcode, const int n );
      virtual void set( const char mcode );
      virtual void set( const int n );
      virtual void set();
      virtual void set(void*);

      virtual void clear();

      virtual void push_back( const char );
      virtual void push_back( bytepack& );

      void write( ostream& os );
      void read( istream& is );

      int mpsizeb();

      bool empty();
      bool null();

      int arraydim() { return _arraydim; }
      int bplen_mpsizeb() { return _bplen_mpsizeb; }
      int bplen_coef() {  return _bplen_coef; }
      int bplen_n() { return _bplen_n; }
      int bplen_a() { return _bplen_a; }

      char mcode();
      int m();
      int sw();
      int rs();
      int order();

      int n();

      int mcode_to_m( const char );
      int mcode_to_sw( const char );
      int mcode_to_rs( const char );
      int mcode_to_order( const char );

   protected:

      int _arraydim;
      int _bplen_mpsizeb;
      int _bplen_coef;
      int _bplen_n;
      int _bplen_a;

      int _mpsizeb;

      char _mcode;
      int _n;

      vector<char>* _data;

      bool _null;

   private:
      MCFmpBase() {}

   friend 
   ostream& operator << ( ostream&, MCFmpBase& );

   friend 
   istream& operator >> ( istream&, MCFmpBase& );

};

inline
void MCFmpBase::set( const char mcode ) 
{ 
   _mcode = mcode; 
   _null = 0;
}

inline
void MCFmpBase::set( const int n ) 
{ 
  _n = n; 
  _null = 0;
}

inline
void MCFmpBase::set( const char mcode, const int n )
{
   set(mcode);
   set(n);
  _null = 0;
}

inline
void MCFmpBase::set() { _null = 0; }

inline
void MCFmpBase::set(void*) { _null = 1; }

inline
void MCFmpBase::clear() 
{
   if ( _data != 0 ) { delete _data; _data = 0; } 
   _data = new vector<char>;
}

inline
void MCFmpBase::push_back(const char c) { (*_data).push_back(c); };

inline
void MCFmpBase::push_back( bytepack& bp ) 
{ 
   for( int i = 0; i < bp.size(); i++ ) { (*_data).push_back(bp[i]); }
}

inline
bool MCFmpBase::null() { return _null; }

inline
bool MCFmpBase::empty() { return ( (*_data).size() == 0 ); }

inline
char MCFmpBase::mcode() { return _mcode; };

inline
int MCFmpBase::m() { return mcode_to_m( _mcode ); }

inline
int MCFmpBase::sw() { return mcode_to_sw( _mcode ); }

inline
int MCFmpBase::rs() { return mcode_to_rs( _mcode ); }

inline
int MCFmpBase::order() { return mcode_to_order( _mcode ); }

inline
int MCFmpBase::n() { return _n; };

inline
int MCFmpBase::mcode_to_m( const char mcode ) 
{ 
   return int( (unsigned char)( 0x1F & mcode ) ); 
};

inline
int MCFmpBase::mcode_to_sw( const char mcode ) 
{ 
   return int( (unsigned char)( ( 0x80 & mcode ) >> 7 ) ); 
};

inline
int MCFmpBase::mcode_to_rs( const char mcode ) 
{ 
   return ( ( 0x40 & mcode ) >> 6 ); 
};

inline
int MCFmpBase::mcode_to_order( const char mcode ) 
{ 
   return int( (unsigned char)( ( 0x20 & mcode ) >> 5 ) ); 
};

#endif

---