isobus_task_controller_client_objects.hpp

Go to the documentation of this file.

//================================================================================================
//================================================================================================
#ifndef ISOBUS_TASK_CONTROLLER_CLIENT_OBJECTS_HPP
#define ISOBUS_TASK_CONTROLLER_CLIENT_OBJECTS_HPP
 
#include <array>
#include <cstdint>
#include <string>
#include <vector>
 
namespace isobus
{
    namespace task_controller_object
    {
        enum class ObjectTypes
        {
            Device, 
            DeviceElement, 
            DeviceProcessData, 
            DeviceProperty, 
            DeviceValuePresentation 
        };
 
        class Object
        {
        public:
            Object(std::string objectDesignator, std::uint16_t uniqueID);
 
            virtual ~Object() = default;
 
            std::string get_designator() const;
 
            void set_designator(const std::string &newDesignator);
 
            std::uint16_t get_object_id() const;
 
            void set_object_id(std::uint16_t id);
 
            virtual std::string get_table_id() const = 0;
 
            virtual ObjectTypes get_object_type() const = 0;
 
            virtual std::vector<std::uint8_t> get_binary_object() const = 0;
 
            static constexpr std::uint16_t MAX_OBJECT_ID = 65534;
 
            static constexpr std::size_t MAX_DESIGNATOR_LENGTH = 128;
 
            static constexpr std::size_t MAX_DESIGNATOR_LEGACY_LENGTH = 32;
 
        protected:
            std::string designator; 
            std::uint16_t objectID; 
        };
 
        class DeviceObject : public Object
        {
        public:
            DeviceObject(std::string deviceDesignator,
                         std::string deviceSoftwareVersion,
                         std::string deviceSerialNumber,
                         std::string deviceStructureLabel,
                         std::array<std::uint8_t, 7> deviceLocalizationLabel,
                         std::vector<std::uint8_t> deviceExtendedStructureLabel,
                         std::uint64_t clientIsoNAME,
                         bool shouldUseExtendedStructureLabel);
 
            ~DeviceObject() override = default;
 
            std::string get_table_id() const override;
 
            ObjectTypes get_object_type() const override;
 
            std::vector<std::uint8_t> get_binary_object() const override;
 
            std::string get_software_version() const;
 
            void set_software_version(const std::string &version);
 
            std::string get_serial_number() const;
 
            void set_serial_number(const std::string &serial);
 
            std::string get_structure_label() const;
 
            void set_structure_label(const std::string &label);
 
            std::array<std::uint8_t, 7> get_localization_label() const;
 
            void set_localization_label(std::array<std::uint8_t, 7> label);
 
            std::vector<std::uint8_t> get_extended_structure_label() const;
 
            void set_extended_structure_label(const std::vector<std::uint8_t> &label);
 
            std::uint64_t get_iso_name() const;
 
            void set_iso_name(std::uint64_t name);
 
            bool get_use_extended_structure_label() const;
 
            void set_use_extended_structure_label(bool shouldUseExtendedStructureLabel);
 
            static constexpr std::size_t MAX_STRUCTURE_AND_LOCALIZATION_LABEL_LENGTH = 7;
 
            static constexpr std::size_t MAX_EXTENDED_STRUCTURE_LABEL_LENGTH = 32;
 
        private:
            static const std::string tableID; 
            std::string serialNumber; 
            std::string softwareVersion; 
            std::string structureLabel; 
            std::array<std::uint8_t, task_controller_object::DeviceObject::MAX_STRUCTURE_AND_LOCALIZATION_LABEL_LENGTH> localizationLabel; 
            std::vector<std::uint8_t> extendedStructureLabel; 
            std::uint64_t NAME; 
            bool useExtendedStructureLabel; 
        };
 
        class DeviceElementObject : public Object
        {
        public:
            enum class Type : std::uint8_t
            {
                Device = 1, 
                Function = 2, 
                Bin = 3, 
                Section = 4, 
                Unit = 5, 
                Connector = 6, 
                NavigationReference = 7 
            };
 
            DeviceElementObject(std::string deviceElementDesignator,
                                std::uint16_t deviceElementNumber,
                                std::uint16_t parentObjectID,
                                Type deviceEelementType,
                                std::uint16_t uniqueID);
 
            ~DeviceElementObject() override = default;
 
            std::string get_table_id() const override;
 
            ObjectTypes get_object_type() const override;
 
            std::vector<std::uint8_t> get_binary_object() const override;
 
            std::uint16_t get_element_number() const;
 
            void set_element_number(std::uint16_t newElementNumber);
 
            std::uint16_t get_parent_object() const;
 
            void set_parent_object(std::uint16_t parentObjectID);
 
            Type get_type() const;
 
            void add_reference_to_child_object(std::uint16_t childID);
 
            bool remove_reference_to_child_object(std::uint16_t childID);
 
            std::uint16_t get_number_child_objects() const;
 
            std::uint16_t get_child_object_id(std::size_t index);
 
        private:
            static const std::string tableID; 
            std::vector<std::uint16_t> referenceList; 
            std::uint16_t elementNumber; 
            std::uint16_t parentObject; 
            Type elementType; 
        };
 
        class DeviceProcessDataObject : public Object
        {
        public:
            enum class PropertiesBit : std::uint8_t
            {
                MemberOfDefaultSet = 0x01, 
                Settable = 0x02, 
                ControlSource = 0x04 
            };
 
            enum class AvailableTriggerMethods
            {
                TimeInterval = 0x01, 
                DistanceInterval = 0x02, 
                ThresholdLimits = 0x04, 
                OnChange = 0x08, 
                Total = 0x10 
            };
 
            DeviceProcessDataObject(std::string processDataDesignator,
                                    std::uint16_t processDataDDI,
                                    std::uint16_t deviceValuePresentationObjectID,
                                    std::uint8_t processDataProperties,
                                    std::uint8_t processDataTriggerMethods,
                                    std::uint16_t uniqueID);
 
            ~DeviceProcessDataObject() override = default;
 
            std::string get_table_id() const override;
 
            ObjectTypes get_object_type() const override;
 
            std::vector<std::uint8_t> get_binary_object() const override;
 
            std::uint16_t get_ddi() const;
 
            void set_ddi(std::uint16_t newDDI);
 
            std::uint16_t get_device_value_presentation_object_id() const;
 
            void set_device_value_presentation_object_id(std::uint16_t id);
 
            std::uint8_t get_properties_bitfield() const;
 
            void set_properties_bitfield(std::uint8_t properties);
 
            std::uint8_t get_trigger_methods_bitfield() const;
 
            void set_trigger_methods_bitfield(std::uint8_t methods);
 
        private:
            static const std::string tableID; 
            std::uint16_t ddi; 
            std::uint16_t deviceValuePresentationObject; 
            std::uint8_t propertiesBitfield; 
            std::uint8_t triggerMethodsBitfield; 
        };
 
        class DevicePropertyObject : public Object
        {
        public:
            DevicePropertyObject(std::string propertyDesignator,
                                 std::int32_t propertyValue,
                                 std::uint16_t propertyDDI,
                                 std::uint16_t valuePresentationObject,
                                 std::uint16_t uniqueID);
 
            ~DevicePropertyObject() override = default;
 
            std::string get_table_id() const override;
 
            ObjectTypes get_object_type() const override;
 
            std::vector<std::uint8_t> get_binary_object() const override;
 
            std::int32_t get_value() const;
 
            void set_value(std::int32_t newValue);
 
            std::uint16_t get_ddi() const;
 
            void set_ddi(std::uint16_t newDDI);
 
            std::uint16_t get_device_value_presentation_object_id() const;
 
            void set_device_value_presentation_object_id(std::uint16_t id);
 
        private:
            static const std::string tableID; 
            std::int32_t value; 
            std::uint16_t ddi; 
            std::uint16_t deviceValuePresentationObject; 
        };
 
        class DeviceValuePresentationObject : public Object
        {
        public:
            DeviceValuePresentationObject(std::string unitDesignator,
                                          std::int32_t offsetValue,
                                          float scaleFactor,
                                          std::uint8_t numberDecimals,
                                          std::uint16_t uniqueID);
 
            ~DeviceValuePresentationObject() override = default;
 
            std::string get_table_id() const override;
 
            ObjectTypes get_object_type() const override;
 
            std::vector<std::uint8_t> get_binary_object() const override;
 
            std::int32_t get_offset() const;
 
            void set_offset(std::int32_t newOffset);
 
            float get_scale() const;
 
            void set_scale(float newScale);
 
            std::uint8_t get_number_of_decimals() const;
 
            void set_number_of_decimals(std::uint8_t decimals);
 
        private:
            static const std::string tableID; 
            std::int32_t offset; 
            float scale; 
            std::uint8_t numberOfDecimals; 
        };
    } // namespace task_controller_object
} // namespace isobus
 
#endif // ISOBUS_TASK_CONTROLLER_CLIENT_OBJECTS_HPP