MRAcrange.h

Go to the documentation of this file.

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

#ifndef MRACRANGE_H
#define MRACRANGE_H

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

#include "BufferBase.h"
#include "MRAclevel.h"

class MRAcrange { 

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

      MRAclevel cmin, cmax;

      MRAcrange( const MRAcrange& );
      MRAcrange();
      MRAcrange( const MRAclevel& cmin2, const MRAclevel& cmax2 );
      MRAcrange( MRAclevel );
      
      MRAcrange& copy( const MRAcrange& );
      MRAcrange& operator = ( const MRAcrange& );

      MRAcrange& operator () ( const MRAcrange& );
      MRAcrange& operator () ();
      MRAcrange& operator () ( const MRAclevel& cmin2, const MRAclevel& cmax2 );

      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 frag();

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

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

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

      int sizeb();

      void report( ostream& os = cout );

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

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

   protected:
      int _state;

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

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

};

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

bool equal( MRAcrange, MRAcrange );

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

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

bool contains( MRAcrange, MRAcrange );

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

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

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

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

bool disjoint( MRAcrange, MRAcrange );

bool connected( MRAcrange, MRAcrange );

bool interior( MRAcrange, MRAcrange );

MRAcrange Union( MRAcrange, MRAcrange );

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

MRAcrange Intersection( MRAcrange, MRAcrange );

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

MRAcrange Difference( MRAcrange, MRAcrange );

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

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

inline
MRAcrange::MRAcrange( const MRAcrange& crange ) 
{
      _state = crange._state;
      cmin = crange.cmin;
      cmax = crange.cmax;
}

inline
MRAcrange::MRAcrange() {}

inline
MRAcrange::MRAcrange( const MRAclevel& cmin2, const MRAclevel& cmax2 ) 
{
   _state = goodbit;
   cmin = cmin2;
   cmax = cmax2;
}

inline
MRAcrange::MRAcrange( const MRAclevel clevel ) 
{
      _state = goodbit;
      cmin = clevel;
      cmax = clevel;
}

inline
MRAcrange& MRAcrange::copy( const MRAcrange& crange ) 
{
   _state = crange._state;
   cmin = crange.cmin;
   cmax = crange.cmax;
   return *this;
}

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

inline
MRAcrange& MRAcrange::operator () ( const MRAcrange& crange ) 
{ 
   _state = crange._state;
   cmin = crange.cmin;
   cmax = crange.cmax;
   return *this;
}

inline
MRAcrange& MRAcrange::operator () () 
{ 
   _state = 0;
   cmin = MRAclevel::cmax_limit;
   cmax = MRAclevel::cmin_limit;
   return *this; 
}

inline
MRAcrange& MRAcrange::operator () ( 
  const MRAclevel& cmin2, const MRAclevel& cmax2 
) 
{ 
   clear();
   cmin = cmin2;
   cmax = cmax2;
   return *this;
}

inline
void MRAcrange::set_null() 
{
   _state = 0;
   cmin = MRAclevel::cmax_limit;
   cmax = MRAclevel::cmin_limit; // implies is_empty
}

inline
bool MRAcrange::is_null() 
{
   if ( _state == 0 ) return true;
   return false;
}

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

inline
void MRAcrange::set_empty() 
{
   if ( !is_null() ) {
      clear();
      cmin = MRAclevel::cmax_limit;
      cmax = MRAclevel::cmin_limit;
   } else {
      setstate(failbit);
   }
}

inline
bool MRAcrange::is_empty() 
{
   if ( good() ) {
      if ( int(cmin) > int(cmax) ) return true;
   }
   return false;
}

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

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

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

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

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

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

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

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

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

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

inline
int MRAcrange::sizeb() { return cmin.sizeb() + cmax.sizeb(); }

inline
void MRAcrange::report( ostream& os ) {
   os << "MRAcrange::report(){\n";
   os << "state = " << _state << " = 0b0000"<<frag()<<'*'<<fail()<<good()<< '\n';
   os << "cmin = " << int(cmin)
      << " cmax = " << int(cmax);
   if ( int(cmin) > int(cmax) ) cout << " ==> is_empty\n";
   else cout << "\n";
   os << "}\n";
}

inline
void MRAcrange::write( BufferBase& buffer )
{
   buffer >> cmin;
   buffer >> cmax;
   _state = goodbit;
}

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

inline
void MRAcrange::read( BufferBase& buffer )
{
   buffer << cmin;
   buffer << cmax;
}

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

inline
void MRAcrange::write( istream& is )
{
   is >> cmin;
   is >> cmax;
   _state = goodbit;
}

inline
void MRAcrange::read( ostream& os )
{
   os << cmin;
   os << cmax;
}

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

inline
BufferBase& operator >> ( BufferBase& buffer, MRAcrange& crange )
{
   crange.write(buffer);
   return buffer;
}

inline
BufferBase& operator << ( BufferBase& buffer, MRAcrange& crange )
{
   crange.read(buffer);
   return buffer;
}

inline
istream& operator >> ( istream& is, MRAcrange& crange )
{
   crange.write(is);
   return is;
}

inline
ostream& operator << ( ostream& os, MRAcrange& crange )
{
   crange.read(os);
   return os;
}

#endif

---