Bonjour,

je souhaiterais faire quelque chose comme ceci :

template <typename... Signature, typename DynamicTuple, typename System, typename... Params, class R>
                void apply(DynamicTuple& tuple, System& system, std::vector<EntityId>& entities, std::tuple<Params...>& params, std::vector<R>& ret, bool reverse=false) {
                  EntityId tmpRootEntityId;
                  EntityId tmpParentEntityId;
                  EntityId tmpClonedParentEntityId;
                  bool first  = true;
                  auto additionnal_params = std::make_tuple(tmpClonedParentEntityId, tmpRootEntityId, tmpParentEntityId, first);
                  auto cated_params = std::tuple_cat(params, additionnal_params);
                  if (reverse) {
                      for (unsigned int i = 0; i < entities.size(); i++) {
                        size_t level = (treeLevels[*entities[i].get().load()].has_value()) ? treeLevels[*entities[i].get().load()].value() : 0;
                        for (unsigned int j = nbLevels[*entities[i].get().load()]; j > 0; j--) {
                          for(unsigned int k = 0; k < childrenMapping[*entities[i].get().load()][j-1].size(); k++) {
                            this->template apply_impl<Signature...>(childrenMapping[*entities[i].get().load()][j-1][k], tuple, system, cated_params, std::index_sequence_for<Signature...>(), ret);
                          }
                        }
                        this->template apply_impl<Signature...>(entities[i], tuple, system, cated_params, std::index_sequence_for<Signature...>());
                      }
                  } else {
                      for (unsigned int i = 0; i < entities.size(); i++) {
                        this->template apply_impl<Signature...>(entities[i], tuple, system, cated_params, std::index_sequence_for<Signature...>(), ret);
                        size_t level = (treeLevels[*entities[i].get().load()].has_value()) ? treeLevels[*entities[i].get().load()].value() : 0;
                        for (unsigned int j = level; j < nbLevels[*entities[i].get().load()]; j++) {
                          for(unsigned int k = 0; k < childrenMapping[*getRoot(entities[i]).get().load()][j].size(); k++)
                            this->template apply_impl<Signature...>(childrenMapping[*getRoot(entities[i]).get().load()][j][k], cated_params, system, params, std::index_sequence_for<Signature...>(), ret);
                        }
                      }
                  }
                }
                template <typename... Signature, typename DynamicTuple, typename System, size_t... I, typename... Params, typename R>
                void apply_impl(EntityId entityId, DynamicTuple& tuple, System& system, std::tuple<Params...>& params, std::index_sequence<I...>, std::vector<R>& rets) {
                    auto tp = std::make_tuple(getAgregate<std::tuple_element_t<I, std::tuple<Signature...>>>(tuple, entityId)...);
                    rets.push_back(system(tp, entityId, params));
                }

Mais j'ai une erreur en compilation qui me dit que tuple est un std::tuple hors que getAgregate attend un DynamicTuple du coup j'ai cette erreur à cette ligne :

if (componentMapping[*entityId.get().load()][tuple.template getIndexOfTypeT<T>()].has_value())

/home/laurent/gitODFAEG/Demos/ODFAEGECSDemo/../../ODFAEG/include/odfaeg/Graphics/ECS/../../Core/ecs.hpp|269|error: ‘class std::tuple<odfaeg::core::DynamicTuple<odfaeg::graphic::ecs::MeshComponent, odfaeg::graphic::ecs::ClonableComponent, odfaeg::graphic::ecs::EntityInfoComponent, odfaeg::graphic::ecs::TransformComponent>, odfaeg::graphic::ecs::ComponentMapping, odfaeg::graphic::ecs::atomwrapper<long unsigned int*>, odfaeg::graphic::ecs::atomwrapper<long unsigned int*>, odfaeg::graphic::ecs::atomwrapper<long unsigned int*>, odfaeg::graphic::ecs::atomwrapper<long unsigned int*>, bool>’ has no member named ‘getIndexOfTypeT’|

Bref le paramètre variadique ne s'étend pas comme je le veux il passe std::tuple de composants à la fonction getAgregate hors que moi je veux qu'il passe tout les composants du tuple 1 par 1 à getAgregate pour former un nouveau tuple comment faire ?

Merci.

-
Edité par OmbreNoire 8 avril 2022 à 21:04:20

template <typename DynamicTuple>
void foo(DynamicTuple /* const &*/ param)

DynamicTuple n'est que le nom auquel sera associé, dans le cadre de l'appel de ta fonction, le type particulier (censé respecter certains critères) utilisé lors de la spécialisation de ton template.

Ce n'est donc qu'un alias, que tu aurais pu appeler A, T, U ou TupleType sans que cela n'influe en quoi que ce soit sur tout le reste et qui n'a -- a fortiori -- pas forcément le moindre rapport avec une quelconque classe (ou structure) qui aurait été déclarée sous une forme proche de

class /* ou  struct */ DynamicTuple{
    /* ... */
};

Si, pour une raison ou une autre, le compilateur a une bonne raison de croire que  std::tuple est le type qui doit être associé à cet alias et que, par malheur, std::tuple ne fournit pas l'ensemble des services dont tu as besoin dans le cadre de cette fonction (et qui seraient -- a priori  et si j'ai bien compris -- fournis par ta structure DynamicTuple), il est on ne peut plus normal qu'il émette une erreur de compilation

Normalement, le compilateur devrait rajouter à ce message une série d'indications "FROM (fichier, ligne, autre informations) qui devrait t'aider à déterminer à quel moment il a commencé à considérer que le type associé à ce paramètre template était un std::tuple et non un DynamicTuple.

Tu devrais déjà commencer par aller voir du coté de ces spécialisations la raison pour laquelle il a décidé de se rabattre sur ce std::tuple

Et, peut-être, serais tu  bien inspiré de remplacer le nom de ce paramètre template par TupleType, de manière à éviter toute confusion avec ta classe ou ta structure DynamicTuple

J'ai trouvé l'erreur se situait ici :

this->template apply_impl<Signature...>(childrenMapping[*getRoot(entities[i]).get().load()][j][k], cated_params, system, params, std::index_sequence_for<Signature...>(), ret);

Je passais cated_params qui est un tuple et non un DynamicTuple, donc, rectification :

this->template apply_impl<Signature...>(childrenMapping[*getRoot(entities[i]).get().load()][j][k], tp, system, cated_params, std::index_sequence_for<Signature...>(), ret);

markand a écrit:

Le retour des discussions à sens unique est arrivé.

Ce genre de discussions nous manquait tellement