component_base.cppm

Go to the documentation of this file.

// Copyright (c) 2024, Víctor Castillo Agüero.
// SPDX-License-Identifier: GPL-3.0-or-later
 
module;
#include <__stddef_offsetof.h>
#include "cyd_fabric_modules/headers/macros/async_events.h"
 
#define STYLE_SETTER_RETURN_TYPE void
#define STYLE_SETTER_RETURN_EXPR
#include "../style_setters_detail.h"
 
export module cydui.components.base;
 
import std;
 
import fabric.logging;
import fabric.async;
import fabric.templates.functor_arguments;
 
export import cydui.graphics;
export import cydui.styling;
export import cydui.components.base.style;
export import cydui.components.base.identifier;
 
export import :type;
export import :event_dispatcher;
export import :attributes;
export import :contexts;
export import :state;
 
namespace cydui::components {
  export class component_base_t {
  public:
    using sptr = std::shared_ptr<component_base_t>;
    using wptr = std::weak_ptr<component_base_t>;
 
  public:
    explicit component_base_t(identifier_t identifier = {})
        : id_(identifier) { }
 
    virtual ~component_base_t() = default; //{
    //  ! All of this is done in the `component_t` class destructor
    //  clear_subscribed_listeners();
    //  if (state.has_value()) {
    //    state.value()->component_instance = std::nullopt;
    //  }
    //}
    virtual void* get_props() = 0;
 
    virtual component_base_t* find_by_coords(dimension_t::value_type x, dimension_t::value_type y) = 0;
 
    virtual component_dimensional_relations_t get_dimensional_relations() = 0;
    virtual std::shared_ptr<dimension_ctx_t> get_dimensional_context() = 0;
 
    virtual const refl::type_info& get_style_type_info() const = 0;
 
    virtual attrs_component<>* attrs() = 0;
    virtual std::string name() const = 0;
 
  private:
    virtual std::shared_ptr<component_state_t> create_state_instance() = 0;

    virtual bool update_with(std::shared_ptr<component_base_t> other) = 0;
 
    virtual void mount() = 0;
    virtual void dismount() = 0;
 
  public:
    component_state_ref state() const {
      if (state_.has_value()) {
        return state_.value().lock();
      } else {
        return {nullptr};
      }
    }
 
    template <typename T>
    auto& get_data() {
      using type = std::remove_const_t<std::remove_reference_t<T>>;
      static auto tid = refl::type_id<type>;
 
      if (not data_map_.contains(tid)) {
        data_map_[tid] = refl::any::make<type>();
      }
 
      return data_map_.at(tid).template as<type>();
    }
 
    template <typename T>
    bool remove_data() {
      using type = std::remove_const_t<std::remove_reference_t<T>>;
      static auto tid = refl::type_id<type>;
 
      if (data_map_.contains(tid)) {
        data_map_.erase(tid);
        return true;
      }
      return false;
    }
 
    template<typename ContextType>
    void add_context(provide_context<ContextType>& ptr) {
      context_store_.add_context<ContextType>(ptr);
    }
 
    template<typename ContextType>
    std::optional<ContextType*> find_context() {
      if (not context_store_.empty()) {
        auto context = context_store_.find_context<ContextType>();
        if (context.has_value()) {
          return context;
        }
      }
 
      if (parent.has_value()) {
        return parent.value()->find_context<ContextType>();
      }
 
      return std::nullopt;
    }
 
    internal_relations_t& get_internal_relations() {
      return internal_relations;
    }
 
    event_dispatcher_base_t* get_event_dispatcher() {
      return event_dispatcher.has_value()? event_dispatcher.value().get(): nullptr;
    }
 
    style_base_t& get_style() {
      return style_data->as_base();
    }
 
    style_data_base_t& get_style_data() {
      return *(style_data.get());
    }
 
 
    void clear_children() {
      children.clear();
    }
 
    void set_id(const std::string& id) {
      id_.set_id(id);
    }
 
    std::string get_id() {
      return id_.str();
    }
 
    std::string get_id() const {
      return id_.str();
    }
 
    void tag(const std::string& tag_) {
      style_data->tags.insert(tag_);
    }
 
    void untag(const std::string& tag_) {
      style_data->tags.erase(tag_);
    }
 
    bool has_tag(const std::string& tag_) const {
      return style_data->tags.contains(tag_);
    }
 
    std::optional<sptr> find_child(const std::string& id) {
      for (const auto & child : children) {
        if (child->get_id() == id) {
          return child;
        }
        auto descendant = child->find_child(id);
        if (descendant.has_value()) {
          return descendant;
        }
      }
      return std::nullopt;
    }
 
    std::list<sptr> find_children(const std::string& id) {
      std::list<sptr> result{};
      for (const auto & child : children) {
        if (child->get_id() == id) {
          result.push_back(child);
        }
        auto descendants = child->find_children(id);
        for (const auto & d : descendants) {
          result.push_back(d);
        }
      }
      return result;
    }
 
#include "../style_setters.inc"
 
  protected:
    void set_state(const component_state_ref& state) {
      state_ = state;
    }
 
  private:
    friend class ::with_context;
 
    template<typename ContextType>
    friend struct cydui::provide_context;
 
    template<typename ContextType>
    void add_context(const std::shared_ptr<ContextType> &ptr) {
      context_store_.add_context<ContextType>(ptr);
    }
 
    auto& get_context_store() {
      return context_store_;
    }
 
  public:
    friend struct component_actor_t;
 
    std::optional<component_base_t*> parent = std::nullopt;
    std::list<std::shared_ptr<component_base_t>> children{};
 
  protected:
    internal_relations_t internal_relations{};
    [[refl::ignore]]
    std::optional<std::shared_ptr<event_dispatcher_base_t>> event_dispatcher{std::nullopt};
    std::shared_ptr<style_data_base_t> style_data{};
 
  private:
    std::optional<std::weak_ptr<component_state_t>> state_ = std::nullopt;
    context_store_t context_store_{};
    std::unordered_map<refl::type_id_t, refl::any> data_map_ { };
 
    identifier_t id_{};
  };
 
  struct component_actor_t {
    static void set_component_state(component_base_t* component, component_state_ref state) {
      component->set_state(state);
    }
    static std::shared_ptr<component_state_t> create_state_instance(component_base_t* component) {
      return component->create_state_instance();
    }
 
    static bool update_component_with(component_base_t* component, std::shared_ptr<component_base_t> other) {
      return component->update_with(other);
    }
 
    static void mount_component(component_base_t* component) {
      component->mount();
    }
    static void dismount_component(component_base_t* component) {
      component->dismount();
    }
  };
}
 
template<typename ContextType>
cydui::components::component_holder_t cydui::provide_context<ContextType>::operator >(with_context &&components) {
  auto holder = components.build();
 
  for (auto &c: holder.get_components()) {
    if (not c->get_context_store().find_context<ContextType>().has_value()) {
      c->add_context(context_);
    }
  }
 
  return holder;
}