string

// vi:set ft=cpp: -*- Mode: C++ -*-
/*
 * (c) 2008-2009 Alexander Warg <warg@os.inf.tu-dresden.de>
 *     economic rights: Technische Universität Dresden (Germany)
 *
 * License: see LICENSE.spdx (in this directory or the directories above)
 */
 
#pragma once
 
#include <l4/cxx/minmax>
#include <l4/cxx/basic_ostream>
 
 
namespace cxx {
 
class String
{
public:
 
  typedef char const *Index;
 
  String(char const *s) noexcept : _start(s), _len(__builtin_strlen(s)) {}
  String(char const *s, unsigned long len) noexcept : _start(s), _len(len) {}
 
  String(char const *s, char const *e) noexcept : _start(s), _len(e - s) {}
 
  String() : _start(0), _len(0) {}
 
  Index start() const { return _start; }
  Index end() const { return _start + _len; }
  int len() const { return _len; }
 
  void start(char const *s) { _start = s; }
  void len(unsigned long len) { _len = len; }
  bool empty() const { return !_len; }
 
  String head(Index end) const
  {
    if (end < _start)
      return String();
 
    if (eof(end))
      return *this;
 
    return String(_start, end - _start);
  }
  String head(Index end) const {…}
 
  String head(unsigned long end) const
  { return head(start() + end); }
  String head(unsigned long end) const {…}
 
  String substr(unsigned long idx, unsigned long len = ~0UL) const
  {
    if (idx >= _len)
      return String(end(), 0UL);
 
    return String(_start + idx, cxx::min(len, _len - idx));
  }
  String substr(unsigned long idx, unsigned long len = ~0UL) const {…}
 
  String substr(char const *start, unsigned long len = 0) const
  {
    if (start >= _start && !eof(start))
      {
  unsigned long nlen = _start + _len - start;
  if (len != 0)
    nlen = cxx::min(nlen, len);
  return String(start, nlen);
      }
 
    return String(end(), 0UL);
  }
  String substr(char const *start, unsigned long len = 0) const {…}
 
  template< typename F >
  char const *find_match(F &&match) const
  {
    String::Index s = _start;
    while (1)
      {
  if (eof(s))
    return s;
 
  if (match(*s))
    return s;
 
  ++s;
      }
  }
  char const *find_match(F &&match) const {…}
 
  char const *find(char const *c) const
  { return find(c, start());  }
  char const *find(char const *c) const {…}
 
  char const *find(int c) const
  { return find(c, start());  }
  char const *find(int c) const {…}
 
  char const *rfind(char const *c) const
  {
    if (!_len)
      return end();
 
    char const *p = end();
    --p;
    while (p >= _start)
      {
  if (*p == *c)
    return p;
  --p;
      }
    return end();
 
  }
  char const *rfind(char const *c) const {…}
 
  Index starts_with(cxx::String const &c) const
  {
    unsigned long i;
    for (i = 0; i < c._len && i < _len; ++i)
      if (_start[i] != c[i])
  return 0;
    return i == c._len ? start() + i : 0;
  }
  Index starts_with(cxx::String const &c) const {…}
 
  char const *find(int c, char const *s) const
  {
    if (s < _start)
      return end();
 
    while (1)
      {
  if (eof(s))
    return s;
 
  if (*s == c)
    return s;
 
  ++s;
      }
  }
  char const *find(int c, char const *s) const {…}
 
  char const *find(char const *c, char const *s) const
  {
    if (s < _start)
      return end();
 
    while (1)
      {
  if (eof(s))
    return s;
 
  for (char const *x = c; *x; ++x)
    if (*s == *x)
      return s;
 
  ++s;
      }
  }
  char const *find(char const *c, char const *s) const {…}
 
  char const &operator [] (unsigned long idx) const { return _start[idx]; }
  char const &operator [] (int idx) const { return _start[idx]; }
  char const &operator [] (Index idx) const { return *idx; }
 
  bool eof(char const *s) const { return s >= _start + _len || !*s; }
 
  template<typename INT>
  int from_dec(INT *v) const
  {
    *v = 0;
    Index c;
    for (c = start(); !eof(c); ++c)
      {
  unsigned char n;
  if (*c >= '0' && *c <= '9')
    n = *c - '0';
  else
    return c - start();
 
        *v *= 10;
  *v += n;
      }
    return c - start();
  }
  int from_dec(INT *v) const {…}
 
  template<typename INT>
  int from_hex(INT *v) const
  {
    *v = 0;
    unsigned shift = 0;
    Index c;
    for (c = start(); !eof(c); ++c)
      {
  shift += 4;
  if (shift > sizeof(INT) * 8)
    return -1;
  unsigned char n;
  if (*c >= '0' && *c <= '9')
    n = *c - '0';
  else if (*c >= 'A' && *c <= 'F')
    n = *c - 'A' + 10;
  else if (*c >= 'a' && *c <= 'f')
    n = *c - 'a' + 10;
  else
    return c - start();
 
        *v <<= 4;
  *v |= n;
      }
    return c - start();
  }
  int from_hex(INT *v) const {…}
 
  bool operator == (String const &o) const
  {
    if (len() != o.len())
      return false;
 
    for (unsigned long i = 0; i < _len; ++i)
      if (_start[i] != o._start[i])
  return false;
 
    return true;
  }
  bool operator == (String const &o) const {…}
 
  bool operator != (String const &o) const
  { return ! (operator == (o)); }
  bool operator != (String const &o) const {…}
 
private:
  char const *_start;
  unsigned long _len;
};
class String {…};
 
}
 
inline
L4::BasicOStream &operator << (L4::BasicOStream &s, cxx::String const &str)
{
  s.write(str.start(), str.len());
  return s;
}