User Manual, Developers Guide and API Documentation

Interval.hpp

Go to the documentation of this file.

/*******************************************************************************
 * This file is part of openWNS (open Wireless Network Simulator)
 * _____________________________________________________________________________
 *
 * Copyright (C) 2004-2007
 * Chair of Communication Networks (ComNets)
 * Kopernikusstr. 16, D-52074 Aachen, Germany
 * phone: ++49-241-80-27910,
 * fax: ++49-241-80-22242
 * email: info@openwns.org
 * www: http://www.openwns.org
 * _____________________________________________________________________________
 *
 * openWNS is free software; you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 2 as published by the
 * Free Software Foundation;
 *
 * openWNS 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 Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 ******************************************************************************/

#ifndef WNS_INTERVAL_HPP
#define WNS_INTERVAL_HPP

#include <WNS/Enumerator.hpp>
#include <WNS/pyconfig/View.hpp>
#include <WNS/Assure.hpp>

#include <string>

namespace wns
{
    template<typename T>
    class Interval
    {
    friend class Endpoint;
    public:
    typedef T ValueType;
    
    class Endpoint
    {
        friend class Interval;
    public:
        Endpoint(const ValueType& bound, const ValueType& extremum)
        : bound(bound), extremum(extremum)
        {}

        bool operator==(const Endpoint& b) const
        {
        return (bound == b.bound) && (extremum == b.extremum);
        }

        bool operator<(const Endpoint& b) const
        {
        return (extremum < b.extremum);
        }
        
        bool operator<=(const Endpoint& b) const
        {
        return (extremum <= b.extremum);
        }
        
        bool operator>(const Endpoint& b) const
        {
        return (extremum > b.extremum);
        }
        
        bool operator>=(const Endpoint& b) const
        {
        return (extremum >= b.extremum);
        }
        
    private:
        ValueType bound;
        ValueType extremum;
    };

    class FromInclExclEndpoint : public Endpoint
    {
    public:
        FromInclExclEndpoint(const ValueType& bound, const ValueType& extremum)
        : Endpoint(bound, extremum)
        {}

        Interval ToIncluding(const ValueType& b) const
        {
        return Interval(*this, Endpoint(b, b));
        }

        Interval ToExcluding(const ValueType& b) const
        {
        return Interval(*this, Endpoint(b, --makeEnumerable(b)));
        }
    };

    class FromEndpoint : public Endpoint
    {
    public:
        FromEndpoint(const ValueType& bound, const ValueType& extremum)
        : Endpoint(bound, extremum)
        {}

        Interval To(const ValueType& b) const
        {
        return Interval(*this, Endpoint(b, b));
        }

    };

    class BetweenEndpoint : public Endpoint
    {
    public:
        BetweenEndpoint(const ValueType& bound, const ValueType& extremum)
        : Endpoint(bound, extremum)
        {}

        Interval And(const ValueType& b) const
        {
        return Interval(*this, Endpoint(b, --makeEnumerable(b)));
        }
    };

    static Interval CreateFrom(const pyconfig::View& config)
    {
            const ValueType min = config.get<ValueType>("lowerBound");

            const ValueType max = config.get<ValueType>("upperBound");

        const std::string intervalType = config.get<std::string>("intervalType");

            Endpoint a(min, (intervalType[0] == '(') ? ++makeEnumerable(min) : min);
            Endpoint b(max, (intervalType[1] == ')') ? --makeEnumerable(max) : max);
            return Interval<ValueType>(a, b);
    }
    
    static BetweenEndpoint Between(const ValueType& a)
    {
        return BetweenEndpoint(a, ++makeEnumerable(a));
    }

    static FromEndpoint From(const ValueType& a)
    {
        return FromEndpoint(a, a);
    }

    static FromInclExclEndpoint FromIncluding(const ValueType& a)
    {
        return FromInclExclEndpoint(a, a);
    }

    static FromInclExclEndpoint FromExcluding(const ValueType& a)
    {
        return FromInclExclEndpoint(a, ++makeEnumerable(a));
    }

    static Interval EmptyInterval()
    {
        return Interval();
    }

    Interval()
        : a(Endpoint(ValueType(), ++makeEnumerable(ValueType()))),
          b(Endpoint(ValueType(), --makeEnumerable(ValueType())))
    {}

    bool operator==(const Interval& x) const
    {
        return (isEmpty() && x.isEmpty()) || ((a == x.a) && (b == x.b));
    }

    bool operator!=(const Interval& x) const
    {
        return !((*this) == x);
    }

    bool isBelow(const ValueType& x) const
    {
        return !isEmpty() && (b.extremum < x);
    }

    bool isBelow(const Interval& x) const
    {
        return !isEmpty() && !x.isEmpty() && (b.extremum < x.a.extremum);
    }

    bool isAbove(const ValueType& x) const
    {
        return !isEmpty() && (x < a.extremum);
    }

    bool isAbove(const Interval& x) const
    {
        return !isEmpty() && !x.isEmpty() && (a.extremum > x.b.extremum);
    }

    bool isEmpty() const
    {
        return a.extremum > b.extremum;
    }

    ValueType min() const
    {
        assure(!isEmpty(), "Error: Attempt to get minimum of an empty interval.");
        return a.extremum;
    }

    ValueType max() const 
    { 
        assure(!isEmpty(), "Error: Attempt to get maximum of an empty interval.");
        return b.extremum; 
    }

    bool contains(const ValueType& x) const
    {
        return !isEmpty() && (a.extremum <= x) && (b.extremum >= x);
    }

    bool contains(const Interval& x) const
    {
        return x.isEmpty() || (!isEmpty() && (a.extremum <= x.a.extremum) && (b.extremum >= x.b.extremum));
    }

    bool overlaps(const Interval& x) const
    {
        return !isEmpty() && !x.isEmpty()
        && (((x.a.extremum <= a.extremum) && (a.extremum <= x.b.extremum)) ||
            ((a.extremum <= x.a.extremum) && (x.a.extremum <= b.extremum)));
    }

    bool joinableWith(const Interval& x) const
    {
        return isEmpty() || x.isEmpty() ||
        overlaps(Interval(Endpoint(--makeEnumerable(x.a.bound), --makeEnumerable(x.a.extremum)), x.b)) ||
        x.overlaps(Interval(Endpoint(--makeEnumerable(a.bound), --makeEnumerable(a.extremum)), b));
    }

    Interval join(const Interval& x) const
    {
        assure(joinableWith(x), "Error: Attempt to join unjoinable intervals (must be at least adjacent).");
        if (isEmpty()) return Interval(x);
        else if (x.isEmpty()) return Interval(*this);
        else {
        const Endpoint a(std::min(this->a, x.a));
        const Endpoint b(std::max(this->b, x.b));
        return Interval(a, b);
        }
    }

    Interval intersect(const Interval& x) const
    {
        const Endpoint a(std::max(this->a, x.a));
        const Endpoint b(std::min(this->b, x.b));
        return Interval(a, b);
    }

    private:

    Interval(const Endpoint& a, const Endpoint& b)
        : a(a), b(b)
    {}

    Endpoint a;
    Endpoint b;
    };

}

#endif // _INTERVAL_HPP

---