Scroom::Utils::Segment< T > Class Template Reference

#include <linearsegment.hh>

Inheritance diagram for Scroom::Utils::Segment< T >:

Collaboration diagram for Scroom::Utils::Segment< T >:

Public Types
using	value_type = T

Public Member Functions
	Segment ()
	Segment (value_type start_, value_type size_)
template<bool T_is_int = std::is_same<int, typename std::remove_cv<T>::type>::value>
	Segment (typename std::enable_if<!T_is_int, Segment< int > const & >::type other)
Segment	moveTo (value_type p) const
bool	contains (value_type p) const
bool	contains (const Segment< value_type > &other) const
bool	intersects (const Segment< value_type > &other) const
void	reduceSizeToMultipleOf (value_type m)
Segment< value_type >	intersection (const Segment< value_type > &other) const
void	intersect (const Segment< value_type > &other)
Segment< value_type >	before (value_type v) const
Segment< value_type >	after (value_type v) const
value_type	getStart () const
value_type	getEnd () const
value_type	getSize () const
bool	isEmpty () const
bool	operator== (const Segment< value_type > &other) const
bool	operator!= (const Segment< value_type > &other) const
Segment< value_type > &	operator+= (value_type n)
Segment< value_type > &	operator-= (value_type n)
Segment< value_type > &	operator*= (value_type n)
Segment< value_type > &	operator/= (value_type n)
Segment< value_type > &	operator&= (const Segment< value_type > &other)
void	setStart (value_type n)
void	setSize (value_type n)
void	setEnd (value_type n)
template<typename U >
Segment< U >	to () const

Private Member Functions
void	normalize ()

Private Attributes
value_type	start
value_type	size

Member Typedef Documentation

value_type

template<typename T >

using Scroom::Utils::Segment< T >::value_type = T

Constructor & Destructor Documentation

Segment() [1/3]

template<typename T >

Scroom::Utils::Segment< T >::Segment ( )

inline

      : start(0)
      , size(0)
    {
    }

Referenced by Scroom::Utils::Segment< value_type >::moveTo().

Here is the caller graph for this function:

Segment() [2/3]

template<typename T >

Scroom::Utils::Segment< T >::Segment ( value_type  start_, value_type  size_  )

inline

      : start(start_)
      , size(size_)
    {
      normalize();
    }

Segment() [3/3]

template<typename T >

template<bool T_is_int = std::is_same<int, typename std::remove_cv<T>::type>::value>

Scroom::Utils::Segment< T >::Segment ( typename std::enable_if<!T_is_int, Segment< int > const & >::type  other )

inlineexplicit

Implicit conversion from Segment<int> to Segment<T>. If T!=int

      : start(other.getStart())
      , size(other.getSize())
    {
    }

Member Function Documentation

after()

template<typename T >

Segment<value_type> Scroom::Utils::Segment< T >::after ( value_type  v ) const

inline

    {
      if(v > start + size)
      {
        return Segment<value_type>();
      }
      if(v > start)
      {
        return Segment<value_type>(v, start + size - v);
      }
      return *this;
    }

Referenced by Scroom::Utils::Rectangle< int >::below(), and Scroom::Utils::Rectangle< int >::rightOf().

Here is the caller graph for this function:

before()

template<typename T >

Segment<value_type> Scroom::Utils::Segment< T >::before ( value_type  v ) const

inline

    {
      if(v < start)
      {
        return Segment<value_type>();
      }
      if(v < start + size)
      {
        return Segment<value_type>(start, v - start);
      }
      return *this;
    }

Referenced by Scroom::Utils::Rectangle< int >::above(), and Scroom::Utils::Rectangle< int >::leftOf().

Here is the caller graph for this function:

contains() [1/2]

template<typename T >

bool Scroom::Utils::Segment< T >::contains ( const Segment< value_type > &  other ) const

inline

    {
      return getStart() <= other.getStart() && other.getEnd() <= getEnd();
    }

contains() [2/2]

template<typename T >

bool Scroom::Utils::Segment< T >::contains ( value_type  p ) const

inline

{ return start <= p && p < (start + size); }

Referenced by Scroom::Utils::Rectangle< int >::contains().

Here is the caller graph for this function:

getEnd()

template<typename T >

value_type Scroom::Utils::Segment< T >::getEnd ( ) const

inline

{ return start + size; }

Referenced by Scroom::Utils::Rectangle< int >::below(), Scroom::Utils::Segment< value_type >::contains(), Scroom::Utils::Rectangle< int >::getBottom(), Scroom::Utils::Rectangle< int >::getBottomLeft(), Scroom::Utils::Rectangle< int >::getBottomRight(), Scroom::Utils::Rectangle< int >::getRight(), Scroom::Utils::Rectangle< int >::getTopRight(), Scroom::Utils::Segment< value_type >::intersection(), Scroom::Utils::Segment< value_type >::intersects(), Scroom::Utils::Rectangle< int >::rightOf(), Scroom::Utils::roundOutward(), and Scroom::Utils::Segment< value_type >::setStart().

Here is the caller graph for this function:

getSize()

template<typename T >

value_type Scroom::Utils::Segment< T >::getSize ( ) const

inline

{ return size; }

Referenced by Scroom::Utils::center(), Scroom::Utils::Rectangle< int >::getHeight(), Scroom::Utils::Rectangle< int >::getSize(), Scroom::Utils::Rectangle< int >::getWidth(), Scroom::Utils::Segment< value_type >::isEmpty(), and Scroom::Utils::operator<<().

Here is the caller graph for this function:

getStart()

template<typename T >

value_type Scroom::Utils::Segment< T >::getStart ( ) const

inline

{ return start; }

Referenced by Scroom::Utils::Rectangle< int >::above(), Scroom::Utils::center(), Scroom::Utils::Segment< value_type >::contains(), Scroom::Utils::Rectangle< int >::getBottomLeft(), Scroom::Utils::Rectangle< int >::getLeft(), Scroom::Utils::Rectangle< int >::getTop(), Scroom::Utils::Rectangle< int >::getTopLeft(), Scroom::Utils::Rectangle< int >::getTopRight(), Scroom::Utils::Segment< value_type >::intersection(), Scroom::Utils::Segment< value_type >::intersects(), Scroom::Utils::Rectangle< int >::leftOf(), Scroom::Utils::operator<<(), and Scroom::Utils::roundOutward().

Here is the caller graph for this function:

intersect()

template<typename T >

void Scroom::Utils::Segment< T >::intersect ( const Segment< value_type > &  other )

inline

{ *this = intersection(other); }

Referenced by Scroom::Utils::Segment< value_type >::operator&=().

Here is the caller graph for this function:

intersection()

template<typename T >

Segment<value_type> Scroom::Utils::Segment< T >::intersection ( const Segment< value_type > &  other ) const

inline

    {
      const value_type newStart = std::max(getStart(), other.getStart());
      const value_type newEnd   = std::min(getEnd(), other.getEnd());
      const value_type newSize  = newEnd - newStart;
 
      if(newSize >= 0)
      {
        return Segment<value_type>(newStart, newSize);
      }
 
      return Segment<value_type>(); // empty segment
    }

Referenced by Scroom::Utils::Rectangle< int >::above(), Scroom::Utils::Rectangle< int >::below(), Scroom::Utils::Segment< value_type >::intersect(), Scroom::Utils::Rectangle< int >::intersection(), Scroom::Utils::Rectangle< int >::leftOf(), and Scroom::Utils::Rectangle< int >::rightOf().

Here is the caller graph for this function:

intersects()

template<typename T >

bool Scroom::Utils::Segment< T >::intersects ( const Segment< value_type > &  other ) const

inline

    {
      return getStart() < other.getEnd() && other.getStart() < getEnd() && !isEmpty() && !other.isEmpty();
    }

Referenced by Scroom::Utils::Rectangle< int >::intersects().

Here is the caller graph for this function:

isEmpty()

template<typename T >

bool Scroom::Utils::Segment< T >::isEmpty ( ) const

inline

{ return isZero(getSize()); }

Referenced by Scroom::Utils::Segment< value_type >::intersects(), Scroom::Utils::Rectangle< int >::isEmpty(), and Scroom::Utils::Segment< value_type >::operator==().

Here is the caller graph for this function:

moveTo()

template<typename T >

Segment Scroom::Utils::Segment< T >::moveTo ( value_type  p ) const

inline

{ return Segment(p, size); }

Referenced by Scroom::Utils::Rectangle< int >::moveTo().

Here is the caller graph for this function:

normalize()

template<typename T >

void Scroom::Utils::Segment< T >::normalize ( )

inlineprivate

    {
      if(size < 0)
      {
        start += size;
        size = -size;
      }
    }

Referenced by Scroom::Utils::Segment< value_type >::Segment(), and Scroom::Utils::Segment< value_type >::setEnd().

Here is the caller graph for this function:

operator!=()

template<typename T >

bool Scroom::Utils::Segment< T >::operator!= ( const Segment< value_type > &  other ) const

inline

{ return !(*this == other); }

operator&=()

template<typename T >

Segment<value_type>& Scroom::Utils::Segment< T >::operator&= ( const Segment< value_type > &  other )

inline

    {
      intersect(other);
      return *this;
    }

operator*=()

template<typename T >

Segment<value_type>& Scroom::Utils::Segment< T >::operator*= ( value_type  n )

inline

    {
      start *= n;
      size *= n;
      return *this;
    }

operator+=()

template<typename T >

Segment<value_type>& Scroom::Utils::Segment< T >::operator+= ( value_type  n )

inline

    {
      start += n;
      return *this;
    }

operator-=()

template<typename T >

Segment<value_type>& Scroom::Utils::Segment< T >::operator-= ( value_type  n )

inline

    {
      start -= n;
      return *this;
    }

operator/=()

template<typename T >

Segment<value_type>& Scroom::Utils::Segment< T >::operator/= ( value_type  n )

inline

    {
      start /= n;
      size /= n;
      return *this;
    }

operator==()

template<typename T >

bool Scroom::Utils::Segment< T >::operator== ( const Segment< value_type > &  other ) const

inline

    {
      if(isEmpty() != other.isEmpty())
      {
        return false;
      }
 
      if(isEmpty())
      {
        return true;
      }
 
      return areEqual(start, other.start) && areEqual(size, other.size);
    }

reduceSizeToMultipleOf()

template<typename T >

void Scroom::Utils::Segment< T >::reduceSizeToMultipleOf ( value_type  m )

inline

{ size -= size % m; }

Referenced by Scroom::Utils::Rectangle< int >::reduceSizeToMultipleOf().

Here is the caller graph for this function:

setEnd()

template<typename T >

void Scroom::Utils::Segment< T >::setEnd ( value_type  n )

inline

    {
      size = n - start;
      normalize();
    }

Referenced by Scroom::Utils::Rectangle< int >::setBottom(), Scroom::Utils::Rectangle< int >::setRight(), and Scroom::Utils::Segment< value_type >::setStart().

Here is the caller graph for this function:

setSize()

template<typename T >

void Scroom::Utils::Segment< T >::setSize ( value_type  n )

inline

{ size = n; }

Referenced by Scroom::Utils::Rectangle< int >::setSize().

Here is the caller graph for this function:

setStart()

template<typename T >

void Scroom::Utils::Segment< T >::setStart ( value_type  n )

inline

    {
      const auto end = getEnd();
      start          = n;
      setEnd(end);
    }

Referenced by Scroom::Utils::Rectangle< int >::setLeft(), and Scroom::Utils::Rectangle< int >::setTop().

Here is the caller graph for this function:

to()

template<typename T >

template<typename U >

Segment<U> Scroom::Utils::Segment< T >::to ( ) const

inline

    {
      return {
        static_cast<U>(start),
        static_cast<U>(size),
      };
    }

Member Data Documentation

size

template<typename T >

value_type Scroom::Utils::Segment< T >::size

private

Referenced by Scroom::Utils::Segment< value_type >::after(), Scroom::Utils::Segment< value_type >::before(), Scroom::Utils::Segment< value_type >::contains(), Scroom::Utils::Segment< value_type >::getEnd(), Scroom::Utils::Segment< value_type >::getSize(), Scroom::Utils::Segment< value_type >::moveTo(), Scroom::Utils::Segment< value_type >::normalize(), Scroom::Utils::Segment< value_type >::operator*=(), Scroom::Utils::Segment< value_type >::operator/=(), Scroom::Utils::Segment< value_type >::operator==(), Scroom::Utils::Segment< value_type >::reduceSizeToMultipleOf(), Scroom::Utils::Segment< value_type >::setEnd(), Scroom::Utils::Segment< value_type >::setSize(), and Scroom::Utils::Segment< value_type >::to().

start

template<typename T >

value_type Scroom::Utils::Segment< T >::start

private

Referenced by Scroom::Utils::Segment< value_type >::after(), Scroom::Utils::Segment< value_type >::before(), Scroom::Utils::Segment< value_type >::contains(), Scroom::Utils::Segment< value_type >::getEnd(), Scroom::Utils::Segment< value_type >::getStart(), Scroom::Utils::Segment< value_type >::normalize(), Scroom::Utils::Segment< value_type >::operator*=(), Scroom::Utils::Segment< value_type >::operator+=(), Scroom::Utils::Segment< value_type >::operator-=(), Scroom::Utils::Segment< value_type >::operator/=(), Scroom::Utils::Segment< value_type >::operator==(), Scroom::Utils::Segment< value_type >::setEnd(), Scroom::Utils::Segment< value_type >::setStart(), and Scroom::Utils::Segment< value_type >::to().

---

The documentation for this class was generated from the following file:

• inc/scroom/linearsegment.hh