xsmessage.h

Go to the documentation of this file.

 
//  Copyright (c) 2003-2021 Xsens Technologies B.V. or subsidiaries worldwide.
//  All rights reserved.
//  
//  Redistribution and use in source and binary forms, with or without modification,
//  are permitted provided that the following conditions are met:
//  
//  1.  Redistributions of source code must retain the above copyright notice,
//      this list of conditions, and the following disclaimer.
//  
//  2.  Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions, and the following disclaimer in the documentation
//      and/or other materials provided with the distribution.
//  
//  3.  Neither the names of the copyright holders nor the names of their contributors
//      may be used to endorse or promote products derived from this software without
//      specific prior written permission.
//  
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
//  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
//  THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
//  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
//  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR
//  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.THE LAWS OF THE NETHERLANDS 
//  SHALL BE EXCLUSIVELY APPLICABLE AND ANY DISPUTES SHALL BE FINALLY SETTLED UNDER THE RULES 
//  OF ARBITRATION OF THE INTERNATIONAL CHAMBER OF COMMERCE IN THE HAGUE BY ONE OR MORE 
//  ARBITRATORS APPOINTED IN ACCORDANCE WITH SAID RULES.
//  
 
 
//  Copyright (c) 2003-2021 Xsens Technologies B.V. or subsidiaries worldwide.
//  All rights reserved.
//  
//  Redistribution and use in source and binary forms, with or without modification,
//  are permitted provided that the following conditions are met:
//  
//  1.  Redistributions of source code must retain the above copyright notice,
//      this list of conditions, and the following disclaimer.
//  
//  2.  Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions, and the following disclaimer in the documentation
//      and/or other materials provided with the distribution.
//  
//  3.  Neither the names of the copyright holders nor the names of their contributors
//      may be used to endorse or promote products derived from this software without
//      specific prior written permission.
//  
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
//  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
//  THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
//  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
//  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR
//  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.THE LAWS OF THE NETHERLANDS 
//  SHALL BE EXCLUSIVELY APPLICABLE AND ANY DISPUTES SHALL BE FINALLY SETTLED UNDER THE RULES 
//  OF ARBITRATION OF THE INTERNATIONAL CHAMBER OF COMMERCE IN THE HAGUE BY ONE OR MORE 
//  ARBITRATORS APPOINTED IN ACCORDANCE WITH SAID RULES.
//  
 
#ifndef XSMESSAGE_H
#define XSMESSAGE_H
 
#include "xstypesconfig.h"
#include "pstdint.h"
#include "xsbytearray.h"
#include "xsdataidentifier.h"
#include "xsxbusmessageid.h"
#include "xsstring.h"
#include "xsresultvalue.h"
#include "xsbusid.h"
 
struct XsMessage;
struct XsMessageHeader;
 
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __cplusplus
#define XSMESSAGE_INITIALIZER   { XSBYTEARRAY_INITIALIZER, 1, 0 }
typedef struct XsMessage XsMessage;
typedef struct XsMessageHeader XsMessageHeader;
#endif
 
XSTYPES_DLL_API void XsMessage_construct(XsMessage* thisPtr);
XSTYPES_DLL_API void XsMessage_constructSized(XsMessage* thisPtr, XsSize dataSize);
XSTYPES_DLL_API void XsMessage_copyConstruct(XsMessage* thisPtr, XsMessage const* src);
XSTYPES_DLL_API void XsMessage_assign(XsMessage* thisPtr, XsSize dataSize);
XSTYPES_DLL_API void XsMessage_load(XsMessage* thisPtr, XsSize msgSize, unsigned char const* src);
XSTYPES_DLL_API void XsMessage_destruct(XsMessage* thisPtr);
XSTYPES_DLL_API void XsMessage_copy(XsMessage* copy, XsMessage const* src);
XSTYPES_DLL_API void XsMessage_swap(XsMessage* a, XsMessage* b);
XSTYPES_DLL_API XsSize XsMessage_dataSize(XsMessage const* thisPtr);
XSTYPES_DLL_API const uint8_t* XsMessage_constData(XsMessage const* thisPtr, XsSize offset);
XSTYPES_DLL_API const uint8_t* XsMessage_getMessageStart(XsMessage const* thisPtr);
XSTYPES_DLL_API XsSize XsMessage_getTotalMessageSize(XsMessage const* thisPtr);
XSTYPES_DLL_API uint8_t XsMessage_getDataByte(XsMessage const* thisPtr, XsSize offset);
XSTYPES_DLL_API uint16_t XsMessage_getDataShort(XsMessage const* thisPtr, XsSize offset);
XSTYPES_DLL_API uint32_t XsMessage_getDataLong(XsMessage const* thisPtr, XsSize offset);
XSTYPES_DLL_API uint64_t XsMessage_getDataLongLong(XsMessage const* thisPtr, XsSize offset);
XSTYPES_DLL_API float XsMessage_getDataFloat(XsMessage const* thisPtr, XsSize offset);
XSTYPES_DLL_API double XsMessage_getDataDouble(XsMessage const* thisPtr, XsSize offset);
XSTYPES_DLL_API double XsMessage_getDataF1220(XsMessage const* thisPtr, XsSize offset);
XSTYPES_DLL_API double XsMessage_getDataFP1632(XsMessage const* thisPtr, XsSize offset);
XSTYPES_DLL_API const uint8_t* XsMessage_getDataBuffer(XsMessage const* thisPtr, XsSize offset);
XSTYPES_DLL_API void XsMessage_setDataByte(XsMessage* thisPtr, uint8_t value, XsSize offset);
XSTYPES_DLL_API void XsMessage_setDataShort(XsMessage* thisPtr, uint16_t value, XsSize offset);
XSTYPES_DLL_API void XsMessage_setDataLong(XsMessage* thisPtr, uint32_t value, XsSize offset);
XSTYPES_DLL_API void XsMessage_setDataLongLong(XsMessage* thisPtr, uint64_t value, XsSize offset);
XSTYPES_DLL_API void XsMessage_setDataFloat(XsMessage* thisPtr, float value, XsSize offset);
XSTYPES_DLL_API void XsMessage_setDataDouble(XsMessage* thisPtr, double value, XsSize offset);
XSTYPES_DLL_API void XsMessage_setDataF1220(XsMessage* thisPtr, double value, XsSize offset);
XSTYPES_DLL_API void XsMessage_setDataFP1632(XsMessage* thisPtr, double value, XsSize offset);
XSTYPES_DLL_API void XsMessage_setDataBuffer(XsMessage* thisPtr, const uint8_t* buffer, XsSize size, XsSize offset);
XSTYPES_DLL_API uint8_t XsMessage_computeChecksum(XsMessage const* thisPtr);
XSTYPES_DLL_API void XsMessage_recomputeChecksum(XsMessage* thisPtr);
XSTYPES_DLL_API int XsMessage_isChecksumOk(XsMessage const* thisPtr);
XSTYPES_DLL_API XsMessageHeader* XsMessage_getHeader(XsMessage*);
XSTYPES_DLL_API const XsMessageHeader* XsMessage_getConstHeader(XsMessage const* thisPtr);
XSTYPES_DLL_API int XsMessage_empty(XsMessage const* thisPtr);
XSTYPES_DLL_API void XsMessage_resizeData(XsMessage* thisPtr, XsSize newSize);
XSTYPES_DLL_API void XsMessage_setBusId(XsMessage* thisPtr, uint8_t busId);
XSTYPES_DLL_API void XsMessage_setMessageId(XsMessage* thisPtr, XsXbusMessageId msgId);
XSTYPES_DLL_API void XsMessage_insertData(XsMessage* thisPtr, XsSize count, XsSize offset);
XSTYPES_DLL_API void XsMessage_deleteData(XsMessage* thisPtr, XsSize count, XsSize offset);
XSTYPES_DLL_API uint8_t XsMessage_getFPValueSize(XsDataIdentifier id);
XSTYPES_DLL_API void XsMessage_getDataFPValuesById(XsMessage const* thisPtr, XsDataIdentifier dataIdentifier, double* dest, XsSize offset, XsSize numValues);
XSTYPES_DLL_API void XsMessage_setDataFPValuesById(XsMessage* thisPtr, XsDataIdentifier dataIdentifier, double const* data, XsSize offset, XsSize numValues);
XSTYPES_DLL_API void XsMessage_getDataRealValuesById(XsMessage const* thisPtr, XsDataIdentifier dataIdentifier, XsReal* dest, XsSize offset, XsSize numValues);
XSTYPES_DLL_API void XsMessage_setDataRealValuesById(XsMessage* thisPtr, XsDataIdentifier dataIdentifier, XsReal const* data, XsSize offset, XsSize numValues);
XSTYPES_DLL_API int XsMessage_compare(XsMessage const* a, XsMessage const* b);
XSTYPES_DLL_API void XsMessage_toHexString(XsMessage const* thisPtr, XsSize maxBytes, XsString* resultValue);
XSTYPES_DLL_API void XsMessage_getEndianCorrectData(XsMessage const* thisPtr, void* value, XsSize size, XsSize offset);
XSTYPES_DLL_API void XsMessage_setEndianCorrectData(XsMessage* thisPtr, void const* value, XsSize size, XsSize offset);
 
#ifdef __cplusplus
} // extern "C"
#endif
 
#define XS_PREAMBLE           0xFA
#define XS_EXTLENCODE         0xFF
 
#define XS_LEN_MSGHEADER      4
#define XS_LEN_MSGEXTHEADER   6
#define XS_LEN_MSGHEADERCS    5
#define XS_LEN_MSGEXTHEADERCS 7
#define XS_LEN_CHECKSUM       1
#define XS_LEN_UNSIGSHORT     2
#define XS_LEN_UNSIGINT       4
#define XS_LEN_FLOAT          4
 
// Maximum message/data length
#define XS_MAXDATALEN         (8192-XS_LEN_MSGEXTHEADERCS)
#define XS_MAXSHORTDATALEN    254
#define XS_MAXMSGLEN          (XS_MAXDATALEN+XS_LEN_MSGEXTHEADERCS)
#define XS_MAXSHORTMSGLEN     (XS_MAXSHORTDATALEN+XS_LEN_MSGHEADERCS)
#define XS_MAXGARBAGE         (XS_MAXMSGLEN+1)
 
// different alignment commands for gcc / MSVS, the structure needs to be 1-byte aligned.
XS_PACKED_STRUCT_START
struct XsMessageHeader
{
        uint8_t m_preamble;  
        uint8_t m_busId;     
        uint8_t m_messageId; 
        uint8_t m_length;    
 
        union LengthData
        {
                struct ExtendedLength
                {
                        struct ExtendedParts
                        {
                                uint8_t m_high; 
                                uint8_t m_low;  
                        } m_length;                     
                        uint8_t m_data[1];      
                } m_extended;                   
                uint8_t m_data[1];              
        } m_datlen;     
#ifdef SWIG
};
#else
} XS_PACKED_STRUCT;
#endif
 
XS_PACKED_STRUCT_END
 
struct XsMessage
{
#ifdef __cplusplus
 
        inline explicit XsMessage(XsXbusMessageId msgId = XMID_InvalidMessage, XsSize dataLength = 0)
                : m_autoUpdateChecksum(1)
                , m_checksum(0)
        {
                XsMessage_constructSized(this, dataLength);
                XsMessage_setMessageId(this, msgId);
        }
 
        inline XsMessage(const uint8_t* source, XsSize size)
                : m_autoUpdateChecksum(1)
                , m_checksum(0)
        {
                XsMessage_load(this, size, source);
        }
 
        inline XsMessage(const XsString& source, bool computeChecksum = true)
                : m_autoUpdateChecksum(1)
                , m_checksum(0)
        {
                XsSize szm = source.size() / 2;
                XsSize szmcc = szm + (computeChecksum ? 1 : 0);
                XsByteArray tmp(szmcc);
                auto tonibble = [](char a) -> uint8_t
                {
                        if (a >= '0' && a <= '9')
                                return (uint8_t)(a - '0');
                        if (a >= 'a' && a <= 'f')
                                return (uint8_t)(10 + a - 'a');
                        if (a >= 'A' && a <= 'F')
                                return (uint8_t)(10 + a - 'A');
                        return 0;
                };
                for (XsSize i = 0; i < szm; ++i)
                        tmp[i] = tonibble(source[i * 2]) * (uint8_t)16 + tonibble(source[i * 2 + 1]);   //lint !e734
                XsMessage_load(this, tmp.size(), tmp.data());
                if (computeChecksum)
                        XsMessage_recomputeChecksum(this);
        }
 
        inline XsMessage(const XsMessage& src)
                : m_message(src.m_message)
                , m_autoUpdateChecksum(src.m_autoUpdateChecksum)
                , m_checksum(0)
        {
                updateChecksumPtr();
        }
 
        inline ~XsMessage()
        {
                XsMessage_destruct(this);
        }
 
        inline void clear(void)
        {
                XsMessage_destruct(this);
        }
 
        inline bool empty(void) const
        {
                return 0 != XsMessage_empty(this);
        }
 
        inline uint8_t getBusId(void) const
        {
                const XsMessageHeader* hdr = XsMessage_getConstHeader(this);
                if (!hdr)
                        return 0;
                return hdr->m_busId;
        }
 
        inline const uint8_t* getDataBuffer(XsSize offset = 0) const
        {
                return XsMessage_constData(this, offset);
        }
 
        inline uint8_t getDataByte(XsSize offset = 0) const
        {
                return XsMessage_getDataByte(this, offset);
        }
 
        inline double getDataDouble(XsSize offset = 0) const
        {
                return XsMessage_getDataDouble(this, offset);
        }
 
        inline float getDataFloat(XsSize offset = 0) const
        {
                return XsMessage_getDataFloat(this, offset);
        }
 
        inline double getDataF1220(XsSize offset = 0) const
        {
                return XsMessage_getDataF1220(this, offset);
        }
 
        inline double getDataFP1632(XsSize offset = 0) const
        {
                return XsMessage_getDataFP1632(this, offset);
        }
 
        inline uint32_t getDataLong(XsSize offset = 0) const
        {
                return XsMessage_getDataLong(this, offset);
        }
 
        inline uint64_t getDataLongLong(XsSize offset = 0) const
        {
                return XsMessage_getDataLongLong(this, offset);
        }
 
        inline uint16_t getDataShort(XsSize offset = 0) const
        {
                return XsMessage_getDataShort(this, offset);
        }
 
        inline XsSize getDataSize(void) const
        {
                return XsMessage_dataSize(this);
        }
 
        inline XsXbusMessageId getMessageId(void) const
        {
                const XsMessageHeader* hdr = XsMessage_getConstHeader(this);
                if (!hdr)
                        return XMID_InvalidMessage;
                return (XsXbusMessageId) hdr->m_messageId;
        }
 
        inline XsResultValue toResultValue(void) const
        {
                const XsMessageHeader* hdr = XsMessage_getConstHeader(this);
                if (!hdr)
                        return XRV_NULLPTR;
                if (hdr->m_messageId == 0 && hdr->m_busId == XS_BID_MASTER)
                        return XRV_TIMEOUTNODATA;       // we assume that an empty message indicates a timeout
                if ((XsXbusMessageId) hdr->m_messageId != XMID_Error)
                        return XRV_OK;
                return (XsResultValue) getDataByte();
        }
 
        inline const uint8_t* getMessageStart(void) const
        {
                return XsMessage_getMessageStart(this);
        }
 
        inline XsSize getTotalMessageSize(void) const
        {
                return XsMessage_getTotalMessageSize(this);
        }
 
        inline bool isChecksumOk(void) const
        {
                return 0 != XsMessage_isChecksumOk(this);
        }
 
        inline bool loadFromString(const uint8_t* src, XsSize msgSize)
        {
                XsArray_destruct(&m_message);
                XsMessage_load(this, msgSize, src);
                return isChecksumOk();
        }
 
        inline void recomputeChecksum(void)
        {
                XsMessage_recomputeChecksum(this);
        }
 
        inline void resizeData(XsSize newSize)
        {
                XsMessage_resizeData(this, newSize);
        }
 
        inline void setBusId(uint8_t busId)
        {
                XsMessage_setBusId(this, busId);
        }
 
        inline void setBusId(int busId)
        {
                XsMessage_setBusId(this, (uint8_t) busId);
        }
 
        inline void setDataBuffer(const uint8_t* buffer, XsSize size, XsSize offset = 0)
        {
                XsMessage_setDataBuffer(this, buffer, size, offset);
        }
 
        inline void setDataByte(const uint8_t value, XsSize offset = 0)
        {
                XsMessage_setDataByte(this, value, offset);
        }
 
        inline void setDataDouble(const double value, XsSize offset = 0)
        {
                XsMessage_setDataDouble(this, value, offset);
        }
 
        inline void setDataFloat(const float value, XsSize offset = 0)
        {
                XsMessage_setDataFloat(this, value, offset);
        }
 
        inline void setDataF1220(const double value, XsSize offset = 0)
        {
                XsMessage_setDataF1220(this, value, offset);
        }
 
        inline void setDataFP1632(const double value, XsSize offset = 0)
        {
                XsMessage_setDataFP1632(this, value, offset);
        }
 
        inline void setDataLong(const uint32_t value, XsSize offset = 0)
        {
                XsMessage_setDataLong(this, value, offset);
        }
 
        inline void setDataLongLong(const uint64_t value, XsSize offset = 0)
        {
                XsMessage_setDataLongLong(this, value, offset);
        }
 
        inline void setDataShort(const uint16_t value, XsSize offset = 0)
        {
                XsMessage_setDataShort(this, value, offset);
        }
 
        inline void setMessageId(const XsXbusMessageId msgId)
        {
                XsMessage_setMessageId(this, msgId);
        }
 
        inline XsMessage& operator = (const XsMessage& src)
        {
                if (this != &src)
                        XsMessage_copy(this, &src);
                return *this;
        }
 
        inline void deleteData(XsSize count, XsSize offset = 0)
        {
                XsMessage_deleteData(this, count, offset);
        }
 
        inline void insertData(XsSize count, XsSize offset = 0)
        {
                XsMessage_insertData(this, count, offset);
        }
 
        inline static uint8_t getFPValueSize(XsDataIdentifier id)
        {
                return XsMessage_getFPValueSize(id);
        }
 
        inline void getDataFPValue(XsDataIdentifier dataIdentifier, double* dest, XsSize offset = 0, XsSize numValues = 1) const
        {
                XsMessage_getDataFPValuesById(this, dataIdentifier, dest, offset, numValues);
        }
 
        inline double getDataFPValue(XsDataIdentifier dataIdentifier, XsSize offset = 0) const
        {
                double tmp;
                XsMessage_getDataFPValuesById(this, dataIdentifier, &tmp, offset, 1);
                return tmp;
        }
 
        inline void setDataFPValue(XsDataIdentifier dataIdentifier, const double* data, XsSize offset = 0, XsSize numValues = 1)
        {
                XsMessage_setDataFPValuesById(this, dataIdentifier, data, offset, numValues);
        }
 
        inline void setDataFPValue(XsDataIdentifier dataIdentifier, double data, XsSize offset = 0)
        {
                XsMessage_setDataFPValuesById(this, dataIdentifier, &data, offset, 1);
        }
 
        inline bool operator == (const XsMessage& other) const
        {
                if (this == &other)
                        return true;
                return m_message == other.m_message;
        }
 
        inline XsByteArray const& rawMessage() const
        {
                return m_message;
        };
 
        inline XsString toHexString(XsSize maxBytes = 0) const
        {
                XsString rv;
                XsMessage_toHexString(this, maxBytes, &rv);
                return rv;
        }
 
        template <typename T>
        inline void getData(T* data, XsDataIdentifier id, XsSize offset = 0, int numValues = 1) const
        {
                (void) id;
                for (int i = 0; i < numValues; ++i)
                        XsMessage_getEndianCorrectData(this, &data[i], sizeof(T), offset + ((unsigned int)i)*sizeof(T));
        }
 
        template <typename T>
        inline void setData(T const* data, XsDataIdentifier id, XsSize offset = 0, int numValues = 1)
        {
                (void) id;
                for (int i = 0; i < numValues; ++i)
                        XsMessage_setEndianCorrectData(this, &data[i], sizeof(T), offset + ((unsigned int)i)*sizeof(T));
        }
 
        template <typename T>
        inline static int sizeInMsg(XsDataIdentifier id, int numValues = 1)
        {
                (void) id;
                return numValues * (int) sizeof(T);
        }
 
private:
        inline void updateChecksumPtr()
        {
                XsSize sz = XsMessage_getTotalMessageSize(this);
                if (sz)
                        *const_cast<uint8_t**>(&m_checksum) = &m_message[sz - 1];
                else
                        *const_cast<uint8_t**>(&m_checksum) = 0;
        }
 
#endif
 
        XsByteArray m_message;
        int m_autoUpdateChecksum;
        uint8_t* const m_checksum;      
};
 
#ifdef __cplusplus
 
template <>
inline void XsMessage::getData<double>(double* data, XsDataIdentifier id, XsSize offset, int numValues) const
{
        getDataFPValue(id, data, offset, (XsSize)(ptrdiff_t)numValues);
}
 
template <>
inline void XsMessage::setData<double>(double const* data, XsDataIdentifier id, XsSize offset, int numValues)
{
        setDataFPValue(id, data, offset, (XsSize)(ptrdiff_t)numValues);
}
 
template <>
inline int XsMessage::sizeInMsg<XsReal>(XsDataIdentifier id, int numValues)
{
        return XsMessage_getFPValueSize(id) * numValues;
}
#endif
 
// some macros to help when constructing/parsing messages
#define swapEndian16(src) (uint16_t)(((uint16_t)(src) >> 8) | ((uint16_t)(src) << 8))
#define swapEndian32(src) (uint32_t)(((uint32_t)(src) >> 24) | (((uint32_t)(src) >> 8) & 0xFF00) | (((uint32_t)(src) << 8) & 0xFF0000) | ((uint32_t)(src) << 24))
#define swapEndian64(src) (uint64_t)(((src >> 56) & 0xFFULL) | ((src >> 40) & 0xFF00ULL) | ((src >> 24) & 0xFF0000ULL) | ((src >> 8) & 0xFF000000ULL) | ((src << 8) & 0xFF00000000ULL) | ((src << 24) & 0xFF0000000000ULL) | ((src << 40) & 0xFF000000000000ULL) | ((src << 56)))
 
#endif