string_view.hh

Go to the documentation of this file.

#ifndef STRING_VIEW_HH
#define STRING_VIEW_HH

#include <cassert>
#include <cstring>
#include <iosfwd>
#include <iterator>
#include <string>
#include <type_traits>

class string_view
{
public:
        using size_type = size_t;
        using difference_type = std::ptrdiff_t;
        using const_iterator = const char*;
        using const_reverse_iterator = std::reverse_iterator<const_iterator>;

        static const size_type npos = size_type(-1);

        // construct/copy/assign
        string_view() = default;
        /*implicit*/ string_view(const char* s)
                : dat(s), siz(s ? size_type(strlen(s)) : 0) {}
        string_view(const char* s, size_type len)
                : dat(s), siz(len) { if (!dat) assert(siz == 0); }
        string_view(const char* first, const char* last)
                : dat(first), siz(last - first) { if (!dat) assert(siz == 0); }
        /*implicit*/ string_view(const std::string& s)
                : dat(s.data()), siz(s.size()) {}

        // iterators
        auto begin() const { return dat; }
        auto end()   const { return dat + siz; }
        auto rbegin() const { return const_reverse_iterator(end()); }
        auto rend()   const { return const_reverse_iterator(begin()); }

        // capacity
        size_type size()  const { return siz; }
        bool     empty() const { return siz == 0; }
        //size_type max_size() const;
        //size_type length() const;

        // element access
        char operator[](size_type i) const {
                assert(i < siz);
                return dat[i];
        }
        //const char& at(size_type i) const;
        char front() const { return *dat; }
        char back() const { return *(dat + siz - 1); }
        const char* data() const { return dat; }

        // Outgoing conversion operators
        //explicit operator std::string() const; // c++11
        std::string str() const;

        // mutators
        void clear() { siz = 0; } // no need to change 'dat'
        void remove_prefix(size_type n) {
                assert(n <= siz);
                dat += n;
                siz -= n;
        }
        void remove_suffix(size_type n) {
                assert(n <= siz);
                siz -= n;
        }
        void pop_back()  { remove_suffix(1); }
        void pop_front() { remove_prefix(1); }

        // string operations with the same semantics as std::string
        int compare(string_view x) const;
        string_view substr(size_type pos, size_type n = npos) const;
        //size_type copy(char* buf) const;
        size_type find(string_view s) const;
        size_type find(char c) const;
        size_type rfind(string_view s) const;
        size_type rfind(char c) const;
        size_type find_first_of(string_view s) const;
        size_type find_first_of(char c) const;
        //size_type find_first_not_of(string_view s) const;
        //size_type find_first_not_of(char c) const;
        size_type find_last_of(string_view s) const;
        size_type find_last_of(char c) const;
        //size_type find_last_not_of(string_view s) const;
        //size_type find_last_not_of(char c) const;

        // c++20
        bool starts_with(string_view x) const;
        bool starts_with(char x) const;
        bool ends_with(string_view x) const;
        bool ends_with(char x) const;

private:
        const char* dat = nullptr;
        size_type siz = 0;
};

static_assert(std::is_trivially_destructible<string_view>::value, "");
static_assert(std::is_trivially_copyable<string_view>::value, "");
static_assert(std::is_trivially_copy_constructible<string_view>::value, "");
static_assert(std::is_trivially_move_constructible<string_view>::value, "");
static_assert(std::is_trivially_assignable<string_view, string_view>::value, "");
static_assert(std::is_trivially_copy_assignable<string_view>::value, "");
static_assert(std::is_trivially_move_assignable<string_view>::value, "");

// Comparison operators
inline bool operator==(string_view x, string_view y) {
        return (x.size() == y.size()) &&
               (memcmp(x.data(), y.data(), x.size()) == 0);
}

bool operator< (string_view x, string_view y);
inline bool operator!=(string_view x, string_view y) { return !(x == y); }
inline bool operator> (string_view x, string_view y) { return  (y <  x); }
inline bool operator<=(string_view x, string_view y) { return !(y <  x); }
inline bool operator>=(string_view x, string_view y) { return !(x <  y); }

// numeric conversions
//int                stoi  (string_view s, string_view::size_type* idx = nullptr, int base = 0);
//long               stol  (string_view s, string_view::size_type* idx = nullptr, int base = 0);
//unsigned long      stoul (string_view s, string_view::size_type* idx = nullptr, int base = 0);
//long long          stoll (string_view s, string_view::size_type* idx = nullptr, int base = 0);
//unsigned long long stoull(string_view s, string_view::size_type* idx = nullptr, int base = 0);
//float              stof  (string_view s, string_view::size_type* idx = nullptr);
//double             stod  (string_view s, string_view::size_type* idx = nullptr);
//long double        stold (string_view s, string_view::size_type* idx = nullptr);


// Faster than the above, but less general (not part of the std proposal):
// - Only handles decimal.
// - No leading + or - sign (and thus only positive values).
// - No leading whitespace.
// - No trailing non-digit characters.
// - No out-of-range check (so undetected overflow on e.g. 9999999999).
// - Empty string parses as zero.
// Throws std::invalid_argument if any character is different from [0-9],
// similar to the error reporting in the std::stoi() (and related) functions.
unsigned fast_stou(string_view s);


std::ostream& operator<<(std::ostream& os, string_view s);

// begin, end
inline auto begin(const string_view& x) { return x.begin(); }
inline auto end  (const string_view& x) { return x.end();   }


#endif