/*============================================================================*/
/*
  VFLib: https://github.com/vinniefalco/VFLib

  Copyright (C) 2008 by Vinnie Falco <vinnie.falco@gmail.com>

  This library contains portions of other open source products covered by
  separate licenses. Please see the corresponding source files for specific
  terms.

  VFLib is provided under the terms of The MIT License (MIT):

  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:

  The above copyright notice and this permission notice shall be included in
  all copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  IN THE SOFTWARE.
*/
/*============================================================================*/

#ifndef BEAST_INTERVAL_BEASTHEADER
#define BEAST_INTERVAL_BEASTHEADER

/** A half-open interval.

    This represents the half-open interval [begin, end) over the scalar
    type of template parameter `Ty`. It may also be considered as the
    specification of a subset of a 1-dimensional Euclidean space.

    @tparam Ty A scalar numerical type.
*/
template <class Ty>
class Interval
{
public:
    typedef Ty value_type;

    /** The empty interval.
    */
    static const Interval none;

    /** Create an uninitialized interval.
    */
    Interval ()
    {
    }

    /** Create an interval with the specified values.
    */
    Interval (Ty begin, Ty end)
        : m_begin (begin)
        , m_end (end)
    {
    }

    /** Create an interval from another interval.
    */
    Interval (Interval const& other)
        : m_begin (other.m_begin)
        , m_end (other.m_end)
    {
    }

    /** Assign from another interval.

        @param other The interval to assign from.

        @return A reference to this interval.
    */
    Interval& operator= (const Interval& other)
    {
        m_begin = other.m_begin;
        m_end = other.m_end;
        return *this;
    }

    /** Compare an interval for equality.

        Empty intervals are always equal to other empty intervals.

        @param rhs The other interval to compare.

        @return `true` if this interval is equal to the specified interval.
    */
    bool operator== (Interval const& rhs) const
    {
        return (empty () && rhs.empty ()) ||
               (m_begin == rhs.m_begin && m_end == rhs.m_end);
    }

    /** Compare an interval for inequality.

        @param rhs The other interval to compare.

        @return `true` if this interval is not equal to the specified interval.
    */
    bool operator!= (Interval const& rhs) const
    {
        return !this->operator== (rhs);
    }

    /** Get the starting value of the interval.

        @return The starting point of the interval.
    */
    Ty begin () const
    {
        return m_begin;
    }

    /** Get the ending value of the interval.

        @return The ending point of the interval.
    */
    Ty end () const
    {
        return m_end;
    }

    /** Get the Lebesque measure.

        @return The Lebesque measure.
    */
    Ty length () const
    {
        return empty () ? Ty () : (end () - begin ());
    }

    //Ty count () const { return length (); } // sugar
    //Ty distance () const { return length (); } // sugar

    /** Determine if the interval is empty.

        @return `true` if the interval is empty.
    */
    bool empty () const
    {
        return m_begin >= m_end;
    }

    /** Determine if the interval is non-empty.

        @return `true` if the interval is not empty.
    */
    bool notEmpty () const
    {
        return m_begin < m_end;
    }

    /** Set the starting point of the interval.

        @param v The starting point.
    */
    void setBegin (Ty v)
    {
        m_begin = v;
    }

    /** Set the ending point of the interval.

        @param v The ending point.
    */
    void setEnd (Ty v)
    {
        m_end = v;
    }

    /** Set the ending point relative to the starting point.

        @param v The length of the resulting interval.
    */
    void setLength (Ty v)
    {
        m_end = m_begin + v;
    }

    /** Determine if a value is contained in the interval.

        @param v The value to check.

        @return `true` if this interval contains `v`.
    */
    bool contains (Ty v) const
    {
        return notEmpty () && v >= m_begin && v < m_end;
    }

    /** Determine if this interval intersects another interval.

        @param other The other interval.

        @return `true` if the intervals intersect.
    */
    template <class To>
    bool intersects (Interval <To> const& other) const
    {
        return notEmpty () && other.notEmpty () &&
               end () > other.begin () && begin () < other.end ();
    }

    /** Determine if this interval adjoins another interval.

        An interval is adjoint to another interval if and only if the union of the
        intervals is a single non-empty half-open subset.

        @param other The other interval.

        @return `true` if the intervals are adjoint.
    */
    template <class To>
    bool adjoins (Interval <To> const& other) const
    {
        return (empty () != other.empty ()) ||
               (notEmpty () && end () >= other.begin ()
                && begin () <= other.end ());
    }

    /** Determine if this interval is disjoint from another interval.

        @param other The other interval.

        @return `true` if the intervals are disjoint.
    */
    bool disjoint (Interval const& other) const
    {
        return !intersects (other);
    }

    /** Determine if this interval is a superset of another interval.

        An interval A is a superset of interval B if B is empty or if A fully
        contains B.

        @param other The other interval.

        @return `true` if this is a superset of `other`.
    */
    template <class To>
    bool superset_of (Interval <To> const& other) const
    {
        return other.empty () ||
               (notEmpty () && begin () <= other.begin ()
                && end () >= other.end ());
    }

    /** Determine if this interval is a proper superset of another interval.

        An interval A is a proper superset of interval B if A is a superset of
        B and A is not equal to B.

        @param other The other interval.

        @return `true` if this interval is a proper superset of `other`.
    */
    template <class To>
    bool proper_superset_of (Interval <To> const& other) const
    {
        return this->superset_of (other) && this->operator != (other);
    }

    /** Determine if this interval is a subset of another interval.

        @param other The other interval.

        @return `true` if this interval is a subset of `other`.
    */
    template <class To>
    bool subset_of (Interval <To> const& other) const
    {
        return other.superset_of (*this);
    }

    /** Determine if this interval is a proper subset of another interval.

        @param other The other interval.

        @return `true` if this interval is a proper subset of `other`.
    */
    template <class To>
    bool proper_subset_of (Interval <To> const& other) const
    {
        return other.proper_superset_of (*this);
    }

    /** Return the intersection of this interval with another interval.

        @param other The other interval.

        @return The intersection of the intervals.
    */
    template <class To>
    Interval intersection (Interval <To> const& other) const
    {
        return Interval (std::max (begin (), other.begin ()),
                         std::min (end (), other.end ()));
    }

    /** Determine the smallest interval that contains both intervals.

        @param other The other interval.

        @return The simple union of the intervals.
    */
    template <class To>
    Interval simple_union (Interval <To> const& other) const
    {
        return Interval (
                   std::min (other.normalized ().begin (), normalized ().begin ()),
                   std::max (other.normalized ().end (), normalized ().end ()));
    }

    /** Calculate the single-interval union.

        The result is empty if the union cannot be represented as a
        single half-open interval.

        @param other The other interval.

        @return The simple union of the intervals.
    */
    template <class To>
    Interval single_union (Interval <To> const& other) const
    {
        if (empty ())
            return other;

        else if (other.empty ())
            return *this;

        else if (end () < other.begin () || begin () > other.end ())
            return none;

        else
            return Interval (std::min (begin (), other.begin ()),
                             std::max (end (), other.end ()));
    }

    /** Determine if the interval is correctly ordered.

        @return `true` if the interval is correctly ordered.
    */
    bool normal () const
    {
        return end () >= begin ();
    }

    /** Return a normalized interval.

        @return The normalized interval.
    */
    Interval normalized () const
    {
        if (normal ())
            return *this;
        else
            return Interval (end (), begin ());
    }

    /** Clamp a value to the interval.

        @param v The value to clamp.

        @return The clamped result.
    */
    template <typename Tv>
    Ty clamp (Tv v) const
    {
        // These conditionals are carefully ordered so
        // that if m_begin == m_end, value is assigned m_begin.
        if (v > end ())
            v = end () - (std::numeric_limits <Tv>::is_integer ? 1 :
                          std::numeric_limits <Tv>::epsilon ());

        if (v < begin ())
            v = begin ();

        return v;
    }

private:
    Ty m_begin;
    Ty m_end;
};

template <typename Ty>
const Interval<Ty> Interval<Ty>::none = Interval<Ty> (Ty (), Ty ());

#endif