isobus_virtual_terminal_objects.hpp

Go to the documentation of this file.

//================================================================================================
//================================================================================================
#ifndef ISOBUS_VIRTUAL_TERMINAL_OBJECTS_HPP
#define ISOBUS_VIRTUAL_TERMINAL_OBJECTS_HPP
 
#include "isobus/isobus/can_constants.hpp"
 
#include <array>
#include <map>
#include <memory>
#include <string>
#include <vector>
 
namespace isobus
{
    enum class VirtualTerminalObjectType : std::uint8_t
    {
        WorkingSet = 0, 
        DataMask = 1, 
        AlarmMask = 2, 
        Container = 3, 
        WindowMask = 34, 
        SoftKeyMask = 4, 
        Key = 5, 
        Button = 6, 
        KeyGroup = 35, 
        InputBoolean = 7, 
        InputString = 8, 
        InputNumber = 9, 
        InputList = 10, 
        OutputString = 11, 
        OutputNumber = 12, 
        OutputList = 37, 
        OutputLine = 13, 
        OutputRectangle = 14, 
        OutputEllipse = 15, 
        OutputPolygon = 16, 
        OutputMeter = 17, 
        OutputLinearBarGraph = 18, 
        OutputArchedBarGraph = 19, 
        GraphicsContext = 36, 
        Animation = 44, 
        PictureGraphic = 20, 
        GraphicData = 46, 
        ScaledGraphic = 48, 
        NumberVariable = 21, 
        StringVariable = 22, 
        FontAttributes = 23, 
        LineAttributes = 24, 
        FillAttributes = 25, 
        InputAttributes = 26, 
        ExtendedInputAttributes = 38, 
        ColourMap = 39, 
        ObjectLabelRefrenceList = 40, 
        ObjectPointer = 27, 
        ExternalObjectDefinition = 41, 
        ExternalReferenceNAME = 42, 
        ExternalObjectPointer = 43, 
        Macro = 28, 
        AuxiliaryFunctionType1 = 29, 
        AuxiliaryInputType1 = 30, 
        AuxiliaryFunctionType2 = 31, 
        AuxiliaryInputType2 = 32, 
        AuxiliaryControlDesignatorType2 = 33, 
        ManufacturerDefined1 = 240, 
        ManufacturerDefined2 = 241, 
        ManufacturerDefined3 = 242, 
        ManufacturerDefined4 = 243, 
        ManufacturerDefined5 = 244, 
        ManufacturerDefined6 = 245, 
        ManufacturerDefined7 = 246, 
        ManufacturerDefined8 = 247, 
        ManufacturerDefined9 = 248, 
        ManufacturerDefined10 = 249, 
        ManufacturerDefined11 = 250, 
        ManufacturerDefined12 = 251, 
        ManufacturerDefined13 = 252, 
        ManufacturerDefined14 = 253, 
        ManufacturerDefined15 = 254, 
        Reserved = 255 
    };
 
    enum class EventID : std::uint8_t
    {
        Reserved = 0, 
        OnActivate = 1, 
        OnDeactivate = 2, 
        OnShow = 3, 
        OnHide = 4, 
        // OnRefresh - An object that is already on display is redrawn (Macros cannot be associated with this event so no event ID is defined).
        OnEnable = 5, 
        OnDisable = 6, 
        OnChangeActiveMask = 7, 
        OnChangeSoftKeyMask = 8, 
        OnChangeAttribute = 9, 
        OnChangeBackgroundColour = 10, 
        ChangeFontAttributes = 11, 
        ChangeLineAttributes = 12, 
        ChangeFillAttributes = 13, 
        ChangeChildLocation = 14, 
        OnChangeSize = 15, 
        OnChangeValue = 16, 
        OnChangePriority = 17, 
        OnChangeEndpoint = 18, 
        OnInputFieldSelection = 19, 
        OnInputFieldDeselection = 20, 
        OnESC = 21, 
        OnEntryOfAValue = 22, 
        OnEntryOfANewValue = 23, 
        OnKeyPress = 24, 
        OnKeyRelease = 25, 
        OnChangeChildPosition = 26, 
        OnPointingEventPress = 27, 
        OnPointingEventRelease = 28, 
        ProprietaryRangeBegin = 240, 
        ProprietaryRangeEnd = 254, 
        UseExtendedMacroReference = 255 
    };
 
    struct MacroMetadata
    {
        EventID event; 
        std::uint16_t macroID; 
    };
 
    class VTColourVector
    {
    public:
        float r; 
        float g; 
        float b; 
 
        constexpr VTColourVector() :
          r(0.0f), g(0.0f), b(0.0f) {}
 
        constexpr VTColourVector(float red, float green, float blue) :
          r(red), g(green), b(blue) {}
    };
 
    class VTColourTable
    {
    public:
        VTColourTable();
 
        VTColourVector get_colour(std::uint8_t colourIndex) const;
 
        void set_colour(std::uint8_t colourIndex, VTColourVector newColour);
 
    private:
        static constexpr std::size_t VT_COLOUR_TABLE_SIZE = 256; 
 
        std::array<VTColourVector, VT_COLOUR_TABLE_SIZE> colourTable; 
    };
 
    class VTObject
    {
    public:
        enum class AttributeError : std::uint8_t
        {
            InvalidObjectID = 0,
            InvalidAttributeID = 1,
            InvalidValue = 2,
            AnyOtherError = 4
        };
 
        VTObject() = default;
 
        virtual ~VTObject() = default;
 
        virtual VirtualTerminalObjectType get_object_type() const = 0;
 
        virtual std::uint32_t get_minumum_object_length() const = 0;
 
        virtual bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const = 0;
 
        virtual bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) = 0;
 
        virtual bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const = 0;
 
        std::uint16_t get_id() const;
 
        void set_id(std::uint16_t value);
 
        std::uint16_t get_width() const;
 
        void set_width(std::uint16_t value);
 
        std::uint16_t get_height() const;
 
        void set_height(std::uint16_t value);
 
        std::uint8_t get_background_color() const;
 
        void set_background_color(std::uint8_t value);
 
        std::uint16_t get_number_children() const;
 
        void add_child(std::uint16_t objectID, std::int16_t relativeXLocation, std::int16_t relativeYLocation);
 
        std::uint16_t get_child_id(std::uint16_t index) const;
 
        std::int16_t get_child_x(std::uint16_t index) const;
 
        std::int16_t get_child_y(std::uint16_t index) const;
 
        void set_child_x(std::uint16_t index, std::int16_t xOffset);
 
        void set_child_y(std::uint16_t index, std::int16_t yOffset);
 
        bool offset_all_children_with_id(std::uint16_t childObjectID, std::int8_t xOffset, std::int8_t yOffset);
 
        void remove_child(std::uint16_t objectIDToRemove, std::int16_t relativeXLocation, std::int16_t relativeYLocation);
 
        void pop_child();
 
        std::uint8_t get_number_macros() const;
 
        void add_macro(MacroMetadata macroToAdd);
 
        MacroMetadata get_macro(std::uint8_t index) const;
 
        static std::shared_ptr<VTObject> get_object_by_id(std::uint16_t objectID, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool);
 
    protected:
        class ChildObjectData
        {
        public:
            ChildObjectData() = default;
 
            ChildObjectData(std::uint16_t objectId,
                            std::int16_t x,
                            std::int16_t y);
            std::uint16_t id = NULL_OBJECT_ID; 
            std::int16_t xLocation = 0; 
            std::int16_t yLocation = 0; 
        };
 
        std::vector<ChildObjectData> children; 
        std::vector<MacroMetadata> macros; 
        std::uint16_t objectID = NULL_OBJECT_ID; 
        std::uint16_t width = 0; 
        std::uint16_t height = 0; 
        std::uint8_t backgroundColor = 0; 
    };
 
    class WorkingSet : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            BackgroundColour = 1,
            Selectable = 2,
            ActiveMask = 3,
 
            NumberOfAttributes = 4
        };
 
        WorkingSet() = default;
 
        ~WorkingSet() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        bool get_selectable() const;
 
        void set_selectable(bool value);
 
        std::uint16_t get_active_mask() const;
 
        void set_active_mask(std::uint16_t value);
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 18; 
 
        std::vector<std::string> languageCodes; 
        std::uint16_t activeMask = NULL_OBJECT_ID; 
        bool selectable = false; 
    };
 
    class DataMask : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            BackgroundColour = 1,
            SoftKeyMask = 2,
 
            NumberOfAttributes = 3
        };
 
        DataMask() = default;
 
        ~DataMask() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        bool change_soft_key_mask(std::uint16_t newMaskID, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool);
 
        void set_soft_key_mask(std::uint16_t newMaskID);
 
        std::uint16_t get_soft_key_mask() const;
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 12; 
        std::uint16_t softKeyMaskObjectID = NULL_OBJECT_ID; 
    };
 
    class AlarmMask : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            BackgroundColour = 1,
            SoftKeyMask = 2,
            Priority = 3,
            AcousticSignal = 4,
 
            NumberOfAttributes = 5
        };
 
        enum class Priority : std::uint8_t
        {
            High = 0, 
            Medium = 1, 
            Low = 2 
        };
 
        enum class AcousticSignal : std::uint8_t
        {
            Highest = 0, 
            Medium = 1, 
            Lowest = 3, 
            None = 4 
        };
 
        AlarmMask() = default;
 
        ~AlarmMask() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        Priority get_mask_priority() const;
 
        void set_mask_priority(Priority value);
 
        AcousticSignal get_signal_priority() const;
 
        void set_signal_priority(AcousticSignal value);
 
        bool change_soft_key_mask(std::uint16_t newMaskID, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool);
 
        void set_soft_key_mask(std::uint16_t newMaskID);
 
        std::uint16_t get_soft_key_mask() const;
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 10; 
 
        std::uint16_t softKeyMask = NULL_OBJECT_ID; 
        Priority maskPriority = Priority::High; 
        AcousticSignal signalPriority = AcousticSignal::Highest; 
    };
 
    class Container : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            Width = 1,
            Height = 2,
            Hidden = 3,
 
            NumberOfAttributes = 4
        };
 
        Container() = default;
 
        ~Container() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        bool get_hidden() const;
 
        void set_hidden(bool value);
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 9; 
 
        bool hidden = false; 
    };
 
    class SoftKeyMask : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            BackgroundColour = 1,
 
            NumberOfAttributes = 2
        };
 
        SoftKeyMask() = default;
 
        ~SoftKeyMask() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 6; 
    };
 
    class Key : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            BackgroundColour = 1,
            KeyCode = 2,
 
            NumberOfAttributes = 3
        };
 
        Key() = default;
 
        ~Key() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        std::uint8_t get_key_code() const;
 
        void set_key_code(std::uint8_t value);
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 7; 
 
        std::uint8_t keyCode = 0; 
    };
 
    class KeyGroup : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            Options = 1,
            Name = 2,
 
            NumberOfAttributes = 3
        };
 
        enum class Options : std::uint8_t
        {
            Available = 0, 
            Transparent = 1 
        };
 
        KeyGroup() = default;
 
        ~KeyGroup() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        std::uint16_t get_key_group_icon() const;
 
        void set_key_group_icon(std::uint16_t value);
 
        bool get_option(Options option) const;
 
        void set_options(std::uint8_t value);
 
        void set_option(Options option, bool value);
 
        std::uint16_t get_name_object_id() const;
 
        void set_name_object_id(std::uint16_t value);
 
        static constexpr std::uint8_t MAX_CHILD_KEYS = 4; 
 
    private:
        bool validate_name(std::uint16_t nameIDToValidate, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const;
 
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 10; 
 
        std::uint16_t keyGroupIcon = NULL_OBJECT_ID; 
        std::uint16_t nameID = NULL_OBJECT_ID; 
        std::uint8_t optionsBitfield = 0; 
    };
 
    class Button : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            Width = 1,
            Height = 2,
            BackgroundColour = 3,
            BorderColour = 4,
            KeyCode = 5,
            Options = 6, // Version 4 and later
 
            NumberOfAttributes = 7
        };
 
        enum class Options : std::uint8_t
        {
            Latchable = 0, 
            CurrentButtonStateIfLatchable = 1, 
            SuppressBorder = 2, 
            TransparentBackground = 3, 
            Disabled = 4, 
            NoBorder = 5, 
            Reserved1 = 6, 
            Reserved2 = 7 
        };
 
        Button() = default;
 
        ~Button() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        std::uint8_t get_key_code() const;
 
        void set_key_code(std::uint8_t value);
 
        std::uint8_t get_border_colour() const;
 
        void set_border_colour(std::uint8_t value);
 
        bool get_option(Options option) const;
 
        void set_options(std::uint8_t value);
 
        void set_option(Options option, bool value);
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 13; 
 
        std::uint8_t borderColour = 0; 
        std::uint8_t keyCode = 0; 
        std::uint8_t optionsBitfield = 0; 
    };
 
    class InputBoolean : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            BackgroundColour = 1,
            Width = 2,
            ForegroundColour = 3,
            VariableReference = 4,
            Value = 5,
            Enabled = 6, // Version 4 and later
 
            NumberOfAttributes = 7
        };
 
        InputBoolean() = default;
 
        ~InputBoolean() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        std::uint8_t get_value() const;
 
        void set_value(std::uint8_t inputValue);
 
        bool get_enabled() const;
 
        void set_enabled(bool isEnabled);
 
        std::uint16_t get_foreground_colour_object_id() const;
 
        void set_foreground_colour_object_id(std::uint16_t fontAttributeValue);
 
        std::uint16_t get_variable_reference() const;
 
        void set_variable_reference(std::uint16_t numberVariableValue);
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 13; 
 
        std::uint16_t foregroundColourObjectID = NULL_OBJECT_ID; 
        std::uint16_t variableReference = NULL_OBJECT_ID; 
        std::uint8_t value = 0; 
        bool enabled = false; 
    };
 
    class InputString : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            Width = 1,
            Height = 2,
            BackgroundColour = 3,
            FontAttributes = 4,
            InputAttributes = 5,
            Options = 6,
            VariableReference = 7,
            Justification = 8,
            Enabled = 9, // Version 4 and later
 
            NumberOfAttributes = 10
        };
 
        enum class Options : std::uint8_t
        {
            Transparent = 0, 
            AutoWrap = 1, 
            WrapOnHyphen = 2 
        };
 
        enum class HorizontalJustification : std::uint8_t
        {
            PositionLeft = 0, 
            PositionMiddle = 1, 
            PositionRight = 2, 
            Reserved = 3 
        };
 
        enum class VerticalJustification : std::uint8_t
        {
            PositionTop = 0, 
            PositionMiddle = 1, 
            PositionBottom = 2, 
            Reserved = 3 
        };
 
        InputString() = default;
 
        ~InputString() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        bool get_enabled() const;
 
        void set_enabled(bool value);
 
        bool get_option(Options option) const;
 
        void set_options(std::uint8_t value);
 
        void set_option(Options option, bool value);
 
        HorizontalJustification get_horizontal_justification() const;
 
        VerticalJustification get_vertical_justification() const;
 
        void set_justification_bitfield(std::uint8_t value);
 
        std::string get_value() const;
 
        void set_value(const std::string &value);
 
        std::uint16_t get_font_attributes() const;
 
        void set_font_attributes(std::uint16_t fontAttributesValue);
 
        std::uint16_t get_variable_reference() const;
 
        void set_variable_reference(std::uint16_t variableReferenceValue);
 
        std::uint16_t get_input_attributes() const;
 
        void set_input_attributes(std::uint16_t inputAttributesValue);
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 19; 
 
        std::string stringValue; 
        std::uint16_t fontAttributes = NULL_OBJECT_ID; 
        std::uint16_t inputAttributes = NULL_OBJECT_ID; 
        std::uint16_t variableReference = NULL_OBJECT_ID; 
        std::uint8_t optionsBitfield = 0; 
        std::uint8_t justificationBitfield = 0; 
        bool enabled = false; 
    };
 
    class InputNumber : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            Width = 1,
            Height = 2,
            BackgroundColour = 3,
            FontAttributes = 4,
            Options = 5,
            VariableReference = 6,
            MinValue = 7,
            MaxValue = 8,
            Offset = 9,
            Scale = 10,
            NumberOfDecimals = 11,
            Format = 12,
            Justification = 13,
            Value = 14,
            Options2 = 15, // Version 4 and after
 
            NumberOfAttributes = 16
        };
 
        enum class Options : std::uint8_t
        {
            Transparent = 0, 
            DisplayLeadingZeros = 1, 
            DisplayZeroAsBlank = 2, 
            Truncate = 3 
        };
 
        enum class Options2 : std::uint8_t
        {
            Enabled = 0, 
            RealTimeEditing = 1 
        };
 
        enum class HorizontalJustification : std::uint8_t
        {
            PositionLeft = 0, 
            PositionMiddle = 1, 
            PositionRight = 2, 
            Reserved = 3 
        };
 
        enum class VerticalJustification : std::uint8_t
        {
            PositionTop = 0, 
            PositionMiddle = 1, 
            PositionBottom = 2, 
            Reserved = 3 
        };
 
        InputNumber() = default;
 
        ~InputNumber() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        HorizontalJustification get_horizontal_justification() const;
 
        VerticalJustification get_vertical_justification() const;
 
        void set_justification_bitfield(std::uint8_t newJustification);
 
        float get_scale() const;
 
        void set_scale(float newScale);
 
        std::uint32_t get_maximum_value() const;
 
        void set_maximum_value(std::uint32_t newMax);
 
        std::uint32_t get_minimum_value() const;
 
        void set_minimum_value(std::uint32_t newMin);
 
        std::int32_t get_offset() const;
 
        void set_offset(std::int32_t newOffset);
 
        std::uint8_t get_number_of_decimals() const;
 
        void set_number_of_decimals(std::uint8_t numDecimals);
 
        bool get_format() const;
 
        void set_format(bool newFormat);
 
        bool get_option(Options option) const;
 
        void set_options(std::uint8_t newOptions);
 
        void set_option(Options option, bool optionValue);
 
        bool get_option2(Options2 newOption) const;
 
        void set_options2(std::uint8_t newOptions);
 
        void set_option2(Options2 option, bool newOption);
 
        std::uint32_t get_value() const;
 
        void set_value(std::uint32_t inputValue);
 
        std::uint16_t get_font_attributes() const;
 
        void set_font_attributes(std::uint16_t fontAttributesValue);
 
        std::uint16_t get_variable_reference() const;
 
        void set_variable_reference(std::uint16_t variableReferenceValue);
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 38; 
 
        float scale = 0.0f; 
        std::uint32_t maximumValue = 0; 
        std::uint32_t minimumValue = 0; 
        std::uint32_t value = 0; 
        std::int32_t offset = 0; 
        std::uint16_t fontAttributes = NULL_OBJECT_ID; 
        std::uint16_t variableReference = NULL_OBJECT_ID; 
        std::uint8_t numberOfDecimals = 0; 
        std::uint8_t options = 0; 
        std::uint8_t options2 = 0; 
        std::uint8_t justificationBitfield = 0; 
        bool format = false; 
    };
 
    class InputList : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            Width = 1,
            Height = 2,
            VariableReference = 3,
            Value = 4,
            Options = 5, // Version 4 and after
 
            NumberOfAttributes = 6
        };
 
        enum class Options
        {
            Enabled = 0, 
            RealTimeEditing = 1 
        };
 
        InputList() = default;
 
        ~InputList() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        bool get_option(Options option) const;
 
        void set_options(std::uint8_t options);
 
        void set_option(Options option, bool optionValue);
 
        std::uint8_t get_value() const;
 
        void set_value(std::uint8_t inputValue);
 
        void set_variable_reference(std::uint16_t referencedObjectID);
 
        std::uint16_t get_variable_reference() const;
 
        bool change_list_item(std::uint8_t index, std::uint16_t newListItem, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool);
 
        std::uint8_t get_number_of_list_items() const;
 
        void set_number_of_list_items(std::uint8_t value);
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 13; 
 
        std::uint16_t variableReference = NULL_OBJECT_ID; 
        std::uint8_t numberOfListItems = 0; 
        std::uint8_t optionsBitfield = 0; 
        std::uint8_t value = 0; 
    };
 
    class OutputString : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            Width = 1,
            Height = 2,
            BackgroundColour = 3,
            FontAttributes = 4,
            Options = 5,
            VariableReference = 6,
            Justification = 7,
 
            NumberOfAttributes = 8
        };
 
        enum class Options
        {
            Transparent = 0, 
            AutoWrap = 1, 
            WrapOnHyphen = 2 
        };
 
        enum class HorizontalJustification : std::uint8_t
        {
            PositionLeft = 0, 
            PositionMiddle = 1, 
            PositionRight = 2, 
            Reserved = 3 
        };
 
        enum class VerticalJustification : std::uint8_t
        {
            PositionTop = 0, 
            PositionMiddle = 1, 
            PositionBottom = 2, 
            Reserved = 3 
        };
 
        OutputString() = default;
 
        ~OutputString() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        bool get_option(Options option) const;
 
        void set_options(std::uint8_t value);
 
        void set_option(Options option, bool value);
 
        HorizontalJustification get_horizontal_justification() const;
 
        VerticalJustification get_vertical_justification() const;
 
        void set_justification_bitfield(std::uint8_t value);
 
        std::string get_value() const;
 
        void set_value(const std::string &value);
 
        std::uint16_t get_font_attributes() const;
 
        void set_font_attributes(std::uint16_t fontAttributesValue);
 
        std::uint16_t get_variable_reference() const;
 
        void set_variable_reference(std::uint16_t variableReferenceValue);
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 16; 
 
        std::string stringValue; 
        std::uint16_t fontAttributes = NULL_OBJECT_ID; 
        std::uint16_t variableReference = NULL_OBJECT_ID; 
        std::uint8_t optionsBitfield = 0; 
        std::uint8_t justificationBitfield = 0; 
    };
 
    class OutputNumber : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            Width = 1,
            Height = 2,
            BackgroundColour = 3,
            FontAttributes = 4,
            Options = 5,
            VariableReference = 6,
            Offset = 7,
            Scale = 8,
            NumberOfDecimals = 9,
            Format = 10,
            Justification = 11,
 
            NumberOfAttributes = 12
        };
 
        enum class Options : std::uint8_t
        {
            Transparent = 0, 
            DisplayLeadingZeros = 1, 
            DisplayZeroAsBlank = 2, 
            Truncate = 3 
        };
 
        enum class HorizontalJustification : std::uint8_t
        {
            PositionLeft = 0, 
            PositionMiddle = 1, 
            PositionRight = 2, 
            Reserved = 3 
        };
 
        enum class VerticalJustification : std::uint8_t
        {
            PositionTop = 0, 
            PositionMiddle = 1, 
            PositionBottom = 2, 
            Reserved = 3 
        };
 
        OutputNumber() = default;
 
        ~OutputNumber() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        bool get_option(Options option) const;
 
        void set_options(std::uint8_t value);
 
        void set_option(Options option, bool value);
 
        HorizontalJustification get_horizontal_justification() const;
 
        VerticalJustification get_vertical_justification() const;
 
        void set_justification_bitfield(std::uint8_t value);
 
        float get_scale() const;
 
        void set_scale(float scaleValue);
 
        std::int32_t get_offset() const;
 
        void set_offset(std::int32_t offsetValue);
 
        std::uint8_t get_number_of_decimals() const;
 
        void set_number_of_decimals(std::uint8_t decimalValue);
 
        bool get_format() const;
 
        void set_format(bool shouldFormatAsExponential);
 
        std::uint32_t get_value() const;
 
        void set_value(std::uint32_t inputValue);
 
        void set_variable_reference(std::uint16_t referencedObjectID);
 
        std::uint16_t get_variable_reference() const;
 
        std::uint16_t get_font_attributes() const;
 
        void set_font_attributes(std::uint16_t fontAttributesValue);
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 29; 
 
        float scale = 1.0f; 
        std::int32_t offset = 0; 
        std::uint32_t value = 0; 
        std::uint16_t variableReference = NULL_OBJECT_ID; 
        std::uint16_t fontAttributes = NULL_OBJECT_ID; 
        std::uint8_t numberOfDecimals = 0; 
        std::uint8_t optionsBitfield = 0; 
        std::uint8_t justificationBitfield = 0; 
        bool format = false; 
    };
 
    class OutputList : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            Width = 1,
            Height = 2,
            VariableReference = 3,
            Value = 4,
 
            NumberOfAttributes = 5
        };
 
        OutputList() = default;
 
        ~OutputList() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        std::uint8_t get_number_of_list_items() const;
 
        void set_number_of_list_items(std::uint8_t value);
 
        std::uint8_t get_value() const;
 
        void set_value(std::uint8_t value);
 
        void set_variable_reference(std::uint16_t referencedObjectID);
 
        std::uint16_t get_variable_reference() const;
 
        bool change_list_item(std::uint8_t index, std::uint16_t newListItem, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool);
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 12; 
 
        std::uint16_t variableReference = NULL_OBJECT_ID; 
        std::uint8_t numberOfListItems = 0; 
        std::uint8_t value = 0; 
    };
 
    class OutputLine : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            LineAttributes = 1,
            Width = 2,
            Height = 3,
            LineDirection = 4,
 
            NumberOfAttributes = 5
        };
 
        enum class LineDirection : std::uint8_t
        {
            TopLeftToBottomRight = 0,
            BottomLeftToTopRight = 1
        };
 
        OutputLine() = default;
 
        ~OutputLine() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        LineDirection get_line_direction() const;
 
        void set_line_direction(LineDirection value);
 
        std::uint16_t get_line_attributes() const;
 
        void set_line_attributes(std::uint16_t lineAttributesObject);
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 11; 
 
        std::uint16_t lineAttributes = NULL_OBJECT_ID; 
        std::uint8_t lineDirection = 0; 
    };
 
    class OutputRectangle : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            LineAttributes = 1,
            Width = 2,
            Height = 3,
            LineSuppression = 4,
            FillAttributes = 5,
 
            NumberOfAttributes = 6
        };
        enum class LineSuppressionOption
        {
            SuppressTopLine = 0, 
            SuppressRightSideLine = 1, 
            SuppressBottomLine = 2, 
            SuppressLeftSideLine = 3 
        };
 
        OutputRectangle() = default;
 
        ~OutputRectangle() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        std::uint8_t get_line_suppression_bitfield() const;
 
        void set_line_suppression_bitfield(std::uint8_t value);
 
        std::uint16_t get_line_attributes() const;
 
        void set_line_attributes(std::uint16_t lineAttributesObject);
 
        std::uint16_t get_fill_attributes() const;
 
        void set_fill_attributes(std::uint16_t fillAttributesObject);
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 13; 
 
        std::uint16_t lineAttributes = NULL_OBJECT_ID; 
        std::uint16_t fillAttributes = NULL_OBJECT_ID; 
        std::uint8_t lineSuppressionBitfield = 0; 
    };
 
    class OutputEllipse : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            LineAttributes = 1,
            Width = 2,
            Height = 3,
            EllipseType = 4,
            StartAngle = 5,
            EndAngle = 6,
            FillAttributes = 7,
 
            NumberOfAttributes = 8
        };
 
        enum class EllipseType
        {
            Closed = 0, 
            OpenDefinedByStartEndAngles = 1, 
            ClosedEllipseSegment = 2,
            ClosedEllipseSection = 3
        };
 
        OutputEllipse() = default;
 
        ~OutputEllipse() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        EllipseType get_ellipse_type() const;
 
        void set_ellipse_type(EllipseType value);
 
        std::uint8_t get_start_angle() const;
 
        void set_start_angle(std::uint8_t value);
 
        std::uint8_t get_end_angle() const;
 
        void set_end_angle(std::uint8_t value);
 
        std::uint16_t get_line_attributes() const;
 
        void set_line_attributes(std::uint16_t lineAttributesObject);
 
        std::uint16_t get_fill_attributes() const;
 
        void set_fill_attributes(std::uint16_t fillAttributesObject);
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 15; 
 
        std::uint16_t lineAttributes = NULL_OBJECT_ID; 
        std::uint16_t fillAttributes = NULL_OBJECT_ID; 
        std::uint8_t ellipseType = 0; 
        std::uint8_t startAngle = 0; 
        std::uint8_t endAngle = 0; 
    };
 
    class OutputPolygon : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            Width = 1,
            Height = 2,
            LineAttributes = 3,
            FillAttributes = 4,
            PolygonType = 5,
 
            NumberOfAttributes = 6
        };
 
        enum class PolygonType
        {
            Convex = 0, 
            NonConvex = 1, 
            Complex = 2, 
            Open = 3 
        };
 
        struct PolygonPoint
        {
            std::uint16_t xValue; 
            std::uint16_t yValue; 
        };
 
        OutputPolygon() = default;
 
        ~OutputPolygon() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        void add_point(std::uint16_t x, std::uint16_t y);
 
        std::uint8_t get_number_of_points() const;
 
        PolygonPoint get_point(std::uint8_t index);
 
        PolygonType get_type() const;
 
        void set_type(PolygonType value);
 
        std::uint16_t get_line_attributes() const;
 
        void set_line_attributes(std::uint16_t lineAttributesObject);
 
        std::uint16_t get_fill_attributes() const;
 
        void set_fill_attributes(std::uint16_t fillAttributesObject);
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 14; 
 
        std::vector<PolygonPoint> pointList; 
        std::uint16_t fillAttributes = NULL_OBJECT_ID; 
        std::uint16_t lineAttributes = NULL_OBJECT_ID; 
        std::uint8_t polygonType = 0; 
    };
 
    class OutputMeter : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            Width = 1,
            NeedleColour = 2,
            BorderColour = 3,
            ArcAndTickColour = 4,
            Options = 5,
            NumberOfTicks = 6,
            StartAngle = 7,
            EndAngle = 8,
            MinValue = 9,
            MaxValue = 10,
            VariableReference = 11,
            Value = 12,
 
            NumberOfAttributes = 13
        };
 
        enum class Options : std::uint8_t
        {
            DrawArc = 0, 
            DrawBorder = 1, 
            DrawTicks = 2, 
            DeflectionDirection = 3 
        };
 
        OutputMeter() = default;
 
        ~OutputMeter() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        std::uint16_t get_min_value() const;
 
        void set_min_value(std::uint16_t value);
 
        std::uint16_t get_max_value() const;
 
        void set_max_value(std::uint16_t value);
 
        std::uint16_t get_value() const;
 
        void set_value(std::uint16_t value);
 
        std::uint8_t get_needle_colour() const;
 
        void set_needle_colour(std::uint8_t colourIndex);
 
        std::uint8_t get_border_colour() const;
 
        void set_border_colour(std::uint8_t colourIndex);
 
        std::uint8_t get_arc_and_tick_colour() const;
 
        void set_arc_and_tick_colour(std::uint8_t colourIndex);
 
        std::uint8_t get_number_of_ticks() const;
 
        void set_number_of_ticks(std::uint8_t ticks);
 
        bool get_option(Options option) const;
 
        void set_options(std::uint8_t options);
 
        void set_option(Options option, bool optionValue);
 
        std::uint8_t get_start_angle() const;
 
        void set_start_angle(std::uint8_t value);
 
        std::uint8_t get_end_angle() const;
 
        void set_end_angle(std::uint8_t value);
 
        std::uint16_t get_variable_reference() const;
 
        void set_variable_reference(std::uint16_t variableReferenceValue);
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 21; 
 
        std::uint16_t minValue = 0; 
        std::uint16_t maxValue = 0; 
        std::uint16_t value = 0; 
        std::uint16_t variableReference = NULL_OBJECT_ID; 
        std::uint8_t needleColour = 0; 
        std::uint8_t borderColour = 0; 
        std::uint8_t arcAndTickColour = 0; 
        std::uint8_t optionsBitfield = 0; 
        std::uint8_t numberOfTicks = 0; 
        std::uint8_t startAngle = 0; 
        std::uint8_t endAngle = 0; 
    };
 
    class OutputLinearBarGraph : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            Width = 1,
            Height = 2,
            Colour = 3,
            TargetLineColour = 4,
            Options = 5,
            NumberOfTicks = 6,
            MinValue = 7,
            MaxValue = 8,
            VariableReference = 9,
            TargetValueVariableReference = 10,
            TargetValue = 11,
            Value = 12,
 
            NumberOfAttributes = 13
        };
 
        enum class Options : std::uint8_t
        {
            DrawBorder = 0, 
            DrawTargetLine = 1, 
            DrawTicks = 2, 
            BarGraphType = 3, 
            AxisOrientation = 4, 
            Direction = 5 
        };
 
        OutputLinearBarGraph() = default;
 
        ~OutputLinearBarGraph() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        std::uint16_t get_min_value() const;
 
        void set_min_value(std::uint16_t value);
 
        std::uint16_t get_max_value() const;
 
        void set_max_value(std::uint16_t value);
 
        std::uint16_t get_value() const;
 
        void set_value(std::uint16_t value);
 
        std::uint16_t get_target_value() const;
 
        void set_target_value(std::uint16_t valueTarget);
 
        std::uint16_t get_target_value_reference() const;
 
        void set_target_value_reference(std::uint16_t valueReferenceObjectID);
 
        std::uint8_t get_number_of_ticks() const;
 
        void set_number_of_ticks(std::uint8_t value);
 
        std::uint8_t get_colour() const;
 
        void set_colour(std::uint8_t graphColour);
 
        std::uint8_t get_target_line_colour() const;
 
        void set_target_line_colour(std::uint8_t lineColour);
 
        bool get_option(Options option) const;
 
        void set_options(std::uint8_t options);
 
        void set_option(Options option, bool optionValue);
 
        std::uint16_t get_variable_reference() const;
 
        void set_variable_reference(std::uint16_t variableReferenceValue);
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 24; 
 
        std::uint16_t minValue = 0; 
        std::uint16_t maxValue = 0; 
        std::uint16_t targetValue = 0; 
        std::uint16_t targetValueReference = NULL_OBJECT_ID; 
        std::uint16_t value = 0; 
        std::uint16_t variableReference = NULL_OBJECT_ID; 
        std::uint8_t numberOfTicks = 0; 
        std::uint8_t colour = 0; 
        std::uint8_t targetLineColour = 0; 
        std::uint8_t optionsBitfield = 0; 
    };
 
    class OutputArchedBarGraph : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            Width = 1,
            Height = 2,
            Colour = 3,
            TargetLineColour = 4,
            Options = 5,
            StartAngle = 6,
            EndAngle = 7,
            BarGraphWidth = 8,
            MinValue = 9,
            MaxValue = 10,
            VariableReference = 11,
            TargetValueVariableReference = 12,
            TargetValue = 13,
 
            NumberOfAttributes = 14
        };
 
        enum class Options : std::uint8_t
        {
            DrawBorder = 0, 
            DrawTargetLine = 1, 
            Undefined = 2, 
            BarGraphType = 3, 
            Deflection = 4 
        };
 
        OutputArchedBarGraph() = default;
 
        ~OutputArchedBarGraph() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        std::uint16_t get_bar_graph_width() const;
 
        void set_bar_graph_width(std::uint16_t width);
 
        std::uint16_t get_min_value() const;
 
        void set_min_value(std::uint16_t minimumValue);
 
        std::uint16_t get_max_value() const;
 
        void set_max_value(std::uint16_t maximumValue);
 
        std::uint16_t get_value() const;
 
        void set_value(std::uint16_t value);
 
        std::uint8_t get_target_line_colour() const;
 
        void set_target_line_colour(std::uint8_t value);
 
        std::uint8_t get_colour() const;
 
        void set_colour(std::uint8_t value);
 
        bool get_option(Options option) const;
 
        void set_options(std::uint8_t options);
 
        void set_option(Options option, bool optionValue);
 
        std::uint8_t get_start_angle() const;
 
        void set_start_angle(std::uint8_t value);
 
        std::uint8_t get_end_angle() const;
 
        void set_end_angle(std::uint8_t value);
 
        std::uint16_t get_target_value() const;
 
        void set_target_value(std::uint16_t value);
 
        std::uint16_t get_target_value_reference() const;
 
        void set_target_value_reference(std::uint16_t value);
 
        std::uint16_t get_variable_reference() const;
 
        void set_variable_reference(std::uint16_t variableReferenceValue);
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 27; 
 
        std::uint16_t barGraphWidth = 0; 
        std::uint16_t minValue = 0; 
        std::uint16_t maxValue = 0; 
        std::uint16_t value = 0; 
        std::uint16_t targetValue = 0; 
        std::uint16_t targetValueReference = NULL_OBJECT_ID; 
        std::uint16_t variableReference = NULL_OBJECT_ID; 
        std::uint8_t targetLineColour = 0; 
        std::uint8_t colour = 0; 
        std::uint8_t optionsBitfield = 0; 
        std::uint8_t startAngle = 0; 
        std::uint8_t endAngle = 0; 
    };
 
    class PictureGraphic : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            Width = 1,
            Options = 2,
            TransparencyColour = 3,
            ActualWidth = 4,
            ActualHeight = 5,
            Format = 6,
 
            NumberOfAttributes = 7
        };
 
        enum class Format
        {
            Monochrome = 0, 
            FourBitColour = 1, 
            EightBitColour = 2 
        };
 
        enum class Options
        {
            Transparent = 0, 
            Flashing = 1, 
            RunLengthEncoded = 2 
        };
 
        PictureGraphic() = default;
 
        ~PictureGraphic() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        std::vector<std::uint8_t> &get_raw_data();
 
        void set_raw_data(const std::uint8_t *data, std::uint32_t size);
 
        void add_raw_data(std::uint8_t dataByte);
 
        std::uint32_t get_number_of_bytes_in_raw_data() const;
 
        void set_number_of_bytes_in_raw_data(std::uint32_t value);
 
        std::uint16_t get_actual_width() const;
 
        void set_actual_width(std::uint16_t value);
 
        std::uint16_t get_actual_height() const;
 
        void set_actual_height(std::uint16_t value);
 
        Format get_format() const;
 
        void set_format(Format value);
 
        bool get_option(Options option) const;
 
        void set_options(std::uint8_t value);
 
        void set_option(Options option, bool value);
 
        std::uint8_t get_transparency_colour() const;
 
        void set_transparency_colour(std::uint8_t value);
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 17; 
 
        std::vector<std::uint8_t> rawData; 
        std::uint32_t numberOfBytesInRawData = 0; 
        std::uint16_t actualWidth = 0; 
        std::uint16_t actualHeight = 0; 
        std::uint8_t formatByte = 0; 
        std::uint8_t optionsBitfield = 0; 
        std::uint8_t transparencyColour = 0; 
    };
 
    class NumberVariable : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            Value = 1,
 
            NumberOfAttributes = 2
        };
 
        NumberVariable() = default;
 
        ~NumberVariable() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        std::uint32_t get_value() const;
 
        void set_value(std::uint32_t value);
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 7; 
 
        std::uint32_t value = 0; 
    };
 
    class StringVariable : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
 
            NumberOfAttributes = 1
        };
 
        StringVariable() = default;
 
        ~StringVariable() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        std::string get_value() const;
 
        void set_value(const std::string &value);
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 5; 
 
        std::string value; 
    };
 
    class FontAttributes : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            FontColour = 1,
            FontSize = 2,
            FontType = 3,
            FontStyle = 4,
 
            NumberOfAttributes = 5
        };
 
        enum class FontSize : std::uint8_t
        {
            Size6x8 = 0, 
            Size8x8 = 1, 
            Size8x12 = 2, 
            Size12x16 = 3, 
            Size16x16 = 4, 
            Size16x24 = 5, 
            Size24x32 = 6, 
            Size32x32 = 7, 
            Size32x48 = 8, 
            Size48x64 = 9, 
            Size64x64 = 10, 
            Size64x96 = 11, 
            Size96x128 = 12, 
            Size128x128 = 13, 
            Size128x192 = 14 
        };
 
        enum class FontStyleBits : std::uint8_t
        {
            Bold = 0, 
            CrossedOut = 1, 
            Underlined = 2, 
            Italic = 3, 
            Inverted = 4, 
            Flashing = 5, 
            FlashingHidden = 6, 
            ProportionalFontRendering = 7 
        };
 
        enum class FontType : std::uint8_t
        {
            ISO8859_1 = 0, 
            ISO8859_15 = 1, 
            ISO8859_2 = 2, 
            Reserved_1 = 3, 
            ISO8859_4 = 4, 
            ISO8859_5 = 5, 
            Reserved_2 = 6, 
            ISO8859_7 = 7, 
            ReservedEnd = 239, 
            ProprietaryBegin = 240, 
            ProprietaryEnd = 255 
        };
 
        FontAttributes() = default;
 
        ~FontAttributes() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        FontType get_type() const;
 
        void set_type(FontType value);
 
        std::uint8_t get_style() const;
 
        bool get_style(FontStyleBits styleSetting) const;
 
        void set_style(FontStyleBits bit, bool value);
 
        void set_style(std::uint8_t value);
 
        FontSize get_size() const;
 
        void set_size(FontSize value);
 
        std::uint8_t get_colour() const;
 
        void set_colour(std::uint8_t value);
 
        std::uint8_t get_font_width_pixels() const;
 
        std::uint8_t get_font_height_pixels() const;
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 8; 
 
        std::uint8_t colour = 0; 
        std::uint8_t size = 0; 
        std::uint8_t type = 0; 
        std::uint8_t style = 0; 
    };
 
    class LineAttributes : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            LineColour = 1,
            LineWidth = 2,
            LineArt = 3,
 
            NumberOfAttributes = 4
        };
 
        LineAttributes() = default;
 
        ~LineAttributes() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        std::uint16_t get_line_art_bit_pattern() const;
 
        void set_line_art_bit_pattern(std::uint16_t value);
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 8; 
 
        std::uint16_t lineArtBitpattern = 0; 
    };
 
    class FillAttributes : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            FillType = 1,
            FillColour = 2,
            FillPattern = 3,
 
            NumberOfAttributes = 4
        };
 
        enum class FillType : std::uint8_t
        {
            NoFill = 0, 
            FillWithLineColor = 1, 
            FillWithSpecifiedColorInFillColorAttribute = 2, 
            FillWithPatternGivenByFillPatternAttribute = 3 
        };
 
        FillAttributes() = default;
 
        ~FillAttributes() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        std::uint16_t get_fill_pattern() const;
 
        void set_fill_pattern(std::uint16_t value);
 
        FillType get_type() const;
 
        void set_type(FillType value);
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 8; 
 
        std::uint16_t fillPattern = NULL_OBJECT_ID; 
        FillType type = FillType::NoFill; 
    };
 
    class InputAttributes : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            ValidationType = 1,
 
            NumberOfAttributes = 2
        };
 
        enum class ValidationType : std::uint8_t
        {
            ValidCharactersAreListed = 0,
            InvalidCharactersAreListed = 1
        };
 
        InputAttributes() = default;
 
        ~InputAttributes() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        std::string get_validation_string() const;
 
        void set_validation_string(const std::string &value);
 
        ValidationType get_validation_type() const;
 
        void set_validation_type(ValidationType newValidationType);
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 7; 
 
        std::string validationString; 
        ValidationType validationType = ValidationType::ValidCharactersAreListed; 
    };
 
    class ExtendedInputAttributes : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            ValidationType = 1,
 
            NumberOfAttributes = 2
        };
 
        enum class ValidationType : std::uint8_t
        {
            ValidCharactersAreListed = 0,
            InvalidCharactersAreListed = 1
        };
 
        ExtendedInputAttributes() = default;
 
        ~ExtendedInputAttributes() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        std::uint8_t get_number_of_code_planes() const;
 
        void set_number_of_code_planes(std::uint8_t value);
 
        ValidationType get_validation_type() const;
 
        void set_validation_type(ValidationType value);
 
 
    private:
        class CodePlane
        {
        public:
            std::vector<std::vector<wchar_t>> characterRanges; 
            std::uint8_t numberOfCharacterRanges; 
        };
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 5; 
 
        std::vector<CodePlane> codePlanes; 
        ValidationType validationType = ValidationType::ValidCharactersAreListed; 
    };
 
    class ObjectPointer : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            Value = 1,
 
            NumberOfAttributes = 2
        };
 
        ObjectPointer() = default;
 
        ~ObjectPointer() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        std::uint16_t get_value() const;
 
        void set_value(std::uint16_t objectIDToPointTo);
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 5; 
        std::uint16_t value = NULL_OBJECT_ID; 
    };
 
    class ExternalObjectPointer : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            DefaultObjectID = 1,
            ExternalReferenceNAMEID = 2,
            ExternalObjectID = 3,
 
            NumberOfAttributes = 4
        };
 
        ExternalObjectPointer() = default;
 
        ~ExternalObjectPointer() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        std::uint16_t get_default_object_id() const;
 
        void set_default_object_id(std::uint16_t id);
 
        std::uint16_t get_external_reference_name_id() const;
 
        void set_external_reference_name_id(std::uint16_t id);
 
        std::uint16_t get_external_object_id() const;
 
        void set_external_object_id(std::uint16_t id);
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 5; 
 
        std::uint16_t defaultObjectID = NULL_OBJECT_ID; 
        std::uint16_t externalReferenceNAMEID = NULL_OBJECT_ID; 
        std::uint16_t externalObjectID = NULL_OBJECT_ID; 
    };
 
    class Macro : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
 
            NumberOfAttributes = 1
        };
 
        enum class Command
        {
            HideShowObject = 0xA0,
            EnableDisableObject = 0xA1,
            SelectInputObject = 0xA2,
            ControlAudioSignal = 0xA3,
            SetAudioVolume = 0xA4,
            ChangeChildLocation = 0xA5,
            ChangeSize = 0xA6,
            ChangeBackgroundColour = 0xA7,
            ChangeNumericValue = 0xA8,
            ChangeEndPoint = 0xA9,
            ChangeFontAttributes = 0xAA,
            ChangeLineAttributes = 0xAB,
            ChangeFillAttributes = 0xAC,
            ChangeActiveMask = 0xAD,
            ChangeSoftKeyMask = 0xAE,
            ChangeAttribute = 0xAF,
            ChangePriority = 0xB0,
            ChangeListItem = 0xB1,
            ChangeStringValue = 0xB3,
            ChangeChildPosition = 0xB4,
            ChangeObjectLabel = 0xB5,
            ChangePolygonPoint = 0xB6,
            LockUnlockMask = 0xBD,
            ExecuteMacro = 0xBE,
            ChangePolygonScale = 0xB7,
            GraphicsContextCommand = 0xB8,
            SelectColourMap = 0xBA,
            ExecuteExtendedMacro = 0xBC
        };
 
        Macro() = default;
 
        ~Macro() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        bool add_command_packet(const std::vector<std::uint8_t> &command);
 
        std::uint8_t get_number_of_commands() const;
 
        bool get_command_packet(std::uint8_t index, std::vector<std::uint8_t> &command);
 
        bool remove_command_packet(std::uint8_t index);
 
        bool get_are_command_packets_valid() const;
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 5; 
        static const std::array<std::uint8_t, 28> ALLOWED_COMMANDS_LOOKUP_TABLE; 
        std::vector<std::vector<std::uint8_t>> commandPackets; 
    };
 
    class ColourMap : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
 
            NumberOfAttributes = 1
        };
 
        ColourMap() = default;
 
        ~ColourMap() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        bool set_number_of_colour_indexes(std::uint16_t value);
 
        std::uint16_t get_number_of_colour_indexes() const;
 
        bool set_colour_map_index(std::uint8_t index, std::uint8_t value);
 
        std::uint8_t get_colour_map_index(std::uint8_t index) const;
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 5; 
        std::vector<std::uint8_t> colourMapData; 
    };
 
    class WindowMask : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            BackgroundColour = 1,
            Options = 2,
            Name = 3,
 
            NumberOfAttributes = 4
        };
 
        enum class WindowType : std::uint8_t
        {
            Freeform = 0, 
            NumericOutputValueWithUnits1x1 = 1, 
            NumericOutputValueNoUnits1x1 = 2, 
            StringOutputValue1x1 = 3, 
            NumericInputValueWithUnits1x1 = 4, 
            NumericInputValueNoUnits1x1 = 5, 
            StringInputValue1x1 = 6, 
            HorizontalLinearBarGraphNoUnits1x1 = 7, 
            SingleButton1x1 = 8, 
            DoubleButton1x1 = 9, 
            NumericOutputValueWithUnits2x1 = 10, 
            NumericOutputValueNoUnits2x1 = 11, 
            StringOutputValue2x1 = 12, 
            NumericInputValueWithUnits2x1 = 13, 
            NumericInputValueNoUnits2x1 = 14, 
            StringInputValue2x1 = 15, 
            HorizontalLinearBarGraphNoUnits2x1 = 16, 
            SingleButton2x1 = 17, 
            DoubleButton2x1 = 18 
        };
 
        enum class Options
        {
            Available = 0, 
            Transparent = 1 
        };
 
        WindowMask() = default;
 
        ~WindowMask() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        std::uint16_t get_name_object_id() const;
 
        void set_name_object_id(std::uint16_t object);
 
        std::uint16_t get_title_object_id() const;
 
        void set_title_object_id(std::uint16_t object);
 
        std::uint16_t get_icon_object_id() const;
 
        void set_icon_object_id(std::uint16_t object);
 
        WindowType get_window_type() const;
 
        void set_window_type(WindowType type);
 
        bool get_option(Options option) const;
 
        void set_options(std::uint8_t value);
 
        void set_option(Options option, bool value);
 
    private:
        static constexpr std::uint32_t MIN_OBJECT_LENGTH = 17; 
        std::uint16_t name = NULL_OBJECT_ID; 
        std::uint16_t title = NULL_OBJECT_ID; 
        std::uint16_t icon = NULL_OBJECT_ID; 
        std::uint8_t optionsBitfield = 0; 
        std::uint8_t windowType = 0; 
    };
 
    class AuxiliaryFunctionType1 : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
 
            NumberOfAttributes = 1
        };
 
        enum class FunctionType : std::uint8_t
        {
            LatchingBoolean = 0,
            Analogue = 1,
            NonLatchingBoolean = 2
        };
 
        AuxiliaryFunctionType1() = default;
 
        ~AuxiliaryFunctionType1() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        FunctionType get_function_type() const;
 
        void set_function_type(FunctionType type);
 
    private:
        FunctionType functionType = FunctionType::LatchingBoolean; 
    };
 
    class AuxiliaryFunctionType2 : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            BackgroundColour = 1,
            FunctionAttributes = 2,
 
            NumberOfAttributes = 3
        };
 
        enum class FunctionType : std::uint8_t
        {
            BooleanLatchingOnOff = 0, 
            Analouge = 1, 
            BooleanNonLatchingIncreaseValue = 2, 
            AnalougeReturnTo50Percent = 3, 
            AnalougeReturnTo0PercentIncreaseValue = 4, 
            DualBooleanBothLatching = 5, 
            DualBooleanBothNonLatching = 6, 
            DualBooleanLatchingUp = 7, 
            DualBooleanLatchingDown = 8, 
            CombinedAnalougeReturnTo50PercentWithDualBooleanLatching = 9, 
            CombinedAnalougeMaintainsPositionWithDualBooleanLatching = 10, 
            QuadratureBooleanNonLatching = 11, 
            QuadratureAnalouge = 12, 
            QuadratureAnalougeReturnTo50Percent = 13, 
            BidirectionalEncoder = 14, 
            ReservedRangeStart = 15, 
            ReservedRangeEnd = 31 
        };
 
        enum FunctionAttribute
        {
            CriticalControl = 5, 
            AssignmentRestriction = 6, 
            SingleAssignment = 7, 
        };
 
        AuxiliaryFunctionType2() = default;
 
        ~AuxiliaryFunctionType2() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        FunctionType get_function_type() const;
 
        void set_function_type(FunctionType type);
 
        bool get_function_attribute(FunctionAttribute attributeToCheck) const;
 
        void set_function_attribute(FunctionAttribute attributeToSet, bool value);
 
    private:
        std::uint8_t functionAttributesBitfield = 0; 
    };
 
    class AuxiliaryInputType1 : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
 
            NumberOfAttributes = 1
        };
 
        enum class FunctionType : std::uint8_t
        {
            LatchingBoolean = 0,
            Analogue = 1,
            NonLatchingBoolean = 2
        };
 
        AuxiliaryInputType1() = default;
 
        ~AuxiliaryInputType1() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        FunctionType get_function_type() const;
 
        void set_function_type(FunctionType type);
 
        std::uint8_t get_input_id() const;
 
        bool set_input_id(std::uint8_t id);
 
    private:
        FunctionType functionType = FunctionType::LatchingBoolean; 
        std::uint8_t inputID = 0; 
    };
 
    class AuxiliaryInputType2 : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            BackgroundColour = 1,
            FunctionAttributes = 2,
 
            NumberOfAttributes = 3
        };
 
        enum FunctionAttribute
        {
            CriticalControl = 5, 
            AssignmentRestriction = 6, 
            SingleAssignment = 7, 
        };
 
        AuxiliaryInputType2() = default;
 
        ~AuxiliaryInputType2() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        AuxiliaryFunctionType2::FunctionType get_function_type() const;
 
        void set_function_type(AuxiliaryFunctionType2::FunctionType type);
 
        bool get_function_attribute(FunctionAttribute attributeToCheck) const;
 
        void set_function_attribute(FunctionAttribute attributeToSet, bool value);
 
    private:
        std::uint8_t functionAttributesBitfield = 0; 
    };
 
    class AuxiliaryControlDesignatorType2 : public VTObject
    {
    public:
        enum class AttributeName : std::uint8_t
        {
            Type = 0,
            PointerType = 1,
            AuxiliaryObjectID = 2,
 
            NumberOfAttributes = 3
        };
 
        AuxiliaryControlDesignatorType2() = default;
 
        ~AuxiliaryControlDesignatorType2() override = default;
 
        VirtualTerminalObjectType get_object_type() const override;
 
        std::uint32_t get_minumum_object_length() const override;
 
        bool get_is_valid(const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool) const override;
 
        bool set_attribute(std::uint8_t attributeID, std::uint32_t rawAttributeData, const std::map<std::uint16_t, std::shared_ptr<VTObject>> &objectPool, AttributeError &returnedError) override;
 
        bool get_attribute(std::uint8_t attributeID, std::uint32_t &returnedAttributeData) const override;
 
        std::uint16_t get_auxiliary_object_id() const;
 
        void set_auxiliary_object_id(std::uint16_t id);
 
        std::uint8_t get_pointer_type() const;
 
        void set_pointer_type(std::uint8_t type);
 
    private:
        std::uint16_t auxiliaryObjectID = NULL_OBJECT_ID; 
        std::uint8_t pointerType = 0; 
    };
 
} // namespace isobus
 
#endif // ISOBUS_VIRTUAL_TERMINAL_OBJECTS_HPP