span.hpp

Go to the documentation of this file.

// nros-cpp: Lightweight non-owning view types
//
// Provides rclcpp::Span<T> and rclcpp::StringView as zero-overhead alternatives
// to std::span (C++20) and std::string_view (C++17). Compatible with GCC 5+,
// Clang 3.5+, and all embedded toolchains.
//
// Written in the freestanding C++14 subset, which is a property of this
// FILE and not the project's minimum: nano-ros declares C++17 (issue 1118 —
// `target_compile_features(nros-cpp-headers INTERFACE cxx_std_17)`), because
// that is what ROS 2 Humble's own `rclcpp` exports (phase-426 W4 retired the
// construct-specific half of this claim: `component_node.hpp`'s `if constexpr`
// left with `adopt_launch_seed_`). `just check cpp` still parses
// this header at `-std=c++14 -ffreestanding`, so the subset is enforced and
// not merely claimed.
//
// These types are used by generated borrowed message structs to reference
// variable-length data in the CDR receive buffer without copying.
 
#ifndef NROS_RCLCPP_SPAN_HPP
#define NROS_RCLCPP_SPAN_HPP
 
#include <cstddef>
#include <cstdint>
#include <string.h>
 
namespace rclcpp {
 
template <typename T> struct Span {
    const T* ptr;
    size_t len;
 
    constexpr const T* data() const { return ptr; }
    constexpr size_t size() const { return len; }
    constexpr bool empty() const { return len == 0; }
    constexpr const T& operator[](size_t i) const { return ptr[i]; }
    constexpr const T* begin() const { return ptr; }
    constexpr const T* end() const { return ptr + len; }
};
 
struct StringView {
    const char* ptr;
    size_t len;
 
    constexpr const char* data() const { return ptr; }
    constexpr size_t size() const { return len; }
    constexpr bool empty() const { return len == 0; }
    constexpr char operator[](size_t i) const { return ptr[i]; }
    constexpr const char* begin() const { return ptr; }
    constexpr const char* end() const { return ptr + len; }
 
    bool equals(const char* cstr) const {
        size_t clen = strlen(cstr);
        return clen == len && memcmp(ptr, cstr, len) == 0;
    }
};
 
template <typename T> struct LeSpan {
    const uint8_t* bytes;
    size_t count;
 
    constexpr size_t size() const { return count; }
    constexpr bool empty() const { return count == 0; }
 
    T operator[](size_t i) const {
        const uint8_t* p = bytes + i * sizeof(T);
        unsigned char tmp[sizeof(T)];
#if defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) &&                                    \
    __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
        for (size_t b = 0; b < sizeof(T); ++b)
            tmp[b] = p[sizeof(T) - 1 - b];
#else
        for (size_t b = 0; b < sizeof(T); ++b)
            tmp[b] = p[b];
#endif
        T out;
        memcpy(&out, tmp, sizeof(T));
        return out;
    }
};
 
} // namespace rclcpp
 
#endif // NROS_RCLCPP_SPAN_HPP