TVector2D.h

Go to the documentation of this file.

// ReSharper disable file CppNonExplicitConversionOperator
#pragma once
#include <limits>
#include <string>
 
namespace sf
{
 
// Forward declaration.
template<typename T>
class TMatrix22;
 
// Forward declaration.
template<typename T>
class TRectangle2D;

template<typename T>
class TVector2D
{
  public:
    typedef T value_type;

    TVector2D() = default;

    TVector2D(const TVector2D& v);

    TVector2D(TVector2D&&) noexcept;

    TVector2D(T xp, T yp);

    TVector2D& assign(T xp, T yp);

    TVector2D& assign(const TVector2D& v);

    TVector2D& operator=(const TVector2D& v) noexcept;

    TVector2D& operator=(TVector2D&& v) noexcept;

    TVector2D& operator*=(const TMatrix22<T>& mtx);

    TVector2D operator-() const;

    TVector2D& operator+=(const TVector2D&);

    TVector2D& operator-=(const TVector2D&);

    TVector2D& operator*=(T c);

    TVector2D& operator/=(T);

    TVector2D operator+(const TVector2D&) const;

    TVector2D operator-(const TVector2D&) const;

    TVector2D operator/(T) const;

    bool isEqual(const TVector2D& v, T tol = tolerance) const;

    bool operator==(const TVector2D&) const;

    bool operator!=(const TVector2D&) const;

    T& operator[](size_t);

    const T& operator[](size_t) const;

    constexpr T* data();

    constexpr const T* data() const;

    constexpr operator T*();

    constexpr operator const T*() const;

    constexpr T x() const;

    constexpr T& x();

    constexpr T y() const;

    constexpr T& y();

    T length() const;

    T lengthSqr() const;

    TVector2D& normalize();

    TVector2D normalized() const;

    TVector2D& scale(T factor);

    TVector2D scaled(T factor) const;

    T crossProduct(const TVector2D&) const;

    T dotProduct(const TVector2D&) const;

    T operator*(const TVector2D& v) const;

    T angle(const TVector2D&) const;

    T angle() const;

    T angleNormalized() const;

    T slope() const;

    T distance(const TVector2D&) const;

    T distanceSqr(const TVector2D&) const;

    void updateMin(const TVector2D& vertex);

    void updateMax(const TVector2D& vertex);

    std::string toString() const;

    TVector2D& fromString(const std::string& s, bool ignore_err = false) noexcept(false);

    static constexpr auto tolerance = std::numeric_limits<T>::epsilon() * 10.0;

    static int areOnSameSide(const TVector2D& lp1, const TVector2D& lp2, const TVector2D& p1, const TVector2D& p2);
 
  protected:
    union data_type
    {
        T array[2];
 
        struct point_type
        {
            T x;
            T y;
        } coord;
    } _data{0, 0};
 
    friend TRectangle2D<T>;
};
 
template<typename T>
TVector2D<T> operator*(T c, const TVector2D<T>& v)
{
  return {v.x() * c, v.y() * c};
}
 
template<typename T>
TVector2D<T> operator*(const TVector2D<T>& v, T c)
{
  return {v.x() * c, v.y() * c};
}

template<typename T>
std::istream& operator>>(std::istream& is, TVector2D<T>& v) noexcept(false)
{
  std::string s;
  constexpr auto delimiter = ')';
  std::getline(is, s, delimiter);
  v.fromString(s.append(1, delimiter));
  return is;
}

template<typename T>
std::ostream& operator<<(std::ostream& os, const TVector2D<T>& v)
{
  return os << v.toString();
}
 
}// namespace sf
 
#ifndef __JETBRAINS_IDE__
  // Include all inlined functions and template implementations.
  #include <math/TVector2D.hpp>
#endif