Ocp1Message.h

Go to the documentation of this file.

/* Copyright (c) 2025, Bernardo Escalona
 *
 * This file is part of NanoOcp <https://github.com/ChristianAhrens/NanoOcp>
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 3.0 as published
 * by the Free Software Foundation.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
#pragma once
 
#include <memory>
 
#include "Variant.h"
#include "Ocp1DataTypes.h" //< USE Ocp1DataType
 
 
namespace NanoOcp1
{
 
struct Ocp1CommandDefinition
{
    Ocp1CommandDefinition()
        :   m_targetOno(static_cast<std::uint32_t>(0)),
            m_propertyType(static_cast<std::uint16_t>(0)),
            m_propertyDefLevel(static_cast<std::uint16_t>(0)),
            m_propertyIndex(static_cast<std::uint16_t>(0)),
            m_paramCount(static_cast<std::uint8_t>(0))
    {
    }
 
    Ocp1CommandDefinition(std::uint32_t targetOno,
                          std::uint16_t propertyType,
                          std::uint16_t propertyDefLevel,
                          std::uint16_t propertyIndex,
                          std::uint8_t paramCount = static_cast<std::uint8_t>(0),
                          const ByteVector& parameterData = std::vector<std::uint8_t>())
        :   m_targetOno(targetOno),
            m_propertyType(propertyType),
            m_propertyDefLevel(propertyDefLevel),
            m_propertyIndex(propertyIndex),
            m_paramCount(paramCount),
            m_parameterData(parameterData)
    {
    }
 
    virtual ~Ocp1CommandDefinition() = default;
 
    virtual Ocp1CommandDefinition AddSubscriptionCommand() const;
 
    virtual Ocp1CommandDefinition RemoveSubscriptionCommand() const;
 
    virtual Ocp1CommandDefinition GetValueCommand() const;
 
    virtual Ocp1CommandDefinition SetValueCommand(const Variant& newValue) const;
 
    virtual Ocp1CommandDefinition* Clone() const;
 
    Ocp1DataType GetDataType() const
    {
        return static_cast<Ocp1DataType>(m_propertyType);
    }
 
 
    std::uint32_t m_targetOno;                  // Target ONo of the command.
    std::uint16_t m_propertyType;               // Property type of the command, as a Ocp1DataType.
    std::uint16_t m_propertyDefLevel;           // Level of the property definition within the AES70 class hierarchy.
    std::uint16_t m_propertyIndex;              // Index of the property within its AES70 class definition.
    std::uint8_t m_paramCount;                  // Number of parameters contained in m_parameterData.
    ByteVector m_parameterData;                 // Parameter data for the command.
};
 
 
class Ocp1Header
{
public:
    Ocp1Header(std::uint8_t msgType, std::size_t parameterDataLength)
        :   m_syncVal(0x3b),
            m_protoVers(static_cast<std::uint16_t>(1)),
            m_msgSize(CalculateMessageSize(msgType, parameterDataLength)),
            m_msgType(msgType),
            m_msgCnt(static_cast<std::uint16_t>(1))
    {
    }
 
    explicit Ocp1Header(const ByteVector& memory);
 
    virtual ~Ocp1Header() = default;
 
    std::uint8_t GetMessageType() const
    {
        return m_msgType;
    }
 
    std::uint32_t GetMessageSize() const
    {
        return m_msgSize;
    }
 
    bool IsValid() const;
 
    ByteVector GetSerializedData() const;
 
    static std::uint32_t CalculateMessageSize(std::uint8_t msgType, size_t parameterDataLength);
 
    static constexpr std::uint32_t Ocp1HeaderSize = 10;
 
protected:
    std::uint8_t                m_syncVal;      // Always 0x3b
    std::uint16_t               m_protoVers;    // Always 1
    std::uint32_t               m_msgSize;      // Size of the complete OCA message in bytes, excluding the initial sync bit.
    std::uint8_t                m_msgType;      // Type of OCA message (i.e. Notification, KeepAlive, etc).
    std::uint16_t               m_msgCnt;       // Always 1
};
 
 
class Ocp1Message
{
public:
    enum MessageType
    {
        Command = 0,                    
        CommandResponseRequired = 1,    
        Notification = 2,               
        Response = 3,                   
        KeepAlive = 4                   
    };
 
    Ocp1Message(std::uint8_t msgType, const ByteVector& parameterData)
        : m_header(Ocp1Header(msgType, parameterData.size())),
        m_parameterData(parameterData)
 
    {
    }
 
    virtual ~Ocp1Message() = default;
 
    std::uint8_t GetMessageType() const
    {
        return m_header.GetMessageType();
    }
 
    ByteVector GetParameterData() const
    {
        return m_parameterData;
    }
 
    virtual ByteVector GetSerializedData() = 0;
 
 
    static std::unique_ptr<Ocp1Message> UnmarshalOcp1Message(const ByteVector& receivedData);
 
 
protected:
    Ocp1Header                  m_header;           // OCA message header.
    ByteVector   m_parameterData;                   // Parameter data contained by the message.
    static std::uint32_t        m_nextHandle;       // Static variable to generate unique command handles.
};
 
 
class Ocp1CommandResponseRequired : public Ocp1Message
{
public:
    Ocp1CommandResponseRequired(std::uint32_t targetOno,
                                std::uint16_t methodDefLevel,
                                std::uint16_t methodIndex,
                                std::uint8_t paramCount,
                                const ByteVector& parameterData)
        : Ocp1Message(static_cast<std::uint8_t>(CommandResponseRequired), parameterData),
            m_handle(0),
            m_targetOno(targetOno),
            m_methodDefLevel(methodDefLevel),
            m_methodIndex(methodIndex),
            m_paramCount(paramCount)
    {
    }
 
    Ocp1CommandResponseRequired(std::uint32_t targetOno,
                                std::uint16_t methodDefLevel,
                                std::uint16_t methodIndex,
                                std::uint8_t paramCount,
                                const ByteVector& parameterData,
                                std::uint32_t& handle)
        : Ocp1CommandResponseRequired(targetOno, methodDefLevel, methodIndex,
                                      paramCount, parameterData)
    {
        // Return a new unique handle every time this class is instantiated.
        m_handle = m_nextHandle;
        handle = m_handle;
        m_nextHandle++;
    }
 
    Ocp1CommandResponseRequired(const Ocp1CommandDefinition& def,
                                std::uint32_t& handle)
        : Ocp1CommandResponseRequired(def.m_targetOno, def.m_propertyDefLevel, def.m_propertyIndex,
                                      def.m_paramCount, def.m_parameterData, handle)
    {
    }
 
    ~Ocp1CommandResponseRequired() override = default;
 
    void SetHandle(std::uint32_t handle)
    {
        m_handle = handle;
    }
 
    std::uint32_t GetHandle() const
    {
        return m_handle;
    }
 
    std::uint32_t GetTargetOno() const
    {
        return m_targetOno;
    }
 
    std::uint16_t GetMethodDefLevel() const
    {
        return m_methodDefLevel;
    }
 
    std::uint16_t GetMethodIndex() const
    {
        return m_methodIndex;
    }
    
    // Reimplemented from Ocp1Message
 
    ByteVector GetSerializedData() override;
 
protected:
    std::uint32_t               m_handle;           // Handle of the command.
    std::uint32_t               m_targetOno;        // Target ONo of the command.
    std::uint16_t               m_methodDefLevel;   // Level of the method definition within the AES70 class hierarchy.
    std::uint16_t               m_methodIndex;      // Index of the method within its AES70 class definition.
    std::uint8_t                m_paramCount;       // Number of parameters contained in the command.
};
 
 
class Ocp1Response : public Ocp1Message
{
public:
    Ocp1Response(std::uint32_t handle,
                 std::uint8_t status,
                 std::uint8_t paramCount,
                 const ByteVector& parameterData)
        : Ocp1Message(static_cast<std::uint8_t>(Response), parameterData),
            m_handle(handle),
            m_status(status),
            m_paramCount(paramCount)
    {
    }
 
    ~Ocp1Response() override = default;
 
    std::uint32_t GetResponseHandle() const
    {
        return m_handle;
    }
 
    std::uint8_t GetResponseStatus() const
    {
        return m_status;
    }
 
    std::uint8_t GetParamCount() const
    {
        return m_paramCount;
    }
 
    // Reimplemented from Ocp1Message
 
    ByteVector GetSerializedData() override;
 
protected:
    std::uint32_t               m_handle;
 
    std::uint8_t                m_status;
 
    std::uint8_t                m_paramCount;
};
 
 
class Ocp1Notification : public Ocp1Message
{
public:
    Ocp1Notification(std::uint32_t emitterOno,
                     std::uint16_t emitterPropertyDefLevel,
                     std::uint16_t emitterPropertyIndex,
                     std::uint8_t paramCount,
                     const ByteVector& parameterData)
        : Ocp1Message(static_cast<std::uint8_t>(Notification), parameterData),
            m_emitterOno(emitterOno),
            m_emitterPropertyDefLevel(emitterPropertyDefLevel),
            m_emitterPropertyIndex(emitterPropertyIndex),
            m_paramCount(paramCount)
    {
    }
 
    std::uint32_t GetEmitterOno() const
    {
        return m_emitterOno;
    }
 
    ~Ocp1Notification() override = default;
 
    std::uint8_t GetParamCount() const
    {
        return m_paramCount;
    }
 
    bool MatchesObject(const Ocp1CommandDefinition* def) const
    {
        return ((def->m_targetOno == m_emitterOno) && 
                (def->m_propertyDefLevel == m_emitterPropertyDefLevel) &&
                (def->m_propertyIndex == m_emitterPropertyIndex));
    }
 
    // Reimplemented from Ocp1Message
 
    ByteVector GetSerializedData() override;
 
protected:
    std::uint32_t               m_emitterOno;               // ONo of the object whose property changed, triggering this notification.
    std::uint16_t               m_emitterPropertyDefLevel;  // Level of the property definition within the AES70 class hierarchy.
    std::uint16_t               m_emitterPropertyIndex;     // Index of the property within its AES70 class definition.
 
    std::uint8_t                m_paramCount;
};
 
 
class Ocp1KeepAlive : public Ocp1Message
{
public:
    Ocp1KeepAlive(std::uint16_t heartBeatSeconds);
    
    Ocp1KeepAlive(std::uint32_t heartBeatMilliseconds);
 
    ~Ocp1KeepAlive() override = default;
 
    std::uint16_t GetHeartBeatSeconds() const;
    
    std::uint32_t GetHeartBeatMilliseconds() const;
 
 
    // Reimplemented from Ocp1Message
 
    ByteVector GetSerializedData() override;
};
 
}