Interval.h

Go to the documentation of this file.

// header definitions
#ifndef _INTERVAL_H_
#define _INTERVAL_H_

// attributes description includes
#include "Range.h"

// VRECKO namespace
namespace vrecko
{

template <class tval, class tref = tval>
class Interval : public Range
{
public:

    Interval(tref lowerBound, tref upperBound) : Range(Range::RANGE_INTERVAL)
    {
        // set both bounds to desired values
        this->lowerBound = lowerBound;
        this->upperBound = upperBound;

        // implicitly set inclusive bounds
        lowerInclusive = true;
        upperInclusive = true;
    }

    Interval(tref lowerBound, tref upperBound, bool lowerInclusive,
        bool upperInclusive) : Range(Range::RANGE_INTERVAL)
    {
        // set both bounds to desired values
        this->lowerBound = lowerBound;
        this->upperBound = upperBound;

        // set flags for both bounds
        this->lowerInclusive = lowerInclusive;
        this->upperInclusive = upperInclusive;
    }

    inline tref getLowerBound() const
    {
        return lowerBound;
    }

    inline tref getUpperBound() const
    {
        return upperBound;
    }

    inline bool isLowerInclusive() const
    {
        return lowerInclusive;
    }

    inline bool isUpperInclusive() const
    {
        return upperInclusive;
    }

    bool includesValue(tref value) const
    {
        // both bounds are inclusive
        if (isLowerInclusive() && isUpperInclusive())
        {
            return (value >= getLowerBound() && value <= getUpperBound());
        }

        // lower bound is not inclusive and the upper bound is inclusive
        if (!isLowerInclusive() && isUpperInclusive())
        {
            return (value > getLowerBound() && value <= getUpperBound());
        }

        // lower bound is not inclusive and the upper bound is inclusive
        if (isLowerInclusive() && !isUpperInclusive())
        {
            return (value >= getLowerBound() && value < getUpperBound());
        }

        // both bounds are not inclusive
        return (value > getLowerBound() && value < getUpperBound());
    }

private:

    // bounds
    tval lowerBound;        
    tval upperBound;        

    // flags
    bool lowerInclusive;    
    bool upperInclusive;    
};

typedef Interval<int> IntInterval;              
typedef Interval<long> LongInterval;            
typedef Interval<float> FloatInterval;          
typedef Interval<double> DoubleInterval;        

// end of vrecko namespace
}

// end header definitions
#endif