text.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <detail/preprocessor.hpp>
#include <memory/from_string.hpp>
 
#include <string>
#include <utility>
 
// TODO: anchor vtable
namespace from {
// "Dantelion text" namespace
namespace DLTX {
struct string_hash {
    string_hash() : str(nullptr), hash_value(0), needs_hashing(true) {}
 
    explicit string_hash(const wchar_t* str)
        : str(str), hash_value(0), needs_hashing(true) {}
 
    void may_change() noexcept {
        this->needs_hashing = true;
    }
 
    template <typename T>
    int get_hash(const T& str) noexcept {
        if (this->needs_hashing)
            this->hash_string(str);
        return this->hash_value;
    }
 
    template <typename T>
    int hash_string(const T& str) noexcept {
        int result = 0;
        for (int chr : str) {
            // To lowercase (approximate)
            if (chr <= 'Z')
                chr += 0x20;
            // Treat backslashes identically
            else if (chr == '\\')
                chr = '/';
            result *= 137;
            result += chr;
        }
        this->hash_value = result;
        this->needs_hashing = false;
        return result;
    }
 
    void set_string_ptr(const wchar_t* new_ptr) {
        this->str = new_ptr;
    }
 
private:
    const wchar_t* str;
    int hash_value;
    bool needs_hashing;
};
 
class FD4BasicHashString {
    using string_type = from::wstring;
 
public:
    LIBER_CLASS(FD4BasicHashString);
 
    virtual ~FD4BasicHashString() = default;
 
    template <typename... Args>
    FD4BasicHashString(Args&&... args) : string(std::forward<Args>(args)...) {}
 
    operator string_type&() noexcept {
        this->string_hash.may_change();
        return this->get_string();
    }
 
    operator const string_type&() const noexcept {
        return this->get_string();
    }
 
    string_type& get_string() noexcept {
        this->string_hash.may_change();
        return this->string;
    }
 
    const string_type& get_string() const noexcept {
        return this->string;
    }
 
    int get_hash() const noexcept {
        return string_hash.get_hash(*this);
    }
 
    auto begin() noexcept {
        return this->string.begin();
    }
 
    auto begin() const noexcept {
        return this->string.begin();
    }
 
    auto end() noexcept {
        return this->string.end();
    }
 
    auto end() const noexcept {
        return this->string.end();
    }
 
private:
    string_type string;
    // May be rehashed
    mutable string_hash string_hash;
};
 
using DLString = std::pair<from::wstring, bool>;
 
LIBER_ASSERTS_BEGIN(FD4BasicHashString);
LIBER_ASSERT_SIZE(0x40);
LIBER_ASSERTS_END;
} // namespace DLTX
} // namespace from