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, a constexpr constructor will be available in String. It is an
// experimental change that needs some more work to be stable.
#define STRING_WITH_CONSTEXPR_CONSTRUCTOR 0

// If non-zero, all copy-construction will be disabled. An explicit call to
// copy() is needed to actively copy a String object in that case. This can be
// helpful for removing copies that are not necessary.
#define STRING_DISABLE_COPY_CONSTRUCTION 0

// Disable just-in-time hashing on all string objects, which causes String
// creation (including from substrings and copies) to be much slower, but can
// avoid many re-hashes on const String objects that would otherwise be unable
// to store the hash.
#define STRING_DISABLE_JIT_HASHING 0

class EXPORTED_PUBLIC String
{
  public:
    String();
    String(const char *s);
    String(const char *s, size_t length);
#if STRING_DISABLE_COPY_CONSTRUCTION
    String(const String &x) = delete;
#else
    String(const String &x);
#endif
    String(String &&x);
    ~String();

#if STRING_WITH_CONSTEXPR_CONSTRUCTOR
    template <size_t N>
    constexpr String(const char (&s)[N]);
#endif

    String &operator=(String &&x);
#if !STRING_DISABLE_COPY_CONSTRUCTION
    String &operator=(const String &x);
    String &operator=(const char *s);
#endif
    operator const char *() const
    {
        if (m_Size == StaticSize)
            return m_Static;
        else if (m_Data == 0)
            return "";
        else
            return m_Data;
    }
    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;

    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();

    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);

    void assign(const String &x);
    void assign(const char *s, size_t len = 0, bool unsafe = false);
    void reserve(size_t size);
    void free();

    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;

  private:
    void reserve(size_t size, bool zero);
    char *extract() const;
    void computeHash();
    uint32_t computeHash() const;
    void move(String &&other);
    static constexpr const size_t StaticSize = 64;
    char *m_Data;
    const char *m_ConstData;
    size_t m_Length;
    size_t m_Size;
    char m_Static[StaticSize];
    bool m_HeapData;
    bool iswhitespace(const char c) const;

    uint32_t m_Hash;
};

#if STRING_WITH_CONSTEXPR_CONSTRUCTOR
template <size_t N>
constexpr String::String(const char (&s)[N])
    : m_Data(nullptr), m_ConstData(s), m_Length(N ? N - 1 : 0), m_Size(N),
      m_HeapData(false)
{
}
#endif

#endif