solid.hh

#ifndef VTESTBED_STL_SOLID_HH
#define VTESTBED_STL_SOLID_HH

#include <istream>
#include <ostream>
#include <string>

#include <vtestbed/geometry/polyhedron.hh>

namespace vtb {

    namespace stl {

        template <class T>
        class Solid {

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

        private:
            std::string _name;
            polyhedron_type _polyhedron;

        public:

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

            inline explicit
            Solid(const polyhedron_type& polyhedron):
            _polyhedron(polyhedron) {}

            inline explicit
            Solid(polyhedron_type&& polyhedron):
            _polyhedron(std::move(polyhedron)) {}

            inline void clear() { this->_polyhedron.clear(); }
            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->_polyhedron; }
            inline polyhedron_type& polyhedron() { return this->_polyhedron; }

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

        };

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

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

    }

}

#endif // vim:filetype=cpp