roland/xo-flatstring
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

xo-flatstring: + README + docs + test coverage

Browse source
This commit is contained in:
Roland Conybeare 2024-04-16 17:25:14 -04:00
commit a958217c38
26 changed files with 4161 additions and 156 deletions
Download patch file Download diff file Expand all files Collapse all files

414
include/xo/flatstring/flatstring.hpp Normal file
View file

@ -0,0 +1,414 @@
/** @file flatstring.hpp
*
* Author: Roland Conybeare
**/
#pragma once
#include <string_view>
#include <sstream>
#include <algorithm>
#include <memory>
namespace xo {
/** @class flatstring
* @brief class to represent a string with a fixed amount of storage space.
*
* - Flatstring memory layout is a fixed-size, null-terminated char array.
* - With a few exceptions, flatstring methods are noexcept.
* @c flatstring<N>::at() may throw, for consistency with @c std::string::at() behavior
* - Construction and concatenation of flatstrings are constexpr,
* and can be done at compile time.
* We rely on this in related projects (e.g. https://github.com:rconybea/xo-unit)
* - Preserves as much of the c++23 @c std::string api as practicable
*
* @c N includes mandatory null terminator, so we require @c N > 0.
*
* @invariant all flatstring instances are null-terminated.
* @invariant sizeof(flatstring<N>) == N
**/
template <std::size_t N>
struct flatstring {
/** @defgroup flatstring-types template types **/
///@{
using traits_type = std::char_traits<char>;
using value_type = char;
using allocator_type = std::allocator<char>;
using size_type = std::allocator_traits<allocator_type>::size_type;
using difference_type = std::allocator_traits<allocator_type>::difference_type;
using reference = value_type &;
using const_reference = const value_type &;
using pointer = std::allocator_traits<allocator_type>::pointer;
using const_pointer = std::allocator_traits<allocator_type>::const_pointer;
using iterator = char *;
using const_iterator = const char *;
using reverse_iterator = char *;
using const_reverse_iterator = const char *;
///@}
/** @defgroup flatstring-constants constants **/
///@{
static constexpr const size_type npos = size_type(-1);
/** @brief capacity of this flatstring, including final null terminator.
*
* @note not present in @c std::string api
**/
static constexpr const std::size_t fixed_capacity = N;
///@}
public:
/** @defgroup flatstring-ctor constructors **/
///@{
/** @brief create empty string literal. Will contain N null characters
*
* Example
* @code
* constexpr flatstring<5> s1;
* static_assert(s1.empty());
* @endcode
**/
constexpr flatstring() noexcept {
/* note: clang verifies that we fully initialize memory; otherwise will not recognize
* instance as constexpr
*/
std::fill_n(value_, N, '\0');
}
/** @brief create string literal from a correctly-sized char array
*
* Example
* @code
* constexpr flatstring s1("hello");
* static_assert(s1.size() > 0);
* @endcode
**/
constexpr flatstring(const char (&str)[N]) noexcept {
std::copy_n(str, N, value_);
}
///@}
/** @defgroup flatstring-properties property-methods **/
///@{
/** @brief true if (and only if) string is empty **/
constexpr bool empty() const noexcept { return value_[0] == '\0'; }
/** @brief returns current size of this string **/
constexpr size_type size() const noexcept {
return this->cend() - this->cbegin();
}
/** @brief synonym for @c size() **/
constexpr size_type length() const noexcept { return size(); }
constexpr size_type capacity() const noexcept { return fixed_capacity - 1; }
constexpr size_type max_size() const noexcept { return fixed_capacity - 1; }
/** @brief contents as plain old C-style string. **/
constexpr const char * c_str() const noexcept { return value_; }
///@}
/** @defgroup flatstring-access access methods **/
///@{
/** @brief return char at position @p pos in this string (counting from zero).
*
* Throws @c std::out_of_range exception if @p pos >= @c N
**/
constexpr value_type & at(size_type pos) throw() { return this->at_aux(pos); }
constexpr const value_type & at(size_type pos) const throw() { return const_cast<flatstring *>(this)->at_aux(pos); }
/** @brief return char at position @p pos in this string (counting from zero).
*
* Does not check bounds: undefined behavior if @p pos >= @c N
*
* @pre 0<=pos<=N-1
**/
constexpr value_type & operator[](size_type pos) { return value_[pos]; }
constexpr const value_type & operator[](size_type pos) const { return value_[pos]; }
///@}
/** @defgroup flatstring-iterators iterators **/
///@{
constexpr iterator begin() { return &value_[0]; }
constexpr iterator end() { return this->last(); }
constexpr const_iterator cbegin() const { return &value_[0]; }
constexpr const_iterator cend() const { return const_cast<flatstring*>(this)->last<iterator>(); }
constexpr const_iterator begin() const { return cbegin(); }
constexpr const_iterator end() const { return cend(); }
constexpr reverse_iterator rbegin() { return this->last(); }
constexpr reverse_iterator rend() { return &value_[0]; }
constexpr const_reverse_iterator crbegin() const { return const_cast<flatstring*>(this)->last<iterator>(); }
constexpr const_reverse_iterator crend() const { return &value_[0]; }
constexpr const_reverse_iterator rbegin() const { return crbegin(); }
constexpr const_reverse_iterator rend() const { return crend(); }
///@}
/** @defgroup flatstring-assign assignment **/
///@{
/** @brief put string into empty state. fills entire char array with nulls **/
void clear() { std::fill_n(value_, N, '\0'); }
/** @brief replace contents with min(count,N-1) copies of character ch **/
constexpr flatstring & assign(size_type count, value_type ch) {
std::size_t pos = 0;
for (; pos < std::min(count, N-1); ++pos)
value_[pos] = ch;
for (; pos < N; ++pos)
value_[pos] = '\0';
return *this;
}
/** @brief replace contents with first N-1 characters of str **/
constexpr flatstring & assign(const flatstring & x) {
for (std::size_t pos = 0; pos < N-1; ++pos)
value_[pos] = x.value_[pos];
value_[N-1] = '\0';
return *this;
}
/** @brief replace contents with substring [pos,pos+count] of str **/
constexpr flatstring & assign(const flatstring & x,
size_type pos, size_type count = npos) {
std::size_t i = 0;
for (;
i < std::min(std::min(count,
std::max(x.capacity-1 - pos,
0)),
N-1);
++i)
value_[i] = x.value_[pos+i];
for (; i < N; ++i)
value_[i] = '\0';
return *this;
}
/** @brief replace contents with range [cstr, cstr + count) **/
constexpr flatstring & assign(const value_type * cstr, size_type count) {
std::size_t i = 0;
for (; i < std::min(N-1, count); ++i)
value_[i] = cstr[i];
for (; i < N; ++i)
value_[i] = '\0';
return *this;
}
/** @brief replace contents with C-style string cstr **/
constexpr flatstring & assign(const value_type * cstr) {
std::size_t i = 0;
const value_type * p = cstr;
while ((i < N-1) && (*p != '\0')) {
value_[i] = *p;
++i;
++p;
}
for (; i < N; ++i)
value_[i] = '\0';
return *this;
}
/** @brief replace contents with iterator range [first, last) **/
template <typename InputIter>
constexpr flatstring & assign(InputIter first, InputIter last) {
InputIter ix = first;
std::size_t i = 0;
for (; (i < N-1) && (ix != last); ++i) {
value_[i] = *ix;
}
for (; i < N; ++i)
value_[i] = '\0';
return *this;
}
///@}
// insert
// insert_range
// erase
// push_back
// append
// append_range
// operator+=
// replace
// replace_with_range
// copy
// find
// rfind
// find_first_of
// find_first_not_of
// find_last_of
// find_last_not_of
// compare
// starts_with
// end_with
// contains
// substr
/** @defgroup flatstring-conversion-operators conversion operators **/
///@{
/** @brief conversion to @c std::string
*
* Example
* @code
* constexpr flatstring s("bazinga!");
* std::string s_str{s.str()};
* @endcode
**/
std::string str() const { return std::string(value_); }
/** @brief conversion operator to string_view **/
constexpr operator std::string_view() const noexcept { return std::string_view(value_); }
/** @brief conversion operator to C-style string.
*
* Example
* @code
* constexpr flatstring s("obey gravity..");
* strcmp(s, "obey...");
* @endcode
**/
constexpr operator const char * () const { return value_; }
///@}
private:
constexpr value_type & at_aux(size_type pos) {
if (pos >= N) {
#ifdef NOT_USING
/* note: can't build stringstream at compile time */
std::stringstream ss;
ss << "flatstring<" << N << ">::at: expected pos=[" << pos << "] in interval [0," << N << ")" << std::endl;
#endif
throw std::out_of_range("at_aux: range error");
}
return (*this)[pos];
}
template <typename Iterator>
constexpr Iterator last() {
Iterator p = &value_[N-1];
/* search backward for first padding '\0' */
while ((p > &value_[0]) && (*(p-1) == '\0'))
--p;
return p;
}
public:
/** @defgroup flatstring-instance-variables instance variables **/
///@{
/** @brief characters comprising this literal string **/
char value_[N];
///@}
};
/** @brief sentinel type, for forbidden stringliteral with no space for a null terminator **/
template <>
struct flatstring<0> { flatstring() = delete; };
// non-member functions
// erase
// erase_if
// operator<<
// operator>>
// getline
// stoi
// stol
// stoll
// stoul
// stoull
// stof
// stod
// stold
#ifdef NOT_USING
/** @brief all_same_v<T1, .., Tn> is true iff types T1 = .. = Tn
**/
template < typename First, typename... Rest >
constexpr auto
all_same_v = std::conjunction_v< std::is_same<First, Rest>... >;
#endif
/** @brief Concatenate native or wrapped string literals
*
* Can mix stringliteral objects and native C-style string literals,
* and still preserve constexpr-ness.
*
* Example:
* @code
* constexpr auto s = stringliteral_concat(stringliteral("hello"),
* ", ",
* stringliteral("world"));
* static_assert(s.capacity == 13);
* @endcode
*
**/
template < typename... Ts>
constexpr auto
flatstring_concat(Ts && ... args) noexcept
{
#ifdef NOT_USING
static_assert(all_same_v<std::decay_t<Ts>...>,
"string must share the same char type");
using char_type = std::remove_const_t< std::remove_pointer_t < std::common_type_t < Ts... > > >;
#endif
using value_type = char;
/** n1: total number of bytes used by arguments **/
constexpr std::size_t n1 = (sizeof(Ts) + ...);
/** z1: each string arg has a null terminator included in its size,
* z1 is the number of arguments in parameter pack Ts,
* which equals the number of null terminators used
**/
constexpr std::size_t z1 = sizeof...(Ts);
/** n: number of chars in concatenated string. +1 for final null **/
constexpr std::size_t n
= (n1 / sizeof(value_type)) - z1 + 1;
flatstring<n> result;
std::size_t pos = 0;
auto detail_concat = [ &pos, &result ](auto && arg) {
constexpr auto count = (sizeof(arg) - sizeof(value_type)) / sizeof(value_type);
std::copy_n(/*arg.c_str()*/ static_cast<const char *>(arg), count, result.value_ + pos);
pos += count;
};
(detail_concat(args), ...);
return result;
}
/** @brief compare two string literals lexicographically.
*
* Example:
* @code
* constexpr auto cmp = stringliteral_compare(stringliteral("foo"), stringliteral("bar"));
* static_assert(cmp > 0);
* @endcode
**/
template <std::size_t N1,
std::size_t N2>
constexpr auto
flatstring_compare(const flatstring<N1> & s1,
const flatstring<N2> & s2) noexcept
{
return (std::string_view(s1.value_) <=> std::string_view(s2.value_));
}
/** @brief 3-way compare for two stringliterals **/
template <std::size_t N1,
std::size_t N2>
constexpr auto
operator<=>(const flatstring<N1> & s1,
const flatstring<N2> & s2) noexcept
{
return flatstring_compare(s1, s2);
}
} /*namespace xo*/
/** end stringliteral.hpp **/

37
include/xo/flatstring/flatstring_iostream.hpp Normal file
View file

@ -0,0 +1,37 @@
/** @file flatstring_iostream.hpp
*
* Author: Roland Conybeare
**/
#pragma once
#include "flatstring.hpp"
#include <ostream>
//#include <cstdint>
namespace xo {
/** @brief print flatstring on stream os.
*
**/
template <std::size_t N>
void
print_flatstring (std::ostream & os, const flatstring<N> & x) {
os << x.c_str();
}
/** @brief print flatstring x on stream os.
*
* Example
* @code
* cout << flatstring("foo"); // outputs "foo"
* @endcode
**/
template <std::size_t N>
inline std::ostream &
operator<< (std::ostream & os, const flatstring<N> & x) {
print_flatstring(os, x);
return os;
}
} /*namespace xo*/
/** end flatstring_iostream.hpp **/

30
include/xo/flatstring/string_view_concat.hpp Normal file
View file

@ -0,0 +1,30 @@
#include <string_view>
#include <array>
template <std::string_view const & ... Strings>
struct sv_concat
{
static constexpr auto impl() noexcept {
constexpr std::size_t n = (Strings.size() + ... + 0);
std::array<char, n + 1> arr{};
auto append = [i=0, &arr](const auto & s) mutable {
for (auto c : s)
arr[i++] = c;
};
(append(Strings), ...);
arr[n] = '\0';
return arr;
}
static constexpr auto arr = impl();
static constexpr std::string_view value {
arr.data(),
arr.size() - 1
};
};
template <std::string_view const & ... Strings>
static constexpr auto concat_v = sv_concat<Strings...>::value;