graphics.hh

#ifndef VTESTBED_IGES_GRAPHICS_HH
#define VTESTBED_IGES_GRAPHICS_HH

#include <istream>
#include <limits>
#include <memory>
#include <ostream>
#include <string>
#include <vector>

#include <vtestbed/iges/directory_entry.hh>
#include <vtestbed/iges/section.hh>
#include <vtestbed/iges/string.hh>
#include <vtestbed/iges/timestamp.hh>
#include <vtestbed/iges/types.hh>
#include <vtestbed/iges/unit.hh>
#include <vtestbed/iges/entity.hh>

namespace vtb {

    namespace iges {

        class Graphics {

        private:
            typedef Double Real;
            typedef timestamp::time_point time_point;
            typedef std::shared_ptr<Entity> entity_ptr;

        private:
            std::string _prologue;
            char _parameter_delimiter = ',';
            char _record_delimiter = ';';
            string _senderproduct, _receiverproduct, _filename, _software, _preprocessor;
            Integer _nbits = std::numeric_limits<Integer>::digits;
            Integer _single_maxexp10 = std::numeric_limits<Single>::max_exponent10;
            Integer _single_maxdigits10 = std::numeric_limits<Single>::max_digits10;
            Integer _double_maxexp10 = std::numeric_limits<Double>::max_exponent10;
            Integer _double_maxdigits10 = std::numeric_limits<Double>::max_digits10;
            Integer _maxlineweightgradations{1};
            Real _scale{1}, _lineweight{1}, _minresolution{0}, _maxcoord{0};
            Unit _unit = Unit::Inches;
            string _unitname{"IN"}, _author, _organisation;
            timestamp _created, _modified;
            Integer _version{3}, _draft{0};
            string _protocol;
            std::vector<Directory_entry> _entries;
            std::vector<entity_ptr> _entities;
            std::string _real_filename;

        public:

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

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

            inline const std::string& prologue() const noexcept { return this->_prologue; }
            inline const std::string& author() const noexcept { return this->_author; }
            inline const std::string& organisation() const { return this->_organisation; }
            inline const time_point& created() const noexcept { return this->_created; }
            inline const time_point& modified() const noexcept { return this->_modified; }
            inline const std::string& real_filename() const { return this->_real_filename; }

            inline void unit(Unit rhs) { this->unit(rhs, unit_name(rhs)); }

            inline void
            unit(Unit rhs, const string& name) {
                this->_unit = rhs;
                this->_unitname = name;
            }

            inline void max_coordinate(Real rhs) { this->_maxcoord = rhs; }
            inline void prologue(const std::string& rhs) { this->_prologue = rhs; }
            inline void created(const timestamp& rhs) { this->_created = rhs; }
            inline void modified(const timestamp& rhs) { this->_modified = rhs; }
            inline void real_filename(const std::string& rhs) { this->_real_filename = rhs; }

            void dump(std::ostream& out);

            inline void
            emplace_back(entity_ptr&& ptr) {
                this->_entities.emplace_back(std::forward<entity_ptr>(ptr));
            }

            inline void
            push_back(const entity_ptr& ptr) {
                this->_entities.push_back(ptr);
            }

        private:

            void
            validate_section(Section last, Section current);

            void
            parse_global_section(const std::string& text);

            void
            parse_directory_entry_section(const std::vector<std::string>& text);

            void
            parse_parameter_data_section(const std::vector<std::string>& text);

            void
            parse_terminate_section(const std::string& text);

        };

        inline std::istream&
        operator>>(std::istream& in, Graphics& rhs) {
            rhs.read(in); return in;
        }

        inline std::ostream&
        operator<<(std::ostream& out, const Graphics& rhs) {
            rhs.write(out); return out;
        }

    }

}

#endif // vim:filetype=cpp