helios::container::BasicStaticString< StrCapacity, CharT, Traits > Class Template Reference

A fixed-capacity string class that owns its storage. More...

#include <static_string.hpp>

Public Types
using	traits_type = Traits
using	value_type = CharT
using	pointer = CharT *
using	const_pointer = const CharT *
using	reference = CharT &
using	const_reference = const CharT &
using	iterator = CharT *
using	const_iterator = const CharT *
using	reverse_iterator = std::reverse_iterator< iterator >
using	const_reverse_iterator = std::reverse_iterator< const_iterator >
using	size_type = size_t
using	difference_type = ptrdiff_t

Public Member Functions
constexpr	BasicStaticString () noexcept
	Default constructor. Creates an empty string.
constexpr	BasicStaticString (std::basic_string_view< CharT, Traits > sv) noexcept
	Constructs from a string_view.
constexpr	BasicStaticString (std::basic_string_view< CharT, Traits > sv, size_type pos, size_type count=npos) noexcept
	Constructs a substring from a string_view with position and count.
constexpr	BasicStaticString (const CharT *str) noexcept
	Constructs from a null-terminated C string.
template<size_t N> requires (N <= StrCapacity + 1)
constexpr	explicit (false) BasicStaticString(const CharT(&str)[N]) noexcept
	Constructs from a character array of known size.
constexpr	BasicStaticString (size_type count, CharT ch) noexcept
	Constructs from count copies of character ch.
constexpr	BasicStaticString (const CharT *str, size_type len) noexcept
	Constructs from a pointer and length.
template<std::input_iterator InputIt> requires (StrCapacity > 0)
constexpr	BasicStaticString (InputIt first, InputIt last) noexcept
	Constructs from an iterator range.
template<std::ranges::input_range Range> requires std::convertible_to<std::ranges::range_value_t<Range>, CharT>
constexpr	BasicStaticString (std::from_range_t, Range &&rg) noexcept
	Constructs from a range using std::from_range_t (C++23).
constexpr	BasicStaticString (std::initializer_list< CharT > ilist) noexcept
	Constructs from an initializer list.
	BasicStaticString (std::nullptr_t)=delete
	Explicitly delete construction from nullptr.
constexpr	BasicStaticString (const BasicStaticString &) noexcept=default
constexpr	BasicStaticString (BasicStaticString &&) noexcept=default
template<size_t OtherCapacity> requires (OtherCapacity < StrCapacity)
constexpr	BasicStaticString (const BasicStaticString< OtherCapacity, CharT, Traits > &other) noexcept
	Copy constructor from smaller capacity string.
template<size_t OtherCapacity> requires (OtherCapacity < StrCapacity)
constexpr	BasicStaticString (BasicStaticString< OtherCapacity, CharT, Traits > &&other) noexcept
	Move constructor from smaller capacity string.
constexpr	BasicStaticString (const BasicStaticString &other, size_type pos, size_type count=npos) noexcept
	Substring copy constructor from same capacity string.
constexpr	BasicStaticString (BasicStaticString &&other, size_type pos, size_type count=npos) noexcept
	Substring move constructor from same capacity string (C++23).
template<size_t OtherCapacity> requires (OtherCapacity < StrCapacity)
constexpr	BasicStaticString (const BasicStaticString< OtherCapacity, CharT, Traits > &other, size_type pos, size_type count=npos) noexcept
	Substring copy constructor from smaller capacity string.
template<size_t OtherCapacity> requires (OtherCapacity < StrCapacity)
constexpr	BasicStaticString (BasicStaticString< OtherCapacity, CharT, Traits > &&other, size_type pos, size_type count=npos) noexcept
	Substring move constructor from smaller capacity string (C++23).
constexpr	~BasicStaticString () noexcept=default
constexpr BasicStaticString &	operator= (const BasicStaticString &) noexcept=default
constexpr BasicStaticString &	operator= (BasicStaticString &&) noexcept=default
template<size_t OtherCapacity> requires (OtherCapacity < StrCapacity)
constexpr BasicStaticString &	operator= (const BasicStaticString< OtherCapacity, CharT, Traits > &other) noexcept
	Copy assignment from smaller capacity string.
template<size_t OtherCapacity> requires (OtherCapacity < StrCapacity)
constexpr BasicStaticString &	operator= (BasicStaticString< OtherCapacity, CharT, Traits > &&other) noexcept
	Move assignment from smaller capacity string.
constexpr BasicStaticString &	operator= (std::basic_string_view< CharT, Traits > sv) noexcept
	Assigns from a string_view.
constexpr BasicStaticString &	operator= (const CharT *str) noexcept
	Assigns from a null-terminated C string.
constexpr void	Clear () noexcept
	Clears the string content.
constexpr BasicStaticString &	Insert (size_type pos, std::basic_string_view< CharT, Traits > sv) noexcept
	Inserts a string_view at position.
constexpr BasicStaticString &	Insert (size_type pos, size_type count, CharT ch) noexcept
	Inserts count copies of character at position..
template<std::ranges::input_range Range> requires std::convertible_to<std::ranges::range_value_t<Range>, CharT>
constexpr BasicStaticString &	InsertRange (size_type pos, Range &&rg) noexcept
	Inserts characters from a range at position.
constexpr BasicStaticString &	Erase (size_type pos=0, size_type count=npos) noexcept
	Erases characters from pos to pos + count.
constexpr void	PushBack (CharT ch) noexcept
	Appends a character.
constexpr void	PopBack () noexcept
	Removes the last character.
constexpr BasicStaticString &	Append (std::basic_string_view< CharT, Traits > sv) noexcept
	Appends a string_view.
constexpr BasicStaticString &	Append (size_type count, CharT ch) noexcept
	Appends count copies of character ch.
constexpr BasicStaticString &	Append (const CharT *str) noexcept
	Appends a null-terminated C string.
template<std::ranges::input_range Range> requires std::convertible_to<std::ranges::range_value_t<Range>, CharT>
constexpr BasicStaticString &	AppendRange (Range &&rg) noexcept
	Appends characters from a range.
constexpr BasicStaticString &	Replace (size_type pos, size_type count, std::basic_string_view< CharT, Traits > sv) noexcept
	Replaces characters in range [pos, pos + count) with string_view.
constexpr BasicStaticString &	Replace (size_type pos, size_type count, size_type count2, CharT ch) noexcept
	Replaces characters in range [pos, pos + count) with count2 copies of ch.
template<std::ranges::input_range Range> requires std::convertible_to<std::ranges::range_value_t<Range>, CharT>
constexpr BasicStaticString &	ReplaceWithRange (size_type pos, size_type count, Range &&rg) noexcept
	Replaces characters in range [pos, pos + count) with characters from a range.
constexpr size_type	Copy (CharT *dest, size_type count, size_type pos=0) const noexcept
	Copies characters to a buffer.
constexpr void	Resize (size_type count, CharT ch=CharT{}) noexcept
	Resizes the string.
constexpr void	Swap (BasicStaticString &other) noexcept
	Swaps contents with another BasicStaticString.
constexpr BasicStaticString &	Assign (std::basic_string_view< CharT, Traits > sv) noexcept
	Assigns a string_view.
constexpr BasicStaticString &	Assign (const CharT *str) noexcept
	Assigns a null-terminated C string.
constexpr BasicStaticString &	Assign (size_type count, CharT ch) noexcept
	Assigns count copies of character ch.
template<std::ranges::input_range Range> requires std::convertible_to<std::ranges::range_value_t<Range>, CharT>
constexpr BasicStaticString &	AssignRange (Range &&rg) noexcept
	Assigns characters from a range.
constexpr BasicStaticString	Substr (size_type pos=0, size_type count=npos) const noexcept
	Returns a substring.
constexpr int	Compare (std::basic_string_view< CharT, Traits > other) const noexcept
	Compares with another string.
template<size_t OtherCapacity>
constexpr int	Compare (const BasicStaticString< OtherCapacity, CharT, Traits > &other) const noexcept
	Compares with another BasicStaticString.
constexpr size_type	Find (std::basic_string_view< CharT, Traits > sv, size_type pos=0) const noexcept
	Finds first occurrence of substring.
constexpr size_type	Find (CharT ch, size_type pos=0) const noexcept
	Finds first occurrence of character.
constexpr size_type	RFind (std::basic_string_view< CharT, Traits > sv, size_type pos=npos) const noexcept
	Finds last occurrence of substring.
constexpr size_type	RFind (CharT ch, size_type pos=npos) const noexcept
	Finds last occurrence of character.
constexpr size_type	FindFirstOf (std::basic_string_view< CharT, Traits > sv, size_type pos=0) const noexcept
	Finds first occurrence of any character in sv.
constexpr size_type	FindLastOf (std::basic_string_view< CharT, Traits > sv, size_type pos=npos) const noexcept
	Finds last occurrence of any character in sv.
constexpr size_type	FindFirstNotOf (std::basic_string_view< CharT, Traits > sv, size_type pos=0) const noexcept
	Finds first character not in sv.
constexpr size_type	FindLastNotOf (std::basic_string_view< CharT, Traits > sv, size_type pos=npos) const noexcept
	Finds last character not in sv.
constexpr BasicStaticString &	operator+= (std::basic_string_view< CharT, Traits > sv) noexcept
	Appends a string_view.
constexpr BasicStaticString &	operator+= (CharT ch) noexcept
	Appends a character.
constexpr BasicStaticString &	operator+= (const CharT *str) noexcept
	Appends a null-terminated C string.
constexpr reference	operator[] (size_type pos) noexcept
	Accesses character at specified position.
constexpr const_reference	operator[] (size_type pos) const noexcept
	Accesses character at specified position (const).
constexpr	operator std::basic_string_view< CharT, Traits > () const noexcept
	Converts to string_view.
template<size_t OtherCapacity>
constexpr bool	operator== (const BasicStaticString< OtherCapacity, CharT, Traits > &other) const noexcept
constexpr bool	operator== (std::basic_string_view< CharT, Traits > other) const noexcept
constexpr bool	operator== (const CharT *other) const noexcept
template<size_t OtherCapacity> requires (StrCapacity > 0)
constexpr auto	operator<=> (const BasicStaticString< OtherCapacity, CharT, Traits > &other) const noexcept -> std::strong_ordering
constexpr auto	operator<=> (std::basic_string_view< CharT, Traits > other) const noexcept -> std::strong_ordering
constexpr auto	operator<=> (const CharT *other) const noexcept -> std::strong_ordering
constexpr bool	Empty () const noexcept
	Checks if the string is empty.
constexpr bool	StartsWith (std::basic_string_view< CharT, Traits > sv) const noexcept
	Checks if string starts with prefix.
constexpr bool	StartsWith (CharT ch) const noexcept
	Checks if string starts with character.
constexpr bool	EndsWith (std::basic_string_view< CharT, Traits > sv) const noexcept
	Checks if string ends with suffix.
constexpr bool	EndsWith (CharT ch) const noexcept
	Checks if string ends with character.
constexpr bool	Contains (std::basic_string_view< CharT, Traits > sv) const noexcept
	Checks if string contains substring.
constexpr bool	Contains (CharT ch) const noexcept
	Checks if string contains character.
constexpr size_type	Size () const noexcept
	Returns the number of characters.
constexpr size_type	Length () const noexcept
	Returns the number of characters.
constexpr size_type	RemainingCapacity () const noexcept
	Returns the remaining capacity.
constexpr reference	At (size_type pos) noexcept
	Accesses character at specified position with bounds checking.
constexpr const_reference	At (size_type pos) const noexcept
	Accesses character at specified position with bounds checking (const).
constexpr reference	Front () noexcept
	Accesses the first character.
constexpr const_reference	Front () const noexcept
	Accesses the first character (const).
constexpr reference	Back () noexcept
	Accesses the last character.
constexpr const_reference	Back () const noexcept
	Accesses the last character (const).
constexpr pointer	Data () noexcept
	Returns pointer to the underlying character array.
constexpr const_pointer	Data () const noexcept
	Returns pointer to the underlying character array (const).
constexpr const_pointer	CStr () const noexcept
	Returns null-terminated C string.
constexpr std::basic_string_view< CharT, Traits >	View () const noexcept
	Returns a string_view of the content.
constexpr iterator	begin () noexcept
constexpr const_iterator	begin () const noexcept
constexpr const_iterator	cbegin () const noexcept
constexpr iterator	end () noexcept
constexpr const_iterator	end () const noexcept
constexpr const_iterator	cend () const noexcept
constexpr reverse_iterator	rbegin () noexcept
constexpr const_reverse_iterator	rbegin () const noexcept
constexpr const_reverse_iterator	crbegin () const noexcept
constexpr reverse_iterator	rend () noexcept
constexpr const_reverse_iterator	rend () const noexcept
constexpr const_reverse_iterator	crend () const noexcept
template<size_t N> requires (N <= StrCapacity + 1)
constexpr	BasicStaticString (const CharT(&str)[N]) noexcept
template<std::ranges::input_range Range> requires std::convertible_to<std::ranges::range_value_t<Range>, CharT>
constexpr auto	InsertRange (size_type pos, Range &&rg) noexcept -> BasicStaticString &
template<std::ranges::input_range Range> requires std::convertible_to<std::ranges::range_value_t<Range>, CharT>
constexpr auto	AppendRange (Range &&rg) noexcept -> BasicStaticString &
template<std::ranges::input_range Range> requires std::convertible_to<std::ranges::range_value_t<Range>, CharT>
constexpr auto	ReplaceWithRange (size_type pos, size_type count, Range &&rg) noexcept -> BasicStaticString &
template<std::ranges::input_range Range> requires std::convertible_to<std::ranges::range_value_t<Range>, CharT>
constexpr auto	AssignRange (Range &&rg) noexcept -> BasicStaticString &
template<size_t OtherCapacity> requires (OtherCapacity < StrCapacity)
constexpr auto	operator= (const BasicStaticString< OtherCapacity, CharT, Traits > &other) noexcept -> BasicStaticString &
template<size_t OtherCapacity> requires (OtherCapacity < StrCapacity)
constexpr auto	operator= (BasicStaticString< OtherCapacity, CharT, Traits > &&other) noexcept -> BasicStaticString &

Static Public Member Functions
static constexpr size_type	MaxSize () noexcept
	Returns the maximum possible number of characters.
static constexpr size_type	Capacity () noexcept
	Returns the capacity.

Static Public Attributes
static constexpr size_type	npos = static_cast<size_type>(-1)

Detailed Description

template<size_t StrCapacity, typename CharT, typename Traits = std::char_traits<CharT>>
requires (StrCapacity > 0)
class helios::container::BasicStaticString< StrCapacity, CharT, Traits >

A fixed-capacity string class that owns its storage.

Similar to std::string_view but mutable and owning, with a compile-time fixed capacity. Provides all operations of std::string_view plus mutation operations. Does not allocate heap memory.

Template Parameters

StrCapacity	Maximum number of characters (excluding null terminator)
CharT	Character type
Traits	Character traits type

Definition at line 34 of file static_string.hpp.

Member Typedef Documentation

const_iterator

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

using helios::container::BasicStaticString< StrCapacity, CharT, Traits >::const_iterator = const CharT*

Definition at line 44 of file static_string.hpp.

const_pointer

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

using helios::container::BasicStaticString< StrCapacity, CharT, Traits >::const_pointer = const CharT*

Definition at line 40 of file static_string.hpp.

const_reference

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

using helios::container::BasicStaticString< StrCapacity, CharT, Traits >::const_reference = const CharT&

Definition at line 42 of file static_string.hpp.

const_reverse_iterator

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

using helios::container::BasicStaticString< StrCapacity, CharT, Traits >::const_reverse_iterator = std::reverse_iterator<const_iterator>

Definition at line 46 of file static_string.hpp.

difference_type

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

using helios::container::BasicStaticString< StrCapacity, CharT, Traits >::difference_type = ptrdiff_t

Definition at line 48 of file static_string.hpp.

iterator

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

using helios::container::BasicStaticString< StrCapacity, CharT, Traits >::iterator = CharT*

Definition at line 43 of file static_string.hpp.

pointer

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

using helios::container::BasicStaticString< StrCapacity, CharT, Traits >::pointer = CharT*

Definition at line 39 of file static_string.hpp.

reference

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

using helios::container::BasicStaticString< StrCapacity, CharT, Traits >::reference = CharT&

Definition at line 41 of file static_string.hpp.

reverse_iterator

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

using helios::container::BasicStaticString< StrCapacity, CharT, Traits >::reverse_iterator = std::reverse_iterator<iterator>

Definition at line 45 of file static_string.hpp.

size_type

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

using helios::container::BasicStaticString< StrCapacity, CharT, Traits >::size_type = size_t

Definition at line 47 of file static_string.hpp.

traits_type

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

using helios::container::BasicStaticString< StrCapacity, CharT, Traits >::traits_type = Traits

Definition at line 37 of file static_string.hpp.

value_type

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

using helios::container::BasicStaticString< StrCapacity, CharT, Traits >::value_type = CharT

Definition at line 38 of file static_string.hpp.

Constructor & Destructor Documentation

BasicStaticString() [1/19]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr helios::container::BasicStaticString< StrCapacity, CharT, Traits >::BasicStaticString ( )

inlineconstexprnoexcept

Default constructor. Creates an empty string.

Definition at line 55 of file static_string.hpp.

{ data_[0] = CharT{}; }

BasicStaticString() [2/19]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr helios::container::BasicStaticString< StrCapacity, CharT, Traits >::BasicStaticString ( std::basic_string_view< CharT, Traits >  sv )

explicitconstexprnoexcept

Constructs from a string_view.

Warning

Triggers assertion if sv.size() > StrCapacity.

Parameters

sv	Source string view

Definition at line 805 of file static_string.hpp.

                                                     {
  HELIOS_ASSERT(sv.size() <= StrCapacity, "String view size exceeds capacity!");
  const size_type copy_len = std::min(sv.size(), StrCapacity);
  Traits::copy(data_.data(), sv.data(), copy_len);
  size_ = copy_len;
  data_[size_] = CharT{};
}

BasicStaticString() [3/19]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr helios::container::BasicStaticString< StrCapacity, CharT, Traits >::BasicStaticString ( std::basic_string_view< CharT, Traits >  sv, size_type  pos, size_type  count = npos  )

explicitconstexprnoexcept

Constructs a substring from a string_view with position and count.

Warning

Triggers assertion if (pos + count) > sv.size() or count > StrCapacity.

Parameters

sv	Source string view
pos	Starting position in the view
count	Number of characters to copy (default: all remaining)

Definition at line 816 of file static_string.hpp.

                                                                                                                    {
  HELIOS_ASSERT(pos <= sv.size(), "Position out of range!");
  const size_type substr_len = std::min(count, sv.size() - pos);
  HELIOS_ASSERT(substr_len <= StrCapacity, "Substring size exceeds capacity!");
  Traits::copy(data_.data(), sv.data() + pos, substr_len);
  size_ = substr_len;
  data_[size_] = CharT{};
}

BasicStaticString() [4/19]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr helios::container::BasicStaticString< StrCapacity, CharT, Traits >::BasicStaticString ( const CharT *  str )

inlineexplicitconstexprnoexcept

Constructs from a null-terminated C string.

Warning

Triggers assertion if string length > StrCapacity.

Parameters

str	Source C string

Definition at line 79 of file static_string.hpp.

      : BasicStaticString(std::basic_string_view<CharT, Traits>(str)) {}

BasicStaticString() [5/19]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr helios::container::BasicStaticString< StrCapacity, CharT, Traits >::BasicStaticString ( size_type  count, CharT  ch  )

constexprnoexcept

Constructs from count copies of character ch.

Warning

Triggers assertion if count > StrCapacity.

Parameters

count	Number of characters
ch	Character to repeat

Definition at line 841 of file static_string.hpp.

                                                                                                             {
  HELIOS_ASSERT(count <= StrCapacity, "Count exceeds capacity!");
  std::ranges::fill_n(data_.begin(), count, ch);
  size_ = count;
  data_[size_] = CharT{};
}

BasicStaticString() [6/19]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr helios::container::BasicStaticString< StrCapacity, CharT, Traits >::BasicStaticString ( const CharT *  str, size_type  len  )

constexprnoexcept

Constructs from a pointer and length.

Warning

Triggers assertion if len > StrCapacity.

Parameters

str	Source string pointer
len	Length of the string

Definition at line 850 of file static_string.hpp.

                                                                                                                   {
  HELIOS_ASSERT(len <= StrCapacity, "Length exceeds capacity!");
  Traits::copy(data_.data(), str, len);
  size_ = len;
  data_[size_] = CharT{};
}

BasicStaticString() [7/19]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

template<std::input_iterator InputIt>
requires (StrCapacity > 0)

constexpr helios::container::BasicStaticString< StrCapacity, CharT, Traits >::BasicStaticString ( InputIt  first, InputIt  last  )

constexprnoexcept

Constructs from an iterator range.

Warning

Triggers assertion if distance(first, last) > StrCapacity.

Template Parameters

InputIt

Input iterator type

Parameters

first	Beginning of range
last	End of range

Definition at line 860 of file static_string.hpp.

                                                                                                               {
  size_type count = 0;
  for (auto it = first; it != last && count < StrCapacity; ++it, ++count) {
    data_[count] = *it;
  }
  size_ = count;
  data_[size_] = CharT{};
}

BasicStaticString() [8/19]

template<size_t StrCapacity, typename CharT , typename Traits >
requires std::convertible_to<std::ranges::range_value_t<Range>, CharT>

template<std::ranges::input_range Range>
requires std::convertible_to<std::ranges::range_value_t<Range>, CharT>

constexpr helios::container::BasicStaticString< StrCapacity, CharT, Traits >::BasicStaticString ( std::from_range_t  , Range &&  rg  )

constexprnoexcept

Constructs from a range using std::from_range_t (C++23).

Warning

Triggers assertion if range size > StrCapacity.

Template Parameters

Range

Range type

Parameters

rg	Range to construct from

Definition at line 873 of file static_string.hpp.

                                                                                                               {
  size_type count = 0;
  for (auto&& ch : rg) {
    if (count >= StrCapacity)
      break;
    data_[count++] = static_cast<CharT>(ch);
  }
  size_ = count;
  data_[size_] = CharT{};
}

BasicStaticString() [9/19]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr helios::container::BasicStaticString< StrCapacity, CharT, Traits >::BasicStaticString ( std::initializer_list< CharT >  ilist )

constexprnoexcept

Constructs from an initializer list.

Warning

Triggers assertion if ilist.size() > StrCapacity.

Parameters

ilist

Initializer list

Definition at line 886 of file static_string.hpp.

                                               {
  HELIOS_ASSERT(ilist.size() <= StrCapacity, "Initializer list size exceeds capacity!");
  Traits::copy(data_.data(), ilist.begin(), ilist.size());
  size_ = ilist.size();
  data_[size_] = CharT{};
}

BasicStaticString() [10/19]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

helios::container::BasicStaticString< StrCapacity, CharT, Traits >::BasicStaticString ( std::nullptr_t  )

delete

Explicitly delete construction from nullptr.

BasicStaticString() [11/19]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr helios::container::BasicStaticString< StrCapacity, CharT, Traits >::BasicStaticString ( const BasicStaticString< StrCapacity, CharT, Traits > &  )

constexprdefaultnoexcept

BasicStaticString() [12/19]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr helios::container::BasicStaticString< StrCapacity, CharT, Traits >::BasicStaticString ( BasicStaticString< StrCapacity, CharT, Traits > &&  )

constexprdefaultnoexcept

BasicStaticString() [13/19]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (OtherCapacity < StrCapacity)

template<size_t OtherCapacity>
requires (OtherCapacity < StrCapacity)

constexpr helios::container::BasicStaticString< StrCapacity, CharT, Traits >::BasicStaticString ( const BasicStaticString< OtherCapacity, CharT, Traits > &  other )

explicitconstexprnoexcept

Copy constructor from smaller capacity string.

Warning

Triggers assertion if other.Size() > StrCapacity.

Template Parameters

OtherCapacity

StrCapacity of source string (must be less than StrCapacity)

Parameters

other

Source string with smaller capacity

Definition at line 1335 of file static_string.hpp.

                                                                           {
  HELIOS_ASSERT(other.Size() <= StrCapacity, "Source string size exceeds capacity!");
  Traits::copy(data_.data(), other.Data(), other.Size());
  size_ = other.Size();
  data_[size_] = CharT{};
}

BasicStaticString() [14/19]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (OtherCapacity < StrCapacity)

template<size_t OtherCapacity>
requires (OtherCapacity < StrCapacity)

constexpr helios::container::BasicStaticString< StrCapacity, CharT, Traits >::BasicStaticString ( BasicStaticString< OtherCapacity, CharT, Traits > &&  other )

explicitconstexprnoexcept

Move constructor from smaller capacity string.

Warning

Triggers assertion if other.Size() > StrCapacity.

Template Parameters

OtherCapacity

StrCapacity of source string (must be less than StrCapacity)

Parameters

other

Source string with smaller capacity

Definition at line 1347 of file static_string.hpp.

                                                                      {
  HELIOS_ASSERT(other.Size() <= StrCapacity, "Source string size exceeds capacity!");
  Traits::copy(data_.data(), other.Data(), other.Size());
  size_ = other.Size();
  data_[size_] = CharT{};
}

BasicStaticString() [15/19]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr helios::container::BasicStaticString< StrCapacity, CharT, Traits >::BasicStaticString ( const BasicStaticString< StrCapacity, CharT, Traits > &  other, size_type  pos, size_type  count = npos  )

constexprnoexcept

Substring copy constructor from same capacity string.

Warning

Triggers assertion if (pos + count) > other.Size() or count > StrCapacity.

Parameters

other	Source string
pos	Starting position (default: 0)
count	Number of characters to copy (default: all remaining)

Definition at line 1309 of file static_string.hpp.

                                                                                                                    {
  HELIOS_ASSERT(pos <= other.Size(), "Position out of range!");
  const size_type substr_len = std::min(count, other.Size() - pos);
  HELIOS_ASSERT(substr_len <= StrCapacity, "Substring size exceeds capacity!");
  Traits::copy(data_.data(), other.Data() + pos, substr_len);
  size_ = substr_len;
  data_[size_] = CharT{};
}

BasicStaticString() [16/19]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr helios::container::BasicStaticString< StrCapacity, CharT, Traits >::BasicStaticString ( BasicStaticString< StrCapacity, CharT, Traits > &&  other, size_type  pos, size_type  count = npos  )

constexprnoexcept

Substring move constructor from same capacity string (C++23).

Warning

Triggers assertion if (pos + count) > other.Size() or count > StrCapacity.

Parameters

other	Source string
pos	Starting position (default: 0)
count	Number of characters to copy (default: all remaining)

Definition at line 1321 of file static_string.hpp.

                                                                                                     {
  HELIOS_ASSERT(pos <= other.Size(), "Position out of range!");
  const size_type substr_len = std::min(count, other.Size() - pos);
  HELIOS_ASSERT(substr_len <= StrCapacity, "Substring size exceeds capacity!");
  Traits::copy(data_.data(), other.Data() + pos, substr_len);
  size_ = substr_len;
  data_[size_] = CharT{};
}

BasicStaticString() [17/19]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (OtherCapacity < StrCapacity)

template<size_t OtherCapacity>
requires (OtherCapacity < StrCapacity)

constexpr helios::container::BasicStaticString< StrCapacity, CharT, Traits >::BasicStaticString ( const BasicStaticString< OtherCapacity, CharT, Traits > &  other, size_type  pos, size_type  count = npos  )

constexprnoexcept

Substring copy constructor from smaller capacity string.

Warning

Triggers assertion if (pos + count) > other.Size() or count > StrCapacity.

Template Parameters

OtherCapacity

StrCapacity of source string (must be less than StrCapacity)

Parameters

other	Source string with smaller capacity
pos	Starting position (default: 0)
count	Number of characters to copy (default: all remaining)

Definition at line 1359 of file static_string.hpp.

                                                                                                           {
  HELIOS_ASSERT(pos <= other.Size(), "Position out of range!");
  const size_type substr_len = std::min(count, other.Size() - pos);
  HELIOS_ASSERT(substr_len <= StrCapacity, "Substring size exceeds capacity!");
  Traits::copy(data_.data(), other.Data() + pos, substr_len);
  size_ = substr_len;
  data_[size_] = CharT{};
}

BasicStaticString() [18/19]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (OtherCapacity < StrCapacity)

template<size_t OtherCapacity>
requires (OtherCapacity < StrCapacity)

constexpr helios::container::BasicStaticString< StrCapacity, CharT, Traits >::BasicStaticString ( BasicStaticString< OtherCapacity, CharT, Traits > &&  other, size_type  pos, size_type  count = npos  )

constexprnoexcept

Substring move constructor from smaller capacity string (C++23).

Warning

Triggers assertion if (pos + count) > other.Size() or count > StrCapacity.

Template Parameters

OtherCapacity

StrCapacity of source string (must be less than StrCapacity)

Parameters

other	Source string with smaller capacity
pos	Starting position (default: 0)
count	Number of characters to copy (default: all remaining)

Definition at line 1373 of file static_string.hpp.

                                                                                                      {
  HELIOS_ASSERT(pos <= other.Size(), "Position out of range!");
  const size_type substr_len = std::min(count, other.Size() - pos);
  HELIOS_ASSERT(substr_len <= StrCapacity, "Substring size exceeds capacity!");
  Traits::copy(data_.data(), other.Data() + pos, substr_len);
  size_ = substr_len;
  data_[size_] = CharT{};
}

~BasicStaticString()

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr helios::container::BasicStaticString< StrCapacity, CharT, Traits >::~BasicStaticString ( )

constexprdefaultnoexcept

BasicStaticString() [19/19]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

template<size_t N>
requires (N <= StrCapacity + 1)

constexpr helios::container::BasicStaticString< StrCapacity, CharT, Traits >::BasicStaticString ( const CharT(&)  str[N] )

constexprnoexcept

Definition at line 830 of file static_string.hpp.

                                                                                                         {
  // N includes null terminator for string literals
  const size_type copy_len = (N > 0 && str[N - 1] == CharT{}) ? N - 1 : N;
  HELIOS_ASSERT(copy_len <= StrCapacity, "String literal size exceeds capacity!");
  Traits::copy(data_.data(), str, copy_len);
  size_ = copy_len;
  data_[size_] = CharT{};
}

Member Function Documentation

Append() [1/3]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr BasicStaticString & helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Append ( const CharT *  str )

inlineconstexprnoexcept

Appends a null-terminated C string.

Warning

Triggers assertion if resulting size > capacity().

Parameters

str	C string to append

Returns

Reference to this

Definition at line 331 of file static_string.hpp.

                                                                 {
    return Append(std::basic_string_view<CharT, Traits>(str));
  }

Append() [2/3]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Append ( size_type  count, CharT  ch  )

constexprnoexcept

Appends count copies of character ch.

Warning

Triggers assertion if resulting size > capacity().

Parameters

count	Number of characters
ch	Character to append

Returns

Reference to this

Definition at line 1039 of file static_string.hpp.

                          {
  HELIOS_ASSERT(size_ + count <= StrCapacity, "Append would exceed capacity!");
  std::ranges::fill_n(data_.begin() + size_, count, ch);
  size_ += count;
  data_[size_] = CharT{};
  return *this;
}

Append() [3/3]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Append ( std::basic_string_view< CharT, Traits >  sv )

constexprnoexcept

Appends a string_view.

Warning

Triggers assertion if resulting size > capacity().

Parameters

sv	String view to append

Returns

Reference to this

Definition at line 1028 of file static_string.hpp.

                          {
  HELIOS_ASSERT(size_ + sv.size() <= StrCapacity, "Append would exceed capacity!");
  Traits::copy(data_.data() + size_, sv.data(), sv.size());
  size_ += sv.size();
  data_[size_] = CharT{};
  return *this;
}

AppendRange() [1/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

template<std::ranges::input_range Range>
requires std::convertible_to<std::ranges::range_value_t<Range>, CharT>

constexpr BasicStaticString & helios::container::BasicStaticString< StrCapacity, CharT, Traits >::AppendRange ( Range &&  rg )

constexprnoexcept

Appends characters from a range.

Warning

Triggers assertion if resulting size > capacity().

Template Parameters

Range

Range type

Parameters

rg	Range to append

Returns

Reference to this

AppendRange() [2/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

template<std::ranges::input_range Range>
requires std::convertible_to<std::ranges::range_value_t<Range>, CharT>

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::AppendRange ( Range &&  rg ) -> BasicStaticString&

constexprnoexcept

Definition at line 1052 of file static_string.hpp.

                                                                                                                   {
  for (auto&& ch : rg) {
    PushBack(static_cast<CharT>(ch));
  }
  return *this;
}

Assign() [1/3]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr BasicStaticString & helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Assign ( const CharT *  str )

inlineconstexprnoexcept

Assigns a null-terminated C string.

Warning

Triggers assertion if string length > capacity().

Parameters

str	C string to assign

Returns

Reference to this

Definition at line 419 of file static_string.hpp.

                                                                 {
    return Assign(std::basic_string_view<CharT, Traits>(str));
  }

Assign() [2/3]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Assign ( size_type  count, CharT  ch  )

constexprnoexcept

Assigns count copies of character ch.

Warning

Triggers assertion if count > capacity().

Parameters

count	Number of characters
ch	Character to assign

Returns

Reference to this

Definition at line 1187 of file static_string.hpp.

                          {
  HELIOS_ASSERT(count <= StrCapacity, "Count exceeds capacity!");
  std::ranges::fill_n(data_.begin(), count, ch);
  size_ = count;
  data_[size_] = CharT{};
  return *this;
}

Assign() [3/3]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Assign ( std::basic_string_view< CharT, Traits >  sv )

constexprnoexcept

Assigns a string_view.

Warning

Triggers assertion if sv.size() > capacity().

Parameters

sv	String view to assign

Returns

Reference to this

Definition at line 1176 of file static_string.hpp.

                          {
  HELIOS_ASSERT(sv.size() <= StrCapacity, "String view size exceeds capacity!");
  Traits::copy(data_.data(), sv.data(), sv.size());
  size_ = sv.size();
  data_[size_] = CharT{};
  return *this;
}

AssignRange() [1/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

template<std::ranges::input_range Range>
requires std::convertible_to<std::ranges::range_value_t<Range>, CharT>

constexpr BasicStaticString & helios::container::BasicStaticString< StrCapacity, CharT, Traits >::AssignRange ( Range &&  rg )

constexprnoexcept

Assigns characters from a range.

Warning

Triggers assertion if range size > capacity().

Template Parameters

Range

Range type

Parameters

rg	Range to assign from

Returns

Reference to this

AssignRange() [2/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

template<std::ranges::input_range Range>
requires std::convertible_to<std::ranges::range_value_t<Range>, CharT>

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::AssignRange ( Range &&  rg ) -> BasicStaticString&

constexprnoexcept

Definition at line 1200 of file static_string.hpp.

                                                                                                                   {
  Clear();
  return AppendRange(std::forward<Range>(rg));
}

At() [1/2]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::At ( size_type  pos ) const

constexprnoexcept

Accesses character at specified position with bounds checking (const).

Warning

Triggers assertion if pos >= size().

Parameters

pos	Position of the character

Returns

Const reference to the character

Definition at line 1236 of file static_string.hpp.

                                                                                                                {
  HELIOS_ASSERT(pos < size_, "Position out of range!");
  return data_[pos];
}

At() [2/2]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::At ( size_type  pos )

constexprnoexcept

Accesses character at specified position with bounds checking.

Warning

Triggers assertion if pos >= size().

Parameters

pos	Position of the character

Returns

Reference to the character

Definition at line 1229 of file static_string.hpp.

                                                                                                    {
  HELIOS_ASSERT(pos < size_, "Position out of range!");
  return data_[pos];
}

Back() [1/2]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Back ( ) const

constexprnoexcept

Accesses the last character (const).

Warning

Triggers assertion if string is empty.

Returns

Const reference to the last character

Definition at line 1264 of file static_string.hpp.

                                                                                                     {
  HELIOS_ASSERT(!Empty(), "String is empty!");
  return data_[size_ - 1];
}

Back() [2/2]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Back ( )

constexprnoexcept

Accesses the last character.

Warning

Triggers assertion if string is empty.

Returns

Reference to the last character

Definition at line 1257 of file static_string.hpp.

                                                                                         {
  HELIOS_ASSERT(!Empty(), "String is empty!");
  return data_[size_ - 1];
}

begin() [1/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr const_iterator helios::container::BasicStaticString< StrCapacity, CharT, Traits >::begin ( ) const

inlineconstexprnoexcept

Definition at line 783 of file static_string.hpp.

{ return data_.data(); }

begin() [2/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr iterator helios::container::BasicStaticString< StrCapacity, CharT, Traits >::begin ( )

inlineconstexprnoexcept

Definition at line 782 of file static_string.hpp.

{ return data_.data(); }

Capacity()

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

static constexpr size_type helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Capacity ( )

inlinestaticconstexprnoexcept

Returns the capacity.

Returns

StrCapacity

Definition at line 703 of file static_string.hpp.

{ return StrCapacity; }

cbegin()

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr const_iterator helios::container::BasicStaticString< StrCapacity, CharT, Traits >::cbegin ( ) const

inlineconstexprnoexcept

Definition at line 784 of file static_string.hpp.

{ return data_.data(); }

cend()

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr const_iterator helios::container::BasicStaticString< StrCapacity, CharT, Traits >::cend ( ) const

inlineconstexprnoexcept

Definition at line 788 of file static_string.hpp.

{ return data_.data() + size_; }

Clear()

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr void helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Clear ( )

constexprnoexcept

Clears the string content.

Definition at line 912 of file static_string.hpp.

                                                                             {
  size_ = 0;
  data_[0] = CharT{};
}

Compare() [1/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

template<size_t OtherCapacity>

constexpr int helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Compare ( const BasicStaticString< OtherCapacity, CharT, Traits > &  other ) const

inlineconstexprnoexcept

Compares with another BasicStaticString.

Template Parameters

OtherCapacity

StrCapacity of the other string

Parameters

other

String to compare with

Returns

Negative if less, zero if equal, positive if greater

Definition at line 468 of file static_string.hpp.

                                                                                                                   {
    return View().compare(other.View());
  }

Compare() [2/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr int helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Compare ( std::basic_string_view< CharT, Traits >  other ) const

inlineconstexprnoexcept

Compares with another string.

Parameters

other

String to compare with

Returns

Negative if less, zero if equal, positive if greater

Definition at line 457 of file static_string.hpp.

                                                                                                {
    return View().compare(other);
  }

Contains() [1/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr bool helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Contains ( CharT  ch ) const

inlineconstexprnoexcept

Checks if string contains character.

Parameters

ch	Character to search for

Returns

True if string contains ch

Definition at line 679 of file static_string.hpp.

{ return View().find(ch) != npos; }

Contains() [2/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr bool helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Contains ( std::basic_string_view< CharT, Traits >  sv ) const

inlineconstexprnoexcept

Checks if string contains substring.

Parameters

sv	Substring to search for

Returns

True if string contains sv

Definition at line 670 of file static_string.hpp.

                                                                                               {
    return View().find(sv) != npos;
  }

Copy()

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Copy ( CharT *  dest, size_type  count, size_type  pos = 0  ) const

constexprnoexcept

Copies characters to a buffer.

Warning

Triggers assertion if pos > Size().

Parameters

dest	Destination buffer
count	Maximum number of characters to copy
pos	Starting position

Returns

Number of characters copied

Definition at line 1148 of file static_string.hpp.

                                                                                                              {
  HELIOS_ASSERT(pos <= size_, "Position out of range!");
  const size_type copy_count = std::min(count, size_ - pos);
  Traits::copy(dest, data_.data() + pos, copy_count);
  return copy_count;
}

crbegin()

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr const_reverse_iterator helios::container::BasicStaticString< StrCapacity, CharT, Traits >::crbegin ( ) const

inlineconstexprnoexcept

Definition at line 792 of file static_string.hpp.

{ return const_reverse_iterator(end()); }

crend()

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr const_reverse_iterator helios::container::BasicStaticString< StrCapacity, CharT, Traits >::crend ( ) const

inlineconstexprnoexcept

Definition at line 796 of file static_string.hpp.

{ return const_reverse_iterator(begin()); }

CStr()

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr const_pointer helios::container::BasicStaticString< StrCapacity, CharT, Traits >::CStr ( ) const

inlineconstexprnoexcept

Returns null-terminated C string.

Returns

Null-terminated character array

Definition at line 772 of file static_string.hpp.

{ return data_.data(); }

Data() [1/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr const_pointer helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Data ( ) const

inlineconstexprnoexcept

Returns pointer to the underlying character array (const).

Returns

Const pointer to the character array

Definition at line 766 of file static_string.hpp.

{ return data_.data(); }

Data() [2/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr pointer helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Data ( )

inlineconstexprnoexcept

Returns pointer to the underlying character array.

Returns

Pointer to the character array

Definition at line 760 of file static_string.hpp.

{ return data_.data(); }

Empty()

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr bool helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Empty ( ) const

inlineconstexprnoexcept

Checks if the string is empty.

Returns

True if Size() == 0

Definition at line 631 of file static_string.hpp.

{ return size_ == 0; }

end() [1/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr const_iterator helios::container::BasicStaticString< StrCapacity, CharT, Traits >::end ( ) const

inlineconstexprnoexcept

Definition at line 787 of file static_string.hpp.

{ return data_.data() + size_; }

end() [2/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr iterator helios::container::BasicStaticString< StrCapacity, CharT, Traits >::end ( )

inlineconstexprnoexcept

Definition at line 786 of file static_string.hpp.

{ return data_.data() + size_; }

EndsWith() [1/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr bool helios::container::BasicStaticString< StrCapacity, CharT, Traits >::EndsWith ( CharT  ch ) const

inlineconstexprnoexcept

Checks if string ends with character.

Parameters

ch	Character to check

Returns

True if string ends with ch

Definition at line 663 of file static_string.hpp.

{ return !Empty() && Back() == ch; }

EndsWith() [2/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr bool helios::container::BasicStaticString< StrCapacity, CharT, Traits >::EndsWith ( std::basic_string_view< CharT, Traits >  sv ) const

inlineconstexprnoexcept

Checks if string ends with suffix.

Parameters

sv	Suffix to check

Returns

True if string ends with sv

Definition at line 654 of file static_string.hpp.

                                                                                               {
    return View().ends_with(sv);
  }

Erase()

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Erase ( size_type  pos = 0, size_type  count = npos  )

constexprnoexcept

Erases characters from pos to pos + count.

Warning

Triggers assertion if pos > Size().

Parameters

pos	Starting position
count	Number of characters to erase (default: all remaining)

Returns

Reference to this

Definition at line 998 of file static_string.hpp.

                          {
  HELIOS_ASSERT(pos <= size_, "Position out of range!");
  const size_type erase_count = std::min(count, size_ - pos);
  const size_type remaining = size_ - pos - erase_count;
  if (remaining > 0) {
    Traits::move(data_.data() + pos, data_.data() + pos + erase_count, remaining);
  }
  size_ -= erase_count;
  data_[size_] = CharT{};
  return *this;
}

explicit()

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

template<size_t N>
requires (N <= StrCapacity + 1)

constexpr helios::container::BasicStaticString< StrCapacity, CharT, Traits >::explicit ( false  ) )[N] const &

constexprnoexcept

Constructs from a character array of known size.

Warning

Triggers assertion if N-1 > StrCapacity (excluding null terminator).

Template Parameters

N	Size of the character array

Parameters

str	Source character array

Find() [1/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr size_type helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Find ( CharT  ch, size_type  pos = 0  ) const

inlineconstexprnoexcept

Finds first occurrence of character.

Parameters

ch	Character to search for
pos	Starting position

Returns

Position of first occurrence, or npos if not found

Definition at line 488 of file static_string.hpp.

{ return View().find(ch, pos); }

Find() [2/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr size_type helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Find ( std::basic_string_view< CharT, Traits >  sv, size_type  pos = 0  ) const

inlineconstexprnoexcept

Finds first occurrence of substring.

Parameters

sv	Substring to search for
pos	Starting position

Returns

Position of first occurrence, or npos if not found

Definition at line 478 of file static_string.hpp.

                                                                                                                   {
    return View().find(sv, pos);
  }

FindFirstNotOf()

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr size_type helios::container::BasicStaticString< StrCapacity, CharT, Traits >::FindFirstNotOf ( std::basic_string_view< CharT, Traits >  sv, size_type  pos = 0  ) const

inlineconstexprnoexcept

Finds first character not in sv.

Parameters

sv	Characters to exclude
pos	Starting position

Returns

Position of first non-matching character, or npos if not found

Definition at line 539 of file static_string.hpp.

                                                                                     {
    return View().find_first_not_of(sv, pos);
  }

FindFirstOf()

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr size_type helios::container::BasicStaticString< StrCapacity, CharT, Traits >::FindFirstOf ( std::basic_string_view< CharT, Traits >  sv, size_type  pos = 0  ) const

inlineconstexprnoexcept

Finds first occurrence of any character in sv.

Parameters

sv	Characters to search for
pos	Starting position

Returns

Position of first occurrence, or npos if not found

Definition at line 517 of file static_string.hpp.

                                                                                  {
    return View().find_first_of(sv, pos);
  }

FindLastNotOf()

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr size_type helios::container::BasicStaticString< StrCapacity, CharT, Traits >::FindLastNotOf ( std::basic_string_view< CharT, Traits >  sv, size_type  pos = npos  ) const

inlineconstexprnoexcept

Finds last character not in sv.

Parameters

sv	Characters to exclude
pos	Starting position (searches backwards from here)

Returns

Position of last non-matching character, or npos if not found

Definition at line 550 of file static_string.hpp.

                                                                                       {
    return View().find_last_not_of(sv, pos);
  }

FindLastOf()

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr size_type helios::container::BasicStaticString< StrCapacity, CharT, Traits >::FindLastOf ( std::basic_string_view< CharT, Traits >  sv, size_type  pos = npos  ) const

inlineconstexprnoexcept

Finds last occurrence of any character in sv.

Parameters

sv	Characters to search for
pos	Starting position (searches backwards from here)

Returns

Position of last occurrence, or npos if not found

Definition at line 528 of file static_string.hpp.

                                                                                    {
    return View().find_last_of(sv, pos);
  }

Front() [1/2]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Front ( ) const

constexprnoexcept

Accesses the first character (const).

Warning

Triggers assertion if string is empty.

Returns

Const reference to the first character

Definition at line 1250 of file static_string.hpp.

                                                                                                      {
  HELIOS_ASSERT(!Empty(), "String is empty!");
  return data_[0];
}

Front() [2/2]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Front ( )

constexprnoexcept

Accesses the first character.

Warning

Triggers assertion if string is empty.

Returns

Reference to the first character

Definition at line 1243 of file static_string.hpp.

                                                                                          {
  HELIOS_ASSERT(!Empty(), "String is empty!");
  return data_[0];
}

Insert() [1/2]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Insert ( size_type  pos, size_type  count, CharT  ch  )

constexprnoexcept

Inserts count copies of character at position..

Warning

Triggers assertion if pos > Size() or resulting size > capacity()

Parameters

pos	Position to insert at
count	Number of characters
ch	Character to insert

Returns

Reference to this

Definition at line 939 of file static_string.hpp.

                          {
  HELIOS_ASSERT(pos <= size_, "Position out of range!");
  HELIOS_ASSERT(size_ + count <= StrCapacity, "Insert would exceed capacity!");
 
  if (pos < size_) {
    Traits::move(data_.data() + pos + count, data_.data() + pos, size_ - pos);
  }
 
  std::ranges::fill_n(data_.begin() + pos, count, ch);
  size_ += count;
  data_[size_] = CharT{};
  return *this;
}

Insert() [2/2]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Insert ( size_type  pos, std::basic_string_view< CharT, Traits >  sv  )

constexprnoexcept

Inserts a string_view at position.

Warning

Triggers assertion if pos > Size() or resulting size > capacity().

Parameters

pos	Position to insert at
sv	String view to insert

Returns

Reference to this

Definition at line 919 of file static_string.hpp.

                          {
  HELIOS_ASSERT(pos <= size_, "Position out of range!");
  HELIOS_ASSERT(size_ + sv.size() <= StrCapacity, "Insert would exceed capacity!");
 
  // Move existing characters to make room
  if (pos < size_) {
    Traits::move(data_.data() + pos + sv.size(), data_.data() + pos, size_ - pos);
  }
 
  // Copy new characters
  Traits::copy(data_.data() + pos, sv.data(), sv.size());
  size_ += sv.size();
  data_[size_] = CharT{};
  return *this;
}

InsertRange() [1/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

template<std::ranges::input_range Range>
requires std::convertible_to<std::ranges::range_value_t<Range>, CharT>

constexpr BasicStaticString & helios::container::BasicStaticString< StrCapacity, CharT, Traits >::InsertRange ( size_type  pos, Range &&  rg  )

constexprnoexcept

Inserts characters from a range at position.

Warning

Triggers assertion if pos > Size() or resulting size > capacity().

Template Parameters

Range

Range type

Parameters

pos	Position to insert at
rg	Range to insert

Returns

Reference to this

InsertRange() [2/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

template<std::ranges::input_range Range>
requires std::convertible_to<std::ranges::range_value_t<Range>, CharT>

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::InsertRange ( size_type  pos, Range &&  rg  ) -> BasicStaticString&

constexprnoexcept

Definition at line 958 of file static_string.hpp.

                          {
  HELIOS_ASSERT(pos <= size_, "Position out of range!");
 
  // Calculate range size if possible
  size_type range_size = 0;
  if constexpr (std::ranges::sized_range<Range>) {
    range_size = static_cast<size_type>(std::ranges::size(rg));
    HELIOS_ASSERT(size_ + range_size <= StrCapacity, "Insert would exceed capacity!");
 
    // Move existing characters
    if (pos < size_) {
      Traits::move(data_.data() + pos + range_size, data_.data() + pos, size_ - pos);
    }
 
    // Copy from range
    auto dest = data_.begin() + pos;
    for (auto&& ch : rg) {
      *dest++ = static_cast<CharT>(ch);
    }
    size_ += range_size;
  } else {
    // For non-sized ranges, insert one by one
    auto insert_pos = pos;
    for (auto&& ch : rg) {
      HELIOS_ASSERT(size_ < StrCapacity, "Insert would exceed capacity!");
      if (insert_pos < size_) {
        Traits::move(data_.data() + insert_pos + 1, data_.data() + insert_pos, size_ - insert_pos);
      }
      data_[insert_pos++] = static_cast<CharT>(ch);
      ++size_;
    }
  }
 
  data_[size_] = CharT{};
  return *this;
}

Length()

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr size_type helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Length ( ) const

inlineconstexprnoexcept

Returns the number of characters.

Returns

Number of characters (excluding null terminator)

Definition at line 691 of file static_string.hpp.

{ return size_; }

MaxSize()

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

static constexpr size_type helios::container::BasicStaticString< StrCapacity, CharT, Traits >::MaxSize ( )

inlinestaticconstexprnoexcept

Returns the maximum possible number of characters.

Returns

StrCapacity

Definition at line 697 of file static_string.hpp.

{ return StrCapacity; }

operator std::basic_string_view< CharT, Traits >()

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr helios::container::BasicStaticString< StrCapacity, CharT, Traits >::operator std::basic_string_view< CharT, Traits > ( ) const

inlineconstexprnoexcept

Converts to string_view.

Returns

String view of the content

Definition at line 599 of file static_string.hpp.

                                                                                        {
    return std::basic_string_view<CharT, Traits>(data_.data(), size_);
  }

operator+=() [1/3]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::operator+= ( CharT  ch )

constexprnoexcept

Appends a character.

Warning

Triggers assertion if resulting size > capacity().

Parameters

ch	Character to append

Returns

Reference to this

Definition at line 1207 of file static_string.hpp.

                                                                                                                {
  PushBack(ch);
  return *this;
}

operator+=() [2/3]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr BasicStaticString & helios::container::BasicStaticString< StrCapacity, CharT, Traits >::operator+= ( const CharT *  str )

inlineconstexprnoexcept

Appends a null-terminated C string.

Warning

Triggers assertion if resulting size > capacity().

Parameters

str	C string to append

Returns

Reference to this

Definition at line 577 of file static_string.hpp.

{ return Append(str); }

operator+=() [3/3]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr BasicStaticString & helios::container::BasicStaticString< StrCapacity, CharT, Traits >::operator+= ( std::basic_string_view< CharT, Traits >  sv )

inlineconstexprnoexcept

Appends a string_view.

Warning

Triggers assertion if resulting size > capacity().

Parameters

sv	String view to append

Returns

Reference to this

Definition at line 561 of file static_string.hpp.

{ return Append(sv); }

operator<=>() [1/3]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

template<size_t OtherCapacity>
requires (StrCapacity > 0)

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::operator<=> ( const BasicStaticString< OtherCapacity, CharT, Traits > &  other ) const -> std::strong_ordering

constexprnoexcept

Definition at line 1281 of file static_string.hpp.

                                                                                                       {
  const auto result = View().compare(other.View());
  if (result < 0) {
    return std::strong_ordering::less;
  }
  if (result > 0) {
    return std::strong_ordering::greater;
  }
  return std::strong_ordering::equal;
}

operator<=>() [2/3]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::operator<=> ( const CharT *  other ) const -> std::strong_ordering

inlineconstexprnoexcept

Definition at line 623 of file static_string.hpp.

                                                                                                    {
    return *this <=> std::basic_string_view<CharT, Traits>(other);
  }

operator<=>() [3/3]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::operator<=> ( std::basic_string_view< CharT, Traits >  other ) const -> std::strong_ordering

constexprnoexcept

Definition at line 1295 of file static_string.hpp.

                                                                                    {
  const auto result = View().compare(other);
  if (result < 0) {
    return std::strong_ordering::less;
  }
  if (result > 0) {
    return std::strong_ordering::greater;
  }
  return std::strong_ordering::equal;
}

operator=() [1/8]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr BasicStaticString & helios::container::BasicStaticString< StrCapacity, CharT, Traits >::operator= ( BasicStaticString< StrCapacity, CharT, Traits > &&  )

constexprdefaultnoexcept

operator=() [2/8]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

template<size_t OtherCapacity>
requires (OtherCapacity < StrCapacity)

constexpr BasicStaticString & helios::container::BasicStaticString< StrCapacity, CharT, Traits >::operator= ( BasicStaticString< OtherCapacity, CharT, Traits > &&  other )

constexprnoexcept

Move assignment from smaller capacity string.

Warning

Triggers assertion if other.Size() > StrCapacity.

Template Parameters

OtherCapacity

StrCapacity of source string (must be less than StrCapacity)

Parameters

other

Source string with smaller capacity

Returns

Reference to this

operator=() [3/8]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

template<size_t OtherCapacity>
requires (OtherCapacity < StrCapacity)

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::operator= ( BasicStaticString< OtherCapacity, CharT, Traits > &&  other ) -> BasicStaticString&

constexprnoexcept

Definition at line 1400 of file static_string.hpp.

                                                                                            {
  HELIOS_ASSERT(other.Size() <= StrCapacity, "Source string size exceeds capacity!");
  Traits::copy(data_.data(), other.Data(), other.Size());
  size_ = other.Size();
  data_[size_] = CharT{};
  return *this;
}

operator=() [4/8]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr BasicStaticString & helios::container::BasicStaticString< StrCapacity, CharT, Traits >::operator= ( const BasicStaticString< StrCapacity, CharT, Traits > &  )

constexprdefaultnoexcept

operator=() [5/8]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

template<size_t OtherCapacity>
requires (OtherCapacity < StrCapacity)

constexpr BasicStaticString & helios::container::BasicStaticString< StrCapacity, CharT, Traits >::operator= ( const BasicStaticString< OtherCapacity, CharT, Traits > &  other )

constexprnoexcept

Copy assignment from smaller capacity string.

Warning

Triggers assertion if other.Size() > StrCapacity.

Template Parameters

OtherCapacity

StrCapacity of source string (must be less than StrCapacity)

Parameters

other

Source string with smaller capacity

Returns

Reference to this

operator=() [6/8]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

template<size_t OtherCapacity>
requires (OtherCapacity < StrCapacity)

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::operator= ( const BasicStaticString< OtherCapacity, CharT, Traits > &  other ) -> BasicStaticString&

constexprnoexcept

Definition at line 1387 of file static_string.hpp.

                                                                                                 {
  HELIOS_ASSERT(other.Size() <= StrCapacity, "Source string size exceeds capacity!");
  Traits::copy(data_.data(), other.Data(), other.Size());
  size_ = other.Size();
  data_[size_] = CharT{};
  return *this;
}

operator=() [7/8]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::operator= ( const CharT *  str )

constexprnoexcept

Assigns from a null-terminated C string.

Warning

Triggers assertion if string length > StrCapacity.

Parameters

str	Source C string

Returns

Reference to this

Definition at line 904 of file static_string.hpp.

                          {
  Assign(str);
  return *this;
}

operator=() [8/8]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::operator= ( std::basic_string_view< CharT, Traits >  sv )

constexprnoexcept

Assigns from a string_view.

Warning

Triggers assertion if sv.size() > StrCapacity.

Parameters

sv	Source string view

Returns

Reference to this

Definition at line 896 of file static_string.hpp.

                                                                           {
  Assign(sv);
  return *this;
}

operator==() [1/3]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

template<size_t OtherCapacity>

constexpr bool helios::container::BasicStaticString< StrCapacity, CharT, Traits >::operator== ( const BasicStaticString< OtherCapacity, CharT, Traits > &  other ) const

inlineconstexprnoexcept

Definition at line 604 of file static_string.hpp.

                                                                                                                       {
    return View() == other.View();
  }

operator==() [2/3]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr bool helios::container::BasicStaticString< StrCapacity, CharT, Traits >::operator== ( const CharT *  other ) const

inlineconstexprnoexcept

Definition at line 612 of file static_string.hpp.

                                                                             {
    return View() == std::basic_string_view<CharT, Traits>(other);
  }

operator==() [3/3]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr bool helios::container::BasicStaticString< StrCapacity, CharT, Traits >::operator== ( std::basic_string_view< CharT, Traits >  other ) const

inlineconstexprnoexcept

Definition at line 608 of file static_string.hpp.

                                                                                                    {
    return View() == other;
  }

operator[]() [1/2]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::operator[] ( size_type  pos ) const

constexprnoexcept

Accesses character at specified position (const).

Warning

Triggers assertion if pos >= size().

Parameters

pos	Position of the character

Returns

Const reference to the character

Definition at line 1221 of file static_string.hpp.

                       {
  HELIOS_ASSERT(pos < size_, "Position out of range!");
  return data_[pos];
}

operator[]() [2/2]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::operator[] ( size_type  pos )

constexprnoexcept

Accesses character at specified position.

Warning

Triggers assertion if pos >= size().

Parameters

pos	Position of the character

Returns

Reference to the character

Definition at line 1214 of file static_string.hpp.

                                                                                                            {
  HELIOS_ASSERT(pos < size_, "Position out of range!");
  return data_[pos];
}

PopBack()

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr void helios::container::BasicStaticString< StrCapacity, CharT, Traits >::PopBack ( )

constexprnoexcept

Removes the last character.

Warning

Triggers assertion if string is empty.

Definition at line 1021 of file static_string.hpp.

                                                                               {
  HELIOS_ASSERT(!Empty(), "Cannot PopBack: string is empty!");
  data_[--size_] = CharT{};
}

PushBack()

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr void helios::container::BasicStaticString< StrCapacity, CharT, Traits >::PushBack ( CharT  ch )

constexprnoexcept

Appends a character.

Warning

Triggers assertion if Size() >= capacity().

Parameters

ch	Character to append

Definition at line 1013 of file static_string.hpp.

                                                                                        {
  HELIOS_ASSERT(size_ < StrCapacity, "Cannot PushBack: string is at capacity!");
  data_[size_++] = ch;
  data_[size_] = CharT{};
}

rbegin() [1/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr const_reverse_iterator helios::container::BasicStaticString< StrCapacity, CharT, Traits >::rbegin ( ) const

inlineconstexprnoexcept

Definition at line 791 of file static_string.hpp.

{ return const_reverse_iterator(end()); }

rbegin() [2/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr reverse_iterator helios::container::BasicStaticString< StrCapacity, CharT, Traits >::rbegin ( )

inlineconstexprnoexcept

Definition at line 790 of file static_string.hpp.

{ return reverse_iterator(end()); }

RemainingCapacity()

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr size_type helios::container::BasicStaticString< StrCapacity, CharT, Traits >::RemainingCapacity ( ) const

inlineconstexprnoexcept

Returns the remaining capacity.

Returns

StrCapacity - Size()

Definition at line 709 of file static_string.hpp.

{ return StrCapacity - size_; }

rend() [1/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr const_reverse_iterator helios::container::BasicStaticString< StrCapacity, CharT, Traits >::rend ( ) const

inlineconstexprnoexcept

Definition at line 795 of file static_string.hpp.

{ return const_reverse_iterator(begin()); }

rend() [2/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr reverse_iterator helios::container::BasicStaticString< StrCapacity, CharT, Traits >::rend ( )

inlineconstexprnoexcept

Definition at line 794 of file static_string.hpp.

{ return reverse_iterator(begin()); }

Replace() [1/2]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Replace ( size_type  pos, size_type  count, size_type  count2, CharT  ch  )

constexprnoexcept

Replaces characters in range [pos, pos + count) with count2 copies of ch.

Warning

Triggers assertion if pos > Size() or resulting size > capacity().

Parameters

pos	Starting position
count	Number of characters to replace
count2	Number of replacement characters
ch	Replacement character

Returns

Reference to this

Definition at line 1085 of file static_string.hpp.

                                                                                                               {
  HELIOS_ASSERT(pos <= size_, "Position out of range!");
  const size_type replace_count = std::min(count, size_ - pos);
  const size_type new_size = size_ - replace_count + count2;
  HELIOS_ASSERT(new_size <= StrCapacity, "Replace would exceed capacity!");
 
  const size_type tail_pos = pos + replace_count;
  const size_type tail_len = size_ - tail_pos;
  if (tail_len > 0 && count2 != replace_count) {
    Traits::move(data_.data() + pos + count2, data_.data() + tail_pos, tail_len);
  }
 
  std::ranges::fill_n(data_.begin() + pos, count2, ch);
  size_ = new_size;
  data_[size_] = CharT{};
  return *this;
}

Replace() [2/2]

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Replace ( size_type  pos, size_type  count, std::basic_string_view< CharT, Traits >  sv  )

constexprnoexcept

Replaces characters in range [pos, pos + count) with string_view.

Warning

Triggers assertion if pos > Size() or resulting size > capacity().

Parameters

pos	Starting position
count	Number of characters to replace
sv	Replacement string view

Returns

Reference to this

Definition at line 1061 of file static_string.hpp.

                          {
  HELIOS_ASSERT(pos <= size_, "Position out of range!");
  const size_type replace_count = std::min(count, size_ - pos);
  const size_type new_size = size_ - replace_count + sv.size();
  HELIOS_ASSERT(new_size <= StrCapacity, "Replace would exceed capacity!");
 
  // Move tail
  const size_type tail_pos = pos + replace_count;
  const size_type tail_len = size_ - tail_pos;
  if (tail_len > 0 && sv.size() != replace_count) {
    Traits::move(data_.data() + pos + sv.size(), data_.data() + tail_pos, tail_len);
  }
 
  // Copy replacement
  Traits::copy(data_.data() + pos, sv.data(), sv.size());
  size_ = new_size;
  data_[size_] = CharT{};
  return *this;
}

ReplaceWithRange() [1/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

template<std::ranges::input_range Range>
requires std::convertible_to<std::ranges::range_value_t<Range>, CharT>

constexpr BasicStaticString & helios::container::BasicStaticString< StrCapacity, CharT, Traits >::ReplaceWithRange ( size_type  pos, size_type  count, Range &&  rg  )

constexprnoexcept

Replaces characters in range [pos, pos + count) with characters from a range.

Warning

Triggers assertion if pos > Size() or resulting size > capacity().

Template Parameters

Range

Range type

Parameters

pos	Starting position
count	Number of characters to replace
rg	Range of replacement characters

Returns

Reference to this

ReplaceWithRange() [2/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

template<std::ranges::input_range Range>
requires std::convertible_to<std::ranges::range_value_t<Range>, CharT>

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::ReplaceWithRange ( size_type  pos, size_type  count, Range &&  rg  ) -> BasicStaticString&

constexprnoexcept

Definition at line 1108 of file static_string.hpp.

                          {
  HELIOS_ASSERT(pos <= size_, "Position out of range!");
 
  const size_type replace_count = std::min(count, size_ - pos);
 
  if constexpr (std::ranges::sized_range<Range>) {
    const size_type range_size = static_cast<size_type>(std::ranges::size(rg));
    const size_type new_size = size_ - replace_count + range_size;
    HELIOS_ASSERT(new_size <= StrCapacity, "Replace would exceed capacity!");
 
    const size_type tail_pos = pos + replace_count;
    const size_type tail_len = size_ - tail_pos;
    if (tail_len > 0 && range_size != replace_count) {
      Traits::move(data_.data() + pos + range_size, data_.data() + tail_pos, tail_len);
    }
 
    auto dest = data_.begin() + pos;
    for (auto&& ch : rg) {
      *dest++ = static_cast<CharT>(ch);
    }
    size_ = new_size;
  } else {
    // For non-sized ranges, use temporary storage
    BasicStaticString temp;
    temp.Assign(View().substr(0, pos));
    temp.AppendRange(std::forward<Range>(rg));
    if (pos + replace_count < size_) {
      temp.Append(View().substr(pos + replace_count));
    }
    *this = std::move(temp);
  }
 
  data_[size_] = CharT{};
  return *this;
}

Resize()

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr void helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Resize ( size_type  count, CharT  ch = CharT{}  )

constexprnoexcept

Resizes the string.

Warning

Triggers assertion if count > capacity()

Parameters

count	New size
ch	Character to fill if expanding

Definition at line 1158 of file static_string.hpp.

                                                                                                       {
  HELIOS_ASSERT(count <= StrCapacity, "Resize count exceeds capacity!");
  if (count > size_) {
    std::ranges::fill_n(data_.begin() + size_, count - size_, ch);
  }
  size_ = count;
  data_[size_] = CharT{};
}

RFind() [1/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr size_type helios::container::BasicStaticString< StrCapacity, CharT, Traits >::RFind ( CharT  ch, size_type  pos = npos  ) const

inlineconstexprnoexcept

Finds last occurrence of character.

Parameters

ch	Character to search for
pos	Starting position (searches backwards from here)

Returns

Position of last occurrence, or npos if not found

Definition at line 507 of file static_string.hpp.

                                                                                         {
    return View().rfind(ch, pos);
  }

RFind() [2/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr size_type helios::container::BasicStaticString< StrCapacity, CharT, Traits >::RFind ( std::basic_string_view< CharT, Traits >  sv, size_type  pos = npos  ) const

inlineconstexprnoexcept

Finds last occurrence of substring.

Parameters

sv	Substring to search for
pos	Starting position (searches backwards from here)

Returns

Position of last occurrence, or npos if not found

Definition at line 496 of file static_string.hpp.

                                                                               {
    return View().rfind(sv, pos);
  }

Size()

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr size_type helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Size ( ) const

inlineconstexprnoexcept

Returns the number of characters.

Returns

Number of characters (excluding null terminator)

Definition at line 685 of file static_string.hpp.

{ return size_; }

StartsWith() [1/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr bool helios::container::BasicStaticString< StrCapacity, CharT, Traits >::StartsWith ( CharT  ch ) const

inlineconstexprnoexcept

Checks if string starts with character.

Parameters

ch	Character to check

Returns

True if string starts with ch

Definition at line 647 of file static_string.hpp.

{ return !Empty() && Front() == ch; }

StartsWith() [2/2]

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr bool helios::container::BasicStaticString< StrCapacity, CharT, Traits >::StartsWith ( std::basic_string_view< CharT, Traits >  sv ) const

inlineconstexprnoexcept

Checks if string starts with prefix.

Parameters

sv	Prefix to check

Returns

True if string starts with sv

Definition at line 638 of file static_string.hpp.

                                                                                                 {
    return View().starts_with(sv);
  }

Substr()

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr auto helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Substr ( size_type  pos = 0, size_type  count = npos  ) const

constexprnoexcept

Returns a substring.

Warning

Triggers assertion if pos > Size().

Parameters

pos	Starting position
count	Number of characters (default: all remaining)

Returns

Substring as StaticString with same capacity

Definition at line 1271 of file static_string.hpp.

                         {
  HELIOS_ASSERT(pos <= size_, "Position out of range!");
  const size_type substr_len = std::min(count, size_ - pos);
  return BasicStaticString(data_.data() + pos, substr_len);
}

Swap()

template<size_t StrCapacity, typename CharT , typename Traits >
requires (StrCapacity > 0)

constexpr void helios::container::BasicStaticString< StrCapacity, CharT, Traits >::Swap ( BasicStaticString< StrCapacity, CharT, Traits > &  other )

constexprnoexcept

Swaps contents with another BasicStaticString.

Parameters

other

String to swap with

Definition at line 1169 of file static_string.hpp.

                                                                                                    {
  std::swap(data_, other.data_);
  std::swap(size_, other.size_);
}

View()

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr std::basic_string_view< CharT, Traits > helios::container::BasicStaticString< StrCapacity, CharT, Traits >::View ( ) const

inlineconstexprnoexcept

Returns a string_view of the content.

Returns

String view of the content

Definition at line 778 of file static_string.hpp.

                                                                                    {
    return std::basic_string_view<CharT, Traits>(data_.data(), size_);
  }

Member Data Documentation

npos

template<size_t StrCapacity, typename CharT , typename Traits = std::char_traits<CharT>>

constexpr size_type helios::container::BasicStaticString< StrCapacity, CharT, Traits >::npos = static_cast<size_type>(-1)

staticconstexpr

Definition at line 50 of file static_string.hpp.