ship_hull_transformation.hh

#ifndef VTESTBED_DB_SHIP_HULL_TRANSFORMATION_HH
#define VTESTBED_DB_SHIP_HULL_TRANSFORMATION_HH

#include <iosfwd>
#include <string>
#include <vector>

#include <sqlitex/forward.hh>

#include <vtestbed/geometry/polyhedron.hh>

namespace vtb {

    namespace db {

        enum class Transformations {
            Mirror = 1,
            Flip = 2,
            Centre_of_mass = 3,
            Rotate = 4,
            Scale = 5,
            Centre_of_bounding_box = 6,
            Move = 7,
            Centre_auto = 8,
        };

        const char*
        to_string(Transformations rhs);

        std::ostream&
        operator<<(std::ostream& out, Transformations rhs);

        std::istream&
        operator>>(std::istream& in, Transformations& rhs);

        template <class T>
        class Ship_hull_transformation {

        public:
            using polyhedron_type = vtb::geometry::Polyhedron<T>;
            using vertex_type = typename polyhedron_type::vertex_type;

            enum class Type {Integer, Real};

            struct Argument {
                Type type;
                union { int int_number; T real_number; };

                Argument(): type(Type::Integer), int_number(0) {}
                Argument(int n): type(Type::Integer), int_number(n) {}
                Argument(T n): type(Type::Real), real_number(n) {}

            };

        private:
            Transformations _transformation{};
            int _dimension = 0;
            Argument _argument;

        public:

            Ship_hull_transformation() = default;

            inline
            Ship_hull_transformation(Transformations tr):
            _transformation{tr} {}

            inline
            Ship_hull_transformation(Transformations tr, int dim):
            _transformation{tr}, _dimension{dim} {}

            inline
            Ship_hull_transformation(
                Transformations tr,
                int dim,
                Argument arg
            ):
            _transformation{tr}, _dimension{dim}, _argument{arg} {}

            void
            apply(polyhedron_type& hull) const;

            inline Transformations
            transformation() const {
                return this->_transformation;
            }

            template <class X>
            friend std::ostream&
            operator<<(
                std::ostream& out,
                const Ship_hull_transformation<X>& rhs
            );

            template <class X>
            friend std::istream&
            operator>>(
                std::istream& in,
                Ship_hull_transformation<X>& rhs
            );

        };

        template <class T>
        std::ostream&
        operator<<(std::ostream& out, const Ship_hull_transformation<T>& rhs);

        template <class T>
        std::istream&
        operator>>(std::istream& in, Ship_hull_transformation<T>& rhs);

        template <class T>
        std::string
        to_string(const Ship_hull_transformation<T>& rhs);

        template <class T>
        class Transform_sequence {

        public:
            typedef Ship_hull_transformation<T> transform_type;
            typedef std::vector<transform_type> transform_array;
            typedef typename transform_array::iterator iterator;
            typedef typename transform_array::const_iterator const_iterator;

        private:
            transform_array _transforms;
            size_t _index = 0;

        public:

            inline const transform_array&
            transformations() const {
                return this->_transforms;
            }

            inline size_t index() const { return this->_index; }

            inline void
            undo() {
                if (index() == 0) { return; };
                --this->_index;
            }

            inline void
            redo() {
                if (index() == this->_transforms.size()) { return; };
                ++this->_index;
            }

            inline void
            clear() {
                this->_transforms.clear();
                this->_index = 0;
            }

            inline const_iterator
            begin() const {
                return this->_transforms.begin();
            }

            inline const_iterator
            end() const {
                return this->begin() + this->index();
            }

            inline size_t
            size() const {
                return this->_index;
            }

            inline void
            push_back(transform_type t) {
                auto& ts = this->_transforms;
                ts.resize(this->_index);
                this->_transforms.push_back(t);
                ++this->_index;
            }

        };

        template <class T>
        std::ostream&
        operator<<(std::ostream& out, const Transform_sequence<T>& rhs);

        template <class T>
        std::istream&
        operator>>(std::istream& in, Transform_sequence<T>& rhs);

        template <class T>
        std::string
        to_string(const Transform_sequence<T>& rhs);

        template <class T>
        sqlite::cstream&
        operator>>(sqlite::cstream& in, Transform_sequence<T>& rhs);

    }

}

#endif // vim:filetype=cpp