range.h

Go to the documentation of this file.

/**
 * \file range.h <mi32/range.h>
 * \brief Definitions for RANGE template
 *
 * \if NODOC
 * $Id: range.h_v 1.10 2004/03/31 18:46:21 mju Exp $
 *
 * $Log: range.h_v $
 * Revision 1.10  2004/03/31 18:46:21  mju
 * Add getSize.
 *
 * Revision 1.9  2004/02/18 20:17:15  scowan
 * Added limit method.
 *
 * Revision 1.8  2003/09/15 13:49:56  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.7  2003/04/09 19:49:19  dwilliss
 * Don't use _T in templates.  Mac's ctype.h defines a global _T. Thanks Apple!
 *
 * Revision 1.6  2001/10/26 21:46:38  mju
 * Add Set, SetMinimum and SetMaximum methods.
 *
 * Revision 1.5  2001/07/18 19:38:01  mju
 * Use 'minval' and 'maxval' instead of 'min' and 'max' as those are #defined as macros by Windows headers.
 *
 * Revision 1.4  2000/07/07 13:39:57  mju
 * Don't use limits.h.
 *
 * Revision 1.3  2000/06/28 20:27:25  mju
 * Use limits.h for Unix.
 *
 * Revision 1.2  2000/06/26 20:16:49  mju
 * Add ctor from separate min/max values.
 *
 * Revision 1.1  2000/06/26 18:06:09  mju
 * Initial revision
 *
 * \endif
**/

#ifndef  INC_MI32_RANGE_H
#define  INC_MI32_RANGE_H

#ifndef  INC_MI32_STDDEFNS_H
#include <mi32/stddefns.h>
#endif

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

//! Template for storing numeric range.
//! Designed to work with signed integer and floating-point data types, unsigned types are not supported.
template <class _CT> class RANGE {
   public:

      //! Default constructor, initialize to invalid (empty) range.
      RANGE (
         ) {
         SetInvalid();
         }

      //! Construct range with specified minimum and maximum values.
      RANGE (
         _CT minval,
         _CT maxval
         ): m_min(minval), m_max(maxval)
         { }

      //! Construct range to include only specified value.
      explicit RANGE (
         _CT value
         ) : m_min(value), m_max(value)
         { }

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

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

      //! Determine if range contains specified value.
      bool Contains (
         _CT value
         ) const {
         return (value >= m_min && value <= m_max);
         }

      //! Determine if range containes specified range.
      bool Contains (
         const RANGE& rhs
         ) const {
         return (rhs.m_min >= m_min && rhs.m_max <= m_max);
         }

      //! Expand range by specified amount.
      void Expand (
         _CT value
         ) {
         m_min -= value;
         m_max += value;
         return;
         }

      //! Extend range to include specified value.
      void Extend (
         _CT value
         ) {
         if (value < m_min) m_min = value;
         if (value > m_max) m_max = value;
         return;
         }

      //! Extend range to include specified range.
      void Extend (
         _CT minval,
         _CT maxval
         ) {
         if (minval < m_min) m_min = minval;
         if (maxval > m_max) m_max = maxval;
         return;
         }

      //! Extend range to include specified range.
      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;
         return;
         }

      //! Get center of range.
      _CT GetCenter (
         ) const {
         return ((m_min + m_max) / 2);
         }

      //! Get maximum value in range.
      _CT GetMaximum (
         ) const {
         return (m_max);
         }

      //! Get minimum value in range.
      _CT GetMinimum (
         ) const {
         return (m_min);
         }

      //! Get 'size' of range.
      _CT GetSize (
         ) const { return (m_max - m_min); }

      //! Intersect range with another range.
      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;
         }

      //! Determine if range is valid.
      bool IsValid (
         ) const {
         return (m_min <= m_max);
         }
         
      //! Limit the value based on the current range
      //! Can be used to replace the bound() macro
      //! @return Limit'ed value based on the range
      _CT Limit (
         _CT value
         ) const {
         return ((value < m_min) ? m_min : ((value > m_max) ? m_max : value));
         }

      //! Determine if range overlaps another range.
      bool Overlaps (
         const RANGE& rhs
         ) const {
         return (!(rhs.m_max < m_min || rhs.m_max > m_min));
         }

      //! Set range to be "invalid" (empty).
      void SetInvalid (
         ) {
         m_min = std::numeric_limits<_CT>::max();
         m_max = -m_min;
         return;
         }

      //! Set minimum and maximum values.
      void Set (
         _CT minval,
         _CT maxval
         ) { m_min = minval; m_max = maxval; }

      //! Set maximum value.
      void SetMaximum (
         _CT val
         ) { m_max = val; }

      //! Set minimum value.
      void SetMinimum (
         _CT val
         ) { m_min = val; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      _CT m_min;                             //!< Minimum value in range
      _CT m_max;                             //!< Maximum value in range
      #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   //!< INC_MI32_RANGE_H

---