rectangle.hh

#ifndef VTESTBED_GEOMETRY_RECTANGLE_HH
#define VTESTBED_GEOMETRY_RECTANGLE_HH

#include <array>

#include <vtestbed/geometry/types.hh>

namespace vtb {

    namespace geometry {

        template <class T, int N>
        class Rectangle: public std::array<Vertex<T,N>,2> {

        private:
            using base_type = std::array<Vertex<T,N>,2>;

        public:
            static constexpr const int dimensions = N;
            using scalar_type = T;
            using value_type = typename base_type::value_type;
            using pointer = typename base_type::pointer;
            using const_pointer = typename base_type::const_pointer;
            using reference = typename base_type::reference;
            using const_reference = typename base_type::const_reference;
            using iterator = typename base_type::iterator;
            using const_iterator = typename base_type::const_iterator;
            using size_type = typename base_type::size_type;
            using difference_type = typename base_type::difference_type;
            using reverse_iterator = typename base_type::reverse_iterator;
            using const_reverse_iterator = typename base_type::const_reverse_iterator;

        public:
            using base_type::base_type;
            using base_type::operator=;
            using base_type::operator[];


            inline explicit
            Rectangle(const_reference p0, const_reference p1):
            base_type{p0,p1} {}

            inline value_type
            extent() const {
                return this->back() - this->front();
            }

            inline const_reference min() const { return this->front(); }
            inline const_reference max() const { return this->back(); }
            inline reference min() { return this->front(); }
            inline reference max() { return this->back(); }
            inline void clear() { this->front() = T{}, this->back() = T{}; }

        };

        template <class T, int N>
        inline Vertex<T,N>
        centroid(const Rectangle<T,N>& r) {
            return (r[0]+r[1])*T{0.5};
        }

        template <class T, int N>
        inline Vertex<T,N>
        area(const Rectangle<T,N>& r) {
            return product(r[1] - r[0]);
        }

    }

}

#endif // vim:filetype=cpp