blob: fd2071117f1dc0762691c5dca7602fc2960a80f1 [file] [log] [blame]
// Copyright 2022 The Pigweed Authors
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy of
// the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations under
// the License.
// This file contains the definitions of most pw::InlineBasicString functions.
// The file is included inline in the fixed-capacity pw::InlineBasicString<T,
// kCapacity> and generic-capacity pw::InlineBasicString<T> specialization
// classes.
//
// These functions cannot simply be defined in the pw::InlineBasicString<T> base
// class because:
//
// 1. Many functions return a *this reference. The functions should to return
// a reference to the exact type they are called on rather than the
// generic-capacity base class.
// 2. Operations on the generic base class cannot be constexpr unless the
// class is an InlineBasicString<T, 0>. The functions must be defined in
// the fixed-capacity dervied classes to support constexpr operations.
//
// These functions have no logic and simply defer to shared, length-agnostic
// implementations so they do not increase code size.
PW_MODIFY_DIAGNOSTICS_PUSH();
PW_MODIFY_DIAGNOSTIC_GCC(ignored, "-Wtype-limits");
// Assignment functions
constexpr InlineBasicString& assign(size_t count, T ch) {
return static_cast<InlineBasicString&>(Fill(data(), ch, count));
}
// Checks capacity rather than current size.
template <size_t kOtherCapacity>
constexpr InlineBasicString& assign(
const InlineBasicString<T, kOtherCapacity>& other) {
static_assert(
kOtherCapacity == string_impl::kGeneric || kOtherCapacity <= kCapacity,
_PW_STRING_CAPACITY_TOO_SMALL_FOR_STRING);
return static_cast<InlineBasicString&>(
Copy(data(), other.data(), other.size()));
}
constexpr InlineBasicString& assign(const InlineBasicString& other,
size_t index,
size_t count = npos) {
return static_cast<InlineBasicString&>(
CopySubstr(data(), other.data(), other.size(), index, count));
}
constexpr InlineBasicString& assign(const T* string, size_t count) {
return static_cast<InlineBasicString&>(Copy(data(), string, count));
}
template <typename U, typename = string_impl::EnableIfNonArrayCharPointer<T, U>>
constexpr InlineBasicString& assign(U c_string) {
return assign(c_string,
string_impl::BoundedStringLength(c_string, max_size()));
}
// Assignment from character array or string literal. For known-size strings,
// the capacity is checked against the string/array size at compile time.
template <size_t kCharArraySize>
constexpr InlineBasicString& assign(const T (&array)[kCharArraySize]) {
static_assert(
string_impl::NullTerminatedArrayFitsInString(kCharArraySize, kCapacity),
_PW_STRING_CAPACITY_TOO_SMALL_FOR_ARRAY);
return static_cast<InlineBasicString&>(
Copy(data(), array, string_impl::ArrayStringLength(array, max_size())));
}
template <typename InputIterator,
typename = string_impl::EnableIfInputIterator<InputIterator>>
constexpr InlineBasicString& assign(InputIterator start, InputIterator finish) {
return static_cast<InlineBasicString&>(CopyIterator(data(), start, finish));
}
constexpr InlineBasicString& assign(std::initializer_list<T> list) {
return assign(list.begin(), list.size());
}
template <typename StringView,
typename = string_impl::EnableIfStringViewLike<T, StringView>>
constexpr InlineBasicString& assign(const StringView& string) {
const string_impl::View<T> view = string;
PW_ASSERT(view.size() < npos);
return assign(view.data(), view.size());
}
template <typename StringView,
typename = string_impl::EnableIfStringViewLike<T, StringView>>
constexpr InlineBasicString& assign(const StringView& string,
size_t index,
size_t count = npos) {
const string_impl::View<T> view = string;
PW_ASSERT(view.size() < npos);
return static_cast<InlineBasicString&>(
CopySubstr(data(), view.data(), view.size(), index, count));
}
constexpr InlineBasicString& assign(std::nullptr_t) = delete;
// Element access
constexpr reference at(size_t index) {
PW_ASSERT(index < length());
return data()[index];
}
constexpr const_reference at(size_t index) const {
PW_ASSERT(index < length());
return data()[index];
}
constexpr reference operator[](size_t index) { return data()[index]; }
constexpr const_reference operator[](size_t index) const {
return data()[index];
}
constexpr reference front() { return data()[0]; }
constexpr const_reference front() const { return data()[0]; }
constexpr reference back() { return data()[size() - 1]; }
constexpr const_reference back() const { return data()[size() - 1]; }
constexpr const_pointer c_str() const noexcept { return data(); }
constexpr operator string_impl::View<T>() const noexcept {
return string_impl::View<T>(data(), size());
}
// Iterators
constexpr iterator begin() noexcept { return &data()[0]; }
constexpr const_iterator begin() const noexcept { return &data()[0]; }
constexpr const_iterator cbegin() const noexcept { return &data()[0]; }
constexpr iterator end() noexcept { return &data()[size()]; }
constexpr const_iterator end() const noexcept { return &data()[size()]; }
constexpr const_iterator cend() const noexcept { return &data()[size()]; }
constexpr reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }
constexpr const_reverse_iterator rbegin() const noexcept {
return const_reverse_iterator(end());
}
constexpr const_reverse_iterator crbegin() const noexcept {
return const_reverse_iterator(cend());
}
constexpr reverse_iterator rend() noexcept { return reverse_iterator(begin()); }
constexpr const_reverse_iterator rend() const noexcept {
return const_reverse_iterator(begin());
}
constexpr const_reverse_iterator crend() const noexcept {
return const_reverse_iterator(cbegin());
}
// Capacity
[[nodiscard]] constexpr bool empty() const noexcept { return size() == 0u; }
// The number of characters in the string.
constexpr size_t length() const noexcept { return size(); }
constexpr size_t capacity() const noexcept { return max_size(); }
// Operations
constexpr void clear() { SetSizeAndTerminate(data(), 0); }
constexpr InlineBasicString& insert(size_t index, size_t count, T ch) {
MoveExtend(data(), index, index + count);
return static_cast<InlineBasicString&>(FillExtend(data(), index, ch, count));
}
constexpr InlineBasicString& insert(size_t index,
const T* string,
size_t count) {
MoveExtend(data(), index, index + count);
return static_cast<InlineBasicString&>(
CopyExtend(data(), index, string, count));
}
template <size_t kCharArraySize>
constexpr InlineBasicString& insert(size_t index,
const T (&array)[kCharArraySize]) {
return insert(
index, array, string_impl::ArrayStringLength(array, max_size()));
}
template <typename U, typename = string_impl::EnableIfNonArrayCharPointer<T, U>>
constexpr InlineBasicString& insert(size_t index, U c_string) {
return insert(
index, c_string, string_impl::BoundedStringLength(c_string, max_size()));
}
template <size_t kOtherCapacity>
constexpr InlineBasicString& insert(
size_t index, const InlineBasicString<T, kOtherCapacity>& string) {
return insert(index, string.data(), string.size());
}
template <size_t kOtherCapacity>
constexpr InlineBasicString& insert(
size_t index,
const InlineBasicString<T, kOtherCapacity>& other,
size_t other_index,
size_t count = npos) {
PW_ASSERT(other_index <= other.size());
if (count == npos || count > other.size() - other_index) {
count = other.size() - other_index;
}
PW_ASSERT(index <= index + count);
MoveExtend(data(), index, index + count);
return static_cast<InlineBasicString&>(CopyExtendSubstr(
data(), index, other.data(), other.size(), other_index, count));
}
// Use a templated type rather than `const_iterator` to convince the compiler
// to prefer `0` as an index rather than as a `nullptr`.
template <typename U>
constexpr iterator insert(const U* pos, size_t count, T ch) {
PW_ASSERT(cbegin() <= pos && pos <= cend());
size_t index = static_cast<size_t>(pos - cbegin());
PW_ASSERT(index <= index + count);
MoveExtend(data(), index, index + count);
FillExtend(data(), index, ch, count);
return begin() + index;
}
template <typename U>
constexpr iterator insert(const U* pos, T ch) {
return insert(pos, 1, ch);
}
template <typename U, class InputIt>
constexpr iterator insert(const U* pos, InputIt first, InputIt last) {
PW_ASSERT(cbegin() <= pos && pos <= cend());
size_t index = static_cast<size_t>(pos - cbegin());
size_t count = 0;
for (auto tmp = first; tmp != last; ++tmp) {
PW_ASSERT(count < max_size());
++count;
}
PW_ASSERT(index <= index + count);
MoveExtend(data(), index, index + count);
CopyIteratorExtend(data(), index, first, last);
return begin() + index;
}
template <typename U>
constexpr iterator insert(const U* pos, std::initializer_list<T> list) {
return insert(pos, list.begin(), list.end());
}
template <typename StringView,
typename = string_impl::EnableIfStringViewLike<T, StringView>>
constexpr InlineBasicString& insert(size_t index,
const StringView& string,
size_t string_index,
size_t count = npos) {
const string_impl::View<T> view = string;
PW_ASSERT(view.size() < npos);
PW_ASSERT(string_index <= view.size());
if (count == npos || count > view.size() - string_index) {
count = view.size() - string_index;
}
PW_ASSERT(index <= index + count);
MoveExtend(data(), index, index + count);
return static_cast<InlineBasicString&>(CopyExtendSubstr(
data(), index, view.data(), view.size(), string_index, count));
}
template <typename StringView,
typename = string_impl::EnableIfStringViewLike<T, StringView>>
constexpr InlineBasicString& insert(size_t index, const StringView& string) {
return insert(index, string, 0);
}
constexpr InlineBasicString& erase(size_t index = 0, size_t count = npos) {
PW_ASSERT(index <= size());
size_t old_index =
index + std::min(count == npos ? size() : count, size() - index);
return static_cast<InlineBasicString&>(MoveExtend(data(), old_index, index));
}
// Use a templated type rather than `const_iterator` to convince the compiler
// to prefer `0` as an index rather than as a `nullptr`.
template <typename U>
constexpr iterator erase(const U* pos) {
PW_ASSERT(cbegin() <= pos && pos <= cend());
size_t index = static_cast<size_t>(pos - cbegin());
size_t old_index = index + 1;
if (old_index <= size()) {
MoveExtend(data(), old_index, index);
}
return old_index <= size() ? begin() + index : end();
}
template <typename U>
constexpr iterator erase(const U* first, const U* last) {
PW_ASSERT(cbegin() <= first && first <= cend());
size_t old_index =
first == cend() ? size() : static_cast<size_t>(first - cbegin());
size_t index = old_index;
for (auto tmp = first; tmp != last; ++tmp) {
PW_ASSERT(index < size());
++old_index;
}
MoveExtend(data(), old_index, index);
return old_index <= size() ? begin() + index : end();
}
constexpr void push_back(value_type ch) {
static_assert(kCapacity != 0,
"Cannot add a character to pw::InlineString<0>");
PushBack(data(), ch);
}
constexpr void pop_back() {
static_assert(kCapacity != 0,
"Cannot remove a character from pw::InlineString<0>");
PopBack(data());
}
constexpr InlineBasicString& append(size_t count, T ch) {
return static_cast<InlineBasicString&>(FillExtend(data(), size(), ch, count));
}
template <size_t kOtherCapacity>
constexpr InlineBasicString& append(
const InlineBasicString<T, kOtherCapacity>& string) {
static_assert(
kOtherCapacity == string_impl::kGeneric || kOtherCapacity <= kCapacity,
_PW_STRING_CAPACITY_TOO_SMALL_FOR_STRING);
return append(string.data(), string.size());
}
template <size_t kOtherCapacity>
constexpr InlineBasicString& append(
const InlineBasicString<T, kOtherCapacity>& other,
size_t index,
size_t count = npos) {
return static_cast<InlineBasicString&>(CopyExtendSubstr(
data(), size(), other.data(), other.size(), index, count));
}
constexpr InlineBasicString& append(const T* string, size_t count) {
return static_cast<InlineBasicString&>(
CopyExtend(data(), size(), string, count));
}
template <size_t kCharArraySize>
constexpr InlineBasicString& append(const T (&array)[kCharArraySize]) {
static_assert(
string_impl::NullTerminatedArrayFitsInString(kCharArraySize, kCapacity),
_PW_STRING_CAPACITY_TOO_SMALL_FOR_ARRAY);
return append(array, string_impl::ArrayStringLength(array, max_size()));
}
template <typename U, typename = string_impl::EnableIfNonArrayCharPointer<T, U>>
constexpr InlineBasicString& append(U c_string) {
return append(c_string,
string_impl::BoundedStringLength(c_string, max_size()));
}
template <typename InputIterator,
typename = string_impl::EnableIfInputIterator<InputIterator>>
constexpr InlineBasicString& append(InputIterator first, InputIterator last) {
return static_cast<InlineBasicString&>(
CopyIteratorExtend(data(), size(), first, last));
}
constexpr InlineBasicString& append(std::initializer_list<T> list) {
return append(list.begin(), list.size());
}
template <typename StringView,
typename = string_impl::EnableIfStringViewLike<T, StringView>>
constexpr InlineBasicString& append(const StringView& string) {
const string_impl::View<T> view = string;
PW_ASSERT(view.size() < npos);
return append(view.data(), view.size());
}
template <typename StringView,
typename = string_impl::EnableIfStringViewLike<T, StringView>>
constexpr InlineBasicString& append(const StringView& string,
size_t index,
size_t count = npos) {
const string_impl::View<T> view = string;
PW_ASSERT(view.size() < npos);
return static_cast<InlineBasicString&>(
CopyExtendSubstr(data(), size(), view.data(), view.size(), index, count));
}
template <size_t kOtherCapacity>
constexpr int compare(
const InlineBasicString<T, kOtherCapacity>& other) const noexcept {
return string_impl::Compare(data(), size(), other.data(), other.size());
}
constexpr int compare(const T* other) const {
return string_impl::Compare(
data(),
size(),
other,
string_impl::BoundedStringLength(other, max_size()));
}
// TODO: b/239996007 - Implement other compare overloads.
// TODO: b/239996007 - Implement other std::string functions:
//
// - starts_with
// - ends_with
// - replace
// - substr
// - copy
constexpr void resize(size_t new_size) { resize(new_size, T()); }
constexpr void resize(size_t new_size, T ch) {
return Resize(data(), new_size, ch);
}
// resize_and_overwrite() only takes the callable object since the underlying
// buffer has a fixed size.
template <typename Operation>
constexpr void resize_and_overwrite(Operation operation) {
const auto new_size =
static_cast<size_t>(std::move(operation)(data(), max_size()));
PW_ASSERT(new_size <= max_size());
SetSizeAndTerminate(data(), new_size);
}
// TODO: b/239996007 - Implement swap
// Search
// TODO: b/239996007 - Implement std::string search functions:
//
// - find
// - rfind
// - find_first_of
// - find_first_not_of
// - find_last_of
// - find_last_not_of
PW_MODIFY_DIAGNOSTICS_POP();