Search  

---

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

Go to the documentation of this file.

#ifndef __JCounter_CPP__
#define __JCounter_CPP__

#include "JCounter.hpp"

  // Default Constructor
  inline  JCounter::JCounter( register ULONG initial, register ULONG maximum )
   : count( initial ), max( maximum )
  {
    check();
  }

  // Copy Constructor
  inline  JCounter::JCounter( const JCounter& src )
   : count( src.count ), max( src.max ) { }

  // Destructor
  inline  JCounter::~JCounter() { }

  // Assign operator
  inline  const JCounter&  JCounter::operator =  ( const JCounter& src )
  {
    count = src.count;
    max   = src.max;
    return *this;
  }

  inline  const JCounter&  JCounter::operator =  ( register ULONG value )
  {
    count = value;
    check();
    return *this;
  }

  // Add and Subtract operator
  inline  const JCounter&  JCounter::operator += ( const JCounter& src ) 
  {
    count = verify( count + src.count );
    return *this; 
  }

  inline  const JCounter&  JCounter::operator -= ( const JCounter& src ) 
  { 
    count = verify( count - src.count );  
    return *this; 
  }

  inline  const JCounter&  JCounter::operator += ( register ULONG v ) 
  {
    count = verify( count +  v );  
    return *this; 
  }

  inline  const JCounter&  JCounter::operator -= ( register ULONG v ) 
  {
    count = verify( count -  v );  
    return *this; 
  }

  // Pre update                                        
  inline  const JCounter&  JCounter::operator ++ ( ) 
  {  
    ++count;    
    check();  
    return *this; 
  }

  inline  const JCounter&  JCounter::operator -- ( ) 
  {  
    --count;    
    check();  
    return *this; 
  }

  // Post update
  inline  const JCounter&  JCounter::operator ++ ( int )
  {  
    count++;    
    check();  
    return *this; 
  }

  inline  const JCounter&  JCounter::operator -- ( int )
  {  
    count--;    
    check();  
    return *this; 
  }

  // Get Maximum
  inline  const JCounter&  JCounter::operator ~  ( ) 
  {
    count = (ULONG)(~0);
    return *this; 
  }
 
  // Get Minimum
  inline  const JCounter&  JCounter::operator !  ( )
  {
    count = 0;
    return *this; 
  }

  inline  ULONG            JCounter::operator() ( ) { return count; }

  // Compare operators:
  inline  BOOL  JCounter::operator == ( const JCounter& src ) { return (count == src.count); }
  inline  BOOL  JCounter::operator != ( const JCounter& src ) { return (count == src.count); }
  inline  BOOL  JCounter::operator >  ( const JCounter& src ) { return (count >  src.count); }
  inline  BOOL  JCounter::operator >= ( const JCounter& src ) { return (count >= src.count); }
  inline  BOOL  JCounter::operator <  ( const JCounter& src ) { return (count <  src.count); }
  inline  BOOL  JCounter::operator <= ( const JCounter& src ) { return (count <= src.count); }

  inline  BOOL  JCounter::operator == ( register ULONG v ) { return (count == v); }
  inline  BOOL  JCounter::operator != ( register ULONG v ) { return (count != v); }
  inline  BOOL  JCounter::operator >  ( register ULONG v ) { return (count >  v); }
  inline  BOOL  JCounter::operator >= ( register ULONG v ) { return (count >= v); }
  inline  BOOL  JCounter::operator <  ( register ULONG v ) { return (count <  v); }
  inline  BOOL  JCounter::operator <= ( register ULONG v ) { return (count <= v); }

  // Arithmetic operator
  inline JCounter  JCounter::operator + ( const JCounter& right ) 
  { 
    return add(       right.count, MAX( max, right.max ) ); 
  }

  inline JCounter  JCounter::operator - ( const JCounter& right ) 
  { 
    return substract( right.count, MAX( max, right.max ) ); 
  }

  inline JCounter  JCounter::operator * ( const JCounter& right ) 
  { 
    return multiply(  right.count, MAX( max, right.max ) ); 
  }

  inline JCounter  JCounter::operator / ( const JCounter& right ) 
  {
    return divideBy(  right.count, MAX( max, right.max ) ); 
  }

  inline JCounter  JCounter::operator + ( register ULONG right ) { return add(       right, max ); }
  inline JCounter  JCounter::operator - ( register ULONG right ) { return substract( right, max ); }
  inline JCounter  JCounter::operator * ( register ULONG right ) { return multiply(  right, max ); }
  inline JCounter  JCounter::operator / ( register ULONG right ) { return divideBy(  right, max ); }

 
#endif

---