MRAmrange.h

Go to the documentation of this file.

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

#ifndef MRAMRANGE_H
#define MRAMRANGE_H

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

#include "BufferBase.h"
#include "MRAmlevel.h"

class MRAmrange { 

   public: 
      
      static const int goodbit = 0x01;
      static const int failbit = 0x02;
      static const int baddimbit = 0x04;
      static const int fragbit = 0x08;

      MRAmlevel mmin, mmax;

      MRAmrange( const MRAmrange& );
      MRAmrange();
      MRAmrange( int dim );
      MRAmrange( const MRAmlevel& mmin2, const MRAmlevel& mmax2 );
      MRAmrange( MRAmlevel );
      
      MRAmrange& copy( const MRAmrange& );
      MRAmrange& operator = ( const MRAmrange& );

      MRAmrange& operator () ( const MRAmrange& );
      MRAmrange& operator () ();
      MRAmrange& operator () ( int dim );
      MRAmrange& operator () ( const MRAmlevel& mmin2, const MRAmlevel& mmax2 );

      void set_null();
      bool is_null();
      bool operator ! ();

      void set_empty();
      bool is_empty();

      void clear();
      void setstate(int);
      void clrstate(int);
      int rdstate( int = 0xFF );
      bool good();
      bool fail();
      bool baddim();
      bool frag();

      MRAmrange& Union( MRAmrange );
      MRAmrange& operator += ( MRAmrange );

      MRAmrange& Intersection( MRAmrange );
      MRAmrange& operator *= ( MRAmrange );

      MRAmrange& Difference( MRAmrange );
      MRAmrange& operator -= ( MRAmrange );

      int dim();

      int sizeb();

      void report( ostream& os = cout );

      void write( BufferBase& );
      MRAmrange& operator << ( BufferBase& );
      void read( BufferBase& );
      MRAmrange& operator >> ( BufferBase& );

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

   protected:
      int _state;
      int _dim;

   friend bool equal( MRAmrange, MRAmrange );
   friend bool operator == ( MRAmrange, MRAmrange );
   friend bool operator != ( MRAmrange, MRAmrange );
   friend bool contains( MRAmrange, MRAmrange );
   friend bool operator < ( MRAmrange, MRAmrange );
   friend bool operator > ( MRAmrange, MRAmrange );
   friend bool operator <= ( MRAmrange, MRAmrange );
   friend bool operator >= ( MRAmrange, MRAmrange );
   friend bool disjoint( MRAmrange, MRAmrange );
   friend bool connected( MRAmrange, MRAmrange );
   friend bool interior( MRAmrange, MRAmrange );
   friend MRAmrange Union( MRAmrange, MRAmrange );
   friend MRAmrange operator + ( MRAmrange, MRAmrange );
   friend MRAmrange Intersection( MRAmrange, MRAmrange );
   friend MRAmrange operator * ( MRAmrange, MRAmrange );
   friend MRAmrange Difference( MRAmrange, MRAmrange );
   friend MRAmrange operator - ( MRAmrange, MRAmrange );

   friend BufferBase& operator << ( BufferBase&, MRAmrange& );
   friend BufferBase& operator >> ( BufferBase&, MRAmrange& );
   friend ostream& operator << ( ostream&, MRAmrange& );
   friend istream& operator >> ( istream&, MRAmrange& );

};

// ##### overloaded namespace functions #####

bool equal( MRAmrange, MRAmrange );

inline
bool operator == ( MRAmrange lhs, MRAmrange rhs )
{
   return equal( rhs, lhs );
}

inline
bool operator != ( MRAmrange lhs, MRAmrange rhs )
{
   return !equal( rhs, lhs );
}

bool contains( MRAmrange, MRAmrange );

inline
bool operator < ( MRAmrange lhs, MRAmrange rhs )
{
   return contains( rhs, lhs ) && lhs != rhs;
}

inline
bool operator > ( MRAmrange lhs, MRAmrange rhs )
{
   return contains( lhs, rhs ) && lhs != rhs;
}

inline
bool operator <= ( MRAmrange lhs, MRAmrange rhs )
{
   return contains( rhs, lhs );
}

inline
bool operator >= ( MRAmrange lhs, MRAmrange rhs )
{
   return contains( lhs, rhs );
}

bool disjoint( MRAmrange, MRAmrange );

bool connected( MRAmrange, MRAmrange );

bool interior( MRAmrange, MRAmrange );

MRAmrange Union( MRAmrange, MRAmrange );

inline
MRAmrange operator + ( MRAmrange lhs, MRAmrange rhs )
{
   return Union( lhs, rhs );
}

MRAmrange Intersection( MRAmrange, MRAmrange );

inline
MRAmrange operator * ( MRAmrange lhs, MRAmrange rhs )
{
   return Intersection( lhs, rhs );
}

MRAmrange Difference( MRAmrange, MRAmrange );

inline
MRAmrange operator - ( MRAmrange lhs, MRAmrange rhs )
{
   return Difference( lhs, rhs );
}

// ##### class member functions #####

inline
MRAmrange::MRAmrange( const MRAmrange& mrange ) 
{
      _state = mrange._state;
      _dim = mrange._dim;
      mmin = mrange.mmin;
      mmax = mrange.mmax;
}

inline
MRAmrange::MRAmrange() 
  : _state(0), _dim(0)
{
   mmin();
   mmax();
}

inline
MRAmrange::MRAmrange( int dim ) 
  : _state(goodbit), _dim(dim)
{
   mmin(dim);
   mmax(dim);
}

inline
MRAmrange::MRAmrange( const MRAmlevel& mmin2, const MRAmlevel& mmax2 ) 
{
   if ( mmin2._dim != 0 && mmin2._dim == mmax2._dim ) {
      _state = goodbit;
      _dim = mmin2._dim;
      mmin = mmin2;
      mmax = mmax2;
   } else {
      _state &= !goodbit; _state |= baddimbit;
      _dim = 0;
      mmin();
      mmax();
   }
}

inline
MRAmrange::MRAmrange( const MRAmlevel mlevel ) 
{
   if ( mlevel._dim != 0 ) {
      _state = goodbit;
      _dim = mlevel._dim;
      mmin = mlevel;
      mmax = mlevel;
   } else {
      _state &= !goodbit; _state |= baddimbit;
      _dim = 0;
      mmin();
      mmax();
   }
}

inline
MRAmrange& MRAmrange::copy( const MRAmrange& mrange ) 
{
   _state = mrange._state;
   _dim = mrange._dim;
   mmin = mrange.mmin;
   mmax = mrange.mmax;
   return *this;
}

inline
MRAmrange& MRAmrange::operator = ( const MRAmrange& rhs ) { return copy(rhs); }

inline
MRAmrange& MRAmrange::operator () ( const MRAmrange& mrange ) 
{ 
   _state = mrange._state;
   _dim = mrange._dim;
   mmin = mrange.mmin;
   mmax = mrange.mmax;
   return *this;
}

inline
MRAmrange& MRAmrange::operator () () 
{ 
   _state = 0;
   _dim = 0; 
   mmin();
   mmax(); 
   return *this; 
}

inline
MRAmrange& MRAmrange::operator () ( int dim ) 
{ 
   clear();
   _dim = dim;
   mmin(dim); 
   mmax(dim); 
   return *this; 
}

inline
MRAmrange& MRAmrange::operator () ( 
  const MRAmlevel& mmin2, const MRAmlevel& mmax2 
) 
{ 
   if ( mmin2._dim != 0 && mmin2._dim == mmax2._dim ) {
      clear();
      _dim = mmin2._dim;
      mmin = mmin2;
      mmax = mmax2;
   } else {
      clear(); setstate(baddimbit);
      _dim = 0;
      mmin();
      mmax();
   }
   return *this;
}

inline
void MRAmrange::set_null() 
{
   _state = 0;
   _dim = 0;
   mmin();
   mmax();
}

inline
bool MRAmrange::is_null() 
{
   if ( _dim == 0 ) return true;
   return false;
}

inline
bool MRAmrange::operator ! () 
{
   return is_null();
}

inline
void MRAmrange::set_empty() 
{
   if ( !is_null() ) {
      clear();
      mmin = MRAmlevel::mmax_limit;
      mmax = MRAmlevel::mmin_limit;
   } else {
      setstate(failbit);
   }
}

inline
bool MRAmrange::is_empty() 
{
   if ( good() ) {
      for( int d = 0; d < _dim; ++d ) if ( mmin[d] > mmax[d] ) return true;
   } else {
      setstate(failbit);
   }
   return false;
}

inline
void MRAmrange::clear() { _state = goodbit; }

inline
void MRAmrange::setstate( int s ) { _state |= s; }

inline
void MRAmrange::clrstate( int s ) { _state &= ~s; }

inline
int MRAmrange::rdstate( int s ) { return (_state & s); }

inline
bool MRAmrange::good() { return _state == goodbit; }

inline
bool MRAmrange::fail() { return rdstate(failbit) != 0; }

inline
bool MRAmrange::baddim() { return rdstate(baddimbit) != 0; }

inline
bool MRAmrange::frag() { return rdstate(fragbit) != 0; }

inline
MRAmrange& MRAmrange::operator += ( MRAmrange rhs ) 
{ 
   return Union(rhs); 
}

inline
MRAmrange& MRAmrange::operator *= ( MRAmrange rhs )
{
   return Intersection(rhs); 
}

inline
MRAmrange& MRAmrange::operator -= ( MRAmrange rhs ) 
{ 
   return Difference(rhs); 
}

inline
int MRAmrange::dim() { return _dim; }

inline
int MRAmrange::sizeb() { return mmin.sizeb() + mmax.sizeb(); }

inline
void MRAmrange::report( ostream& os ) {
   os << "MRAmrange::report(){\n";
   os << "state = " << _state << " = 0b0000"<<frag()<<baddim()<<fail()<<good()<< '\n';
   os << "dim = " << _dim;
   if ( _dim == 0 ) cout << " ==> is null\n";
   else cout << "\n";
   for( int d = 0; d < _dim; ++d ) {
      os << "mmin[] = " << mmin[d] 
         << " mmax[] = " << mmax[d];
      if ( mmin[d] > mmax[d] ) cout << " ==> is_empty\n";
      else cout << "\n";
   }
   os << "}\n";
}

inline
void MRAmrange::write( BufferBase& buffer )
{
   buffer >> mmin;
   buffer >> mmax;
}

inline
MRAmrange& MRAmrange::operator << ( BufferBase& buffer )
{
   write(buffer);
   return *this;
}

inline
void MRAmrange::read( BufferBase& buffer )
{
   buffer << mmin;
   buffer << mmax;
}

inline
MRAmrange& MRAmrange::operator >> ( BufferBase& buffer )
{
   read(buffer);
   return *this;
}

inline
void MRAmrange::write( istream& is )
{
   is >> mmin;
   is >> mmax;
}

inline
void MRAmrange::read( ostream& os )
{
   os << mmin;
   os << mmax;
}

// ##### friends #####

inline
BufferBase& operator >> ( BufferBase& buffer, MRAmrange& mrange )
{
   mrange.write(buffer);
   return buffer;
}

inline
BufferBase& operator << ( BufferBase& buffer, MRAmrange& mrange )
{
   mrange.read(buffer);
   return buffer;
}

inline
istream& operator >> ( istream& is, MRAmrange& mrange )
{
   mrange.write(is);
   return is;
}

inline
ostream& operator << ( ostream& os, MRAmrange& mrange )
{
   mrange.read(os);
   return os;
}

#endif

---