stream.hh

#ifndef VTESTBED_IGES_STREAM_HH
#define VTESTBED_IGES_STREAM_HH

#include <ostream>
#include <streambuf>

#include <vtestbed/iges/section.hh>

namespace vtb {

    namespace iges {

        class iges_ostreambuf: public std::streambuf {

        public:
            using std::streambuf::int_type;
            using std::streambuf::char_type;
            using std::streambuf::traits_type;
            typedef char_type* pointer;
            typedef const char_type* const_pointer;

        private:
            std::streambuf* _sink = nullptr;
            char_type _line[82];
            Section _section = Section::Start;
            size_t _lineno = 0;
            size_t _number = 0;
            std::streamsize _maxsize = 72;
            char _parameter_delimiter = ',';
            char _record_delimiter = ';';

        public:

            iges_ostreambuf() = default;
            virtual ~iges_ostreambuf() = default;

            inline
            iges_ostreambuf(std::streambuf* sink, char d1, char d2):
            _sink{sink}, _parameter_delimiter{d1}, _record_delimiter{d2} {
                reset();
            }

            inline char
            parameter_delimiter() const noexcept {
                return this->_parameter_delimiter;
            }

            inline char
            record_delimiter() const noexcept {
                return this->_record_delimiter;
            }

            void
            section(Section s);

            inline void
            finish() {
                if (this->pptr() != this->pbase()) {
                    this->newline();
                }
            }

            inline void
            sink(std::streambuf* sink) {
                this->_sink = sink;
            }

            inline size_t
            next_entity_number() {
                return ++this->_number;
            }

            inline size_t
            line_number() const {
                return _lineno+1;
            }

            int_type
            overflow(int_type ch) override;

            std::streamsize
            xsputn(const char_type* s, std::streamsize n) override;

            int_type
            sync() override;

        private:

            inline pointer
            data() noexcept {
                return this->_line;
            }

            inline const_pointer
            data() const noexcept {
                return this->_line;
            }

            inline static std::streamsize
            size() noexcept {
                return sizeof(_line);
            }

            inline std::streamsize
            max_size() noexcept {
                return this->_maxsize;
            }

            inline char_type
            section_character() const noexcept {
                return static_cast<char_type>(_section);
            }

            inline void
            reset() {
                this->setp(this->data(), this->data() + this->max_size());
            }

            void
            newline();

        };

        class iges_ostream: public std::ostream {

        private:
            iges_ostreambuf _buffer;

        public:
            using std::ostream::ostream;

            inline
            iges_ostream(std::ios& sink, char d1, char d2):
            iges_ostream(sink.rdbuf(), d1, d2) {}

            inline
            iges_ostream(std::streambuf* sink, char d1, char d2):
            _buffer(sink, d1, d2) {
                init(&_buffer);
            }

            inline char
            parameter_delimiter() const noexcept {
                return this->_buffer.parameter_delimiter();
            }

            inline char
            record_delimiter() const noexcept {
                return this->_buffer.record_delimiter();
            }

            inline size_t
            next_entity_number() {
                return this->_buffer.next_entity_number();
            }

            inline size_t
            line_number() const {
                return this->_buffer.line_number();
            }

            inline void
            section(Section s) noexcept {
                this->_buffer.section(s);
            }

            inline void
            finish() {
                this->_buffer.finish();
            }

            inline void
            sink(std::streambuf* sink) {
                this->_buffer.sink(sink);
            }

        };


    }

}

#endif // vim:filetype=cpp