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() = default;


    explicit Polygon3D(std::vector<T> &&points)
        : points_(std::move(points))
    {
    }
    explicit Polygon3D(std::vector<T> &&points) {…}
 
    Polygon3D(Polygon3D &&)            = default;
    Polygon3D &operator=(Polygon3D &&) = default;


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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

    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));
    }
    explicit operator Polygon3D<C>() const noexcept {…}
 
  private:
    std::vector<T> points_;
  };
  class Polygon3D final {…};
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb