reflect-cpp/include/rfl/Attribute.hpp at a344de03e7a8c547e8aff1819ff36b64a9ffd958 · getml/reflect-cpp · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
#ifndef RFL_ATTRIBUTE_HPP_
#define RFL_ATTRIBUTE_HPP_

#include <algorithm>
#include <string_view>
#include <tuple>
#include <type_traits>
#include <utility>

#include "Literal.hpp"
#include "default.hpp"

namespace rfl {

template <class T>
struct Attribute {
  using Type = T;
  using ReflectionType = T;

  Attribute() : value_(Type()) {}

  Attribute(const Type& _value) : value_(_value) {}

  Attribute(Type&& _value) noexcept : value_(std::move(_value)) {}

  Attribute(Attribute<T>&& _attr) noexcept = default;

  Attribute(const Attribute<Type>& _attr) = default;

  template <class U>
  Attribute(const Attribute<U>& _attr) : value_(_attr.get()) {}

  template <class U>
  Attribute(Attribute<U>&& _attr) : value_(_attr.get()) {}

  template <class U>
    requires std::is_convertible_v<U, Type>
  Attribute(const U& _value) : value_(_value) {}

  template <class U>
    requires std::is_convertible_v<U, Type>
  Attribute(U&& _value) noexcept : value_(std::forward<U>(_value)) {}

  template <class U>
    requires std::is_convertible_v<U, Type>
  Attribute(const Attribute<U>& _attr) : value_(_attr.value()) {}

  /// Assigns the underlying object to its default value.
  template <class U = Type>
    requires std::is_default_constructible_v<U>
  Attribute(const Default&) : value_(Type()) {}

  ~Attribute() = default;

  /// Returns the underlying object.
  const Type& get() const { return value_; }

  /// Returns the underlying object.
  Type& operator()() { return value_; }

  /// Returns the underlying object.
  const Type& operator()() const { return value_; }

  /// Assigns the underlying object.
  auto& operator=(const Type& _value) {
    value_ = _value;
    return *this;
  }

  /// Assigns the underlying object.
  auto& operator=(Type&& _value) noexcept {
    value_ = std::move(_value);
    return *this;
  }

  /// Assigns the underlying object.
  template <class U>
    requires std::is_convertible_v<U, Type>
  auto& operator=(const U& _value) {
    value_ = _value;
    return *this;
  }

  /// Assigns the underlying object to its default value.
  template <class U = Type>
    requires std::is_default_constructible_v<U>
  auto& operator=(const Default&) {
    value_ = Type();
    return *this;
  }

  /// Assigns the underlying object.
  Attribute<T>& operator=(const Attribute<T>& _attr) = default;

  /// Assigns the underlying object.
  Attribute<T>& operator=(Attribute<T>&& _attr) = default;

  /// Assigns the underlying object.
  template <class U>
  auto& operator=(const Attribute<U>& _attr) {
    value_ = _attr.get();
    return *this;
  }

  /// Assigns the underlying object.
  template <class U>
  auto& operator=(Attribute<U>&& _attr) {
    value_ = std::forward<T>(_attr.value_);
    return *this;
  }

  /// We want all parsers other than the XML parser to treat attributes like
  /// normal fields, so we just implement the reflection interface.
  const ReflectionType& reflection() const { return value_; }

  /// Assigns the underlying object.
  void set(const Type& _value) { value_ = _value; }

  /// Assigns the underlying object.
  void set(Type&& _value) { value_ = std::move(_value); }

  /// Returns the underlying object.
  Type& value() { return value_; }

  /// Returns the underlying object.
  const Type& value() const { return value_; }

  /// The underlying value.
  Type value_;
};

}  // namespace rfl

#endif