Range.h

Go to the documentation of this file.

#ifndef GCP_UTIL_RANGE_H
#define GCP_UTIL_RANGE_H

#include "gcp/util/common/Exception.h"
#include "gcp/util/common/LogStream.h"

namespace gcp {
  namespace util {
    
    template<class Type>
      class Range;
    
    template <class Type>
      std::ostream& operator<<(std::ostream& os, 
                      const Range<Type>& range);
    
    // Class for managing a range
    
    template<class Type>
      class Range {
      public:
      
      Range();
      
      Range(Type start, Type stop);
      
      virtual ~Range();
      
      void setStart(Type start);
      void setStop(Type stop);
      
      Type start();
      Type stop();
      
      friend std::ostream& gcp::util::operator << <>
    (std::ostream& os, const Range<Type>& range);
      
      Range& operator+=(Type incr);
      
      Range& operator*=(Type mult);
      
      private:
      
      Type start_;
      bool startInit_;
      Type stop_;
      bool stopInit_;
      
    }; // End class Range
    
    template<class Type>
      Range<Type>::Range() {
      startInit_ = false;
      stopInit_   = false;
    };
    
    // Constructor with initialization
    
    template<class Type>
      Range<Type>::Range(Type start, Type stop) {
      startInit_ = false;
      stopInit_   = false;
      
      setStart(start);
      setStop(stop);
    };
    
    template<class Type>
      Range<Type>::~Range() {};
    
    template<class Type>
      void Range<Type>::setStart(Type start) {
      start_ = start;
      startInit_ = true;
    }
    
    template<class Type>
      void Range<Type>::setStop(Type stop) {
      stop_ = stop;
      stopInit_ = true;
    }
    
    template<class Type>
      Type Range<Type>::start() {
      if(!startInit_) {
    LogStream errStr;
    errStr.appendMessage(true, "Start value has not been initialized\n");
    throw Error(errStr);
      }
      return start_;
    }
    
    template<class Type>
      Type Range<Type>::stop() {
      if(!startInit_) {
    LogStream errStr;
    errStr.appendMessage(true, "End value has not been initialized\n");
    throw Error(errStr);
      }
      return stop_;
    }
    
    template <class Type>
      std::ostream& operator<<(std::ostream& os, 
                      const Range<Type>& range)
      {
    os << "(" << range.start_ << "-" << range.stop_ << ")";
    return os;
      }
    
    
    template <class Type>
      Range<Type>& Range<Type>::operator+=(Type incr) 
      {
    start_ += incr;
    stop_  += incr;
    
    return *this;
      }
    
    template <class Type>
      Range<Type>& Range<Type>::operator*=(Type mult) 
      {
    start_ *= mult;
    stop_  *= mult;
    return *this;
      }
    
  } // End namespace util
} // End namespace gcp




#endif // End #ifndef GCP_UTIL_RANGE_H