Darray.h

Go to the documentation of this file.

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

#ifndef DARRAY_H
#define DARRAY_H

// class template Darray< Logic_t >

template<class Logic_t>
class Darray {
   public:
      typedef Logic_t DataType;
      Darray( const int Size );
      Darray( const Darray& rhs );
      ~Darray();
      Darray& operator=( const Darray& rhs );
      Logic_t& operator[](const int i) { return _data[i]; }
      int Size() { return _Size; }
   private:
      int _Size;
      Logic_t* _data;
};

template<class Logic_t>
inline Darray<Logic_t>::Darray( const int Size ) 
{ 
   _Size = Size; 
   _data = new Logic_t[ _Size ]; 
}

template<class Logic_t>
inline Darray<Logic_t>::Darray(const Darray& rhs ) 
  : _Size( rhs._Size ) 
{
   _data = new Logic_t[ _Size ];
   for( int i = 0; i < _Size; i++ ) _data[i] = rhs._data[i];
}

template<class Logic_t>
inline Darray<Logic_t>::~Darray() 
{ 
   if ( _data != 0 ) { delete [] _data; _data = 0; } 
}

template<class Logic_t>
inline Darray<Logic_t>& Darray<Logic_t>::operator=( const Darray& rhs ) {
   if ( this != &rhs ) {
      _Size = rhs._Size;
      for( int i = 0; i <= rhs._Size; i++ ) _data[i] = rhs._data[i];
   }
   return *this;
}

template<class Logic_t>
typename Darray<Logic_t>::DataType All( Darray<Logic_t>& a ) {
   typename Darray<Logic_t>::DataType tmp;
   tmp = 1;
   for( int i = 0; i< a.Size(); i++ ) tmp &= a[i];
   return tmp;
};

template<class Logic_t>
typename Darray<Logic_t>::DataType Any( Darray<Logic_t>& a ) {
   typename Darray<Logic_t>::DataType tmp;
   tmp = 0;
   for( int i=0; i < a.Size(); i++ ) tmp |= a[i];
   return tmp;
};

template<class Logic_t>
typename Darray<Logic_t>::DataType 
  MAll( const bool* mask, Darray<Logic_t>& a ) {
   typename Darray<Logic_t>::DataType tmp;
   tmp = 1;
   for( int i = 0; i < a.Size(); i++) if (mask[i]) tmp &= a[i];
   return tmp;
};

template<class Logic_t>
typename Darray<Logic_t>::DataType 
  MAny( const bool& mask, Darray<Logic_t>& a ) {
   typename Darray<Logic_t>::DataType tmp;
   tmp = 0;
   for( int i = 0; i < a.Size(); i++ ) if ( mask[i] ) tmp |= a[i];
   return tmp;
};

// function templates

template<class Logic_t>
Darray<Logic_t> Not(Darray<Logic_t>& a ) {
   Darray<Logic_t> tmp( a.Size() );
   for( int i = 0; i < a.Size(); i++) tmp[i] = ~a[i] ;
   return tmp;
};

template<class Logic_t>
Darray<Logic_t> And( Darray<Logic_t>& a, Darray<Logic_t>& b ) {
   Darray<Logic_t> tmp( a.Size() );
   for( int i = 0; i < a.Size(); i++ ) tmp[i] = a[i] & b[i] ;
   return tmp;
};

template<class Logic_t>
Darray<Logic_t> Or( Darray<Logic_t>& a, Darray<Logic_t>& b ) {
   Darray<Logic_t> tmp( a.Size() );
   if ( a.Size() == b.Size() ) {
   for( int i = 0; i < a.Size(); i++ ) tmp[i] = a[i] | b[i] ;
   } else {
      for( int i = 0; i < a.Size(); i++ ) tmp[i] = 0;
   }
   return tmp;
};

template<class Logic_t>
Darray<Logic_t> Xor(Darray<Logic_t>& a, Darray<Logic_t>& b ) {
   Darray<Logic_t> tmp(a.Size());
   if ( a.Size() == b.Size() ) {
   for( int i = 0; i < a.Size(); i++ ) tmp[i] = a[i] ^ b[i] ;
   } else {
      for( int i = 0; i < a.Size(); i++ ) tmp[i] = 0;
   }
   return tmp;
};

template<class Logic_t>
Darray<Logic_t> operator~( Darray<Logic_t>& a ) { return Not(a); };

template<class Logic_t>
Darray<Logic_t> 
  operator&( Darray<Logic_t>& a, Darray<Logic_t>& b ) { 
   return And(a,b);
};

template<class Logic_t>
Darray<Logic_t> 
  operator|( Darray<Logic_t>& a, Darray<Logic_t>& b ) {
   return Or(a,b);
};

template<class Logic_t>
Darray<Logic_t> 
  operator^( Darray<Logic_t>& a, Darray<Logic_t>& b ) {
   return Xor(a,b);
};

#endif

---