String.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#ifndef KERNEL_UTILITIES_STRING_H
#define KERNEL_UTILITIES_STRING_H
 
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/StringView.h"
#include "pedigree/kernel/utilities/Vector.h"
#include "pedigree/kernel/utilities/template.h"  // IWYU pragma: keep
 
// If non-zero, disable expensive forms of copy construction.
#ifdef IN_STRING_TESTSUITE
#define STRING_DISABLE_EXPENSIVE_COPY_CONSTRUCTION 0
#else
#define STRING_DISABLE_EXPENSIVE_COPY_CONSTRUCTION 1
#endif
 
class Cord;
 
class EXPORTED_PUBLIC String {
 public:
  String();
  // The constructors marked explicit are slow, but sometimes the only way
  // to instantiate a String object. The intention to these being explicit
  // is that they will not be used accidentally.
  explicit String(const char* s);
  explicit String(const char* s, size_t length);
  explicit String(const char* s, size_t length, bool unsafe);
  explicit String(const Cord& x);
  String(const String& x);
  explicit String(const StringView& x);
  String(String&& x) noexcept;
  virtual ~String();
 
  String& operator=(String&& x) noexcept;
  String& operator=(const Cord& x);
  String& operator=(const String& x);
#if STRING_DISABLE_EXPENSIVE_COPY_CONSTRUCTION
  String& operator=(const char* s) = delete;
#else
  String& operator=(const char* s);
#endif
  explicit operator const char*() const {
    return cstr();
  }
  operator StringView() const {
    return view();
  }
  String& operator+=(const String& x);
  String& operator+=(const char* s);
 
  bool operator==(const String& s) const;
  bool operator==(const StringView& s) const;
  bool operator==(const char* s) const;
 
  bool compare(const char* s, size_t len) const;
 
  template <size_t N>
  bool compare(const char (&s)[N]) const {
    // ignore null in c-string for comparison
    return compare(s, N - 1);
  }
 
  char operator[](size_t i) const;
 
  const char* cstr() const {
    return extract();
  }
 
  size_t length() const {
    return m_Length;
  }
 
  size_t size() const {
    return m_Size;
  }
 
  uint32_t hash() const;
 
  uint32_t hash();
 
  size_t nextCharacter(size_t c) const;
 
  size_t prevCharacter(size_t c) const;
 
  void lchomp();
 
  void chomp();
 
  void strip();
 
  void lstrip();
 
  void rstrip();
 
  void ltrim(size_t n);
 
  void rtrim(size_t n);
 
  String split(size_t offset);
  void split(size_t offset, String& back);
 
  Vector<String> tokenise(char token);
  void tokenise(char token, Vector<String>& output) const;
  void tokenise(char token, Vector<StringView>& output) const;
 
  static size_t Utf32ToUtf8(uint32_t utf32, char* utf8);
 
  void Format(const char* format, ...) FORMAT(printf, 2, 3);
 
  template <size_t N>
  void assign(const char (&s)[N]) {
    assign(s, N, true);
  }
 
  void assign(const String& x);
  void assign(const Cord& x);
  void assign(const char* s, size_t len = 0, bool unsafe = false);
  void reserve(size_t size);
  virtual void clear() noexcept;
 
  void downsize();
 
  bool endswith(const char c) const;
  bool endswith(const String& s) const;
  bool endswith(const char* s, size_t len = 0) const;
 
  bool startswith(const char c) const;
  bool startswith(const String& s) const;
  bool startswith(const char* s, size_t len = 0) const;
 
  ssize_t find(const char c) const;
  ssize_t rfind(const char c) const;
 
  String copy() const;
 
  StringView view() const;
 
 protected:
  bool iswhitespace(const char c) const;
  void reserve(size_t size, bool zero);
  void computeHash();
  uint32_t computeHash() const;
 
 private:
  uint32_t maybeHash() const;
  virtual char* extract() const;
  void move(String&& other) noexcept;
  char* m_Data;
  size_t m_Length;
  size_t m_Size;
  uint32_t m_Hash;
  virtual bool resizable() const;
  virtual bool assignable() const;
 
 protected:
  void setLength(size_t n);
  void setSize(size_t n);
};
 
template <size_t N>
class ConstantString : public String {
 public:
  ConstantString(const char str[N]) {
    setLength(N - 1);
    setSize(N);
    MemoryCopy(m_Data, str, N);
    computeHash();
  }
 
  virtual void clear() noexcept override {}
 
 private:
  virtual char* extract() const override {
    return const_cast<char*>(m_Data);
  }
 
  virtual bool resizable() const override {
    return false;
  }
 
  virtual bool assignable() const override {
    return false;
  }
 
  char m_Data[N];
};
 
template <size_t N>
ConstantString<N> MakeConstantString(const char (&str)[N]) {
  return ConstantString<N>(str);
}
 
#endif