vsl/compartments.hh

#ifndef VTESTBED_VSL_COMPARTMENTS_HH
#define VTESTBED_VSL_COMPARTMENTS_HH

#include <array>
#include <istream>
#include <ostream>
#include <string>
#include <vector>

#include <vtestbed/base/blitz.hh>
#include <vtestbed/geometry/basis.hh>
#include <vtestbed/vsl/description.hh>
#include <vtestbed/vsl/name.hh>

namespace vtb {

    namespace vsl {

        template <class T>
        class Room {

        public:
            using vec3 = blitz::TinyVector<T,3>;
            using basis_type = vtb::geometry::Basis<T,3>;
            using coordinate_system_type = vtb::geometry::Coordinate_system<T,3>;

        private:
            vec3 _origin{T{}};
            basis_type _ibasis{T{}};
            std::string _name;

        public:

            void read(std::istream& in);
            void write(std::ostream& out) const;
            void clear();

            inline const std::string& name() const { return this->_name; }
            inline const vec3& origin() const { return this->_origin; }
            inline const basis_type& inverse_basis() const { return this->_ibasis; }

            inline coordinate_system_type
            coordinate_system() const {
                return coordinate_system_type(inverse(inverse_basis()), origin());
            }

        };

        template <class T>
        inline std::istream&
        operator>>(std::istream& in, Room<T>& rhs) {
            rhs.read(in);
            return in;
        }

        template <class T>
        inline std::ostream&
        operator<<(std::ostream& out, const Room<T>& rhs) {
            rhs.write(out);
            return out;
        }

        template <class T>
        class Compartments {

        private:
            using room_type = Room<T>;
            using room_array = std::vector<room_type>;

        private:
            enum class Reading {Name, Room};

        private:
            std::string _filename;
            Name _name;
            Description _description;
            room_array _rooms;

        public:

            void read(std::istream& in);
            void write(std::ostream& out) const;
            void clear();

            inline const room_array& rooms() const { return this->_rooms; }
            inline void filename(const std::string& filename) { this->_filename = filename; }
            inline const std::string& filename() const noexcept { return this->_filename; }
            inline const Name& name() const { return this->_name; }
            inline const Description& description() const { return this->_description; }

        private:

            void read_line(std::istream& in, Reading& state);
            void read_room(std::istream& in);

        };

        template <class T>
        inline std::istream&
        operator>>(std::istream& in, Compartments<T>& rhs) {
            rhs.read(in);
            return in;
        }

        template <class T>
        inline std::ostream&
        operator<<(std::ostream& out, const Compartments<T>& rhs) {
            rhs.write(out);
            return out;
        }

    }

}

#endif // vim:filetype=cpp