Merge pull request #74 from NuiCpp/devel

Important fix to make Observed<> ctor explicit
NuiCpp · Sep 15, 2023 · 1e1ee1a · 1e1ee1a
2 parents 5283fc0 + 8138bdc
commit 1e1ee1a
Show file tree

Hide file tree

Showing 14 changed files with 186 additions and 96 deletions.
diff --git a/nui/include/nui/frontend/attributes/impl/attribute.hpp b/nui/include/nui/frontend/attributes/impl/attribute.hpp
@@ -23,6 +23,7 @@ namespace Nui
             std::string data;
         };
 
+        Attribute() = default;
         Attribute(
             std::function<void(Dom::ChildlessElement&)> setter,
             std::function<EventContext::EventIdType(std::weak_ptr<Dom::ChildlessElement>&& element)> createEvent = {},
@@ -67,8 +68,8 @@ namespace Nui
         bool isStringData() const;
 
       private:
-        std::variant<RegularAttribute, StringDataAttribute> attributeImpl_;
-        std::function<EventContext::EventIdType(std::weak_ptr<Dom::ChildlessElement>&& element)> createEvent_;
-        std::function<void(EventContext::EventIdType const&)> clearEvent_;
+        std::variant<std::monostate, RegularAttribute, StringDataAttribute> attributeImpl_{};
+        std::function<EventContext::EventIdType(std::weak_ptr<Dom::ChildlessElement>&& element)> createEvent_{};
+        std::function<void(EventContext::EventIdType const&)> clearEvent_{};
     };
 }
diff --git a/nui/include/nui/frontend/components/dialog.hpp b/nui/include/nui/frontend/components/dialog.hpp
@@ -32,11 +32,11 @@ namespace Nui::Components
 
         struct ConstructionArgs
         {
-            Observed<std::optional<std::string>> className = std::nullopt;
-            Observed<std::string> title = "";
-            Observed<std::string> body = "";
-            Observed<std::string> buttonClassName = "";
-            Observed<ButtonConfiguration> buttonConfiguration = ButtonConfiguration::Ok;
+            std::optional<std::string> className{std::nullopt};
+            std::string title{""};
+            std::string body{""};
+            std::string buttonClassName{""};
+            ButtonConfiguration buttonConfiguration{ButtonConfiguration::Ok};
             std::function<void(Button)> onButtonClicked = [](Button) {};
         };
 
@@ -107,6 +107,11 @@ namespace Nui::Components
       private:
         bool isOpen_;
         std::weak_ptr<Dom::Element> element_;
-        ConstructionArgs args_;
+        Observed<std::optional<std::string>> className_;
+        Observed<std::string> title_;
+        Observed<std::string> body_;
+        Observed<std::string> buttonClassName_;
+        Observed<ButtonConfiguration> buttonConfiguration_;
+        std::function<void(Button)> onButtonClicked_;
     };
 }
diff --git a/nui/include/nui/frontend/dom/basic_element.hpp b/nui/include/nui/frontend/dom/basic_element.hpp
@@ -13,7 +13,7 @@ namespace Nui::Dom
     class BasicElement : public std::enable_shared_from_this<BasicElement>
     {
       public:
-        BasicElement(Nui::val val)
+        explicit BasicElement(Nui::val val)
             : element_{std::move(val)}
         {}
         virtual ~BasicElement() = default;

diff --git a/nui/include/nui/frontend/dom/childless_element.hpp b/nui/include/nui/frontend/dom/childless_element.hpp
@@ -4,6 +4,10 @@
 #include <nui/frontend/elements/impl/html_element.hpp>
 #include <nui/frontend/utility/functions.hpp>
 
+#include <optional>
+#include <string>
+#include <string_view>
+
 namespace Nui::Dom
 {
     /**
@@ -13,10 +17,10 @@ namespace Nui::Dom
     class ChildlessElement : public BasicElement
     {
       public:
-        ChildlessElement(HtmlElement const& elem)
+        explicit ChildlessElement(HtmlElement const& elem)
             : BasicElement{ChildlessElement::createElement(elem)}
         {}
-        ChildlessElement(Nui::val val)
+        explicit ChildlessElement(Nui::val val)
             : BasicElement{std::move(val)}
         {}
 

diff --git a/nui/include/nui/frontend/dom/element.hpp b/nui/include/nui/frontend/dom/element.hpp
@@ -46,13 +46,13 @@ namespace Nui::Dom
         using const_iterator = collection_type::const_iterator;
         using value_type = collection_type::value_type;
 
-        Element(HtmlElement const& elem)
+        explicit Element(HtmlElement const& elem)
             : ChildlessElement{elem}
             , children_{}
             , unsetup_{}
         {}
 
-        Element(Nui::val val)
+        explicit Element(Nui::val val)
             : ChildlessElement{std::move(val)}
             , children_{}
             , unsetup_{}

diff --git a/nui/include/nui/frontend/dom/reference.hpp b/nui/include/nui/frontend/dom/reference.hpp
@@ -13,7 +13,7 @@ namespace Nui::Dom
     struct ReferencePasser
     {
       public:
-        ReferencePasser(T&& func)
+        explicit ReferencePasser(T&& func)
             : func_{std::move(func)}
         {}
         void operator()(std::weak_ptr<BasicElement>&& weakElement) const

diff --git a/nui/include/nui/frontend/event_system/observed_value.hpp b/nui/include/nui/frontend/event_system/observed_value.hpp
@@ -168,10 +168,22 @@ namespace Nui
             }
             return *this;
         };
+        ModifiableObserved& operator=(ContainedT const& contained)
+        {
+            contained_ = contained;
+            update();
+            return *this;
+        }
+        ModifiableObserved& operator=(ContainedT&& contained)
+        {
+            contained_ = std::move(contained);
+            update();
+            return *this;
+        }
         ~ModifiableObserved() = default;
 
         template <typename T = ContainedT>
-        ModifiableObserved(T&& t)
+        explicit ModifiableObserved(T&& t)
             : contained_{std::forward<T>(t)}
         {}
 
@@ -316,9 +328,14 @@ namespace Nui
             {
                 return ref_;
             }
-            void operator=(T&& ref)
+            void operator=(T&& val)
+            {
+                ref_ = std::move(val);
+                owner_->insertRangeChecked(pos_, pos_, RangeStateType::Modify);
+            }
+            void operator=(T const& val)
             {
-                ref_ = std::forward<T>(ref);
+                ref_ = val;
                 owner_->insertRangeChecked(pos_, pos_, RangeStateType::Modify);
             }
 
@@ -527,12 +544,12 @@ namespace Nui
             , afterEffectId_{registerAfterEffect()}
         {}
         template <typename T = ContainerT>
-        ObservedContainer(T&& t)
+        explicit ObservedContainer(T&& t)
             : ModifiableObserved<ContainerT>{std::forward<T>(t)}
             , rangeContext_{static_cast<long>(contained_.size())}
             , afterEffectId_{registerAfterEffect()}
         {}
-        ObservedContainer(RangeEventContext&& rangeContext)
+        explicit ObservedContainer(RangeEventContext&& rangeContext)
             : ModifiableObserved<ContainerT>{}
             , rangeContext_{std::move(rangeContext)}
             , afterEffectId_{registerAfterEffect()}
@@ -987,6 +1004,17 @@ namespace Nui
         using ModifiableObserved<T>::ModifiableObserved;
         using ModifiableObserved<T>::operator=;
         using ModifiableObserved<T>::operator->;
+
+        Observed& operator=(T const& contained)
+        {
+            ModifiableObserved<T>::operator=(contained);
+            return *this;
+        }
+        Observed& operator=(T&& contained)
+        {
+            ModifiableObserved<T>::operator=(std::move(contained));
+            return *this;
+        }
     };
     template <typename... Parameters>
     class Observed<std::vector<Parameters...>> : public ObservedContainer<std::vector<Parameters...>>
@@ -996,6 +1024,17 @@ namespace Nui
         using ObservedContainer<std::vector<Parameters...>>::operator=;
         using ObservedContainer<std::vector<Parameters...>>::operator->;
         static constexpr auto isRandomAccess = true;
+
+        Observed<std::vector<Parameters...>>& operator=(std::vector<Parameters...> const& contained)
+        {
+            ObservedContainer<std::vector<Parameters...>>::operator=(contained);
+            return *this;
+        }
+        Observed<std::vector<Parameters...>>& operator=(std::vector<Parameters...>&& contained)
+        {
+            ObservedContainer<std::vector<Parameters...>>::operator=(std::move(contained));
+            return *this;
+        }
     };
     template <typename... Parameters>
     class Observed<std::deque<Parameters...>> : public ObservedContainer<std::deque<Parameters...>>
@@ -1005,6 +1044,17 @@ namespace Nui
         using ObservedContainer<std::deque<Parameters...>>::operator=;
         using ObservedContainer<std::deque<Parameters...>>::operator->;
         static constexpr auto isRandomAccess = true;
+
+        Observed<std::deque<Parameters...>>& operator=(std::deque<Parameters...> const& contained)
+        {
+            ObservedContainer<std::deque<Parameters...>>::operator=(contained);
+            return *this;
+        }
+        Observed<std::deque<Parameters...>>& operator=(std::deque<Parameters...>&& contained)
+        {
+            ObservedContainer<std::deque<Parameters...>>::operator=(std::move(contained));
+            return *this;
+        }
     };
     template <typename... Parameters>
     class Observed<std::basic_string<Parameters...>> : public ObservedContainer<std::basic_string<Parameters...>>
@@ -1015,6 +1065,17 @@ namespace Nui
         using ObservedContainer<std::basic_string<Parameters...>>::operator->;
         static constexpr auto isRandomAccess = true;
 
+        Observed<std::basic_string<Parameters...>>& operator=(std::basic_string<Parameters...> const& contained)
+        {
+            ObservedContainer<std::basic_string<Parameters...>>::operator=(contained);
+            return *this;
+        }
+        Observed<std::basic_string<Parameters...>>& operator=(std::basic_string<Parameters...>&& contained)
+        {
+            ObservedContainer<std::basic_string<Parameters...>>::operator=(std::move(contained));
+            return *this;
+        }
+
         Observed<std::basic_string<Parameters...>>& erase(std::size_t index = 0, std::size_t count = std::string::npos)
         {
             const auto sizeBefore = this->contained_.size();
@@ -1027,18 +1088,32 @@ namespace Nui
     class Observed<std::set<Parameters...>> : public ObservedContainer<std::set<Parameters...>>
     {
       public:
+        using ObservedContainer<std::set<Parameters...>>::ObservedContainer;
+        using ObservedContainer<std::set<Parameters...>>::operator=;
+        using ObservedContainer<std::set<Parameters...>>::operator->;
         static constexpr auto isRandomAccess = false;
 
       public:
         Observed()
             : ObservedContainer<std::set<Parameters...>>{RangeEventContext{0, true}}
         {}
         template <typename T = std::set<Parameters...>>
-        Observed(T&& t)
+        explicit Observed(T&& t)
             : ObservedContainer<std::set<Parameters...>>{
                   std::forward<T>(t),
                   RangeEventContext{static_cast<long>(t.size()), true}}
         {}
+
+        Observed<std::set<Parameters...>>& operator=(std::set<Parameters...> const& contained)
+        {
+            ObservedContainer<std::set<Parameters...>>::operator=(contained);
+            return *this;
+        }
+        Observed<std::set<Parameters...>>& operator=(std::set<Parameters...>&& contained)
+        {
+            ObservedContainer<std::set<Parameters...>>::operator=(std::move(contained));
+            return *this;
+        }
     };
 
     template <typename ContainerT>
@@ -1118,7 +1193,7 @@ namespace Nui
         struct CopiableObservedWrap // minimal wrapper to make Observed<T> copiable
         {
           public:
-            constexpr CopiableObservedWrap(Observed<T> const& observed)
+            explicit constexpr CopiableObservedWrap(Observed<T> const& observed)
                 : observed_{&observed}
             {}
 

diff --git a/nui/include/nui/frontend/event_system/observed_value_combinator.hpp b/nui/include/nui/frontend/event_system/observed_value_combinator.hpp
@@ -12,10 +12,10 @@ namespace Nui
     class ObservedValueCombinatorBase
     {
       public:
-        constexpr ObservedValueCombinatorBase(ObservedValues const&... observedValues)
+        explicit constexpr ObservedValueCombinatorBase(ObservedValues const&... observedValues)
             : observedValues_{observedValues...}
         {}
-        constexpr ObservedValueCombinatorBase(std::tuple<ObservedValues const&...> observedValues)
+        explicit constexpr ObservedValueCombinatorBase(std::tuple<ObservedValues const&...> observedValues)
             : observedValues_{std::move(observedValues)}
         {}
 

diff --git a/nui/include/nui/frontend/event_system/range.hpp b/nui/include/nui/frontend/event_system/range.hpp
@@ -6,7 +6,7 @@ namespace Nui
     class ObservedRange
     {
       public:
-        constexpr ObservedRange(ObservedValue& observedValues)
+        explicit constexpr ObservedRange(ObservedValue& observedValues)
             : observedValue_{observedValues}
         {}
 

diff --git a/nui/include/nui/frontend/event_system/range_event_context.hpp b/nui/include/nui/frontend/event_system/range_event_context.hpp
@@ -182,7 +182,7 @@ namespace Nui
     class RangeEventContext
     {
       public:
-        RangeEventContext(long dataSize)
+        explicit RangeEventContext(long dataSize)
             : modificationRanges_{}
             , fullRangeUpdate_{true}
             , disableOptimizations_{false}