object.hh

#ifndef VTESTBED_GEOMETRY_OBJECT_HH
#define VTESTBED_GEOMETRY_OBJECT_HH

#include <istream>
#include <ostream>
#include <vector>

#include <blitz/array.h>

#include <vtestbed/geometry/polyhedron.hh>

namespace vtb {

    namespace obj {

        template <class T>
        class Object {

        public:
            using polyhedron_type = vtb::geometry::Polyhedron<T>;
            using vertex_array = typename polyhedron_type::vertex_array;
            using face_array = typename polyhedron_type::face_array;
            using face_type = typename face_array::value_type;
            using index_type = typename face_type::value_type;

        private:
            polyhedron_type _polyhedron;

        public:

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

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

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

            inline void clear() { this->_polyhedron.clear(); }
            void write(std::ostream& out) const;
            void read(std::istream& in);

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

        };

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

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

    }

}

#endif // vim:filetype=cpp