db/hull.hh

#ifndef VTESTBED_DB_HULL_HH
#define VTESTBED_DB_HULL_HH

#include <chrono>
#include <vector>

#include <sqlitex/forward.hh>

#include <vtestbed/core/mass.hh>
#include <vtestbed/core/types.hh>
#include <vtestbed/db/entity.hh>
#include <vtestbed/db/ship_hull_transformation.hh>
#include <vtestbed/geometry/polyhedron.hh>

namespace vtb {

    namespace db {

        template <class T>
        class Hull: public Entity {

        public:
            using vec3 = vtb::core::Vector3<T>;
            using transformation_type = Ship_hull_transformation<T>;
            using clock = std::chrono::system_clock;
            using time_point = clock::time_point;
            using duration = clock::duration;
            using color_type = vec3;
            using polyhedron_type = vtb::geometry::Polyhedron<T>;
            using transformation_array = Transform_sequence<T>;
            using polyhedron_array = std::vector<polyhedron_type>;

        private:
            std::string _author;
            std::string _organisation;
            polyhedron_array _polyhedrons{{}};
            vec3 _scale{T{1}};
            T _length{0};
            T _beam{0};
            T _depth{0};
            T _draught{0};
            transformation_array _transforms;
            time_point _created{duration::zero()};
            time_point _modified{duration::zero()};
            color_type _color{T{0.184}, T{0.513}, T{0.8}};

        public:

            using Entity::filename;

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

            inline const std::string& author() const { return this->_author; }
            inline const std::string& organisation() const { return this->_organisation; }
            inline void author(const std::string& rhs) { this->_author = rhs; }
            inline void organisation(const std::string& rhs) { this->_organisation = rhs; }
            void filename(const std::string& filename);

            inline const polyhedron_type&
            polyhedron() const {
                return this->current_polyhedron();
            }

            inline void
            polyhedron(const polyhedron_type& rhs) {
                this->current_polyhedron() = rhs;
            }

            inline void
            polyhedron(polyhedron_type&& rhs) {
                this->current_polyhedron() = std::move(rhs);
            }

            inline const vec3& scale() const { return this->_scale; }
            inline void scale(const vec3& rhs) { this->_scale = rhs; }

            inline T length() const { return this->_length; }

            inline T beam() const { return this->_beam; }

            inline T depth() const { return this->_depth; }

            inline T draught() const { return this->_draught; }
            inline void draught(T rhs) { this->_draught = rhs; }

            inline void
            dimensions(T x, T y, T z) {
                this->_length = x;
                this->_beam = y;
                this->_depth = z;
            }

            inline void
            dimensions(const vec3& v) {
                this->_length = v(0);
                this->_beam = v(1);
                this->_depth = v(2);
            }

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

            inline const time_point& created() const { return this->_created; }
            inline const time_point& modified() const { return this->_modified; }
            inline void created(const time_point& rhs) { this->_created = rhs; }
            inline void modified(const time_point& rhs) { this->_modified = rhs; }

            inline const color_type&
            color() const noexcept {
                return this->_color;
            }

            inline void
            color(const color_type& rhs) {
                this->_color = rhs;
            }

            inline void
            color(T r, T g, T b) {
                this->_color(0) = r;
                this->_color(1) = g;
                this->_color(2) = b;
            }

            std::string
            file_name_for_export() const;

            bool has_valid_id(sqlite::connection* db) const;
            bool original(sqlite::connection* db) const;
            void insert(sqlite::connection* db);
            void copy(sqlite::connection* db);
            void select(sqlite::connection* db);
            void update(sqlite::connection* db);
            void save(sqlite::connection* db);
            void import(std::string filename);
            void import_original();
            void select_blobs(sqlite::connection* db);
            void update_blobs(sqlite::connection* db);
            void save_blobs(sqlite::connection* db);
            void remove(sqlite::connection* db);

            void
            clear();

            void
            swap(Hull& rhs);

            polyhedron_type make_ship_hull(bool transform);

            void transform(const transformation_type& rhs);
            void clear_transforms();
            inline void undo() { this->_transforms.undo(); }
            inline void redo() { this->_transforms.redo(); }

            template <class X>
            friend sqlite::statement&
            operator>>(sqlite::statement& in, Hull<X>& rhs);

            static std::vector<Hull<T>>
            all(sqlite::connection* db);

        private:

            void
            transform();

            void
            update_dimensions();

            inline const polyhedron_type&
            current_polyhedron() const {
                return this->_polyhedrons[this->_transforms.index()];
            }

            inline polyhedron_type&
            current_polyhedron() {
                auto& gs = this->_polyhedrons;
                if (gs.empty()) { gs.emplace_back(); }
                return gs[this->_transforms.index()];
            }

            inline const polyhedron_type&
            original_polyhedron() const {
                return this->_polyhedrons.front();
            }

        };

        template <class T>
        sqlite::statement&
        operator>>(sqlite::statement& in, Hull<T>& rhs);

        template <class T>
        inline void
        swap(Hull<T>& lhs, Hull<T>& rhs) {
            lhs.swap(rhs);
        }

    }

}

#endif // vim:filetype=cpp