D:\git\skunkworks\herald-for-cpp\herald\include\herald\datatype\data.h

Source (jump to first uncovered line)
//  Copyright 2020-2021 Herald Project Contributors
//  SPDX-License-Identifier: Apache-2.0
//

#ifndef HERALD_DATA_H
#define HERALD_DATA_H

#include <string>
#include <iostream>

#include "memory_arena.h"

namespace herald {
namespace datatype {

/// \brief The main data workhorse class of the Herald API
///
/// A vitally important part of Herald's datatypes. Many other types
/// are actually just aliases or thin wrappers to the DataRef class.
/// 
/// This class represents an arbitrarily long Big Endian list of std::byte.
/// DataRef instances are used to encode Bluetooth advert data, to pass payloads
/// between herald enabled devices, or to share data to and from backend systems.
#ifndef HERALD_MEMORYARENA_MAX
template <typename MemoryArenaT = MemoryArena<8192, 8>>
#else
#ifndef HERALD_MEMORYARENA_PAGE
template <typename MemoryArenaT = MemoryArena<HERALD_MEMORYARENA_MAX, 8>>
#else
template <typename MemoryArenaT = MemoryArena<HERALD_MEMORYARENA_MAX, HERALD_MEMORYARENA_PAGE>>
#endif
#endif
class DataRef {
public:
  /// \brief Creates a DataRef with no memory used
  DataRef() : entry()
  {
    ;
  }
  /// \brief Takes control of another DataRef's memory allocation
  DataRef(DataRef&& other)
  : entry()
  {
    std::swap(entry,other.entry);
  }
  /// \brief Initialises a DataRef from a std::uint8_t array of length `length`
  DataRef(const std::uint8_t* value, std::size_t length) : 
  entry(arena.allocate(length)) {
    for (std::size_t i = 0;i < length; ++i474) {
      // data[i] = std::byte(value[i]);
      arena.set(entry, i, (unsigned char)value[i]);
    }
  }
  /// \brief Initialises a DataRef from a std::byte array of length `length`
  DataRef(const std::byte* value, std::size_t length) : entry(arena.allocate(length)) {
    for (std::size_t i = 0;i < length; ++i8) {
      // data[i] = value[i];
      arena.set(entry, i, (unsigned char)value[i]);
    }
  }
  /// \brief Initialises a DataRef from a string of chars
  DataRef(const std::string& from) : entry(arena.allocate(from.size())) {
    for (std::size_t i = 0;i < from.size(); ++i) {
      // data[i] = value[i];
      arena.set(entry, i, (unsigned char)from[i]);
    }
  }
  /// \brief Initialises a DataRef copying another data object (uses more data, to ensure only one object owns the entry)
  DataRef(const DataRef& from) : entry(arena.allocate(from.entry.byteLength)) {
    for (std::size_t i = 0;i < from.size(); ++i2.70k) {
      arena.set(entry, i, from.arena.get(from.entry,i));
    }
  }

  /// \brief Initialises a DataRef with count number of repeating bytes
  DataRef(std::byte repeating, std::size_t count) : entry(arena.allocate(count)) {
    for (std::size_t i = 0;i < count; ++i604) {
      arena.set(entry,i,(unsigned char)repeating);
    }
  }
  /// \brief Initialises a DataRef with reserveLength bytes of undefined data
  DataRef(std::size_t reserveLength) : entry(arena.allocate(reserveLength)) {
    ;
  }


  // Data(Base64String from); // use Base64String.from(std::string).decode() instea
  /// \brief Copy assign operator. Copies the data to be sure only one object owns the entry
  DataRef& operator=(const DataRef& other)
  {
    entry = arena.allocate(other.entry.byteLength);
    for (std::size_t i = 0;i < other.size(); ++i452) {
      arena.set(entry, i, other.arena.get(other.entry,i));
    }
    return *this;
  }

  /// \brief Default destructor
  ~DataRef() {
    clear();
  }

  // std::string base64EncodedString(); // use Base64String.encode(Data) instead
  /// \brief Creates a new DataRef object from a hexadecimal encoded string
  static DataRef fromHexEncodedString(const std::string& hex)
  {
    // parse string
    const std::size_t length = hex.size();
    std::string hexInput;
    // Input size check - two characters per single byte
    if (1 == length % 2) {
      // invalid format - not an even number of characters
      // Prepend input with a 0. (Note '8' and '08' in hex are the same)
      hexInput += "0";
    }
    hexInput += hex;

    DataRef d(hexInput.size() / 2);

    for (std::size_t i = 0; i < hexInput.size(); i += 22.18k) {
      std::string byteString = hexInput.substr(i, 2);
      std::byte byte = std::byte(strtol(byteString.c_str(), NULL, 16));
      // d.data.push_back(byte);
      arena.set(d.entry,i / 2, (unsigned char)byte);
    }

    return d;
  }

  /// \brief Returns the hex encoded string represetation as the description
  std::string description() const
  {
    return hexEncodedString();
  }

  /// \brief Returns a NEWLY allocated DataRef instance returning a subset of this instance
  DataRef subdata(std::size_t offset) const
  {
    if (offset >= entry.byteLength) {
      return DataRef(0);
    }
    DataRef copy(entry.byteLength - offset);
    for (std::size_t i = 0;i < entry.byteLength - offset;++i7) {
      copy.arena.set(copy.entry,i,arena.get(entry,i + offset));
    }
    // std::copy(data.begin() + offset, data.end(), std::back_inserter(copy.data));
    return copy;
  }

  /// \brief Returns a NEWLY allocated DataRef instance returning a subset of this instance
  DataRef subdata(std::size_t offset, std::size_t length) const
  {
    // Note: offset if passed as -1 could be MAX_LONG_LONG, so check it on its own too
    if (offset >= entry.byteLength) {
      return DataRef(0);
    }
    std::size_t correctedLength = length;
    if (length > entry.byteLength || length + offset > entry.byteLength22) {
      correctedLength = entry.byteLength - offset;
    }
    DataRef copy(correctedLength);
    // Note the below is necessary as calling with (4,-1), the second condition IS valid!
    // if (length > entry.byteLength || offset + length > entry.byteLength) {
    //   for (std::size_t i = 0;i < entry.byteLength - offset;++i) {
    //     copy.arena.set(copy.entry,i,arena.get(entry,offset + i));
    //   }
    //   // std::copy(data.begin() + offset, data.end(), std::back_inserter(copy.data));
    // } else {
      for (std::size_t i = 0;i < correctedLength;++i83) {
        copy.arena.set(copy.entry,i,arena.get(entry,offset + i));
      }
      // std::copy(data.begin() + offset, data.begin() + offset + length, std::back_inserter(copy.data));
    // }
    return copy;
  }

  /// \brief Returns the individual byte at index position, or a byte value of zero if index is out of bounds.
  std::byte at(std::size_t index) const {
    if (index > (unsigned short)(entry.byteLength - 1)) {
      return std::byte(0);
    }
    return std::byte(arena.get(entry,index));
  }

  /// \brief 
  /// Assigns the data in-place, reserving the size required if 
  /// the current size is too small.
  ///
  /// Avoids repeated reallocation of memory on a copy.
  void assign(const DataRef& other)
  {
    if (other.size() > entry.byteLength) {
      arena.reserve(entry,other.size());
    }
    for (std::size_t pos = 0; pos < other.size();++pos) {
      arena.set(entry,pos,other.arena.get(other.entry,pos));
    }
  }

  /// \brief Copies another DataRef into this instance, expanding if required
  void append(const DataRef& rawData, std::size_t offset, std::size_t length)
  {
    auto curSize = entry.byteLength;
    arena.reserve(entry,curSize + length);
    for (std::size_t pos = 0; pos < length;++pos) {
      arena.set(entry,curSize + pos,rawData.arena.get(rawData.entry,pos + offset));
    }
    // std::copy(rawData.data.begin() + offset, 
    //           rawData.data.begin() + offset + length, 
    //           std::back_inserter(data)
    // );
  }

  /// \brief Appends a set of characters to the end of this DataRef
  void append(const std::string& rawData)
  {
    auto curSize = entry.byteLength;
    arena.reserve(entry,curSize + rawData.size());
    for (std::size_t pos = 0; pos < rawData.size();++pos70) {
      arena.set(entry,curSize + pos,rawData[pos]);
    }
  }

  /// \brief Copies a uint8_t array onto the end of this instance, expanding if necessary
  void append(const std::uint8_t* rawData, std::size_t offset, std::size_t length)
  {
    auto curSize = entry.byteLength;
    arena.reserve(entry,curSize + length);
    for (std::size_t i = 0;i < length;++i146) {
      arena.set(entry,curSize + i,(unsigned char)(rawData[offset + i]));
      // arena.set(entry,curSize,std::byte(rawData[offset + i]));
    }
  }

  /// \brief Appends the specified DataRef to this one, but in its reverse order
  void appendReversed(const DataRef& rawData, std::size_t offset, std::size_t length)
  {
    if (offset > rawData.size()) {
      return; // append nothing - out of range
    }
    std::size_t checkedLength = length;
    if (length > (rawData.size() - offset)) {
      checkedLength = rawData.size() - offset;
    }
    auto curSize = entry.byteLength;
    arena.reserve(entry,curSize + checkedLength);
    for (std::size_t i = 0;i < checkedLength;++i18) {
      arena.set(entry,curSize + i,
      rawData.arena.get(rawData.entry,offset + (checkedLength - i - 1)));
    // std::reverse_copy(rawData.data.begin() + offset, 
    //                   rawData.data.begin() + offset + checkedLength, 
    //                   std::back_inserter(data)
    // );
    }
  }

  /// \brief Appends the specified DataRef to this one
  void append(const DataRef& rawData)
  {
    auto orig = entry.byteLength;
    arena.reserve(entry,rawData.size() + orig);
    for (std::size_t pos = 0; pos < rawData.size();++pos178) {
      arena.set(entry,orig + pos,rawData.arena.get(rawData.entry,pos));
    }
    // std::copy(rawData.data.begin(), rawData.data.end(), std::back_inserter(data));
  }

  /// \brief Appends a single byte
  void append(std::byte rawData)
  {
    std::size_t curSize = entry.byteLength;
    arena.reserve(entry,curSize + 1);
    // data.push_back(rawData);
    arena.set(entry,curSize,(unsigned char)rawData);
    // curSize++;
  }

  /// \brief appends a single uint8_t
  void append(uint8_t rawData)
  {
    std::size_t curSize = entry.byteLength;
    arena.reserve(entry,curSize + 1); // C++ ensures types are AT LEAST x bits
    // arena.set(entry,curSize,std::byte(rawData));
    arena.set(entry,curSize,(unsigned char)(rawData));
    // curSize++;
  }

  /// \brief Appends a single uint16_t
  void append(uint16_t rawData)
  {
    std::size_t curSize = entry.byteLength;
    arena.reserve(entry,curSize + 2); // C++ ensures types are AT LEAST x bits
    arena.set(entry,curSize,(unsigned char)(rawData & 0xff));
    arena.set(entry,curSize + 1,(unsigned char)(rawData >> 8));
  }

  /// \brief Appends a single uint32_t
  void append(uint32_t rawData)
  {
    std::size_t curSize = entry.byteLength;
    arena.reserve(entry,curSize + 4); // C++ ensures types are AT LEAST x bits
    arena.set(entry,curSize,(unsigned char)(rawData & 0xff));
    arena.set(entry,curSize + 1,(unsigned char)(rawData >> 8));
    arena.set(entry,curSize + 2,(unsigned char)(rawData >> 16));
    arena.set(entry,curSize + 3,(unsigned char)(rawData >> 24));
  }

  /// \brief Appends a single uint64_t
  void append(uint64_t rawData)
  {
    std::size_t curSize = entry.byteLength;
    arena.reserve(entry,curSize + 8); // C++ ensures types are AT LEAST x bits
    arena.set(entry,curSize,(unsigned char)(rawData & 0xff));
    arena.set(entry,curSize + 1,(unsigned char)(rawData >> 8));
    arena.set(entry,curSize + 2,(unsigned char)(rawData >> 16));
    arena.set(entry,curSize + 3,(unsigned char)(rawData >> 24));
    arena.set(entry,curSize + 4,(unsigned char)(rawData >> 32));
    arena.set(entry,curSize + 5,(unsigned char)(rawData >> 40));
    arena.set(entry,curSize + 6,(unsigned char)(rawData >> 48));
    arena.set(entry,curSize + 7,(unsigned char)(rawData >> 56));
  }

  /// \brief Returns whether reading a single uint8_t to `into` at `fromIndex` was successful
  bool uint8(std::size_t fromIndex, uint8_t& into) const noexcept
  {
    if (fromIndex > (unsigned short)(entry.byteLength - 1)) {
      return false;
    }
    into = std::uint8_t(arena.get(entry,fromIndex));
    return true;
  }

  /// \brief Returns whether reading a single uint16_t to `into` at `fromIndex` was successful
  bool uint16(std::size_t fromIndex, uint16_t& into) const noexcept
  {
    if (fromIndex > (unsigned short)(entry.byteLength - 2)) {
      return false;
    }
    into = (std::uint16_t(std::uint8_t(arena.get(entry,fromIndex + 1))) << 8) | std::uint16_t(std::uint8_t(arena.get(entry,fromIndex)));
    return true;
  }

  /// \brief Returns whether reading a single uint32_t to `into` at `fromIndex` was successful
  bool uint32(std::size_t fromIndex, uint32_t& into) const noexcept
  {
    if (fromIndex > entry.byteLength - 4) {
      return false;
    }
    into =  std::uint32_t(std::uint8_t(arena.get(entry,fromIndex)))            | (std::uint32_t(std::uint8_t(arena.get(entry,fromIndex + 1))) << 8) |
          (std::uint32_t(std::uint8_t(arena.get(entry,fromIndex + 2))) << 16) | (std::uint32_t(std::uint8_t(arena.get(entry,fromIndex + 3))) << 24);
    return true;
  }

  /// \brief Returns whether reading a single uint64_t to `into` at `fromIndex` was successful
  bool uint64(std::size_t fromIndex, uint64_t& into) const noexcept
  {
    if (entry.byteLength < 8 || fromIndex > entry.byteLength - 8) {
      return false;
    }
    into = (std::uint64_t(std::uint8_t(arena.get(entry,fromIndex + 7))) << 56) | (std::uint64_t(std::uint8_t(arena.get(entry,fromIndex + 6))) << 48) |
          (std::uint64_t(std::uint8_t(arena.get(entry,fromIndex + 5))) << 40) | (std::uint64_t(std::uint8_t(arena.get(entry,fromIndex + 4))) << 32) |
          (std::uint64_t(std::uint8_t(arena.get(entry,fromIndex + 3))) << 24) | (std::uint64_t(std::uint8_t(arena.get(entry,fromIndex + 2))) << 16) |
          (std::uint64_t(std::uint8_t(arena.get(entry,fromIndex + 1))) << 8)  |  std::uint64_t(std::uint8_t(arena.get(entry,fromIndex)));
    return true;
  }

  // TODO signed versions of the above functions too
  /// \brief Equality operator for another DataRef instance (same memory arena)
  bool operator==(const DataRef& other) const noexcept
  {
    if (size() != other.size()) {
      return false;
    }
    //if (hashCode() != other.hashCode()) {
    //  return false;
    //}
    // else compare each value

    // alternatively, cheat...
    return hashCode() == other.hashCode(); // Somewhat naughty
  }

  /// \brief Inequality operator for another DataRef instance (same memory arena)
  bool operator!=(const DataRef& other) const noexcept
  {
    if (size() != other.size()) {
      return true;
    }
    return hashCode() != other.hashCode();
  }

  /// \brief Less than operator for another DataRef instance (same memory arena)
  bool operator<(const DataRef& other) const noexcept
  {
    return hashCode() < other.hashCode();
  }

  /// \brief Greater than operator for another DataRef instance (same memory arena)
  bool operator>(const DataRef& other) const noexcept
  {
    return hashCode() > other.hashCode();
  }

  /// \brief Returns a new DataRef instance with the same data as this one, but in the reverse order
  DataRef reversed() const
  {
    DataRef result(entry.byteLength);
    // result.reserve(entry.byteLength);
    for (std::size_t pos = 0;pos < entry.byteLength;++pos184) {
      result.arena.set(result.entry,pos,arena.get(entry,entry.byteLength - pos - 1));
    }
    // std::reverse_copy(data.begin(),data.end(),
    //   std::back_inserter(result.data)
    // );
    return result;
  }

  /// \brief Returns the same order of bytes, but with the bits in each byte reversed
  DataRef reverseEndianness() const
  {
    DataRef result(entry.byteLength);
    // result.data.reserve(entry.byteLength);

    // Keep byte order intact (caller could use reversed() to change that)
    // but reverse the order of the individual bits by each byte
    std::uint8_t value, original;
    for (std::size_t i = 0;i < entry.byteLength;++i5) {
      original = std::uint8_t(arena.get(entry,i));
      value = 0;
      for (int b = 0;b < 8;++b40) {
        if ((original & (1 << b)) > 0) {
          value |= 1 << (7 - b);
        }
      }
      // result.data[i] = std::byte(value);
      result.arena.set(result.entry,entry.byteLength - i - 1,value);
    }

    return result;
  }

  /// \brief Returns a hex encoded string of this binary data
  std::string hexEncodedString() const noexcept
  {
    if (0 == entry.byteLength) {
      return "";
    }
    std::string result;
    std::size_t size = entry.byteLength;
    result.reserve(size * 2);
    std::size_t v;
    for (std::size_t i = 0; i < size; ++i651) {
      // v = std::size_t(data.at(i));
      v = std::size_t(arena.get(entry,i));
      result += hexChars[0x0F & (v >> 4)]; // MSB
      result += hexChars[0x0F &  v      ]; // LSB
    }
    return result;
  }

  /// \brief Returns the hash code of this instance
  std::size_t hashCode() const noexcept
  {
    // TODO consider a faster (E.g. SIMD) algorithm or one with less hotspots (see hashdos attacks)
    return std::hash<DataRef<MemoryArenaT>>{}(*this);
  }

  /// \brief Returns the size in allocated bytes of this instance
  std::size_t size() const noexcept{
    return entry.byteLength;
  }
  // TODO support other C++ STD container type functions to allow iteration over data elements (uint8)

  /// \brief Clears (deallocates) the bytes referred to by this instance
  void clear() noexcept
  {
    arena.deallocate(entry);
  }

  static MemoryArenaT& getArena() {
    return arena;
  }
  
protected:
  static const char hexChars[];
  static MemoryArenaT arena;
  MemoryArenaEntry entry;
};




/// \brief Instantiates the MemoryArena instance used by all DataRefs that share it
template <typename MemoryArenaT>
MemoryArenaT DataRef<MemoryArenaT>::arena = MemoryArenaT();

template <typename MemoryArenaT>
const char DataRef<MemoryArenaT>::hexChars[] = {
  '0','1','2','3','4','5','6','7',
  '8','9','a','b','c','d','e','f'
};

/// \brief Defaults references to Data to equal the DataRef with the default Memory Arena dimensions, unless HERALD_MEMORYARENA_MAX is specified
/// May also have its allocation size set by HERALD_MEMORYARENA_PAGE. Note this only takes
/// affect if HERALD_MEMORYARENA_MAX is also specified.
using Data = DataRef<>; // uses MemoryArenaT<4096,8>




/// \brief Represents a fixed array of Data references using the default memory arena that tracks its own in-use size
template <std::size_t maxSize = 8>
class DataSections {
public:
  static constexpr std::size_t MaxSize = maxSize;

  /// \brief Default constructors. No memory allocation other than size (8 bytes)
  DataSections() noexcept : sections(), sz(0) {}
  /// \brief Default destructor
  ~DataSections() noexcept = default;

  /// \brief Adds a new section, if room exists. Otherwise quietly performs a NO OP.
  void append(const Data& toCopy) noexcept {
    if (sz >= MaxSize) {
      return;
    }
    sections[sz] = toCopy; // copy assign operator
    ++sz;
  }

  /// \brief Returns the number of dataref elements in use
  std::size_t size() noexcept {
    return sz;
  }

  /// \brief Returns the DataRef at the relevant index, or an empty DataRef
  const Data& get(std::size_t index) noexcept {
    if (index >= MaxSize) {
      return emptyRef;
    }
    return sections[index];
  }

  /// \brief Returns the DataRef at the relevant index, or an empty DataRef
  const Data& operator[](std::size_t index) noexcept {
    return get(index);
  }

private:
  static Data emptyRef;
  std::array<Data,MaxSize> sections;
  std::size_t sz;
};

/// \brief Reference to empty data item for optional/empty return by ref
template <std::size_t maxSize>
Data DataSections<maxSize>::emptyRef = Data();

} // end namespace
} // end namespace

namespace std {
  template <typename MemoryArenaT>
  inline std::ostream& operator<<(std::ostream &os, const herald::datatype::DataRef<MemoryArenaT>& d)
  {
    return os << d.hexEncodedString();
  }

  inline void hash_combine_impl(std::size_t& seed, std::size_t value)
  {
    seed ^= value + 0x9e3779b9 + (seed<<6) + (seed>>2);
  }

  template<typename MemoryArenaT>
  struct hash<herald::datatype::DataRef<MemoryArenaT>>
  {
    size_t operator()(const herald::datatype::DataRef<MemoryArenaT>& v) const
    {
      std::size_t hv = 0;
      std::uint8_t ui = 0;
      bool ok;
      for (std::size_t pos = 0;pos < v.size();++pos1.46k) {
        ok = v.uint8(pos,ui);
        hash_combine_impl(hv, std::hash<std::uint8_t>()(ui));
      }
      return hv;
    }
  };
} // end namespace

#endif

Coverage Report

Created: 2021-08-28 18:14