422 lines
11 KiB
C++
422 lines
11 KiB
C++
/*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* Copyright 2011-2018 Danny Robson <danny@nerdcruft.net>
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "ascii.hpp"
|
|
#include "debug/assert.hpp"
|
|
#include "view.hpp"
|
|
|
|
#include <string>
|
|
#include <type_traits>
|
|
|
|
|
|
namespace cruft {
|
|
std::string to_utf8 (const wchar_t*);
|
|
std::string to_utf8 (const std::wstring&);
|
|
|
|
|
|
/// Apply a functor to each character of a string and return the result.
|
|
template <typename FunctionT>
|
|
std::string
|
|
transform (std::string &&val, FunctionT &&func)
|
|
{
|
|
std::transform (
|
|
std::begin (val),
|
|
std::end (val),
|
|
std::begin (val),
|
|
std::forward<FunctionT> (func)
|
|
);
|
|
|
|
return std::move (val);
|
|
}
|
|
|
|
|
|
/// Apply a functor to each character of a string and return the result.
|
|
template <typename FunctionT>
|
|
std::string
|
|
transform (std::string_view val, FunctionT &&func)
|
|
{
|
|
std::string res;
|
|
res.reserve (val.size ());
|
|
|
|
std::transform (
|
|
std::begin (val),
|
|
std::end (val),
|
|
std::back_inserter (res),
|
|
std::forward<FunctionT> (func)
|
|
);
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
inline std::string
|
|
to_upper (std::string_view const &val)
|
|
{
|
|
return transform (val, ::toupper);
|
|
}
|
|
|
|
|
|
template <std::size_t N>
|
|
inline std::string
|
|
to_upper (char const (&val)[N])
|
|
{
|
|
return to_upper (std::string_view (val));
|
|
}
|
|
|
|
|
|
/// Convert the provided string to all upper case
|
|
inline std::string
|
|
to_upper (std::string &&val)
|
|
{
|
|
return transform (std::move (val), ::toupper);
|
|
}
|
|
|
|
|
|
/// Convert the provided string to all upper case
|
|
inline std::string
|
|
to_upper (std::string const &val)
|
|
{
|
|
return transform (val, ::toupper);
|
|
}
|
|
|
|
|
|
/// Convert the provided string to all upper case
|
|
inline std::string
|
|
to_lower (std::string &&val)
|
|
{
|
|
return transform (std::move (val), ::tolower);
|
|
}
|
|
|
|
|
|
/// Convert the provided string to all upper case
|
|
inline std::string
|
|
to_lower (std::string const &val)
|
|
{
|
|
return transform (val, ::tolower);
|
|
}
|
|
|
|
|
|
inline std::string_view
|
|
lstrip (std::string_view str)
|
|
{
|
|
auto const pos = std::find_if_not (std::begin (str), std::end (str), ascii::is_space);
|
|
return { pos, std::end (str) };
|
|
}
|
|
|
|
|
|
inline std::string_view
|
|
rstrip (std::string_view str)
|
|
{
|
|
auto const pos = std::find_if_not (std::rbegin (str), std::rend (str), ascii::is_space);
|
|
return { str.begin (), pos.base () };
|
|
}
|
|
|
|
|
|
inline std::string_view
|
|
strip (std::string_view str)
|
|
{
|
|
return lstrip (rstrip (str));
|
|
}
|
|
}
|
|
|
|
|
|
bool
|
|
strbegins(const char *restrict str,
|
|
const char *restrict prefix);
|
|
|
|
|
|
namespace cruft {
|
|
/// Provides an iterator interface over a string, breaking at each
|
|
/// occurence of a specific character.
|
|
///
|
|
/// It is up to the constructor to ensure the lifetime of the string.
|
|
/// This class simply provides an interface for iteration and doesn't
|
|
/// concern itself with lifetimes.
|
|
template <std::forward_iterator Iterator>
|
|
struct tokeniser {
|
|
public:
|
|
using value_type = view<Iterator>;
|
|
using element_type = typename std::iterator_traits<Iterator>::value_type;
|
|
|
|
tokeniser (cruft::view<Iterator,Iterator> _range, element_type _separator):
|
|
m_range (_range),
|
|
m_separator (_separator)
|
|
{ ; }
|
|
|
|
tokeniser (const char *_range, char _separator):
|
|
m_range (_range),
|
|
m_separator (_separator)
|
|
{ ; }
|
|
|
|
struct iterator {
|
|
public:
|
|
using iterator_category = std::forward_iterator_tag;
|
|
using value_type = tokeniser::value_type;
|
|
using difference_type = std::iter_difference_t<Iterator>;
|
|
using pointer = value_type*;
|
|
using reference = value_type&;
|
|
|
|
iterator
|
|
operator++ (int)
|
|
{
|
|
iterator res(*this);
|
|
++*this;
|
|
return res;
|
|
}
|
|
|
|
iterator& operator++ (void)&
|
|
{
|
|
if (m_data.end () == m_end) {
|
|
m_data = { m_data.end (), m_data.end () };
|
|
m_base = m_end;
|
|
return *this;
|
|
}
|
|
|
|
m_base = m_data.end ();
|
|
m_data = { m_data.end () + 1, std::find (m_data.end () + 1, m_end, m_separator) };
|
|
return *this;
|
|
}
|
|
|
|
iterator operator+ (int count)
|
|
{
|
|
return std::next (*this, count);
|
|
}
|
|
|
|
auto const&
|
|
operator* (void) const&
|
|
{
|
|
return m_data;
|
|
}
|
|
|
|
auto
|
|
operator-> (void) const&
|
|
{
|
|
return &m_data;
|
|
}
|
|
|
|
bool operator== (const iterator &rhs) const
|
|
{
|
|
CHECK_EQ (m_separator, rhs.m_separator);
|
|
return m_base == rhs.m_base;
|
|
}
|
|
|
|
bool operator!= (iterator const &rhs) const
|
|
{
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
iterator (value_type _range, element_type _separator)
|
|
: m_separator (_separator)
|
|
, m_base (_range.begin ())
|
|
, m_data (_range.begin (), std::find (_range.begin (), _range.end (), _separator))
|
|
, m_end (_range.end ())
|
|
{ ; }
|
|
|
|
private:
|
|
element_type m_separator;
|
|
|
|
Iterator m_base;
|
|
view<Iterator> m_data;
|
|
Iterator m_end;
|
|
};
|
|
|
|
|
|
iterator cbegin (void) const { return { m_range, m_separator }; }
|
|
iterator begin (void) const { return { m_range, m_separator }; }
|
|
|
|
iterator cend (void) const { return { { m_range.cend (), m_range.cend () }, m_separator }; }
|
|
iterator end (void) const { return { { m_range.cend (), m_range.cend () }, m_separator }; }
|
|
|
|
std::size_t
|
|
size (void) const
|
|
{
|
|
return std::count (
|
|
m_range.begin (),
|
|
m_range.end (),
|
|
m_separator
|
|
) + 1u;
|
|
}
|
|
|
|
bool contains (std::string_view key) const noexcept
|
|
{
|
|
for (auto const &i: *this)
|
|
if (equal (i, key))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
private:
|
|
const value_type m_range;
|
|
const element_type m_separator;
|
|
};
|
|
|
|
|
|
template <typename ContainerT>
|
|
tokeniser (ContainerT&, typename ContainerT::value_type) -> tokeniser<typename ContainerT::iterator>;
|
|
|
|
tokeniser (const char*,char) -> tokeniser<const char*>;
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
template <typename CharT, std::size_t LengthV>
|
|
auto
|
|
make_tokeniser (CharT (&data)[LengthV], CharT separator)
|
|
{
|
|
return tokeniser { std::begin (data), std::end (data), separator };
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
/// Calculate the line and column of an iterator within a view.
|
|
///
|
|
/// Returns an anonymous struct containing the line and column number.
|
|
///
|
|
/// The column number for newline is undefined. However it should never
|
|
/// return the value {0,-1} and so it should not result in underruns when
|
|
/// offsetting a pointer using the column index.
|
|
template <typename IteratorT>
|
|
auto
|
|
character_position (
|
|
cruft::view<IteratorT> data,
|
|
IteratorT const cursor
|
|
) {
|
|
using difference_type = typename std::iterator_traits<IteratorT>::difference_type;
|
|
difference_type line_count = 0;
|
|
auto current_line = data.begin ();
|
|
|
|
do {
|
|
auto next_line = std::find (current_line, data.end (), '\n');
|
|
if (next_line == data.end () || next_line > cursor)
|
|
break;
|
|
|
|
++line_count;
|
|
current_line = next_line + 1;
|
|
} while (1);
|
|
|
|
struct {
|
|
difference_type line;
|
|
difference_type column;
|
|
} val = {
|
|
.line = line_count,
|
|
.column = cursor - current_line,
|
|
};
|
|
|
|
return val;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
/// A comparator for string-like objects that uses strcmp rather than
|
|
/// pointer comparison.
|
|
///
|
|
/// TODO: handle string and string_view objects
|
|
struct string_less {
|
|
template <
|
|
typename CharT,
|
|
typename = std::void_t<typename std::char_traits<CharT>::char_type>
|
|
>
|
|
bool operator() (CharT const *a, CharT const *b) const noexcept
|
|
{
|
|
return strcmp (a, b) < 0;
|
|
}
|
|
};
|
|
}
|
|
|
|
|
|
namespace cruft::string {
|
|
template <char (*TransformV)(char) noexcept>
|
|
struct less {
|
|
bool operator() (char const *a, char const *b) const noexcept
|
|
{
|
|
for (; *a && *b; ++a, ++b) {
|
|
auto const &a_val = TransformV (*a);
|
|
auto const &b_val = TransformV (*b);
|
|
|
|
if (a_val < b_val)
|
|
return true;
|
|
if (a_val > b_val)
|
|
return false;
|
|
}
|
|
|
|
return *a == '\0' && *b != '\0';
|
|
}
|
|
|
|
bool operator() (std::string const &a, std::string const & b) const noexcept
|
|
{
|
|
return (*this) (std::string_view (a), std::string_view (b));
|
|
}
|
|
|
|
bool operator() (std::string_view a, std::string_view b) const noexcept
|
|
{
|
|
auto a_cursor = a.begin ();
|
|
auto b_cursor = b.begin ();
|
|
|
|
for ( ; a_cursor != a.end () && b_cursor != b.end (); ++a_cursor, ++b_cursor) {
|
|
auto const &a_val = TransformV (*a_cursor);
|
|
auto const &b_val = TransformV (*b_cursor);
|
|
if (a_val < b_val)
|
|
return true;
|
|
if (a_val > b_val)
|
|
return false;
|
|
}
|
|
|
|
if (a_cursor == a.end () && b_cursor != b.end ())
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
using is_transparent = void;
|
|
|
|
template <typename A, typename B>
|
|
requires (!std::is_same_v<A,B>)
|
|
bool operator() (A &&a, B &&b) const noexcept
|
|
{
|
|
return (*this) (
|
|
std::string_view (a),
|
|
std::string_view (b)
|
|
);
|
|
}
|
|
};
|
|
|
|
|
|
using less_lower = less<ascii::try_lower>;
|
|
}
|
|
|
|
|
|
namespace cruft::string::equality {
|
|
///////////////////////////////////////////////////////////////////////////
|
|
/// A case comparator that tests equality on a string after a
|
|
/// per-character transform is applied.
|
|
///
|
|
/// Neither string will be modified.
|
|
///
|
|
/// \tparam TransformV A character transform function
|
|
template <char (*TransformV)(char) noexcept>
|
|
struct transform {
|
|
static bool operator() (
|
|
std::string_view const &a,
|
|
std::string_view const &b
|
|
) noexcept {
|
|
if (a.size () != b.size ())
|
|
return false;
|
|
|
|
for (auto i = a.begin (), j = b.begin (); i != a.end (); ++i, ++j)
|
|
if (TransformV (*i) != TransformV (*j))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
using lower = transform<ascii::try_lower>;
|
|
using upper = transform<ascii::try_upper>;
|
|
}
|