ExportedDependencyResolver.h

#pragma once
#include <vector>
 
#include "GDCore/Extensions/Metadata/DependencyMetadata.h"
#include "GDCore/Extensions/PlatformExtension.h"
#include "GDCore/Project/Project.h"
#include "GDCore/Extensions/Platform.h"
 
namespace gd {
 
struct DependencyMetadataAndExtension {
  DependencyMetadataAndExtension(gd::DependencyMetadata &dependency_,
                                 gd::PlatformExtension &extension_)
      : dependency(&dependency_), extension(&extension_){};
 
  gd::DependencyMetadata &GetDependency() const { return *dependency; };
  gd::PlatformExtension &GetExtension() const { return *extension; };
 
 private:
  gd::DependencyMetadata *dependency;
  gd::PlatformExtension *extension;
};
 
class ExportedDependencyResolver {
 public:
  static std::vector<DependencyMetadataAndExtension> GetDependenciesFor(
      const gd::Project &project,
      std::set<gd::String> usedExtensions,
      const gd::String &dependencyType) {
    std::vector<DependencyMetadataAndExtension> dependenciesWithProperType;
    for (const gd::String &extensionName : usedExtensions) {
      auto extension = project.GetCurrentPlatform().GetExtension(extensionName);
      for (gd::DependencyMetadata &dependency :
           extension->GetAllDependencies()) {
        if (dependency.GetDependencyType() == dependencyType) {
          DependencyMetadataAndExtension dependencyMetadataAndExtension(
              dependency, *extension);
          dependenciesWithProperType.push_back(dependencyMetadataAndExtension);
        }
      }
    }
 
    // Keep only the dependencies that have their extra settings filled
    // and those that don't require extra settings to be filled.
    std::vector<DependencyMetadataAndExtension> dependenciesWithFilledSettings;
    for (auto dependencyAndExtension : dependenciesWithProperType) {
      auto &dependency = dependencyAndExtension.GetDependency();
      auto extraSettingValues = GetExtensionDependencyExtraSettingValues(
          project, dependencyAndExtension);
 
      bool hasExtraSettings = !extraSettingValues.empty();
      if (!dependency.IsOnlyIfSomeExtraSettingsNonEmpty() || hasExtraSettings)
        dependenciesWithFilledSettings.push_back(dependencyAndExtension);
    }
 
    // Keep only the dependency that depends on another dependencies that is
    // exported (or dependencies that don't require another dependency).
    std::vector<DependencyMetadataAndExtension> exportedDependencies;
    for (auto dependencyAndExtension : dependenciesWithFilledSettings) {
      auto &dependency = dependencyAndExtension.GetDependency();
      auto &otherDependencyName =
          dependency.GetOtherDependencyThatMustBeExported();
      if (otherDependencyName.empty() ||
          std::find_if(
              dependenciesWithFilledSettings.begin(),
              dependenciesWithFilledSettings.end(),
              [&otherDependencyName](
                  DependencyMetadataAndExtension &otherDependencyAndExtension) {
                return otherDependencyAndExtension.GetDependency().GetName() ==
                       otherDependencyName;
              }) != dependenciesWithFilledSettings.end()) {
        exportedDependencies.push_back(dependencyAndExtension);
      }
    }
 
    return exportedDependencies;
  }
 
  static std::map<gd::String, gd::String>
  GetExtensionDependencyExtraSettingValues(
      const gd::Project &project,
      const gd::DependencyMetadataAndExtension &dependencyAndExtension) {
    std::map<gd::String, gd::String> values;
    auto &dependency = dependencyAndExtension.GetDependency();
    const gd::String &extensionName =
        dependencyAndExtension.GetExtension().GetName();
 
    for (const auto &extraSetting : dependency.GetAllExtraSettings()) {
      const gd::String &type = extraSetting.second.GetType();
      const gd::String extraSettingValue =
          type == "ExtensionProperty"
              ? project.GetExtensionProperties().GetValue(
                    extensionName, extraSetting.second.GetValue())
              : extraSetting.second.GetValue();
 
      if (!extraSettingValue.empty())
        values[extraSetting.first] = extraSettingValue;
    }
 
    return values;
  };
};
 
}  // namespace gd