mi32/range.h

Go to the documentation of this file.

#ifndef  INC_MI32_RANGE_H
#define  INC_MI32_RANGE_H

#ifndef  INC_MI32_INIDEFNS_H
#include <mi32/inidefns.h>
#endif

#ifndef  INC_LIMITS
#include <limits>
#define  INC_LIMITS
#endif

template <class _CT> class RANGE {
   public:

      RANGE (
         ) {
         SetInvalid();
         }

      RANGE (
         _CT minval,
         _CT maxval
         ): m_min(minval), m_max(maxval)
         { }

      explicit RANGE (
         _CT value
         ) : m_min(value), m_max(value)
         { }

      RANGE& operator= (
         _CT value
         ) { m_min = m_max = value; return (*this); }

      bool operator== (
         const RANGE& rhs
         ) const {
         return (m_min == rhs.m_min && m_max == rhs.m_max);
         }

      bool operator!= (
         const RANGE& rhs
         ) const {
         return (!(*this == rhs));
         }

      bool Contains (
         _CT value
         ) const {
         return (value >= m_min && value <= m_max);
         }

      bool Contains (
         const RANGE& rhs
         ) const {
         return (rhs.m_min >= m_min && rhs.m_max <= m_max);
         }

      bool Contains (
         _CT valuemin,        
         _CT valuemax         
         ) const {
         return (valuemin >= m_min && valuemax <= m_max);
         }

      void Expand (
         _CT value
         ) {
         m_min -= value;
         m_max += value;
         }

      void Extend (
         _CT value
         ) {
         if (value < m_min) m_min = value;
         if (value > m_max) m_max = value;
         }

      void Extend (
         _CT minval,
         _CT maxval
         ) {
         if (minval < m_min) m_min = minval;
         if (maxval > m_max) m_max = maxval;
         }

      void Extend (
         const RANGE& rhs
         ) {
         if (rhs.m_min < m_min) m_min = rhs.m_min;
         if (rhs.m_max > m_max) m_max = rhs.m_max;
         }

      _CT GetCenter (
         ) const {
         return ((m_min + m_max) / 2);
         }

      _CT GetMaximum (
         ) const {
         return (m_max);
         }

      _CT GetMinimum (
         ) const {
         return (m_min);
         }

      _CT GetSize (
         ) const { return (m_max - m_min); }

      void IniRead (
         INIHANDLE hdl,
         const char *GroupName,
         const char *FieldNameMin,
         const char *FieldNameMax
         ) { ::IniRead(hdl,GroupName,FieldNameMin,m_min); ::IniRead(hdl,GroupName,FieldNameMax,m_max); }

      void IniWrite (
         INIHANDLE hdl,
         const char *GroupName,
         const char *FieldNameMin,
         const char *FieldNameMax
         ) const { ::IniWrite(hdl,GroupName,FieldNameMin,m_min); ::IniWrite(hdl,GroupName,FieldNameMax,m_max); }

      void Intersect (
         const RANGE& rhs
         ) {
         if (rhs.IsValid()) {
            if (rhs.m_min > m_min) m_min = rhs.m_min;
            if (rhs.m_max < m_max) m_max = rhs.m_max;
            }
         else {
            *this = rhs;
            }
         return;
         }

      bool IsNonEmpty (
         ) const {
         return (m_min < m_max);
         }
         
      bool IsValid (
         ) const {
         return (m_min <= m_max);
         }
         
      _CT Limit (
         _CT value
         ) const {
         return ((value < m_min) ? m_min : ((value > m_max) ? m_max : value));
         }

      bool Overlaps (
         const RANGE& rhs
         ) const {
         return (!(rhs.m_max < m_min || rhs.m_min > m_max));
         }

      void SetInvalid (
         ) {
         m_min = std::numeric_limits<_CT>::max();
         m_max = -m_min;
         }

      void Set (
         _CT minval,
         _CT maxval
         ) { m_min = minval; m_max = maxval; }

      void SetMaximum (
         _CT val
         ) { m_max = val; }

      void SetMinimum (
         _CT val
         ) { m_min = val; }

      void ShiftFast (
         _CT value
         ) { m_min += value; m_max += value; }
         
      void Validate (
         ) {
         if (IsValid()) return;
         _CT tmp = m_min;
         m_min = m_max;
         m_max = tmp;
         }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      _CT m_min;                             
      _CT m_max;                             
      #endif // GENERATING_DOXYGEN_OUTPUT

   };

typedef RANGE<INT16> INT16_RANGE;
typedef RANGE<INT32> INT32_RANGE;
typedef RANGE<float> FLOAT_RANGE;
typedef RANGE<double> DOUBLE_RANGE;

#endif   

---