db/compartments.hh

#ifndef VTESTBED_DB_COMPARTMENTS_HH
#define VTESTBED_DB_COMPARTMENTS_HH

#include <string>
#include <vector>

#include <sqlitex/forward.hh>

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

namespace vtb {

    namespace db {

        template <class T>
        class Room {

        public:
            using polyhedron_type = vtb::geometry::Polyhedron<T,3>;
            using id_type = int64_t;

        private:
            id_type _id = 0;
            std::string _name;
            polyhedron_type _geometry;

        public:

            void clear();
            void read(sqlite::statement& in);

            inline id_type id() const { return this->_id; }
            inline void id(id_type rhs) { this->_id = rhs; }
            inline bool has_id() { return this->_id != 0; }
            inline const std::string& name() const { return this->_name; }
            inline void name(const std::string& rhs) { this->_name = rhs; }
            inline const polyhedron_type& polyhedron() const { return this->_geometry; }
            inline void polyhedron(const polyhedron_type& rhs) { this->_geometry = rhs; }
            inline void polyhedron(polyhedron_type&& rhs) { this->_geometry = std::move(rhs); }

        };

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

        template <class T>
        class Compartments: public Entity {

        public:
            using room_type = Room<T>;
            using room_array = std::vector<room_type>;
            using polyhedron_type = typename room_type::polyhedron_type;
            using geometry_array = std::vector<polyhedron_type>;
            using vec3 = vtb::geometry::Vertex<T,3>;
            using int3 = vtb::geometry::Vertex<int,3>;
            using core_room_array = vtb::core::Compartment_array<T>;

        private:
            room_array _rooms;

        public:
            using Entity::filename;

            void clear();
            void import(std::string filename);
            void import_original();
            void filename(const std::string& filename);
            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 select_blobs(sqlite::connection* db);
            void update(sqlite::connection* db);
            void remove(sqlite::connection* db);
            void save(sqlite::connection* db);
            void read(sqlite::statement& in);

            void install(polyhedron_type hull, T wall_thickness, T eps);

            inline const room_array& rooms() const { return this->_rooms; }
            inline void rooms(room_array&& rhs) { this->_rooms = std::move(rhs); }
            void set_compartments(const core_room_array& rhs);
            core_room_array make_compartments(bool transform) const;

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

        private:

            inline room_array& rooms() { return this->_rooms; }
            void insert_rooms(sqlite::connection* db);

        };

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

    }

}

#endif // vim:filetype=cpp