directory_entry.hh

#ifndef VTESTBED_IGES_DIRECTORY_ENTRY_HH
#define VTESTBED_IGES_DIRECTORY_ENTRY_HH

#include <iosfwd>

#include <vtestbed/iges/types.hh>

namespace vtb {

    namespace iges {

        struct Directory_entry {

            typedef Integer* pointer;
            typedef const Integer* const_pointer;
            typedef pointer iterator;
            typedef const_pointer const_iterator;
            typedef size_t size_type;
            typedef Integer& reference;
            typedef const Integer& const_reference;

            union {
                struct {
                    Integer _entitytype = 0;
                    mutable Integer _parameterdata = 0;
                    Integer _structure = 0;
                    Integer _linefontpattern = 0;
                    Integer _level = 0;
                    Integer _view = 0;
                    Integer _transformation_matrix = 0;
                    Integer _display_associativity = 0;
                    char _status[8] {'0', '0', '0', '0', '0', '0', '0', '0'};
                    Integer _entitytype2 = 0;
                    Integer _lineweight = 0;
                    Integer _color = 0;
                    Integer _linecount = 0;
                    Integer _form = 0;
                    Integer _reserved1 = 0;
                    Integer _reserved2 = 0;
                    char _label[8] {' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '};
                    Integer _subscript = 0;
                };
                Integer _fields[18];
            };

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

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

            static constexpr inline size_type
            size() noexcept {
                return sizeof(_fields) / sizeof(Integer);
            }

            inline iterator
            begin() noexcept {
                return this->data();
            }

            inline const_iterator
            begin() const noexcept {
                return this->data();
            }

            inline iterator
            end() noexcept {
                return this->data() + this->size();
            }

            inline const_iterator
            end() const noexcept {
                return this->data() + this->size();
            }

            inline reference
            operator[](size_type i) noexcept {
                return this->_fields[i];
            }

            inline const_reference
            operator[](size_type i) const noexcept {
                return this->_fields[i];
            }

            inline Integer
            type() const noexcept {
                return this->_entitytype;
            }

            inline void
            type(Integer rhs) noexcept {
                this->_entitytype = rhs;
            }

            inline void
            parameter_data(Integer number) const {
                this->_parameterdata = number;
            }

            inline size_type
            sequence_number() const noexcept {
                return 2*this->_parameterdata - 1;
            }

            inline void
            status(size_type i, char ch) {
                this->_status[i] = ch;
            }

            inline void
            dependent(bool b) {
                this->status(3, b ? '3' : '0');
            }

        };

        const char*
        operator>>(const char* text, Directory_entry& entry);

        std::ostream&
        operator<<(std::ostream& out, const Directory_entry& rhs);

    }

}

#endif // vim:filetype=cpp