ntv2nubtypes.h

Go to the documentation of this file.

/* SPDX-License-Identifier: MIT */
#ifndef __NTV2NUBTYPES_H
#define __NTV2NUBTYPES_H

#include "ntv2endian.h"
#include <vector>

#if !defined(NTV2_DEPRECATE_16_3)
    //  In SDK 16.3 or later, client/server RPC implementations are plugins, each with their own protocols/versioning
    typedef ULWord NTV2NubProtocolVersion;
#endif  //  !defined(NTV2_DEPRECATE_16_3)

typedef std::vector<uint8_t>    RPCBlob;

namespace ntv2nub
{
    const bool kDisableByteSwap (true);
    const bool kEnableByteSwapIfNeeded (false);


    inline void PUSHU8(const uint8_t val, RPCBlob & blob)
    {
        blob.push_back(val);
    }

    inline void PUSHU16(const uint16_t val, RPCBlob & blob, const bool dontSwap = false)
    {
        const uint16_t _u16 ((NTV2HostIsBigEndian || dontSwap) ? val : NTV2EndianSwap16HtoB(val));
        const UByte * _pU16 (reinterpret_cast<const UByte*>(&_u16));
        blob.push_back(_pU16[0]); blob.push_back(_pU16[1]);
    }

    inline void PUSHU32(const uint32_t val, RPCBlob & blob, const bool dontSwap = false)
    {
        const uint32_t _u32 ((NTV2HostIsBigEndian || dontSwap) ? val : NTV2EndianSwap32HtoB(val));
        const UByte * _pU32 (reinterpret_cast<const UByte*>(&_u32));
        blob.push_back(_pU32[0]); blob.push_back(_pU32[1]);
        blob.push_back(_pU32[2]); blob.push_back(_pU32[3]);
    }

    inline void PUSHU64(const uint64_t val, RPCBlob & blob, const bool dontSwap = false)
    {
        const uint64_t _u64 ((NTV2HostIsBigEndian || dontSwap) ? val : NTV2EndianSwap64HtoB(val));
        const UByte * _pU64 (reinterpret_cast<const UByte*>(&_u64));
        blob.push_back(_pU64[0]); blob.push_back(_pU64[1]);
        blob.push_back(_pU64[2]); blob.push_back(_pU64[3]);
        blob.push_back(_pU64[4]); blob.push_back(_pU64[5]);
        blob.push_back(_pU64[6]); blob.push_back(_pU64[7]);
    }

#if defined(_DEBUG)
    #define NTV2_NUB_RGCHK(_cnt_)       if (inOutNdx + (_cnt_) > blob.size())   \
                                            return false;
#else
    #define NTV2_NUB_RGCHK(_cnt_)   
#endif


    inline bool POPU8 (uint8_t & outVal, const RPCBlob & blob, std::size_t & inOutNdx)
    {
        NTV2_NUB_RGCHK(1)
        outVal = blob.at(inOutNdx++);
        return true;
    }

    inline bool POPU16 (uint16_t & outVal, const RPCBlob & blob, std::size_t & inOutNdx, const bool dontSwap = false)
    {
        uint16_t _u16(0);
        UByte * _pU8(reinterpret_cast<UByte*>(&_u16));
        NTV2_NUB_RGCHK(2)
        _pU8[0] = blob.at(inOutNdx++); _pU8[1] = blob.at(inOutNdx++);
        outVal = (NTV2HostIsBigEndian || dontSwap) ? _u16 : NTV2EndianSwap16BtoH(_u16);
        return true;
    }

    inline bool POPU32 (uint32_t & outVal, const RPCBlob & blob, std::size_t & inOutNdx, const bool dontSwap = false)
    {
        uint32_t _u32(0);
        UByte * _pU8(reinterpret_cast<UByte*>(&_u32));
        NTV2_NUB_RGCHK(4)
        _pU8[0] = blob.at(inOutNdx++); _pU8[1] = blob.at(inOutNdx++);
        _pU8[2] = blob.at(inOutNdx++); _pU8[3] = blob.at(inOutNdx++);
        outVal = (NTV2HostIsBigEndian || dontSwap) ? _u32 : NTV2EndianSwap32BtoH(_u32);
        return true;
    }

    inline bool POPU64 (uint64_t & outVal, const RPCBlob & blob, std::size_t & inOutNdx, const bool dontSwap = false)
    {
        uint64_t _u64(0);
        UByte * _pU8(reinterpret_cast<UByte*>(&_u64));
        NTV2_NUB_RGCHK(8)
        _pU8[0] = blob.at(inOutNdx++); _pU8[1] = blob.at(inOutNdx++);
        _pU8[2] = blob.at(inOutNdx++); _pU8[3] = blob.at(inOutNdx++);
        _pU8[4] = blob.at(inOutNdx++); _pU8[5] = blob.at(inOutNdx++);
        _pU8[6] = blob.at(inOutNdx++); _pU8[7] = blob.at(inOutNdx++);
        outVal = (NTV2HostIsBigEndian || dontSwap) ? _u64 : NTV2EndianSwap64BtoH(_u64);
        return true;
    }

}   //  namespace ntv2nub

#endif  //  __NTV2NUBTYPES_H