Search  

---

C:/temp/src/j2k/Fred/JCounter.hpp

Go to the documentation of this file.

#ifndef __JCounter_HPP__
#define __JCounter_HPP__

#include <stdio.h>
#include <stdlib.h>
#include <iostream.h>
#include <string.h>
#include <math.h>
#include <assert.h>

#define BOOL   bool
#define ULONG  unsigned long

inline ULONG MAX( register ULONG x, register ULONG y ) 
{
   return ( x > y ? x : y );
}


class JCounter {
public:
  // Default Constructor
  inline JCounter( register ULONG initial = 0, register ULONG maximum = ~0 );

  // Copy Constructor
  inline JCounter( const JCounter& src );

  // Destructor
  inline virtual ~JCounter();

  // Assign operator
  inline  const JCounter&  operator =  ( const JCounter& src );
  inline  const JCounter&  operator =  ( register ULONG value );

  // Add and Subtract operator
  inline  const JCounter&  operator += ( const JCounter& src );
  inline  const JCounter&  operator -= ( const JCounter& src );
  inline  const JCounter&  operator += ( register ULONG v );
  inline  const JCounter&  operator -= ( register ULONG v );

  // Pre update
  inline  const JCounter&  operator ++ ( );
  inline  const JCounter&  operator -- ( );

  // Post update
  inline  const JCounter&  operator ++ ( int );
  inline  const JCounter&  operator -- ( int );

  // Set Maximum
  inline  const JCounter&  operator ~  ();
 
  // Set Minimum
  inline  const JCounter&  operator !  ();

  // Retrieve value
  inline  ULONG            operator()  ();

  // Compare operators:
  inline  BOOL     operator == ( const JCounter& src );
  inline  BOOL     operator != ( const JCounter& src );
  inline  BOOL     operator >  ( const JCounter& src );
  inline  BOOL     operator >= ( const JCounter& src );
  inline  BOOL     operator <  ( const JCounter& src );
  inline  BOOL     operator <= ( const JCounter& src );
                  
  inline  BOOL     operator == ( register ULONG v );
  inline  BOOL     operator != ( register ULONG v );
  inline  BOOL     operator >  ( register ULONG v );
  inline  BOOL     operator >= ( register ULONG v );
  inline  BOOL     operator <  ( register ULONG v );
  inline  BOOL     operator <= ( register ULONG v );

  // Arithmetic operator
  inline JCounter  operator + ( const JCounter& right );
  inline JCounter  operator - ( const JCounter& right );
  inline JCounter  operator * ( const JCounter& right );
  inline JCounter  operator / ( const JCounter& right );

  inline JCounter  operator + ( register ULONG right );
  inline JCounter  operator - ( register ULONG right );
  inline JCounter  operator * ( register ULONG right );
  inline JCounter  operator / ( register ULONG right );


// FRIENDS:
// ========

  // Stream operator
  friend ostream& operator << (ostream& os, JCounter& right )
  {
     return os << right.count;
  }

  friend istream& operator >> (istream& is, JCounter& right )
  {
     return is >> right.count;
  }

  // Compare with a ULONG type left and this class right
  // e.g.   ULONG val = 0;
  //        JCounter counter;
  //        assert( val == counter );

  inline  friend BOOL  operator == ( register ULONG left, const JCounter& right ) { return ( left == right.count ); }
  inline  friend BOOL  operator != ( register ULONG left, const JCounter& right ) { return ( left != right.count ); }
  inline  friend BOOL  operator >  ( register ULONG left, const JCounter& right ) { return ( left >  right.count ); }
  inline  friend BOOL  operator >= ( register ULONG left, const JCounter& right ) { return ( left >= right.count ); }
  inline  friend BOOL  operator <  ( register ULONG left, const JCounter& right ) { return ( left <  right.count ); }
  inline  friend BOOL  operator <= ( register ULONG left, const JCounter& right ) { return ( left <= right.count ); }

  // Arithmetic friends
  inline friend JCounter  JCounter::operator + ( register ULONG left, const JCounter& right ) 
  {
    register ULONG val = verify( ( _int64 )left + ( _int64 )right.count, right.max );
    return JCounter( val );
  }

  inline friend JCounter  JCounter::operator - ( register ULONG left, const JCounter& right ) 
  {
    register ULONG val = verify( ( _int64 )left - ( _int64 )right.count, right.max );
    return JCounter( val );
  }

  inline friend JCounter  JCounter::operator * ( register ULONG left, const JCounter& right ) 
  {
    register ULONG val = verify( ( _int64 )left * ( _int64 )right.count, right.max );
    return JCounter( val );
  }

  inline friend JCounter  JCounter::operator / ( register ULONG left, const JCounter& right ) 
  {
    if ( right.count == 0 ) return JCounter( right.max );
    register ULONG val = verify( ( _int64 )left / ( _int64 )right.count, right.max );
    return JCounter( val );
  }


  // Cast operator
  inline operator ULONG () const
  {
     return count;
  }

  // Set stuff
  inline void setMax( register ULONG maximum )
  {
     max = maximum;
  }

  inline void set( register ULONG value )
  {
     count = verify( (_int64)value );
  }

protected:
  // Verification
  inline void JCounter::check()
  {
    count = (  ( count >= max ) ? max : count  );
  }

  ULONG JCounter::verify( _int64 value )
  {
    if ( value <= 0   ) return 0;
    if ( value >= max ) return max;

    return (ULONG)value;
  }

  static ULONG JCounter::verify( _int64 value, register ULONG maximum )
  {
    if ( value <= 0       ) return 0;
    if ( value >= maximum ) return maximum;

    return (ULONG)value;
  }

  // Safe arithmetic Operators
  JCounter  JCounter::add(       register ULONG right, register ULONG maximum )
  {                              
    register ULONG val = verify( ( _int64 )count + ( _int64 )right, maximum );
    return JCounter( val );
  }

  JCounter  JCounter::substract( register ULONG right, register ULONG maximum )
  {
    register ULONG val = verify( ( _int64 )count - ( _int64 )right, maximum );
    return JCounter( val );
  }

  JCounter  JCounter::multiply(  register ULONG right, register ULONG maximum )
  {
    register ULONG val = verify( ( _int64 )count * ( _int64 )right, maximum );
    return JCounter( val );
  }

  JCounter  JCounter::divideBy(  register ULONG right, register ULONG maximum )
  {
    if ( right == 0 ) return JCounter( maximum );
    register ULONG val = verify( ( _int64 )count / ( _int64 )right, maximum );
    return JCounter( val );
  }

private:
  ULONG count;
  ULONG max;

};

#endif

---