EnumBitArray.h

/*  _________________________________________________________________________
 *
 *  UTILIB: A utility library for developing portable C++ codes.
 *  Copyright (c) 2001, Sandia National Laboratories.
 *  This software is distributed under the GNU Lesser General Public License.
 *  For more information, see the README file in the top UTILIB directory.
 *  _________________________________________________________________________
 */

//
// EnumBitArray.h
//
#ifndef __EnumBitArray
#define __EnumBitArray

#ifdef __GNUC__
#pragma interface
#endif

#ifdef NON_ANSI
#include <iostream.h>
#else
#include <iostream>
using namespace std;
#endif
#ifndef ANSI_HDRS
#include <math.h>
#else
#include <cmath>
#endif
#include "BitArrayBase.h"

// I'm not sure that this would work if BYTESIZE != 8
#define BYTESIZE 8      /* bits per char */

#if !defined(EnumBitArraySanityChecking)
#define EnumBitArraySanityChecking      1
#endif


template <class T>
class UTILIB_API EnumBitArray : public BitArrayBase {

public:

  EnumBitArray() : BitArrayBase() {}
  EnumBitArray(const size_type len, const size_type nbytes=0, char* d=(char*)0, 
                         const EnumDataOwned o=DataNotOwned)
                {construct(len,
                        (nbytes==0 ?  (len+BYTESIZE-1)/(BYTESIZE/element_size())                                
                                   : nbytes), 
                        d,o); }
  EnumBitArray(const EnumBitArray& array)
                : BitArrayBase(array) {}

  T operator()(const size_type idx) const;
  void put(const size_type idx, const T val);
  EnumBitArray<T>& operator=(const T value);

  int write(ostream& input) const;
  int read(istream& input);

protected:

  int operator[](const size_type idx) const;
  void put(const size_type , const int ) {}
  int element_size() const
                {return enum_count;}

  static int   enum_count;
  static char  enum_labels[];
  static T     enum_vals[];

};
 

template <class T>
inline int EnumBitArray<T>::operator[](const size_type idx) const
{
#if (EnumBitArraySanityChecking==1)
if (idx >= array_len)
   ErrAbort(errmsg("EnumBitArray<T>::operator() : iterator out of range. idx=%d len=%d",idx,array_len));
#endif

unsigned char X = Data[(2*idx)/BYTESIZE];
size_type i = 2*idx;
unsigned char val = (X & (char)(3 << (i & (BYTESIZE - 1))));
val = val >> (i & (BYTESIZE - 1));

return (int)val;
}
 

template <class T>
inline T EnumBitArray<T>::operator()(const size_type idx) const
{ return (T) operator[](idx); }
 

template <class T>
inline void EnumBitArray<T>::put(const size_type idx, const T val)
{
#if (EnumBitArraySanityChecking==1)
if (idx >= array_len)
   ErrAbort(errmsg("EnumBitArray<T>::put : iterator out of range. idx=%d len=%d",idx,array_len));
#endif

int tval = (int)val;
unsigned char X = Data[(2*idx)/BYTESIZE];
size_type i = 2*idx;
unsigned char qwerty = (3 << (i & (BYTESIZE - 1)));
unsigned char qwertydata = X & qwerty;
X ^= qwertydata;
X |= ((tval & 3) << (i & (BYTESIZE - 1)));
Data[(2*idx)/BYTESIZE] = X;
}


//
// This only works for element_size() <= 4 right now...
//
template <class T>
int EnumBitArray<T>::read(istream& s)
{
  size_type i;
  char c;

  if (Data) {// size is known
     for (i=0; i<array_len; i++) {
       s.get(c);
       while (s && ((c == ' ') || (c == '\t') || (c == '\n')))
         s.get(c);
       int j;
       for (j=0; j<element_size(); j++)
         if (c == enum_labels[j]) break;
       if (j<element_size())
          put(i,enum_vals[j]);
       else {
          ErrAbort(errmsg("TwoBitArray::read : Bad input value: %c.",c));
          break;
          }
       }
     }

  else                  // size and sparseity is not known
    ErrAbort( "TwoBitArray::read: size and sparseity not known" );

  return OK ;
}



template <class T>
int EnumBitArray<T>::write(ostream& s) const
{
s << array_len << ": ";
if (Data) {
   for (size_type i=0; i<array_len; i++)
     s << enum_labels[(int)(operator()(i))];
   }

return OK ;
}


template <class T>
EnumBitArray<T>& EnumBitArray<T>::operator=(const T val)
{
BitArrayBase::operator=((int)val);
return *this;
}

#endif