face.hh

#ifndef VTESTBED_GEOMETRY_FACE_HH
#define VTESTBED_GEOMETRY_FACE_HH

#include <algorithm>
#include <initializer_list>
#include <iosfwd>
#include <utility>

#include <vtestbed/base/bstream.hh>

namespace vtb {

    namespace geometry {

        template <int N>
        class Face {

            static_assert(N >= 3, "bad N");

        public:
            using value_type = unsigned int;
            using size_type = int;
            using iterator = value_type*;
            using const_iterator = const value_type*;

        private:
            value_type _indices[N] {};

        public:

            Face() = default;
            Face(const Face&) = default;
            Face& operator=(const Face&) = default;
            ~Face() = default;

            inline
            Face(std::initializer_list<value_type> list) {
                std::copy_n(list.begin(), N, this->_indices);
            }

            template <class ... Args>
            inline explicit
            Face(Args ... indices): _indices{indices...} {}

            inline value_type
            operator()(size_type i) const {
                return this->_indices[i];
            }

            inline value_type&
            operator()(size_type i) {
                return this->_indices[i];
            }

            inline value_type
            operator[](size_type i) const {
                return this->_indices[i];
            }

            inline value_type&
            operator[](size_type i) {
                return this->_indices[i];
            }

            inline iterator begin() { return this->_indices; }
            inline iterator end() { return this->_indices + N; }
            inline const_iterator begin() const { return this->_indices; }
            inline const_iterator end() const { return this->_indices + N; }

            inline value_type front() const { return this->_indices[0]; }
            inline value_type back() const { return this->_indices[N-1]; }

            static constexpr inline size_type size() { return N; }

            inline size_type
            index_of(value_type value) const {
                for (size_type i=0; i<N; ++i) {
                    if (this->_indices[i] == value) {
                        return i;
                    }
                }
                return -1;
            }

            inline bool
            contains(value_type value) const {
                for (size_type i=0; i<N; ++i) {
                    if (this->_indices[i] == value) {
                        return true;
                    }
                }
                return false;
            }

            inline void
            flip_winding() {
                std::swap(this->_indices[0], this->_indices[1]);
            }

            bool reorder(const Face<N>& rhs, value_type shared_vertex);
            void sort();

            inline Face&
            operator+=(value_type rhs) {
                for (auto& idx : this->_indices) {
                    idx += rhs;
                }
                return *this;
            }

        };

        template <int N>
        inline bool
        operator==(const Face<N>& lhs, const Face<N>& rhs) {
            return std::equal(lhs.begin(), lhs.end(), rhs.begin());
        }

        template <int N>
        inline bool
        operator!=(const Face<N>& lhs, const Face<N>& rhs) {
            return !operator==(lhs, rhs);
        }

        template <int N>
        inline bool
        operator<(const Face<N>& lhs, const Face<N>& rhs) {
            return std::lexicographical_compare(
                lhs.begin(), lhs.end(),
                rhs.begin(), rhs.end()
            );
        }

        template <int N>
        std::ostream&
        operator<<(std::ostream& out, const Face<N>& rhs);

        template <int N>
        std::istream&
        operator>>(std::istream& in, Face<N>& rhs);

        template <int N>
        vtb::core::bstream&
        operator<<(vtb::core::bstream& out, const Face<N>& rhs);

        template <int N>
        vtb::core::bstream&
        operator>>(vtb::core::bstream& in, Face<N>& rhs);

    }

}

#endif // vim:filetype=cpp