polygon_3d.hpp

#pragma once

#include <vector>

#include "global.hpp"

#include "point_3d.hpp"
#include "point_3d_h.hpp"

namespace Cvb
{

CVB_BEGIN_INLINE_NS

template <class T>
using IsPolygonPoint =
std::integral_constant<bool,
  (std::is_same<Point3D<typename T::ValueType>, T>::value || std::is_same<Point3DH<typename T::ValueType>, T>::value) 
    && std::is_floating_point<typename T::ValueType>::value>;

template <class T>
using EnablePolygonPoint = std::enable_if<IsPolygonPoint<T>::value>;


template<class T, class ENABLE = void>
class Polygon3D final
{

#ifndef CVB_DOXYGEN
  static_assert (IsPolygonPoint<T>::value, "CVB: Polygon type must be Point3D or Point3DH with floating point type");
};


template <class T>
class Polygon3D<T,
  typename EnablePolygonPoint<T>::type> final
{

#endif

  public:


    Polygon3D() = default;

    Polygon3D(const Polygon3D&) = default;

    Polygon3D& operator=(const Polygon3D&) = default;


    Polygon3D(std::vector<T>&& points)
      : points_(std::move(points))
    {
    }

    Polygon3D(Polygon3D&&) = default;
    Polygon3D& operator=(Polygon3D&&) = default;


    explicit Polygon3D(const std::vector<T>& points) noexcept
      : points_(points)
    {
    }


    template<std::size_t N>
    Polygon3D(const T(&list)[N]) noexcept
    {
      static_assert(N >= 3, "CVB: Poligon3D must have at least three points");
      points_ = std::vector<T>(list, list + N);
    }


    const T& operator[](std::size_t index) const noexcept
    {
      return points_[index];
    }


    const T& At(std::size_t index) const
    {
      return points_.at(index);
    }


    std::size_t NumPoints() const noexcept
    {
      return points_.size();
    }


    auto CBegin() const noexcept
    {
      return points_.cbegin();
    }


    auto Begin() const noexcept
    {
      return CBegin();
    }


    auto cbegin() const noexcept
    {
      return CBegin();
    }


    auto begin() const noexcept
    {
      return CBegin();
    }


    auto CEnd() const noexcept
    {
      return points_.cend();
    }


    auto End() const noexcept
    {
      return CEnd();
    }


    auto cend() const noexcept
    {
      return CEnd();
    }


    auto end() const noexcept
    {
      return cend();
    }


    auto CRBegin() const noexcept
    {
      return points_.crbegin();
    }


    auto RBegin() const noexcept
    {
      return CRBegin();
    }


    auto crbegin() const noexcept
    {
      return CRBegin();
    }


    auto rbegin() const noexcept
    {
      return crbegin();
    }


    auto CREnd() const noexcept
    {
      return points_.crend();
    }


    auto REnd() const noexcept
    {
      return CREnd();
    }


    auto crend() const noexcept
    {
      return CREnd();
    }


    auto rend() const noexcept
    {
      return crend();
    }


    bool operator==(const Polygon3D<T>& polygon) const noexcept
    {
      return points_ == polygon.points_;
    }



    bool operator!=(const Polygon3D<T>& polygon) const noexcept
    {
      return !(*this == polygon);
    }

    template <class C>
    explicit operator Polygon3D<C>() const noexcept
    {
      std::vector<C> points;
      points.reserve(points_.size());
      for (const auto& point : points_)
        points.emplace_back(static_cast<C>(point));
      return Polygon3D<C>(std::move(points));
    }

  private:

    std::vector<T> points_;



};

CVB_END_INLINE_NS


}