ref.hpp

浏览该文件的文档.

#ifndef NEFORCE_TUI_DOM_REF_HPP__
#define NEFORCE_TUI_DOM_REF_HPP__

 
#include "NeForce/core/string/utf.hpp"
#include "NeForce/core/utility/variant.hpp"
NEFORCE_BEGIN_NAMESPACE__
NEFORCE_BEGIN_TUI__


template <typename T>
class ref {
public:
    ref() :
    storage_(T{}) {}

    explicit ref(T value) :
    storage_(_NEFORCE move(value)) {}

    explicit ref(T* ptr) :
    storage_(ptr) {}

    T& operator*() {
        if (holds_pointer()) {
            return *pointer();
        }
        return value();
    }

    const T& operator*() const {
        if (holds_pointer()) {
            return *pointer();
        }
        return value();
    }

    T* operator->() { return &operator*(); }

    const T* operator->() const { return &operator*(); }

    ref& operator=(T v) {
        if (holds_pointer()) {
            *pointer() = _NEFORCE move(v);
        } else {
            value() = _NEFORCE move(v);
        }
        return *this;
    }

    NEFORCE_NODISCARD bool holds_pointer() const noexcept { return storage_.index() == 1; }
 
private:
    _NEFORCE variant<T, T*> storage_;
 
    NEFORCE_NODISCARD T& value() { return _NEFORCE get<0>(storage_); }
    NEFORCE_NODISCARD const T& value() const { return _NEFORCE get<0>(storage_); }
    NEFORCE_NODISCARD T* pointer() const { return _NEFORCE get<1>(storage_); }
};

template <typename T>
class const_ref {
public:
    const_ref() :
    storage_(T{}) {}

    const_ref(T value) :
    storage_(_NEFORCE move(value)) {}

    const_ref(const T* ptr) :
    storage_(ptr) {}

    const T& operator*() const {
        if (holds_pointer()) {
            return *_NEFORCE get<1>(storage_);
        }
        return _NEFORCE get<0>(storage_);
    }

    const T* operator->() const { return &operator*(); }

    const T& operator()() const { return operator*(); }

    NEFORCE_NODISCARD bool holds_pointer() const noexcept { return storage_.index() == 1; }
 
private:
    _NEFORCE variant<T, const T*> storage_;
};

class string_ref : public ref<string> {
public:
    using ref<string>::ref;

    string_ref(const char* s) :
    ref(string(s)) {}

    string_ref(string_view sv) :
    ref(string(sv)) {}

    string_ref(const wchar_t* ws) :
    ref(to_string(ws)) {}
};

class const_string_ref : public const_ref<string> {
public:
    using const_ref<string>::const_ref;

    const_string_ref(const char* s) :
    const_ref(string(s)) {}

    const_string_ref(string_view sv) :
    const_ref(string(sv)) {}
};
 // TUI
 
NEFORCE_END_TUI__
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_TUI_DOM_REF_HPP__