Utils.h

Go to the documentation of this file.

 
#ifndef __PROSECCOAP_UTILS_H__
#define __PROSECCOAP_UTILS_H__
 
#include <string.h> // For memcpy.
#include <stdint.h>
#include <stddef.h> // For size_t.
 
namespace Coap
{
    namespace Utils
    {
        template <typename T>
        inline void toNetworkByteOrder(T value, uint8_t *result)
        {
#if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
            // If the host is already big-endian, we can just memcpy the value.
            memcpy(result, &value, sizeof(T));
#else
            // The host is little endian, so we need to manually convert to big-endian.
            for (size_t i = 0; i < sizeof(T); ++i)
            {
                // Shift right by (sizeof(T) - 1 - i) * 8 bits, then mask the lowest byte.
                result[i] = static_cast<uint8_t>((value >> ((sizeof(T) - 1 - i) * 8)) & 0xFF);
            }
#endif
        }
 
        inline void toNetworkByteOrder(float value, uint8_t *result)
        {
            uint32_t int_value;
            memcpy(&int_value, &value, sizeof(float));
            toNetworkByteOrder(int_value, result);
        }
 
        inline void toNetworkByteOrder(double value, uint8_t *result)
        {
            uint64_t int_value;
            memcpy(&int_value, &value, sizeof(double));
            toNetworkByteOrder(int_value, result);
        }
 
        // NOTE: The host byte order (big/little endian) does not matter, as the bit shift operator
        // will adjust accordingly.
        // See https://commandcenter.blogspot.com/2012/04/byte-order-fallacy.html
 
        inline constexpr uint16_t read_uint16(const uint8_t *bytes)
        {
            return static_cast<uint16_t>((static_cast<uint16_t>(bytes[0]) << 8) |
                                         static_cast<uint16_t>(bytes[1]));
        }
 
        inline constexpr uint32_t read_uint32(const uint8_t *bytes)
        {
            return (static_cast<uint32_t>(bytes[0]) << 24) |
                   (static_cast<uint32_t>(bytes[1]) << 16) |
                   (static_cast<uint32_t>(bytes[2]) << 8) |
                   (static_cast<uint32_t>(bytes[3]));
        }
 
        inline constexpr uint64_t read_uint64(const uint8_t *bytes)
        {
            return (static_cast<uint64_t>(bytes[0]) << 56) |
                   (static_cast<uint64_t>(bytes[1]) << 48) |
                   (static_cast<uint64_t>(bytes[2]) << 40) |
                   (static_cast<uint64_t>(bytes[3]) << 32) |
                   (static_cast<uint64_t>(bytes[4]) << 24) |
                   (static_cast<uint64_t>(bytes[5]) << 16) |
                   (static_cast<uint64_t>(bytes[6]) << 8) |
                   (static_cast<uint64_t>(bytes[7]));
        }
 
        inline constexpr int16_t read_int16(const uint8_t *bytes)
        {
            // Read as unsigned to avoid bitshift undefined behaviour, then cast to signed.
            return static_cast<int16_t>(read_uint16(bytes));
        }
 
        inline constexpr int32_t read_int32(const uint8_t *bytes)
        {
            return static_cast<int32_t>(read_uint32(bytes));
        }
 
        inline constexpr int64_t read_int64(const uint8_t *bytes)
        {
            return static_cast<int64_t>(read_uint64(bytes));
        }
 
        inline float read_float(const uint8_t *bytes)
        {
            uint32_t value = read_uint32(bytes);
            float host_float;
            memcpy(&host_float, &value, sizeof(float));
            return host_float;
        }
 
        template <typename T = double>
        inline T read_double(const uint8_t *bytes)
        {
            static_assert(sizeof(T) == 8, "Cannot read a 64-bit network double on a 32-bit double architecture (like AVR).");
            uint64_t value = read_uint64(bytes);
            double host_double;
            memcpy(&host_double, &value, sizeof(double));
            return host_double;
        }
    }
}
 
#endif