AForEachUI.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2025 Alex2772 and Contributors
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
#pragma once
 
#include <range/v3/view/transform.hpp>
 
#include "AScrollAreaViewport.h"
#include "AViewContainer.h"
#include <AUI/Model/IListModel.h>
#include <functional>
#include <AUI/Model/AListModelAdapter.h>
#include <AUI/Util/ADataBinding.h>
#include <AUI/Platform/AWindow.h>
#include <AUI/Traits/any_view.h>
 
namespace aui::for_each_ui {

using Key = std::size_t;
 
template <typename T>
   requires requires(T& t) { std::hash<T> {}(t); }
constexpr aui::for_each_ui::Key defaultKey(const T& value, long primaryCandidate) {   // std::hash specialization
   return std::hash<T> {}(value);
}
 
template <typename T>
constexpr aui::for_each_ui::Key
defaultKey(const _<T>& value, int secondaryCandidate) {   // specialization for shared pointers
   return reinterpret_cast<std::uintptr_t>(value.get());
}
 
template <ranges::input_range T>
constexpr aui::for_each_ui::Key defaultKey(const T& value, int secondaryCandidate) {   // specialization for subranges
   auto key = std::hash<AByteBufferView>{}(AByteBufferView::fromRaw(value));
   for (const auto& i : value) {
       // sub produces order sensitive hash.
       // lshift distinguishes equal hashes.
       key = (key << 1) - defaultKey(i, 0L);
   }
   return key;
}
 
namespace detail {
struct InflateOpts {
   bool backward = true;
   bool forward = true;
};
using ViewsSharedCache = AMap<aui::for_each_ui::Key, _<AView>>;
}   // namespace detail
}   // namespace aui::for_each_ui
 
class API_AUI_VIEWS AForEachUIBase : public AViewContainerBase {
public:
   struct Entry {
       _<AView> view;
       aui::for_each_ui::Key id;
   };
 
   using List = aui::any_view<Entry>;
   AForEachUIBase() {}
   ~AForEachUIBase() override = default;
   void setPosition(glm::ivec2 position) override;
 
protected:
   struct Cache {
       struct LazyListItemInfo : Entry {
           List::iterator iterator;
       };
       AVector<LazyListItemInfo> items;
   };
 
   AOptional<Cache> mCache;
 
   void onViewGraphSubtreeChanged() override;
   void applyGeometryToChildren() override;

   void setModelImpl(List model);

   virtual aui::for_each_ui::detail::ViewsSharedCache* getViewsCache() = 0;
 
private:
   _weak<AScrollAreaViewport> mViewport;
   List mViewsModel;
   aui::dyn_range_capabilities mViewsModelCapabilities;
   AOptional<glm::ivec2> mLastInflatedScroll {};
 
   void addView(List::iterator iterator, AOptional<std::size_t> index = std::nullopt);
   void removeViews(aui::range<AVector<_<AView>>::iterator> iterators);
 
   void inflate(aui::for_each_ui::detail::InflateOpts opts = {});
   glm::ivec2 calculateOffsetWithinViewportSlidingSurface();
   glm::ivec2 axisMask();
   void putOurViewsToSharedCache();
 
};
 
namespace aui::detail {
template <typename Factory, typename T>
concept RangeFactory = requires(Factory&& factory) {
   { factory } -> aui::invocable;
   { factory() } -> aui::range_consisting_of<T>;
};
}   // namespace aui::detail
 

template <typename T>
class AForEachUI : public AForEachUIBase, public aui::react::DependencyObserver {
public:
   friend class UIDeclarativeForTest;
 
   static_assert(
       requires(T& t) { aui::for_each_ui::defaultKey(t, 0L); },
       "// ====================> AForEachUI: aui::for_each_ui::defaultKey overload or std::hash specialization is "
       "required for your type.");
 
   using List = AForEachUIBase::List;
   using ListFactory = std::function<List()>;
   using ViewFactory = std::function<_<AView>(const T& value)>;
 
   AForEachUI() {}
   ~AForEachUI() override = default;
 
   template <aui::detail::RangeFactory<T> RangeFactory>
   AForEachUI(RangeFactory&& rangeFactory) {
       this->setModel(std::forward<RangeFactory>(rangeFactory));
   }
 
   template <aui::detail::RangeFactory<T> RangeFactory>
   void setModel(RangeFactory&& rangeFactory) {
       mListFactory = [this, rangeFactory = std::forward<RangeFactory>(rangeFactory)] {
//            ALOG_DEBUG("AForEachUIBase") << this << "(" << AReflect::name(this) << ") range expression evaluation";
           aui::react::DependencyObserverRegistrar r(*this);
           decltype(auto) rng = rangeFactory();
           if (auto it = ranges::begin(rng); it != ranges::end(rng)) {
               [[maybe_unused]] auto discoverReferencedProperties = *it;
           }
           return rng | ranges::views::transform([this](const T& t) {
                      auto key = aui::for_each_ui::defaultKey(t, 0L);
                      _<AView> view;
                      if (mViewsSharedCache) {
                          if (auto c = mViewsSharedCache->contains(key)) {
//                               ALOG_DEBUG("AForEachUIBase")
//                                   << this << "(" << AReflect::name(this) << ") Trying to view from cache: " << key;
                              view = std::move(c->second);
                              mViewsSharedCache->erase(c);
                          }
                      }
                      if (!view) {
                          view = mFactory(t);
                      }
                      return AForEachUIBase::Entry { .view = std::move(view), .id = key };
                  });
       };
   }

   template <aui::invocable<const T&> ViewFactoryT>
   void operator-(ViewFactoryT&& f) {
       mFactory = std::forward<ViewFactoryT>(f);
       mViewsSharedCache = &VIEWS_SHARED_CACHE<ViewFactoryT>;
       updateUnderlyingModel();
   }

   void invalidate() override {
//        ALOG_DEBUG("AForEachUIBase") << this << "(" << AReflect::name(this) << ") invalidate";
       updateUnderlyingModel();
   }
 
   using AViewContainerBase::setLayout;
 
protected:
 
   aui::for_each_ui::detail::ViewsSharedCache* getViewsCache() override { return mViewsSharedCache; }
 
private:
   template <typename FactoryTypeTag>
   static aui::for_each_ui::detail::ViewsSharedCache VIEWS_SHARED_CACHE;
 
   aui::for_each_ui::detail::ViewsSharedCache* mViewsSharedCache = nullptr;
   ListFactory mListFactory;
   ViewFactory mFactory;
 
   void updateUnderlyingModel() {
       if (!mFactory) {
           return;
       }
 
       this->setModelImpl(mListFactory());
   }
};
 
template <typename T>
template <typename FactoryTypeTag>
aui::for_each_ui::detail::ViewsSharedCache AForEachUI<T>::VIEWS_SHARED_CACHE {};
 
namespace aui::detail {
 
template <typename Layout, aui::invocable RangeFactory>
auto makeForEach(RangeFactory&& rangeFactory)
   requires requires {
       { rangeFactory() } -> ranges::range;
   }
{
   using ImmediateValueType = decltype([&]() -> decltype(auto) {
       decltype(auto) rng = rangeFactory();
       return *ranges::begin(rng);
   }());
 
   // | is_reference<ImmediateValueType> | is_const<ImmediateValueType> |   |
   // | -------------------------------- | ---------------------------- | - |
   // | 0                                | 0                            | 1 |
   // | 0                                | 1                            | 1 |
   // | 1                                | 0                            | 0 |
   // | 1                                | 1                            | 1 |
   //
   // This ensures that a borrowed container is constant, and throws a compile-time diagnostics if is not in most
   // scenarios:
   // ```cpp
   // class MyWindow {
   //   void test() {
   //     AUI_DECLARATIVE_FOR(i, ints, ... // error; mark ints as const
   //   }
   //   AVector<int> ints = { 1, 2, 3 };
   // };
   // ```
   //
   // The only known case where this check does not work:
   // ```cpp
   // class MyWindow {
   //   void test() {
   //     AUI_DECLARATIVE_FOR(i, ints | ranges::views::transform([](int i) { return true; }), ... // bad but compiles
   //   }
   //   AVector<int> ints = { 1, 2, 3 };
   // };
   // ```
   static_assert(!std::is_reference_v<ImmediateValueType> || std::is_const_v<std::remove_reference_t<ImmediateValueType>>,
                 "\n"
                 "====================> AUI_DECLARATIVE_FOR: attempt to use a non-const reference. You can:\n"
                 "====================> (1) transfer ownership of the container to AUI_DECLARATIVE_FOR by referencing a local, or\n"
                 "====================> (2) define your container as const field and manually make sure its lifetime exceeds "
                 "AUI_DECLARATIVE_FOR's, or\n"
                 "====================> (3) wrap your container as AProperty.\n"
                 "====================> Please consult with https://aui-framework.github.io/develop/classAForEachUI.html#AFOREACHUI_UPDATE for more info.");
 
   using T = std::decay_t<ImmediateValueType>;
 
   auto result = _new<AForEachUI<T>>(std::forward<RangeFactory>(rangeFactory));
   result->setLayout(std::make_unique<Layout>());
   return result;
}
}   // namespace aui::detail
 
#define AUI_DECLARATIVE_FOR_EX(value, model, layout, ...)      \
   aui::detail::makeForEach<layout>([=]() -> decltype(auto) { \
       return (model);                                        \
   }) - [__VA_ARGS__](const auto& value) -> _<AView>

#define AUI_DECLARATIVE_FOR(value, model, layout) AUI_DECLARATIVE_FOR_EX(value, model, layout, =)

© 2025 AUI Framework Contributors. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. All trademarks are property of their respective owners.