factory.h

/*
 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 "factorylist.h"
#include "typelist.h"
 
namespace Ponca
{
    namespace internal
    {
        template <typename _FactoryEntries>
        struct ComputeObjectList
        {
            using FactoryEntries      = _FactoryEntries;
            static constexpr size_t N = std::tuple_size_v<FactoryEntries>;
 
            constexpr ComputeObjectList()
                : m_entries([]<std::size_t... Is>(std::index_sequence<Is...>) {
                      return FactoryEntries{std::tuple_element_t<Is, FactoryEntries>{Is}...};
                  }(std::make_index_sequence<std::tuple_size_v<FactoryEntries>>{}))
            {
            }

            template <template <typename> class... Preds>
            static decltype(auto) Filter()
            {
                using namespace Factory;
                return ComputeObjectList<typename filterList<conjunction<Preds...>, FactoryEntries>::type>{};
            };

            template <StringLiteral... Names>
            static decltype(auto) Filter()
            {
                return Filter<MethodProvider<Names>::template pred...>();
            }

            template <StringLiteral Name>
            static decltype(auto) GetMethod()
            {
                using MethodList = decltype(Filter<MethodProvider<Name>::template pred>());
                static_assert(MethodList::N == 1);
 
                // Const here to force copy in entries()!
                const MethodList list;
                return std::get<0>(list.entries()).object;
            }

            template <typename Func>
            void foreach (Func&& fun)
            {
                std::apply([&](auto&&... xs) { (fun(xs), ...); }, m_entries);
            }
 
            template <typename Func>
            void ApplyAt(size_t index, Func&& fun)
            {
                // Instead of foreach we could add some runtime helper to get the i-th element.
                // However, this adds utility and compile time generated function for the same
                // results and is not deemed worthwile at the time of writting this.
                this->foreach ([&](auto& x) {
                    if (x.id == index)
                        fun(x);
                });
            }
 
            template <typename Func>
            void ApplyAt(const char* name, Func&& fun)
            {
                // Instead of foreach we could add some runtime helper to get the i-th element.
                // However, this adds utility and compile time generated function for the same
                // results and is not deemed worthwile at the time of writting this.
                this->foreach ([&](auto& x) {
                    if (strcmp(name, x.name) == 0)
                        fun(x);
                });
            }

            constexpr static size_t size() { return N; }

            constexpr static decltype(auto) GetNames()
            {
                return []<std::size_t... Is>(std::index_sequence<Is...>) {
                    return std::array{std::tuple_element_t<Is, FactoryEntries>::name...};
                }(std::make_index_sequence<std::tuple_size_v<FactoryEntries>>{});
            }

            FactoryEntries& entries() { return m_entries; }

            FactoryEntries entries() const { return m_entries; }
 
        private:
            FactoryEntries m_entries;
        };

        template <typename _FactoryEntries>
        struct FactoryBase
        {
            using FactoryEntries        = _FactoryEntries;
            using FullComputeObjectList = ComputeObjectList<FactoryEntries>;

            template <template <typename> class... Preds>
            static decltype(auto) Filter()
            {
                return FullComputeObjectList::template Filter<Preds...>();
            }

            template <StringLiteral... Names>
            static decltype(auto) Filter()
            {
                return FullComputeObjectList::template Filter<Names...>();
            }

            template <StringLiteral Name>
            static decltype(auto) GetMethod()
            {
                return FullComputeObjectList::template GetMethod<Name>();
            }

            template <typename Func>
            static void foreach (Func&& fun)
            {
                FullComputeObjectList{}.foreach (std::forward<Func>(fun));
            }

            constexpr static size_t size() { return FullComputeObjectList::N; }

            constexpr static decltype(auto) GetNames() { return FullComputeObjectList::GetNames(); }
        };
    } // namespace internal

    template <typename P, typename NF, DiffType DerType>
    struct Factory : public internal::FactoryBase<FactoryGenericList<P, NF, DerType>>
    {
    };

    template <typename P, typename NF, DiffType DerType>
        requires Is3D<P>
    struct Factory<P, NF, DerType> : public internal::FactoryBase<Factory3DList<P, NF, DerType>>
    {
    };

    template <typename P, typename NF, DiffType DerType>
        requires Is3D<P> && (bool(DerType & DiffType::FitSpaceDer))
    struct Factory<P, NF, DerType> : public internal::FactoryBase<Factory3DSpaceDerivatives<P, NF, DerType>>
    {
    };
} // namespace Ponca