Cherry changes october (#198)

Overview: Minor improvements, fixes and additions across engine libraries.

Features:
* Introduced 'ownership' concept for Widgets in DevUI library.
* Introduced new query operation 'try_entity'
 * Returns same data as 'for_entity' but allows to fail the operation.
* Extended asset category API.
  * May define 'extension_for_state' function to map 'State' to file extension.

Additions:
* Added a new 'Ptr' type that tracks ref-counted objects.
* Added new functions 'cbegin' and 'cend' for 'HeapVarString' types.
* Added new sort function 'sort_many' to sort any number of arrays based on the first.
* Added additional utility functions: 'less' and 'equal'
* Added formatter to 'ice::Expected' type.
* Added missing construtcors to 'Color' type.

Changes:
* Improved Error tracking for "ResourceWriter" types.
* Separated an 'IDevUIWidget' interface from the 'DevUIWidget' type.
* Initial attempt on Styling the Dev UI.
* Renamed worker threads from 'ice.thread' to 'ice.worker'

Fixes:
* Fixed 'Color' not always properly translating from 'float' to 'int' representations.
* Fixed 'TaskExpected' types not passing 'Error' value when the 'Result' value was different.
* Fixed build errors due to duplicate symbols in logger library.
* Fixed ImGui being loaded even when not used.

Author: Dandielo

source/code/core/collections/public/ice/container_types.hxx

@@ -15,7 +15,7 @@ namespace ice
     //! \details Manages a memory block big enough to hold the items that it holds.
     //!
     //! \tparam Logic The logic used during memory operations for the given type.
-    //!   This value is set by the user to enforce expected behavior for stored types.
+    //!   This value cab be set by the user to enforce expected behavior for stored types.
     template<typename Type, ice::ContainerLogic Logic = ice::Constant_DefaultContainerLogic<Type>>
     struct Array
     {

source/code/core/collections/public/ice/sort.hxx

@@ -162,6 +162,35 @@ namespace ice
             return i + 1;
         }
 
+        template<typename Pred, typename Key, typename... Values>
+        inline auto qsort_partition_many(
+            Pred&& pred,
+            ice::i32 left,
+            ice::i32 right,
+            ice::Span<Key> keys,
+            ice::Span<Values>... values
+        ) noexcept -> ice::i32
+        {
+            Key* pivot = &keys[right];
+
+            ice::i32 i = left - 1;
+            ice::i32 j = left;
+
+            while (j < right)
+            {
+                if (ice::forward<Pred>(pred)(keys[j], *pivot))
+                {
+                    ++i;
+                    ice::swap(keys[i], keys[j]);
+                    (ice::swap(values[i], values[j]), ...);
+                }
+                ++j;
+            }
+            ice::swap(keys[i + 1], keys[right]);
+            (ice::swap(values[i + 1], values[right]), ...);
+            return i + 1;
+        }
+
         template<typename K, typename Pred>
         inline auto qsort_partition_indices(ice::Span<K> keys, ice::Span<ice::u32>& indices, Pred&& pred, ice::i32 left, ice::i32 right) noexcept -> ice::i32
         {
@@ -200,6 +229,27 @@ namespace ice
             }
         }
 
+        template<typename Pred, typename Key, typename... Values>
+        inline void qsort_many(
+            Pred&& pred,
+            ice::i32 left,
+            ice::i32 right,
+            ice::Span<Key> keys,
+            ice::Span<Values>... values
+        ) noexcept
+        {
+            while (left < right)
+            {
+                ice::i32 const pi = qsort_partition_many<Pred, Key, Values...>(
+                    ice::forward<Pred>(pred), left, right, keys, values...
+                );
+
+                ice::detail::qsort_many(ice::forward<Pred>(pred), left, pi - 1, keys, values...);
+
+                left = pi + 1;
+            }
+        }
+
         template<typename K, typename Pred>
         inline void qsort_indices(ice::Span<K> keys, ice::Span<ice::u32> indices, Pred&& pred, ice::i32 left, ice::i32 right) noexcept
         {
@@ -236,6 +286,16 @@ namespace ice
         ice::detail::qsort(keys, values, std::forward<Pred>(pred), first_index, last_index);
     }
 
+    template<typename Key, typename Pred, typename... Values>
+        requires ice::concepts::ComparisonFunction<Pred, Key, Key>
+    inline void sort_many(ice::Span<Key> keys, Pred&& pred, ice::Span<Values>... values) noexcept
+    {
+        ice::i32 const first_index = 0;
+        ice::i32 const last_index = ice::count(keys) - 1;
+
+        ice::detail::qsort_many(std::forward<Pred>(pred), first_index, last_index, keys, values...);
+    }
+
     template<typename K, typename Pred>
     inline void sort_indices(ice::Span<K> keys, ice::Span<ice::u32> indices, Pred&& pred) noexcept
     {

source/code/core/collections/public/ice/string/heap_var_string.hxx

@@ -17,6 +17,12 @@ namespace ice::string
     template<typename CharType>
     inline auto end(ice::HeapVarString<CharType>& str) noexcept -> typename ice::HeapVarString<CharType>::Iterator;
 
+    template<typename CharType>
+    inline auto cbegin(ice::HeapVarString<CharType> const& str) noexcept -> typename ice::HeapVarString<CharType>::ConstIterator;
+
+    template<typename CharType>
+    inline auto cend(ice::HeapVarString<CharType> const& str) noexcept -> typename ice::HeapVarString<CharType>::ConstIterator;
+
     template<typename CharType>
     inline auto rbegin(ice::HeapVarString<CharType>& str) noexcept -> typename ice::HeapVarString<CharType>::ReverseIterator;
 

source/code/core/collections/public/ice/string/impl/heap_var_string.inl

@@ -147,6 +147,20 @@ namespace ice
             return str._data + bytes + size;
         }
 
+        template<typename CharType>
+        inline auto cbegin(ice::HeapVarString<CharType>& str) noexcept -> typename ice::HeapVarString<CharType>::ConstIterator
+        {
+            return ice::string::detail::data_varstring(str._data);
+        }
+
+        template<typename CharType>
+        inline auto cend(ice::HeapVarString<CharType>& str) noexcept -> typename ice::HeapVarString<CharType>::ConstIterator
+        {
+            ice::ucount bytes;
+            ice::ucount const size = ice::string::detail::read_varstring_size(str._data, bytes);
+            return str._data + bytes + size;
+        }
+
         template<typename CharType>
         auto deserialize(ice::HeapVarString<CharType>& str, ice::Data data) noexcept -> ice::Data
         {

source/code/core/core/public/ice/shard.hxx

@@ -10,7 +10,7 @@ namespace ice
 
     //! \brief Small value object able to pass up to 8 bytes of data accross the engine.
     //!
-    //! \detail A single shard is always 16 bytes in size.
+    //! \details A single shard is always 16 bytes in size.
     //!   The first 4 bytes represent the name <em>(ice::ShardID)</em> and the next four the typeid <em>(ice::ShardPayloadID)</em> of the carried data.
     //!   Because this object is designed to only pass small values it's mostly used to carry pointers to constant objects living in a frame.
     //!
@@ -29,7 +29,7 @@ namespace ice
 
     //! \brief Creates a ice::ShardID value from a utf8 string.
     //!
-    //! \detail The passed value can contain the name and typeid.
+    //! \details The passed value can contain the name and typeid.
     //!   To do so the names need to be separated by a '`' <em>(backquote)</em> character. For example.: `my-shard`ice::u32`
     //!
     //! \note Even if you create a ice::ShardID with a typeid that is not enabled, it will not allow you to create a shard with such a value.
@@ -40,7 +40,7 @@ namespace ice
 
     //! \brief Creates a ice::Shard value from a utf8 string and the given value.
     //!
-    //! \detail The function returns the final shard if both the definition and the typeid of the given value match.
+    //! \details The function returns the final shard if both the definition and the typeid of the given value match.
     //!   Otherwise the shard fails to create.
     //!
     //! \param[in] definition Follows the same rules described in ice::shardid(std::u8_string_view).
@@ -50,7 +50,7 @@ namespace ice
 
     //! \brief Creates a ice::Shard value from ice::ShardID and the given value.
     //!
-    //! \detail The function returns the final shard if both the shardid and the typeid of the given value match.
+    //! \details The function returns the final shard if both the shardid and the typeid of the given value match.
     //!   Otherwise the shard fails to create.
     //!
     //! \param[in] id ShardID used to create the shard.

source/code/core/core/public/ice/utility.hxx

@@ -7,6 +7,8 @@
 namespace ice
 {
 
+    using std::tuple;
+
     template<typename... Tuples>
     struct tuples_merged;
 
@@ -51,4 +53,37 @@ namespace ice
     template<typename T>
     using make_unique_tuple = typename make_unique_tuple_helper<T>::type;
 
+
+    // common functions
+
+    namespace concepts
+    {
+        template<typename Fn, typename T, typename O>
+        concept ComparisonFunction = requires(T&& a, O&& b) {
+            { std::forward<Fn>(std::declval<Fn>())(std::forward<T>(a), std::forward<O>(b)) } -> std::convertible_to<bool>;
+        };
+    }
+
+    template<typename Left, typename Right = Left>
+    constexpr auto equal(Left&& left, Right&& right) noexcept -> bool
+    {
+        return std::forward<Left>(left) == std::forward<Left>(right);
+    }
+
+    template<typename Left, typename Right = Left>
+    constexpr auto less(Left const& left, Right const& right) noexcept -> bool
+    {
+        return left < right;
+    }
+
+    // others
+
+    template <typename Field, typename Class>
+    constexpr auto offset_of(Field Class::* member) noexcept -> ice::uptr
+    {
+        return reinterpret_cast<ice::uptr>(
+            &(((Class*)0)->*member)
+        );
+    }
+
 } // namespace ice

source/code/core/devui/private/devui_context.cxx

@@ -38,7 +38,8 @@ namespace ice
     }
 
     bool devui_register_widget(
-        ice::DevUIWidget* widget
+        ice::DevUIWidget* widget,
+        ice::DevUIWidget* owning_widget
     ) noexcept
     {
         if (global_context_register_widget == nullptr)
@@ -50,7 +51,7 @@ namespace ice
             return false;
         }
 
-        global_context_register_widget(widget);
+        global_context_register_widget(widget, owning_widget);
         return true;
     }
 

source/code/core/devui/private/devui_widget.cxx

@@ -9,7 +9,8 @@ namespace ice
 {
 
     DevUIWidget::DevUIWidget(ice::DevUIWidgetInfo const& info) noexcept
-        : widget_info{ info }
+        : IDevUIWidget{ }
+        , widget_info{ info }
     {
     }
 

source/code/core/devui/public/ice/devui_context.hxx

@@ -34,7 +34,8 @@ namespace ice
     auto devui_trait_name() noexcept -> ice::StringID;
 
     bool devui_register_widget(
-        ice::DevUIWidget* widget
+        ice::DevUIWidget* widget,
+        ice::DevUIWidget* owning_widget = nullptr
     ) noexcept;
 
     bool devui_remove_widget(

source/code/core/devui/public/ice/devui_frame.hxx

@@ -9,6 +9,7 @@ namespace ice
 
     struct DevUIWidgetState
     {
+        DevUIWidgetState const* const owner = nullptr;
         bool active = false;
     };