simplejsble 0.0.4 → 0.0.6

package/VERSION

@@ -0,0 +1 @@
+0.10.4

package/android/CMakeLists.txt

@@ -1,35 +1,77 @@
-project(NitroSimplejsble)
 cmake_minimum_required(VERSION 3.9.0)
 
-set (PACKAGE_NAME NitroSimplejsble)
-set (CMAKE_VERBOSE_MAKEFILE ON)
-set (CMAKE_CXX_STANDARD 20)
+# Determine if we're in the SimpleBLE monorepo or npm package
+# In monorepo: packages/simplejsble/android → ../../../../ has cmake/
+# In npm: node_modules/simplejsble/android → ../ has cmake/ (bundled)
+if(EXISTS "${CMAKE_SOURCE_DIR}/../cmake/prelude.cmake")
+    # npm package - bundled cmake
+    set(PROJECT_ROOT_DIR ${CMAKE_SOURCE_DIR}/..)
+elseif(EXISTS "${CMAKE_SOURCE_DIR}/../../../../cmake/prelude.cmake")
+    # Monorepo
+    set(PROJECT_ROOT_DIR ${CMAKE_SOURCE_DIR}/../../../..)
+else()
+    message(FATAL_ERROR "Cannot find SimpleBLE cmake files. Make sure you're using a complete package.")
+endif()
+
+# Read version from VERSION file
+file(READ "${PROJECT_ROOT_DIR}/VERSION" VERSION_FILE_CONTENTS)
+string(STRIP "${VERSION_FILE_CONTENTS}" SIMPLEBLE_VERSION_BASE)
+
+# Include SimpleBLE prelude
+include(${PROJECT_ROOT_DIR}/cmake/prelude.cmake)
+
+project(NitroSimplejsble VERSION ${SIMPLEBLE_VERSION_BASE} LANGUAGES CXX)
+
+# Include SimpleBLE epilogue
+include(${PROJECT_ROOT_DIR}/cmake/epilogue.cmake)
+
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 20)
+
+# Build SimpleBLE as static library
+set(BUILD_SHARED_LIBS OFF)
+add_subdirectory(${PROJECT_ROOT_DIR}/simpleble ${CMAKE_BINARY_DIR}/simpleble)
+set(BUILD_SHARED_LIBS ON)
+
+# Remove nativehelper from SimpleBLE (not available in React Native)
+get_target_property(SIMPLEBLE_LINK_LIBS simpleble INTERFACE_LINK_LIBRARIES)
+if(SIMPLEBLE_LINK_LIBS)
+    list(REMOVE_ITEM SIMPLEBLE_LINK_LIBS nativehelper)
+    set_target_properties(simpleble PROPERTIES INTERFACE_LINK_LIBRARIES "${SIMPLEBLE_LINK_LIBS}")
+endif()
+
+# Glob shared C++ files
+file(GLOB_RECURSE SHARED_CPP_FILES "../cpp/*.cpp")
 
 # Define C++ library and add all sources
-add_library(${PACKAGE_NAME} SHARED
-        src/main/cpp/cpp-adapter.cpp
-        ../cpp/HybridAdapter.cpp
+add_library(NitroSimplejsble SHARED
+    src/main/cpp/cpp-adapter.cpp
+    ${SHARED_CPP_FILES}
 )
 
-# Add Nitrogen specs :)
+# Add Nitrogen specs
 include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/NitroSimplejsble+autolinking.cmake)
 
-# Add simpleble 
-# Path: packages/simplejsble/android → ../../../../simpleble
-add_subdirectory(${CMAKE_SOURCE_DIR}/../../../../simpleble ${CMAKE_BINARY_DIR}/simpleble)
-
 # Set up local includes
-include_directories(
-        "src/main/cpp"
-        "../cpp"
+target_include_directories(NitroSimplejsble PRIVATE
+    src/main/cpp
+    ../cpp
 )
 
 find_library(LOG_LIB log)
 
 # Link all libraries together
-target_link_libraries(
-        ${PACKAGE_NAME}
-        ${LOG_LIB}
-        simpleble::simpleble                      # <-- SimpleBLE library
-        android                                   # <-- Android core
+target_link_libraries(NitroSimplejsble
+    ${LOG_LIB}
+    simpleble::simpleble
+    android
+    -ldl
 )
+
+# Allow undefined JNI symbols (resolved at runtime)
+set_target_properties(NitroSimplejsble PROPERTIES
+    LINK_FLAGS "-Wl,--allow-shlib-undefined -Wl,--unresolved-symbols=ignore-in-object-files"
+)
+
+# Add SimpleBLE compile definitions
+target_compile_definitions(NitroSimplejsble PRIVATE FMT_HEADER_ONLY FMT_UNICODE=0)

package/cmake/epilogue.cmake

@@ -0,0 +1,81 @@
+# Detect if the project is being build within a project or standalone.
+if(PROJECT_IS_TOP_LEVEL)
+    # Configure the build path
+    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+
+    # Nice hack to automatically ignore the build directory
+    file(WRITE ${CMAKE_BINARY_DIR}/.gitignore "*")
+endif()
+
+if(CMAKE_GENERATOR_PLATFORM MATCHES "^[Ww][Ii][Nn]32$")
+    set(WINDOWS_TARGET_ARCH x86)
+elseif(CMAKE_GENERATOR_PLATFORM MATCHES "^[Xx]64$")
+    set(WINDOWS_TARGET_ARCH x64)
+endif()
+
+macro(apply_build_options
+    TARGET
+    PRIVATE_COMPILE_DEFINITIONS
+    PRIVATE_COMPILE_OPTIONS
+    PRIVATE_LINK_OPTIONS
+    PUBLIC_LINK_OPTIONS)
+
+    foreach(DEFINITION ${PRIVATE_COMPILE_DEFINITIONS})
+        message(STATUS "Applying definition: ${DEFINITION}")
+        target_compile_definitions(${TARGET} PRIVATE ${DEFINITION})
+    endforeach()
+
+    foreach(OPTION ${PRIVATE_COMPILE_OPTIONS})
+        message(STATUS "Applying private compile option: ${OPTION}")
+        target_compile_options(${TARGET} PRIVATE ${OPTION})
+    endforeach()
+
+    foreach(OPTION ${PRIVATE_LINK_OPTIONS})
+        message(STATUS "Applying private link option: ${OPTION}")
+        target_link_options(${TARGET} PRIVATE ${OPTION})
+    endforeach()
+
+    foreach(OPTION ${PUBLIC_LINK_OPTIONS})
+        message(STATUS "Applying public link option: ${OPTION}")
+        target_link_options(${TARGET} PUBLIC ${OPTION})
+    endforeach()
+
+endmacro()
+
+macro(append_sanitize_options MODIFIER)
+
+    if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux" OR CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
+        # Note to self: When dealing with memory issues/leaks on Darwin, the following documentation is useful:
+        # - https://clang.llvm.org/docs/AutomaticReferenceCounting.html
+        # - https://developer.apple.com/library/archive/documentation/Performance/Conceptual/ManagingMemory/Articles/FindingLeaks.html
+
+        if(${MODIFIER} MATCHES "Address")
+            list(APPEND PRIVATE_COMPILE_OPTIONS -fsanitize=address)
+            list(APPEND PRIVATE_COMPILE_OPTIONS -fsanitize-recover=address)
+            list(APPEND PRIVATE_COMPILE_OPTIONS -fno-omit-frame-pointer)
+            list(APPEND PRIVATE_COMPILE_OPTIONS -fno-common)
+            list(APPEND PRIVATE_COMPILE_OPTIONS -g)
+            list(APPEND PUBLIC_LINK_OPTIONS     -fsanitize=address)
+
+        elseif(${MODIFIER} MATCHES "Thread")
+            list(APPEND PRIVATE_COMPILE_OPTIONS -fsanitize=thread)
+            list(APPEND PRIVATE_COMPILE_OPTIONS -fno-omit-frame-pointer)
+            list(APPEND PRIVATE_COMPILE_OPTIONS -fno-common)
+            list(APPEND PRIVATE_COMPILE_OPTIONS -g)
+            list(APPEND PUBLIC_LINK_OPTIONS -fsanitize=thread)
+
+        endif()
+
+        elseif (CMAKE_HOST_SYSTEM_NAME STREQUAL "Windows")
+        # TODO: Figure out how to properly link the MSVC address sanitizer libraries.
+        # set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /fsanitize=address /Zi /MD /DEBUG")
+    endif()
+
+endmacro()
+
+# Define the list of source files with relative paths
+set(SIMPLEJNI_SOURCES
+    "${CMAKE_CURRENT_LIST_DIR}/../dependencies/internal/src/simplejni/Common.cpp"
+)

package/cmake/find/FindDBus1.cmake

@@ -0,0 +1,20 @@
+# Attempt to load DBus1 as CONFIG silently
+find_package(DBus1 CONFIG QUIET)
+
+# If DBus1 was not found, try to find it as MODULE
+if(NOT DBus1_FOUND)
+
+    find_package(PkgConfig REQUIRED)
+    pkg_search_module(PC_DBUS REQUIRED dbus-1)
+
+    set(DBus1_LIBRARIES ${PC_DBUS_LIBRARIES})
+    set(DBus1_INCLUDE_DIRS ${PC_DBUS_INCLUDE_DIRS})
+
+    # setup imported target
+    add_library(dbus-1 SHARED IMPORTED)
+    set_property(TARGET dbus-1 APPEND PROPERTY IMPORTED_LOCATION ${PC_DBUS_LINK_LIBRARIES})
+    set_property(TARGET dbus-1 APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${DBus1_INCLUDE_DIRS})
+
+    set(DBus1_FOUND ${PC_DBUS_FOUND})
+
+endif()

package/cmake/find/Findfmt.cmake

@@ -0,0 +1,41 @@
+# Read the documentation of FetchContent first!
+# https://cmake.org/cmake/help/latest/module/FetchContent.html
+
+# TODO: We need to upgrade to a newer version due to the following issue:
+# https://github.com/fmtlib/fmt/issues/3540
+
+include(FetchContent)
+
+if(LIBFMT_VENDORIZE)
+
+    # Load default parameters passed in through the command line.
+    if(NOT LIBFMT_GIT_REPOSITORY)
+        set(LIBFMT_GIT_REPOSITORY "https://github.com/fmtlib/fmt.git")
+    endif()
+    if(NOT LIBFMT_GIT_TAG)
+        set(LIBFMT_GIT_TAG "a33701196adfad74917046096bf5a2aa0ab0bb50") # v9.1.0
+    endif()
+
+    if(NOT LIBFMT_LOCAL_PATH)
+        # Library includes
+        FetchContent_Declare(
+            fmt
+            GIT_REPOSITORY ${LIBFMT_GIT_REPOSITORY}
+            GIT_TAG ${LIBFMT_GIT_TAG}
+        )
+        FetchContent_MakeAvailable(fmt)
+    else()
+        add_subdirectory(${LIBFMT_LOCAL_PATH} ${CMAKE_CURRENT_BINARY_DIR}/libfmt)
+    endif()
+
+    # Because we are in a find module, we are solely responsible for resolution.
+    # Setting this *_FOUND variable to a truthy value will signal to the calling
+    # find_package() command that we were successful.
+    # More relevant info regarding find modules and what variables they use can be
+    # found in the documentation of find_package() and
+    # https://cmake.org/cmake/help/latest/manual/cmake-developer.7.html
+    set(fmt_FOUND 1)
+
+else()
+    find_package(fmt CONFIG REQUIRED)
+endif()

package/cmake/find/Findgoogletest.cmake

@@ -0,0 +1,18 @@
+# Read the documentation of FetchContent first!
+# https://cmake.org/cmake/help/latest/module/FetchContent.html
+
+include(FetchContent)
+
+# Library includes
+FetchContent_Declare(googletest
+  URL https://github.com/google/googletest/archive/refs/tags/v1.13.0.zip
+)
+FetchContent_MakeAvailable(googletest)
+
+# Because we are in a find module, we are solely responsible for resolution.
+# Setting this *_FOUND variable to a truthy value will signal to the calling
+# find_package() command that we were successful.
+# More relevant info regarding find modules and what variables they use can be
+# found in the documentation of find_package() and
+# https://cmake.org/cmake/help/latest/manual/cmake-developer.7.html
+set(googletest_FOUND 1)

package/cmake/parse_version.cmake

@@ -0,0 +1,45 @@
+# Copyright (C) 2020 Google, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# parse_version() reads and parses the version string from FILE, assigning the
+# version string to ${PROJECT}_VERSION and the parsed version to
+# ${PROJECT}_VERSION_MAJOR, ${PROJECT}_VERSION_MINOR, ${PROJECT}_VERSION_PATCH,
+# and the optional ${PROJECT}_VERSION_FLAVOR.
+#
+# The version string take one of the forms:
+#    <major>.<minor>.<patch>
+#    <major>.<minor>.<patch>-<flavor>
+function(parse_version FILE PROJECT)
+    configure_file(${FILE} "${CMAKE_CURRENT_BINARY_DIR}/VERSION") # Required to re-run cmake on version change
+    file(READ ${FILE} VERSION_STR)
+    string(STRIP ${VERSION_STR} VERSION_STR)
+    if(${VERSION_STR} MATCHES "([0-9]+)\\.([0-9]+)\\.([0-9]+)(-[a-zA-Z0-9]+)?")
+        set(FLAVOR "")
+        if(NOT "${CMAKE_MATCH_4}" STREQUAL "")
+            string(SUBSTRING ${CMAKE_MATCH_4} 1 -1 FLAVOR)
+        endif()
+        set("${PROJECT}_VERSION_MAJOR"  ${CMAKE_MATCH_1} PARENT_SCOPE)
+        set("${PROJECT}_VERSION_MINOR"  ${CMAKE_MATCH_2} PARENT_SCOPE)
+        set("${PROJECT}_VERSION_PATCH"  ${CMAKE_MATCH_3} PARENT_SCOPE)
+        set("${PROJECT}_VERSION_FLAVOR" ${FLAVOR}        PARENT_SCOPE)
+        set("${PROJECT}_VERSION"
+            "${CMAKE_MATCH_1}.${CMAKE_MATCH_2}.${CMAKE_MATCH_3}${CMAKE_MATCH_4}"
+            PARENT_SCOPE)
+        set("${PROJECT}_VERSION_BASE"
+            "${CMAKE_MATCH_1}.${CMAKE_MATCH_2}.${CMAKE_MATCH_3}"
+            PARENT_SCOPE)
+    else()
+        message(FATAL_ERROR "Unable to parse version from '${FILE}'")
+    endif()
+endfunction()

package/cmake/prelude.cmake

@@ -0,0 +1,8 @@
+cmake_minimum_required(VERSION 3.21)
+
+# Common configuration used by all projects in this repository
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/find)
+
+include(${CMAKE_CURRENT_LIST_DIR}/parse_version.cmake)
+parse_version(${CMAKE_CURRENT_LIST_DIR}/../VERSION SIMPLEBLE)

package/dependencies/README

@@ -0,0 +1,4 @@
+This folder is intended to contain external and internal dependencies for the project.
+Initially we expect to have header only dependencies.
+External dependencies will be bundled as part of the install directory.
+Internal dependencies are only consumed internally and don't affect any public API.

package/dependencies/external/kvn/kvn_bytearray.h

@@ -0,0 +1,297 @@
+#ifndef KVN_BYTEARRAY_H
+#define KVN_BYTEARRAY_H
+
+#include <cstdint>
+#include <cstring>
+#include <iomanip>
+#include <iostream>
+#include <memory>
+#include <sstream>
+#include <stdexcept>
+#include <type_traits>
+#include <vector>
+
+namespace kvn {
+
+/**
+ * @class bytearray
+ * @brief A class to handle byte arrays and their conversion from/to hex strings.
+ */
+class bytearray {
+  public:
+    /**
+     * @brief Default constructor.
+     */
+    bytearray() = default;
+
+    /**
+     * @brief Constructs byte array from a vector of uint8_t.
+     * @param vec A vector of uint8_t.
+     */
+    bytearray(const std::vector<uint8_t>& vec) : data_(vec) {}
+
+    /**
+     * @brief Constructs byte array from a raw pointer and size.
+     * @param ptr A pointer to uint8_t data.
+     * @param size The size of the data.
+     */
+    bytearray(const uint8_t* ptr, size_t size) : data_(ptr, ptr + size) {}
+
+    /**
+     * @brief Constructs byte array from iterators.
+     * @tparam InputIt Iterator type.
+     * @param first Iterator to the first element.
+     * @param last Iterator to one past the last element.
+     */
+    template <typename InputIt>
+    bytearray(InputIt first, InputIt last) : data_(first, last) {}
+
+    /**
+     * @brief Constructs byte array from a std::string.
+     * @param byteArr A string containing byte data.
+     */
+    bytearray(const std::string& byteArr) : data_(byteArr.begin(), byteArr.end()) {}
+
+    /**
+     * @brief Constructs byte array from a C-style string and size.
+     * @param byteArr A C-style string.
+     * @param size The size of the string.
+     */
+    bytearray(const char* byteArr, size_t size) : bytearray(std::string(byteArr, size)) {}
+
+    /**
+     * @brief Constructs byte array from a C-style string.
+     * @param byteArr A C-style string.
+     */
+    bytearray(const char* byteArr) : bytearray(std::string(byteArr)) {}
+
+    /**
+     * @brief Constructs a byte array of specified size, initialized with zeros.
+     * @param size The number of bytes to allocate.
+     */
+    explicit bytearray(size_t size) : data_(size) {}
+
+    /**
+     * @brief Creates a ByteArray from a hex string.
+     *
+     * Case is ignored and the string may have a '0x' hex prefix or not.
+     *
+     * @param hexStr A string containing hex data.
+     * @return A ByteArray object.
+     * @throws std::invalid_argument If the hex string contains non-hexadecimal characters.
+     * @throws std::length_error If the hex string length is not even.
+     */
+    static bytearray fromHex(const std::string& hexStr) {
+        std::string cleanString(hexStr);
+
+        // Check and skip the '0x' prefix if present
+        if (cleanString.size() >= 2 && cleanString.substr(0, 2) == "0x") {
+            cleanString = cleanString.substr(2);
+        }
+
+        size_t size = cleanString.size();
+        if (size % 2 != 0) {
+            throw std::length_error("Hex string length must be even.");
+        }
+
+        bytearray byteArray;
+        byteArray.data_.reserve(size / 2);
+
+        for (size_t i = 0; i < size; i += 2) {
+            uint8_t byte = static_cast<uint8_t>(std::stoi(cleanString.substr(i, 2), nullptr, 16));
+            byteArray.data_.push_back(byte);
+        }
+
+        return byteArray;
+    }
+
+    /**
+     * @overload
+     */
+    static bytearray fromHex(const char* byteArr) { return fromHex(std::string(byteArr)); }
+
+    /**
+     * @overload
+     */
+    static bytearray fromHex(const char* byteArr, size_t size) { return fromHex(std::string(byteArr, size)); }
+
+    /**
+     * @brief Converts the byte array to a lowercase hex string without '0x' prefix.
+     * @param spacing Whether to include spaces between bytes.
+     *
+     * @return A hex string representation of the byte array.
+     */
+    std::string toHex(bool spacing = false) const {
+        std::ostringstream oss;
+        for (auto byte : data_) {
+            oss << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(byte);
+            if (spacing) {
+                oss << " ";
+            }
+        }
+        return oss.str();
+    }
+
+    /**
+     * @brief Slices  the byte array from a specified start index to an end index.
+     *
+     * This method creates a new byte array containing bytes from the specified range.
+     * The start index is inclusive, while the end index is exclusive.
+     *
+     * @param start The starting index from which to begin slicing.
+     * @param end The ending index up to which to slice (exclusive).
+     * @return byte array A new byte array containing the sliced segment.
+     * @throws std::out_of_range If the start index is greater than the end index or if the end index is out of bounds.
+     */
+    bytearray slice(size_t start, size_t end) const {
+        if (start > end || end > data_.size()) {
+            throw std::out_of_range("Invalid slice range");
+        }
+        return bytearray(std::vector<uint8_t>(data_.begin() + start, data_.begin() + end));
+    }
+
+    /**
+     * @brief Slices the byte array from a specified start index to the end of the array.
+     *
+     * This method creates a new byte array containing all bytes from the specified start index to the end of the
+     * byte array.
+     *
+     * @param start The starting index from which to begin slicing.
+     * @return byte array A new byte array containing the sliced segment from the start index to the end.
+     * @throws std::out_of_range If the start index is out of the bounds of the byte array.
+     */
+    bytearray slice_from(size_t start) const { return slice(start, data_.size()); }
+
+    /**
+     * @brief Slices the byte array from the beginning to a specified end index.
+     *
+     * This method creates a new byte array containing all bytes from the beginning of the byte array to the specified
+     * end index.
+     *
+     * @param end The ending index up to which to slice (exclusive).
+     * @return byte array A new byte array containing the sliced segment from the beginning to the end index.
+     * @throws std::out_of_range If the end index is out of the bounds of the byte array.
+     */
+    bytearray slice_to(size_t end) const { return slice(0, end); }
+
+    /**
+     * @brief Overloaded stream insertion operator for byte array.
+     * @param os The output stream.
+     * @param byteArray The byte array object.
+     * @return The output stream.
+     */
+    friend std::ostream& operator<<(std::ostream& os, const bytearray& byteArray) {
+        os << byteArray.toHex(true);
+        return os;
+    }
+
+    /**
+     * @brief Conversion operator to convert byte array to std::string.
+     *
+     * @note This is provided to support code that relies on byte array
+     *       being representd as a string.
+     * @return String containing the raw bytes of the byte array
+     */
+    operator std::string() const { return std::string(data_.begin(), data_.end()); }
+
+    /**
+     * @brief Conversion operator to convert byte array to std::vector<uint8_t>.
+     * @return Vector containing the raw bytes of the byte array
+     */
+    operator std::vector<uint8_t>() const { return data_; }
+
+    //! @cond Doxygen_Suppress
+    // Expose vector-like functionality
+    size_t size() const { return data_.size(); }
+    const uint8_t* data() const { return data_.data(); }
+    uint8_t* data() { return data_.data(); }
+    bool empty() const { return data_.empty(); }
+    void clear() { data_.clear(); }
+    uint8_t& operator[](size_t index) { return data_[index]; }
+    const uint8_t& operator[](size_t index) const { return data_[index]; }
+    void push_back(uint8_t byte) { data_.push_back(byte); }
+
+    /**
+     * @brief Appends a uint16_t value as 2 little-endian bytes.
+     * @param value The uint16_t value to append.
+     */
+    void push_back(uint16_t value) {
+        for (size_t i = 0; i < 2; ++i) {
+            data_.push_back(static_cast<uint8_t>(value >> (i * 8)));
+        }
+    }
+
+    /**
+     * @brief Appends a uint32_t value as 4 little-endian bytes.
+     * @param value The uint32_t value to append.
+     */
+    void push_back(uint32_t value) {
+        for (size_t i = 0; i < 4; ++i) {
+            data_.push_back(static_cast<uint8_t>(value >> (i * 8)));
+        }
+    }
+
+    /**
+     * @brief Appends a uint64_t value as 8 little-endian bytes.
+     * @param value The uint64_t value to append.
+     */
+    void push_back(uint64_t value) {
+        for (size_t i = 0; i < 8; ++i) {
+            data_.push_back(static_cast<uint8_t>(value >> (i * 8)));
+        }
+    }
+    auto begin() { return data_.begin(); }
+    auto begin() const { return data_.begin(); }
+    auto end() { return data_.end(); }
+    auto end() const { return data_.end(); }
+
+    /**
+     * @brief Inserts a single byte at the specified position.
+     * @param pos Iterator to the position where the element is inserted.
+     * @param value The byte to insert.
+     * @return Iterator pointing to the inserted element.
+     */
+    auto insert(typename std::vector<uint8_t>::iterator pos, uint8_t value) { return data_.insert(pos, value); }
+    auto insert(typename std::vector<uint8_t>::const_iterator pos, uint8_t value) { return data_.insert(pos, value); }
+
+    /**
+     * @brief Inserts multiple copies of a byte at the specified position.
+     * @param pos Iterator to the position where the elements are inserted.
+     * @param count Number of copies to insert.
+     * @param value The byte to insert.
+     * @return Iterator pointing to the first inserted element.
+     */
+    auto insert(typename std::vector<uint8_t>::iterator pos, size_t count, uint8_t value) { return data_.insert(pos, count, value); }
+    auto insert(typename std::vector<uint8_t>::const_iterator pos, size_t count, uint8_t value) { return data_.insert(pos, count, value); }
+
+    /**
+     * @brief Inserts elements from a range at the specified position.
+     * @tparam InputIt Iterator type.
+     * @param pos Iterator to the position where the elements are inserted.
+     * @param first Iterator to the first element of the range.
+     * @param last Iterator to one past the last element of the range.
+     * @return Iterator pointing to the first inserted element.
+     */
+    template <typename InputIt>
+    auto insert(typename std::vector<uint8_t>::iterator pos, InputIt first, InputIt last) { return data_.insert(pos, first, last); }
+    template <typename InputIt>
+    auto insert(typename std::vector<uint8_t>::const_iterator pos, InputIt first, InputIt last) { return data_.insert(pos, first, last); }
+
+    /**
+     * @brief Inserts another bytearray at the specified position.
+     * @param pos Iterator to the position where the elements are inserted.
+     * @param other The bytearray to insert.
+     * @return Iterator pointing to the first inserted element.
+     */
+    auto insert(typename std::vector<uint8_t>::iterator pos, const bytearray& other) { return data_.insert(pos, other.begin(), other.end()); }
+    auto insert(typename std::vector<uint8_t>::const_iterator pos, const bytearray& other) { return data_.insert(pos, other.begin(), other.end()); }
+
+    //! @endcond
+
+  private:
+    std::vector<uint8_t> data_;
+};
+
+}  // namespace kvn
+
+#endif  // KVN_BYTEARRAY_H