intervals.h

/********************************************************************************
 *  FARSA Utilities Library                                                     *
 *  Copyright (C) 2007-2012                                                     *
 *  Gianluca Massera <emmegian@yahoo.it>                                        *
 *  Stefano Nolfi <stefano.nolfi@istc.cnr.it>                                   *
 *  Tomassino Ferrauto <tomassino.ferrauto@istc.cnr.it>                         *
 *                                                                              *
 *  This program is free software; you can redistribute it and/or modify        *
 *  it under the terms of the GNU General Public License as published by        *
 *  the Free Software Foundation; either version 2 of the License, or           *
 *  (at your option) any later version.                                         *
 *                                                                              *
 *  This program is distributed in the hope that it will be useful,             *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of              *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               *
 *  GNU General Public License for more details.                                *
 *                                                                              *
 *  You should have received a copy of the GNU General Public License           *
 *  along with this program; if not, write to the Free Software                 *
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA  *
 ********************************************************************************/

#ifndef INTERVALS_H
#define INTERVALS_H

#include "utilitiesconfig.h"

#include <QLinkedList>
#include <QString>
#include <cmath>
#include <limits>
#include "mathutils.h"

namespace farsa {

class FARSA_UTIL_API SimpleInterval
{
public:
    SimpleInterval() :
        start(),
        end(start)
    {
    }

    SimpleInterval(real s, real e) :
        start(s),
        end(e)
    {
    }

    SimpleInterval(const SimpleInterval& other) :
        start(other.start),
        end(other.end)
    {
    }

    SimpleInterval& operator=(const SimpleInterval& other)
    {
        if (&other == this) {
            return *this;
        }

        start = other.start;
        end = other.end;

        return *this;
    }

    ~SimpleInterval()
    {
    }

    bool operator<(const SimpleInterval& other) const
    {
        return start < other.start;
    }

    real length() const
    {
        return end - start;
    }

    bool equals(const SimpleInterval& other) const
    {
        return (start == other.start) && (end == other.end);
    }

    operator QString() const
    {
        return QString("[%1, %2]").arg(start).arg(end);
    }

    QString toString() const
    {
        return *this;
    }

    static SimpleInterval fromString(QString str, bool* ok = NULL);

    static QString vectorOfSimpleIntervalsToString(QVector<SimpleInterval> v);

    static QVector<SimpleInterval> vectorOfSimpleIntervalsFromString(QString s, bool* ok = NULL);

    real start;

    real end;
};

class FARSA_UTIL_API Intervals
{
public:
    typedef QLinkedList<SimpleInterval>::const_iterator const_iterator;

public:
    Intervals() :
        m_length(0.0),
        m_intervals()
    {
    }

    Intervals(const SimpleInterval& interval);

    template <class List_t>
    Intervals(const List_t& list) :
        m_length(0.0),
        m_intervals()
    {
        for (typename List_t::const_iterator it = list.begin(); it != list.end(); it++) {
            unite(*it);
        }
    }

    Intervals(const Intervals& other) :
        m_length(other.m_length),
        m_intervals(other.m_intervals)
    {
    }

    Intervals& operator=(const Intervals& other);

    ~Intervals()
    {
    }

    operator QString() const;

    QString toString() const
    {
        return *this;
    }

    real length() const
    {
        return m_length;
    }

    const_iterator begin() const
    {
        return m_intervals.begin();
    }

    const_iterator constBegin() const
    {
        return m_intervals.constBegin();
    }

    const_iterator end() const
    {
        return m_intervals.end();
    }

    const_iterator constEnd() const
    {
        return m_intervals.constEnd();
    }

    const QLinkedList<SimpleInterval>& getSimpleIntervalList() const
    {
        return m_intervals;
    }

    bool isEmpty() const
    {
        return m_intervals.isEmpty();
    }

    bool empty() const
    {
        return m_intervals.empty();
    }

    void clear();

    Intervals& intersect(const Intervals& other)
    {
        intersect(other.constBegin(), other.constEnd());
        return *this;
    }

    Intervals& intersect(const SimpleInterval& i)
    {
        intersect(&i, &i + 1);
        return *this;
    }

    Intervals operator&(const Intervals& other) const
    {
        Intervals i(*this);
        return i.intersect(other);
    }

    Intervals operator&(const SimpleInterval& i) const
    {
        Intervals intrv(*this);
        return intrv.intersect(i);
    }

    Intervals& operator&=(const Intervals& other)
    {
        return intersect(other);
    }

    Intervals& operator&=(const SimpleInterval& value)
    {
        return intersect(value);
    }

    Intervals& unite(const Intervals& other)
    {
        unite(other.constBegin(), other.constEnd());
        return *this;
    }

    Intervals& unite(const SimpleInterval& i)
    {
        unite(&i, &i + 1);
        return *this;
    }

    Intervals operator+(const Intervals& other) const
    {
        Intervals i(*this);
        return i.unite(other);
    }

    Intervals operator+(const SimpleInterval& i) const
    {
        Intervals intrv(*this);
        return intrv.unite(i);
    }

    Intervals& operator+=(const Intervals& other)
    {
        return unite(other);
    }

    Intervals& operator+=(const SimpleInterval& value)
    {
        return unite(value);
    }

    Intervals operator|(const Intervals& other) const
    {
        Intervals i(*this);
        return i.unite(other);
    }

    Intervals operator|(const SimpleInterval& i) const
    {
        Intervals intrv(*this);
        return intrv.unite(i);
    }

    Intervals& operator|=(const Intervals& other)
    {
        return unite(other);
    }

    Intervals& operator|=(const SimpleInterval& value)
    {
        return unite(value);
    }

    Intervals& operator<<(const SimpleInterval& value)
    {
        return unite(value);
    }

    Intervals& subtract(const Intervals& other)
    {
        subtract(other.constBegin(), other.constEnd());
        return *this;
    }

    Intervals& subtract(const SimpleInterval& i)
    {
        subtract(&i, &i + 1);
        return *this;
    }

    Intervals operator-(const Intervals& other) const
    {
        Intervals i(*this);
        return i.subtract(other);
    }

    Intervals operator-(const SimpleInterval& i) const
    {
        Intervals intrv(*this);
        return intrv.subtract(i);
    }

    Intervals& operator-=(const Intervals& other)
    {
        return subtract(other);
    }

    Intervals& operator-=(const SimpleInterval& value)
    {
        return subtract(value);
    }

    bool operator!=(const Intervals& other) const
    {
        return !(*this == other);
    }

    bool operator==(const Intervals& other) const;

    bool valueIn(real v) const;

protected:
    void recomputeLength();

    template <class OtherIterator_t>
    void intersect(OtherIterator_t otherBegin, OtherIterator_t otherEnd);

    template <class OtherIterator_t>
    void unite(OtherIterator_t otherBegin, OtherIterator_t otherEnd);

    template <class OtherIterator_t>
    void subtract(OtherIterator_t otherBegin, OtherIterator_t otherEnd);

    real m_length;

    QLinkedList<SimpleInterval> m_intervals;
};

} // end namespace farsa

#endif