ProjectScopedContainers.h

#pragma once
#include <set>
 
#include "GDCore/Extensions/Metadata/ParameterMetadataTools.h"
#include "ObjectsContainersList.h"
#include "PropertiesContainersList.h"
#include "VariablesContainersList.h"
#include "VariablesContainer.h"
 
namespace gd {
class Project;
class ObjectsContainer;
class NamedPropertyDescriptor;
class ParameterMetadataContainer;
class BaseEvent;
class EventsFunctionsExtension;
class EventsFunction;
class EventsBasedBehavior;
class EventsBasedObject;
} // namespace gd
 
namespace gd {
 
class ProjectScopedContainers {
 public:
  ProjectScopedContainers(
      const gd::ObjectsContainersList &objectsContainersList_,
      const gd::VariablesContainersList &variablesContainersList_,
      const gd::VariablesContainer *legacyGlobalVariables_,
      const gd::VariablesContainer *legacySceneVariables_,
      const gd::PropertiesContainersList &propertiesContainersList_)
      : objectsContainersList(objectsContainersList_),
        variablesContainersList(variablesContainersList_),
        legacyGlobalVariables(legacyGlobalVariables_),
        legacySceneVariables(legacySceneVariables_),
        propertiesContainersList(propertiesContainersList_){};
  virtual ~ProjectScopedContainers(){};
 
  static ProjectScopedContainers
  MakeNewProjectScopedContainersForProjectAndLayout(const gd::Project &project,
                                                    const gd::Layout &layout);
 
  static ProjectScopedContainers
  MakeNewProjectScopedContainersForProject(const gd::Project &project);
 
  static ProjectScopedContainers MakeNewProjectScopedContainersFor(
      const gd::ObjectsContainer &globalObjectsContainers,
      const gd::ObjectsContainer &objectsContainers);
 
  static ProjectScopedContainers
  MakeNewProjectScopedContainersForEventsFunctionsExtension(
      const gd::Project &project,
      const gd::EventsFunctionsExtension &eventsFunctionsExtension);
 
  static ProjectScopedContainers
  MakeNewProjectScopedContainersForFreeEventsFunction(
      const gd::Project &project,
      const gd::EventsFunctionsExtension &eventsFunctionsExtension,
      const gd::EventsFunction& eventsFunction,
      gd::ObjectsContainer& parameterObjectsContainer);
 
  static ProjectScopedContainers
  MakeNewProjectScopedContainersForBehaviorEventsFunction(
      const gd::Project &project,
      const gd::EventsFunctionsExtension &eventsFunctionsExtension,
      const gd::EventsBasedBehavior &eventsBasedBehavior,
      const gd::EventsFunction &eventsFunction,
      gd::ObjectsContainer &parameterObjectsContainer);
 
  static ProjectScopedContainers
  MakeNewProjectScopedContainersForObjectEventsFunction(
      const gd::Project &project,
      const gd::EventsFunctionsExtension &eventsFunctionsExtension,
      const gd::EventsBasedObject &eventsBasedObject,
      const gd::EventsFunction &eventsFunction,
      gd::ObjectsContainer &parameterObjectsContainer);
 
  static ProjectScopedContainers
  MakeNewProjectScopedContainersForEventsBasedObject(
      const gd::Project &project,
      const gd::EventsFunctionsExtension &eventsFunctionsExtension,
      const gd::EventsBasedObject &eventsBasedObject,
      gd::ObjectsContainer &outputObjectsContainer);
 
  static ProjectScopedContainers
  MakeNewProjectScopedContainersWithLocalVariables(
      const ProjectScopedContainers &projectScopedContainers,
      const gd::BaseEvent &event);
 
  ProjectScopedContainers &AddPropertiesContainer(
      const gd::PropertiesContainer &container) {
    propertiesContainersList.Add(container);
 
    return *this;
  }
 
  ProjectScopedContainers &AddParameters(
      const ParameterMetadataContainer &parameters) {
    parametersVectorsList.push_back(&parameters);
 
    return *this;
  }
 
  template <class ReturnType>
  ReturnType MatchIdentifierWithName(
      const gd::String &name,
      std::function<ReturnType()> objectCallback,
      std::function<ReturnType()> variableCallback,
      std::function<ReturnType()> propertyCallback,
      std::function<ReturnType()> parameterCallback,
      std::function<ReturnType()> notFoundCallback) const {
    if (objectsContainersList.HasObjectOrGroupNamed(name))
      return objectCallback();
    else if (variablesContainersList.Has(name))
      return variableCallback();
    else if (ParameterMetadataTools::Has(parametersVectorsList, name))
      return parameterCallback();
    else if (propertiesContainersList.Has(name))
      return propertyCallback();
 
    return notFoundCallback();
  };
 
  void ForEachIdentifierMatchingSearch(
      const gd::String &search,
      std::function<void(const gd::String &name,
                         const ObjectConfiguration *objectConfiguration)>
          objectCallback,
      std::function<void(const gd::String &name, const gd::Variable &variable)>
          variableCallback,
      std::function<void(const gd::NamedPropertyDescriptor &property)>
          propertyCallback,
      std::function<void(const gd::ParameterMetadata &parameter)>
          parameterCallback) const {
    std::set<gd::String> namesAlreadySeen;
 
    objectsContainersList.ForEachNameMatchingSearch(
        search,
        [&](const gd::String &name,
            const ObjectConfiguration *objectConfiguration) {
          if (namesAlreadySeen.count(name) == 0) {
            namesAlreadySeen.insert(name);
            objectCallback(name, objectConfiguration);
          }
        });
    variablesContainersList.ForEachVariableMatchingSearch(
        search, [&](const gd::String &name, const gd::Variable &variable) {
          if (namesAlreadySeen.count(name) == 0) {
            namesAlreadySeen.insert(name);
            variableCallback(name, variable);
          }
        });
    gd::ParameterMetadataTools::ForEachParameterMatchingSearch(
        parametersVectorsList,
        search,
        [&](const gd::ParameterMetadata &parameter) {
          if (namesAlreadySeen.count(parameter.GetName()) == 0) {
            namesAlreadySeen.insert(parameter.GetName());
            parameterCallback(parameter);
          }
        });
    propertiesContainersList.ForEachPropertyMatchingSearch(
        search, [&](const gd::NamedPropertyDescriptor &property) {
          if (namesAlreadySeen.count(property.GetName()) == 0) {
            namesAlreadySeen.insert(property.GetName());
            propertyCallback(property);
          }
        });
  };
 
  const gd::ObjectsContainersList &GetObjectsContainersList() const {
    return objectsContainersList;
  };
 
  const gd::VariablesContainersList &GetVariablesContainersList() const {
    return variablesContainersList;
  };
 
  gd::VariablesContainersList &GetVariablesContainersList() {
    return variablesContainersList;
  };
 
  const gd::VariablesContainer *GetLegacyGlobalVariables() const {
    return legacyGlobalVariables;
  };
 
  const gd::VariablesContainer *GetLegacySceneVariables() const {
    return legacySceneVariables;
  };
 
  const gd::PropertiesContainersList &GetPropertiesContainersList() const {
    return propertiesContainersList;
  };
 
  const std::vector<const ParameterMetadataContainer *> &GetParametersVectorsList() const {
    return parametersVectorsList;
  };
 
  ProjectScopedContainers()
      : legacyGlobalVariables(nullptr), legacySceneVariables(nullptr){};
 
private:
  gd::ObjectsContainersList objectsContainersList;
  gd::VariablesContainersList variablesContainersList;
  const gd::VariablesContainer *legacyGlobalVariables;
  const gd::VariablesContainer *legacySceneVariables;
  gd::PropertiesContainersList propertiesContainersList;
  std::vector<const ParameterMetadataContainer *> parametersVectorsList;
};
 
}  // namespace gd