YiRange.h

Go to the documentation of this file.

#ifndef YI_RANGE_H
#define YI_RANGE_H

#include "YiError.h"
#include "YiPreprocessorMacros.h"
#include "YiTypeTraits.h"

#include <glm/gtc/epsilon.hpp>

template<typename Type>
class CYIRange
{
public:
    CYIRange() :
        m_start(0),
        m_end(0)
    {
        static_assert((YiIsIntegral<Type>::value || YiIsFloatingPoint<Type>::value) && !YiIsSameType<Type, bool>::value, "Type must be a primitive data type, and not bool!");
    }

    CYIRange(Type lhs, Type rhs) :
        m_start(std::min(lhs, rhs)),
        m_end(std::max(lhs, rhs))
    {
    }

    CYIRange(const CYIRange<Type> &other) :
        m_start(other.m_start),
        m_end(other.m_end)
    {
    }

    //==============================================================================
    Type GetStart() const
    {
        return m_start;
    }

    Type GetEnd() const
    {
        return m_end;
    }

    Type GetLength() const
    {
        return m_end - m_start;
    }

#ifdef DOXY

    bool IsEmpty() const;
#else
    template<typename T = Type>
    typename std::enable_if<!std::is_floating_point<T>::value, bool>::type IsEmpty() const
    {
        return m_start == m_end;
    }

    template<typename T = Type>
    typename std::enable_if<std::is_floating_point<T>::value, bool>::type IsEmpty() const
    {
        return glm::epsilonEqual(m_start, m_end, glm::epsilon<Type>());
    }
#endif

    bool IsNotEmpty() const
    {
        return !IsEmpty();
    }

    //==============================================================================
    static CYIRange CreateEmptyRange(Type m_start)
    {
        return CYIRange<Type>(m_start, m_start);
    }

    static CYIRange CreateWithStartAndLength(Type startValue, Type length)
    {
        return CYIRange<Type>(startValue, startValue + length);
    }

    //==============================================================================
    void SetStart(Type newStart)
    {
        m_start = newStart;
        m_end = std::max(m_end, newStart);
    }

    void SetEnd(Type newEnd)
    {
        m_start = std::min(m_start, newEnd);
        m_end = newEnd;
    }

    void SetLength(Type newLength)
    {
        m_end = m_start + std::max(Type(), newLength);
    }

    CYIRange<Type> WithStart(Type newStart) const
    {
        return CYIRange<Type>(newStart, std::max(newStart, m_end));
    }

    CYIRange<Type> WithEnd(Type newEnd) const
    {
        return CYIRange<Type>(std::min(m_start, newEnd), newEnd);
    }

    CYIRange<Type> WithLength(Type newLength) const
    {
        return CYIRange<Type>(m_start, m_start + std::max(newLength, Type()));
    }

    CYIRange<Type> Expanded(Type amount) const
    {
        return CYIRange<Type>(m_start - amount, m_end + amount);
    }

    CYIRange<Type> Shifted(Type delta) const
    {
        return CYIRange<Type>(m_start + delta, m_end + delta);
    }

    //==============================================================================
    bool Contains(Type position) const
    {
        return m_start <= position && position < m_end;
    }

    //==============================================================================
    CYIRange<Type> &operator=(const CYIRange<Type> &other)
    {
        m_start = other.m_start;
        m_end = other.m_end;
        return *this;
    }

    CYIRange<Type> operator+=(Type delta)
    {
        m_start += delta;
        m_end += delta;
        return *this;
    }

    CYIRange<Type> operator-=(Type delta)
    {
        m_start -= delta;
        m_end -= delta;
        return *this;
    }

    CYIRange<Type> operator+(Type delta) const
    {
        return CYIRange<Type>(m_start + delta, m_end + delta);
    }

    CYIRange<Type> operator-(Type delta) const
    {
        return CYIRange<Type>(m_start - delta, m_end - delta);
    }

    bool operator==(const CYIRange<Type> &other) const
    {
        return m_start == other.m_start && m_end == other.m_end;
    }

    bool operator!=(const CYIRange<Type> &other) const
    {
        return m_start != other.m_start || m_end != other.m_end;
    }

private:
    Type m_start, m_end;
};

#endif //YI_RANGE_H