semantic_string.hpp

Go to the documentation of this file.

// Copyright (c) 2023 by Apex.AI Inc. All rights reserved.
// Copyright (c) 2025 Contributors to the Eclipse Foundation
//
// See the NOTICE file(s) distributed with this work for additional
// information regarding copyright ownership.
//
// This program and the accompanying materials are made available under the
// terms of the Apache Software License 2.0 which is available at
// https://www.apache.org/licenses/LICENSE-2.0, or the MIT license
// which is available at https://opensource.org/licenses/MIT.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
 
#ifndef IOX2_BB_SEMANTIC_STRING_HPP
#define IOX2_BB_SEMANTIC_STRING_HPP
 
#include "iox2/bb/expected.hpp"
#include "iox2/bb/static_string.hpp"
#include "iox2/legacy/logging.hpp"
 
#include <cstdint>
 
namespace iox2 {
namespace bb {
enum class SemanticStringError : uint8_t {
    InvalidContent,
    ExceedsMaximumLength
};
 
template <typename Child,
          uint64_t Capacity,
          DoesContainInvalidContent<Capacity> DoesContainInvalidContentCall,
          DoesContainInvalidCharacter<Capacity> DoesContainInvalidCharacterCall>
class SemanticString {
  private:
    bb::StaticString<Capacity> m_data;
 
  public:
    template <uint64_t N>
    // avoid-c-arrays: we would like to assign string literals, safe since it is known
    //                 at compile time.
    // NOLINTNEXTLINE(hicpp-avoid-c-arrays, cppcoreguidelines-avoid-c-arrays, hicpp-explicit-conversions, modernize-avoid-c-arrays)
    static auto create(const char (&value)[N]) noexcept -> bb::Expected<Child, SemanticStringError>;
 
    template <uint64_t N>
    static auto create(const bb::StaticString<N>& value) noexcept -> bb::Expected<Child, SemanticStringError>;
 
    constexpr auto size() const noexcept -> uint64_t;
 
    static constexpr auto capacity() noexcept -> uint64_t;
 
    constexpr auto as_string() const noexcept -> const bb::StaticString<Capacity>&;
 
    template <typename T>
    auto append(const T& value) noexcept -> bb::Expected<void, SemanticStringError>;
 
    template <typename T>
    auto insert(uint64_t pos, const T& str, uint64_t count) noexcept -> bb::Expected<void, SemanticStringError>;
 
    auto operator==(const SemanticString& rhs) const noexcept -> bool;
 
    template <typename T>
    auto operator==(const T& rhs) const noexcept -> bb::RequireStaticStringOrCharArray<T, bool>;
 
    auto operator!=(const SemanticString& rhs) const noexcept -> bool;
 
    template <typename T>
    auto operator!=(const T& rhs) const noexcept -> bb::RequireStaticStringOrCharArray<T, bool>;
 
    auto operator<=(const SemanticString& rhs) const noexcept -> bool;
 
    template <typename T>
    auto operator<=(const T& rhs) const noexcept -> bb::RequireStaticStringOrCharArray<T, bool>;
 
    auto operator<(const SemanticString& rhs) const noexcept -> bool;
 
    template <typename T>
    auto operator<(const T& rhs) const noexcept -> bb::RequireStaticStringOrCharArray<T, bool>;
 
    auto operator>=(const SemanticString& rhs) const noexcept -> bool;
 
    template <typename T>
    auto operator>=(const T& rhs) const noexcept -> bb::RequireStaticStringOrCharArray<T, bool>;
 
    auto operator>(const SemanticString& rhs) const noexcept -> bool;
 
    template <typename T>
    auto operator>(const T& rhs) const noexcept -> bb::RequireStaticStringOrCharArray<T, bool>;
 
  protected:
    template <uint64_t N>
    explicit SemanticString(const bb::StaticString<N>& value) noexcept;
 
  private:
    template <uint64_t N>
    static auto create_impl(const char* value) noexcept -> bb::Expected<Child, SemanticStringError>;
};
 
 
template <typename Child,
          uint64_t Capacity,
          DoesContainInvalidContent<Capacity> DoesContainInvalidContentCall,
          DoesContainInvalidCharacter<Capacity> DoesContainInvalidCharacterCall>
template <uint64_t N>
inline SemanticString<Child, Capacity, DoesContainInvalidContentCall, DoesContainInvalidCharacterCall>::SemanticString(
    const bb::StaticString<N>& value) noexcept
    : m_data { value } {
}
 
template <typename Child,
          uint64_t Capacity,
          DoesContainInvalidContent<Capacity> DoesContainInvalidContentCall,
          DoesContainInvalidCharacter<Capacity> DoesContainInvalidCharacterCall>
template <uint64_t N>
inline auto
SemanticString<Child, Capacity, DoesContainInvalidContentCall, DoesContainInvalidCharacterCall>::create_impl(
    const char* value) noexcept -> bb::Expected<Child, SemanticStringError> {
    if (N > Capacity) {
        IOX2_LOG(Debug,
                 "Unable to create semantic string since the value \""
                     << value << "\" exceeds the maximum valid length of " << Capacity << ".");
        return bb::err(SemanticStringError::ExceedsMaximumLength);
    }
 
    auto str = bb::StaticString<Capacity>::from_utf8_null_terminated_unchecked_truncated(value, N);
 
    if (DoesContainInvalidCharacterCall(str)) {
        IOX2_LOG(Debug,
                 "Unable to create semantic string since the value \"" << value
                                                                       << "\" contains invalid characters as content");
        return bb::err(SemanticStringError::InvalidContent);
    }
 
    if (DoesContainInvalidContentCall(str)) {
        IOX2_LOG(Debug,
                 "Unable to create semantic string since the value \"" << value << "\" contains invalid content");
        return bb::err(SemanticStringError::InvalidContent);
    }
 
    return Child(str);
}
 
template <typename Child,
          uint64_t Capacity,
          DoesContainInvalidContent<Capacity> DoesContainInvalidContentCall,
          DoesContainInvalidCharacter<Capacity> DoesContainInvalidCharacterCall>
template <uint64_t N>
inline auto SemanticString<Child, Capacity, DoesContainInvalidContentCall, DoesContainInvalidCharacterCall>::create(
    // avoid-c-arrays: justification in header
    // NOLINTNEXTLINE(hicpp-avoid-c-arrays, cppcoreguidelines-avoid-c-arrays, hicpp-explicit-conversions, modernize-avoid-c-arrays)
    const char (&value)[N]) noexcept -> bb::Expected<Child, SemanticStringError> {
    return SemanticString<Child, Capacity, DoesContainInvalidContentCall, DoesContainInvalidCharacterCall>::
        template create_impl<N>(value);
}
 
template <typename Child,
          uint64_t Capacity,
          DoesContainInvalidContent<Capacity> DoesContainInvalidContentCall,
          DoesContainInvalidCharacter<Capacity> DoesContainInvalidCharacterCall>
template <uint64_t N>
inline auto SemanticString<Child, Capacity, DoesContainInvalidContentCall, DoesContainInvalidCharacterCall>::create(
    const bb::StaticString<N>& value) noexcept -> bb::Expected<Child, SemanticStringError> {
    return SemanticString<Child, Capacity, DoesContainInvalidContentCall, DoesContainInvalidCharacterCall>::
        template create_impl<N>(value.unchecked_access().c_str());
}
 
template <typename Child,
          uint64_t Capacity,
          DoesContainInvalidContent<Capacity> DoesContainInvalidContentCall,
          DoesContainInvalidCharacter<Capacity> DoesContainInvalidCharacterCall>
constexpr auto
SemanticString<Child, Capacity, DoesContainInvalidContentCall, DoesContainInvalidCharacterCall>::size() const noexcept
    -> uint64_t {
    return m_data.size();
}
 
template <typename Child,
          uint64_t Capacity,
          DoesContainInvalidContent<Capacity> DoesContainInvalidContentCall,
          DoesContainInvalidCharacter<Capacity> DoesContainInvalidCharacterCall>
constexpr auto
SemanticString<Child, Capacity, DoesContainInvalidContentCall, DoesContainInvalidCharacterCall>::capacity() noexcept
    -> uint64_t {
    return Capacity;
}
 
template <typename Child,
          uint64_t Capacity,
          DoesContainInvalidContent<Capacity> DoesContainInvalidContentCall,
          DoesContainInvalidCharacter<Capacity> DoesContainInvalidCharacterCall>
constexpr auto
SemanticString<Child, Capacity, DoesContainInvalidContentCall, DoesContainInvalidCharacterCall>::as_string()
    const noexcept -> const bb::StaticString<Capacity>& {
    return m_data;
}
 
template <typename Child,
          uint64_t Capacity,
          DoesContainInvalidContent<Capacity> DoesContainInvalidContentCall,
          DoesContainInvalidCharacter<Capacity> DoesContainInvalidCharacterCall>
template <typename T>
inline auto SemanticString<Child, Capacity, DoesContainInvalidContentCall, DoesContainInvalidCharacterCall>::append(
    const T& value) noexcept -> bb::Expected<void, SemanticStringError> {
    return insert(size(), value, bb::detail::get_size(value));
}
 
template <typename Child,
          uint64_t Capacity,
          DoesContainInvalidContent<Capacity> DoesContainInvalidContentCall,
          DoesContainInvalidCharacter<Capacity> DoesContainInvalidCharacterCall>
template <typename T>
inline auto SemanticString<Child, Capacity, DoesContainInvalidContentCall, DoesContainInvalidCharacterCall>::insert(
    const uint64_t pos, const T& str, const uint64_t count) noexcept -> bb::Expected<void, SemanticStringError> {
    auto temp = m_data;
    if (!temp.unchecked_code_units().insert(pos, str, 0, count)) {
        IOX2_LOG(Debug,
                 "Unable to insert the value \""
                     << str.unchecked_access().c_str()
                     << "\" to the semantic string since it would exceed the maximum valid length of " << Capacity
                     << ".");
        return bb::err(SemanticStringError::ExceedsMaximumLength);
    }
 
    if (DoesContainInvalidCharacterCall(temp)) {
        IOX2_LOG(Debug,
                 "Unable to insert the value \""
                     << str.unchecked_access().c_str()
                     << "\" to the semantic string since it contains invalid characters as content.");
        return bb::err(SemanticStringError::InvalidContent);
    }
 
    if (DoesContainInvalidContentCall(temp)) {
        IOX2_LOG(Debug,
                 "Unable to insert the value \""
                     << str.unchecked_access().c_str()
                     << "\" to the semantic string since it would lead to invalid content.");
        return bb::err(SemanticStringError::InvalidContent);
    }
 
    m_data = temp;
    return {};
}
 
template <typename Child,
          uint64_t Capacity,
          DoesContainInvalidContent<Capacity> DoesContainInvalidContentCall,
          DoesContainInvalidCharacter<Capacity> DoesContainInvalidCharacterCall>
inline auto SemanticString<Child, Capacity, DoesContainInvalidContentCall, DoesContainInvalidCharacterCall>::operator==(
    const SemanticString& rhs) const noexcept -> bool {
    return as_string() == rhs.as_string();
}
 
template <typename Child,
          uint64_t Capacity,
          DoesContainInvalidContent<Capacity> DoesContainInvalidContentCall,
          DoesContainInvalidCharacter<Capacity> DoesContainInvalidCharacterCall>
template <typename T>
inline auto SemanticString<Child, Capacity, DoesContainInvalidContentCall, DoesContainInvalidCharacterCall>::operator==(
    const T& rhs) const noexcept -> bb::RequireStaticStringOrCharArray<T, bool> {
    return as_string() == rhs;
}
 
template <typename Child,
          uint64_t Capacity,
          DoesContainInvalidContent<Capacity> DoesContainInvalidContentCall,
          DoesContainInvalidCharacter<Capacity> DoesContainInvalidCharacterCall>
inline auto SemanticString<Child, Capacity, DoesContainInvalidContentCall, DoesContainInvalidCharacterCall>::operator!=(
    const SemanticString& rhs) const noexcept -> bool {
    return as_string() != rhs.as_string();
}
 
template <typename Child,
          uint64_t Capacity,
          DoesContainInvalidContent<Capacity> DoesContainInvalidContentCall,
          DoesContainInvalidCharacter<Capacity> DoesContainInvalidCharacterCall>
template <typename T>
inline auto SemanticString<Child, Capacity, DoesContainInvalidContentCall, DoesContainInvalidCharacterCall>::operator!=(
    const T& rhs) const noexcept -> bb::RequireStaticStringOrCharArray<T, bool> {
    return as_string() != rhs;
}
 
template <typename Child,
          uint64_t Capacity,
          DoesContainInvalidContent<Capacity> DoesContainInvalidContentCall,
          DoesContainInvalidCharacter<Capacity> DoesContainInvalidCharacterCall>
inline auto SemanticString<Child, Capacity, DoesContainInvalidContentCall, DoesContainInvalidCharacterCall>::operator<=(
    const SemanticString& rhs) const noexcept -> bool {
    return as_string() <= rhs.as_string();
}
 
template <typename Child,
          uint64_t Capacity,
          DoesContainInvalidContent<Capacity> DoesContainInvalidContentCall,
          DoesContainInvalidCharacter<Capacity> DoesContainInvalidCharacterCall>
template <typename T>
inline auto SemanticString<Child, Capacity, DoesContainInvalidContentCall, DoesContainInvalidCharacterCall>::operator<=(
    const T& rhs) const noexcept -> bb::RequireStaticStringOrCharArray<T, bool> {
    return as_string() <= rhs;
}
 
template <typename Child,
          uint64_t Capacity,
          DoesContainInvalidContent<Capacity> DoesContainInvalidContentCall,
          DoesContainInvalidCharacter<Capacity> DoesContainInvalidCharacterCall>
inline auto SemanticString<Child, Capacity, DoesContainInvalidContentCall, DoesContainInvalidCharacterCall>::operator<(
    const SemanticString& rhs) const noexcept -> bool {
    return as_string() < rhs.as_string();
}
 
template <typename Child,
          uint64_t Capacity,
          DoesContainInvalidContent<Capacity> DoesContainInvalidContentCall,
          DoesContainInvalidCharacter<Capacity> DoesContainInvalidCharacterCall>
template <typename T>
inline auto SemanticString<Child, Capacity, DoesContainInvalidContentCall, DoesContainInvalidCharacterCall>::operator<(
    const T& rhs) const noexcept -> bb::RequireStaticStringOrCharArray<T, bool> {
    return as_string() < rhs;
}
 
template <typename Child,
          uint64_t Capacity,
          DoesContainInvalidContent<Capacity> DoesContainInvalidContentCall,
          DoesContainInvalidCharacter<Capacity> DoesContainInvalidCharacterCall>
inline auto SemanticString<Child, Capacity, DoesContainInvalidContentCall, DoesContainInvalidCharacterCall>::operator>=(
    const SemanticString& rhs) const noexcept -> bool {
    return as_string() >= rhs.as_string();
}
 
template <typename Child,
          uint64_t Capacity,
          DoesContainInvalidContent<Capacity> DoesContainInvalidContentCall,
          DoesContainInvalidCharacter<Capacity> DoesContainInvalidCharacterCall>
template <typename T>
inline auto SemanticString<Child, Capacity, DoesContainInvalidContentCall, DoesContainInvalidCharacterCall>::operator>=(
    const T& rhs) const noexcept -> bb::RequireStaticStringOrCharArray<T, bool> {
    return as_string() >= rhs;
}
 
template <typename Child,
          uint64_t Capacity,
          DoesContainInvalidContent<Capacity> DoesContainInvalidContentCall,
          DoesContainInvalidCharacter<Capacity> DoesContainInvalidCharacterCall>
inline auto SemanticString<Child, Capacity, DoesContainInvalidContentCall, DoesContainInvalidCharacterCall>::operator>(
    const SemanticString& rhs) const noexcept -> bool {
    return as_string() > rhs.as_string();
}
 
template <typename Child,
          uint64_t Capacity,
          DoesContainInvalidContent<Capacity> DoesContainInvalidContentCall,
          DoesContainInvalidCharacter<Capacity> DoesContainInvalidCharacterCall>
template <typename T>
inline auto SemanticString<Child, Capacity, DoesContainInvalidContentCall, DoesContainInvalidCharacterCall>::operator>(
    const T& rhs) const noexcept -> bb::RequireStaticStringOrCharArray<T, bool> {
    return as_string() > rhs;
}
 
} // namespace bb
} // namespace iox2
 
#endif // IOX2_BB_SEMANTIC_STRING_HPP