fixed_string.hpp

Go to the documentation of this file.

// nros-cpp: FixedString — fixed-capacity null-terminated string
// Freestanding C++14 — no exceptions, no STL required
//
// Memory layout is repr(C) compatible: identical to char[N].
// Used by codegen-generated message structs for string fields.
 
#ifndef NROS_RCLCPP_FIXED_STRING_HPP
#define NROS_RCLCPP_FIXED_STRING_HPP
 
#include <cstddef>
#include <string.h>
 
// phase-417 W1.c — `std::string` interop. `<string>` is absent from a minimal
// freestanding libcpp and present-but-poisoned under `-ffreestanding`, so the
// interop below exists only where `NROS_CPP_HAS_STD_STRING` does. That macro
// has one definition site, which carries the measurement for both cases.
#include "rclcpp/detail/std_detect.hpp"
 
namespace rclcpp {
 
template <size_t N> struct FixedString {
    char data[N];
 
    FixedString() { data[0] = '\0'; }
 
    FixedString& operator=(const char* s) {
        if (s == nullptr) {
            data[0] = '\0';
            return *this;
        }
        size_t i = 0;
        for (; i < N - 1 && s[i] != '\0'; ++i) {
            data[i] = s[i];
        }
        data[i] = '\0';
        return *this;
    }
 
    const char* c_str() const { return data; }
 
    size_t length() const {
        size_t len = 0;
        while (len < N && data[len] != '\0')
            ++len;
        return len;
    }
 
    static constexpr size_t capacity() { return N - 1; }
 
    size_t size() const { return length(); }
 
    bool empty() const { return data[0] == '\0'; }
 
    bool operator==(const char* s) const {
        if (s == nullptr) return data[0] == '\0';
        return strncmp(data, s, N) == 0;
    }
 
    bool operator!=(const char* s) const { return !(*this == s); }
 
#ifdef NROS_CPP_HAS_STD_STRING // hosted-family: string-interop
    // phase-417 W1.c — `std::string` interop.
    //
    // Codegen emits a message's string field as `FixedString<N>` where
    // upstream rosidl emits `std::string`, so the very first line of a ported
    // node —
    //
    //     message.data = "Hello, world! " + std::to_string(count_++);
    //
    // did not compile: the only assignment was from `const char*`. These
    // members COPY and call through to the existing `const char*` paths; they
    // add no data member and no second code path (RFC-0089 §"Who implements an
    // adopted name" — container/string conversions that copy and delegate are
    // wrapper-side ergonomics), so the `char[N]` layout the FFI relies on is
    // unchanged.
    //
    // Truncation is the same bounded-capacity contract `operator=(const
    // char*)` has always had: a longer source is cut at `N - 1` characters.
 
    FixedString& operator=(const std::string& s) { return *this = s.c_str(); }
 
    // NOLINTNEXTLINE(google-explicit-constructor)
    operator std::string() const { return std::string(data, length()); }
 
    std::string to_string() const { return std::string(data, length()); }
 
    bool operator==(const std::string& s) const { return *this == s.c_str(); }
    bool operator!=(const std::string& s) const { return !(*this == s.c_str()); }
#endif
};
 
} // namespace rclcpp
 
#endif // NROS_RCLCPP_FIXED_STRING_HPP