qwt_double_interval.h

/* -*- mode: C++ ; c-file-style: "stroustrup" -*- *****************************
 * Qwt Widget Library
 * Copyright (C) 1997   Josef Wilgen
 * Copyright (C) 2002   Uwe Rathmann
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the Qwt License, Version 1.0
 *****************************************************************************/

#ifndef QWT_DOUBLE_INTERVAL_H
#define QWT_DOUBLE_INTERVAL_H

#include "qwt_global.h"

class QWT_EXPORT QwtDoubleInterval
{
public:
    enum BorderMode
    {
        IncludeBorders = 0,

        ExcludeMinimum = 1,
        ExcludeMaximum = 2,

        ExcludeBorders = ExcludeMinimum | ExcludeMaximum
    };

    QwtDoubleInterval();
    QwtDoubleInterval(double minValue, double maxValue, 
        int borderFlags = IncludeBorders);

    void setInterval(double minValue, double maxValue, 
        int borderFlags = IncludeBorders);

    QwtDoubleInterval normalized() const;
    QwtDoubleInterval inverted() const;
    QwtDoubleInterval limited(double minValue, double maxValue) const;

    int operator==(const QwtDoubleInterval &) const;
    int operator!=(const QwtDoubleInterval &) const;

    void setBorderFlags(int);
    int borderFlags() const;

    double minValue() const;
    double maxValue() const;
    
    double width() const;

    void setMinValue(double);
    void setMaxValue(double);

    bool contains(double value) const;

    bool intersects(const QwtDoubleInterval &) const;
    QwtDoubleInterval intersect(const QwtDoubleInterval &) const;
    QwtDoubleInterval unite(const QwtDoubleInterval &) const;

    QwtDoubleInterval operator|(const QwtDoubleInterval &) const;
    QwtDoubleInterval operator&(const QwtDoubleInterval &) const;

    QwtDoubleInterval &operator|=(const QwtDoubleInterval &);
    QwtDoubleInterval &operator&=(const QwtDoubleInterval &);

    QwtDoubleInterval extend(double value) const;
    QwtDoubleInterval operator|(double) const;
    QwtDoubleInterval &operator|=(double);

    bool isValid() const;
    bool isNull() const;
    void invalidate();

    QwtDoubleInterval symmetrize(double value) const;

private:
    double d_minValue;
    double d_maxValue;
    int d_borderFlags;
};

inline QwtDoubleInterval::QwtDoubleInterval():
    d_minValue(0.0),
    d_maxValue(-1.0),
    d_borderFlags(IncludeBorders)
{
}

inline QwtDoubleInterval::QwtDoubleInterval(
        double minValue, double maxValue, int borderFlags):
    d_minValue(minValue),
    d_maxValue(maxValue),
    d_borderFlags(borderFlags)
{
}

inline void QwtDoubleInterval::setInterval(
    double minValue, double maxValue, int borderFlags)
{
    d_minValue = minValue;
    d_maxValue = maxValue;
    d_borderFlags = borderFlags;
}

inline void QwtDoubleInterval::setBorderFlags(int borderFlags)
{
    d_borderFlags = borderFlags;
}

inline int QwtDoubleInterval::borderFlags() const
{
    return d_borderFlags; 
}

inline void QwtDoubleInterval::setMinValue(double minValue)
{   
    d_minValue = minValue;
}

inline void QwtDoubleInterval::setMaxValue(double maxValue)
{
    d_maxValue = maxValue;
}

inline double QwtDoubleInterval::minValue() const 
{ 
    return d_minValue; 
}

inline double QwtDoubleInterval::maxValue() const 
{ 
    return d_maxValue; 
}

inline double QwtDoubleInterval::width() const 
{ 
    return isValid() ? (d_maxValue - d_minValue) : 0.0; 
}

inline QwtDoubleInterval QwtDoubleInterval::operator&(
    const QwtDoubleInterval &interval ) const
{
    return intersect(interval);
}

inline QwtDoubleInterval QwtDoubleInterval::operator|(
    const QwtDoubleInterval &interval) const
{
    return unite(interval);
}

inline int QwtDoubleInterval::operator==(const QwtDoubleInterval &other) const
{
    return (d_minValue == other.d_minValue) &&
        (d_maxValue == other.d_maxValue) &&
        (d_borderFlags == other.d_borderFlags);
}

inline int QwtDoubleInterval::operator!=(const QwtDoubleInterval &other) const
{
    return (!(*this == other));
}

inline QwtDoubleInterval QwtDoubleInterval::operator|(double value) const
{
    return extend(value);
}

inline bool QwtDoubleInterval::isNull() const
{
    return isValid() && d_minValue >= d_maxValue;
}

inline bool QwtDoubleInterval::isValid() const
{
    if ( (d_borderFlags & ExcludeBorders) == 0 )
        return d_minValue <= d_maxValue;
    else
        return d_minValue < d_maxValue;
}

inline void QwtDoubleInterval::invalidate()
{
    d_minValue = 0.0;
    d_maxValue = -1.0;
}

#endif