BitArrayBase.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.
 *  _________________________________________________________________________
 */

//
// BitArrayBase.h
//
#ifndef __BitArrayBase_h
#define __BitArrayBase_h

#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 "_generic.h"
#include "PackBuf.h"
#include "ClassRef.h"

#ifndef SWIG
// I'm not sure that this would work if BYTESIZE != 8
#define BYTESIZE 8      /* bits per char */
#define BIT(X,i)        (((X) & (char)(1 << ((i) & (BYTESIZE - 1)))) != 0)
#define SET_BIT(X,i)    ((X) |= (char)(1 << ((i) & (BYTESIZE - 1))))
#define RESET_BIT(X,i)  ((X) &= ~(char)(1 << ((i) & (BYTESIZE - 1))))

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


class UTILIB_API BitArrayBase;

class UTILIB_API BitArrayRef : public ArrayRef<char,BitArrayBase> {

public:

  BitArrayRef() : ArrayRef<char,BitArrayBase>() {array_len=0;}

  virtual void copy_data(BitArrayBase* array);
  virtual void reset_data(BitArrayBase* array);

  size_type array_len;
  void set_data(char* Data_, size_type Len_, size_type array_len_,
                                                        EnumDataOwned own_)
        {
        if (Len_ > 0)
           array_len = array_len_;
        else
           array_len = 0;
        ArrayRef<char,BitArrayBase>::set_data(Data_,Len_, own_);
        }

};
#endif //SWIG


#ifdef SWIG
class BitArrayBase {
#else
class UTILIB_API BitArrayBase {
#endif

  friend class ArrayRef<char,BitArrayBase>;
  friend class BitArrayRef;

public:

  BitArrayBase()
        {construct(0,0,0);}
#ifndef NON_ANSI
  explicit
#endif
  BitArrayBase(const size_type len, const size_type nbytes=0, char* d=(char*)0, 
                         const EnumDataOwned o=DataNotOwned)
        {construct(len,nbytes,d,o);}
  BitArrayBase(const BitArrayBase& array)
        {construct(array.array_len,array.Len, array.Data, AcquireOwnership);}
  virtual ~BitArrayBase()
        {free();}

  int shared_mem() const
        {return (shared != NULL);}
  int resize(const size_type num);
  size_type size() const
        {return array_len;}
  int len() const
        {return (int)size();}
  char* data() const
        {return Data;}
  int nrefs() const
        {if (shared) return shared->ref; else return 0;}

  BitArrayBase& operator=(const BitArrayBase& array);
  BitArrayBase& operator&=(const BitArrayBase& array);
  BitArrayBase& operator&=(BitArrayBase& array);
  BitArrayBase& operator=(const int value);
  BitArrayBase& operator<<(const BitArrayBase& vec);

  virtual void put(const size_type ndx, const int val) = 0;

  int operator==(const BitArrayBase& array) const;
  int operator!=(const BitArrayBase& array) const;
  int compare(const BitArrayBase& array) const;

  int operator>(const BitArrayBase&) const;
  int operator>=(const BitArrayBase&) const;

  int write(ostream& output) const;
  virtual int read(istream& input) = 0;
  int write(PackBuffer& output) const;
  int read(UnPackBuffer& input);        

protected:

  virtual int operator[](const size_type ndx) const = 0;
  char* Data;
  size_type Len;
  size_type array_len;
  BitArrayRef* shared;

  void construct(const size_type len, const size_type nbytes, 
                char *d, const EnumDataOwned o=DataNotOwned);
  void free();
  void set_shared_data(char *data, const size_type len_, 
                const size_type array_len_, const EnumDataOwned o=DataNotOwned);
  virtual int element_size() const = 0;
  void initialize(const size_type curr_array_len, 
                        const size_type new_array_len);

};
 

#ifndef SWIG
inline void BitArrayRef::copy_data(BitArrayBase* array)
{
array->array_len = array_len;
ArrayRef<char,BitArrayBase>::copy_data(array);
}

inline void BitArrayRef::reset_data(BitArrayBase* array)
{
array->array_len = 0;
ArrayRef<char,BitArrayBase>::copy_data(array);
}

inline UTILIB_API ostream& operator<<(ostream& output, const BitArrayBase& array)
{ array.write(output); return(output); }
 
inline UTILIB_API istream& operator>>(istream& input, BitArrayBase& array)
{ array.read(input); return(input); }
 
inline UTILIB_API PackBuffer& operator<<(PackBuffer& output, const BitArrayBase& array)
{ array.write(output); return(output); }
 
inline UTILIB_API UnPackBuffer& operator>>(UnPackBuffer& input, BitArrayBase& array)
{ array.read(input); return(input); }
#endif


#endif