ExpressionMetadata.h

/*
 * GDevelop Core
 * Copyright 2008-2016 Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
#pragma once
 
#include "AbstractFunctionMetadata.h"
 
#include <functional>
#include <memory>
 
#include "GDCore/Events/Instruction.h"
#include "GDCore/Extensions/Metadata/InstructionMetadata.h"
#include "GDCore/String.h"
namespace gd {
class Layout;
}
 
namespace gd {
class ExpressionCodeGenerationInformation {
 public:
  ExpressionCodeGenerationInformation()
      : staticFunction(false), hasCustomCodeGenerator(false){};
  virtual ~ExpressionCodeGenerationInformation(){};
 
  // TODO Move these attributes to ExpressionMetadata.
  bool staticFunction;
  gd::String functionCallName;
  bool hasCustomCodeGenerator;
  std::function<gd::String(const std::vector<gd::Expression>& parameters,
                           gd::EventsCodeGenerator& codeGenerator,
                           gd::EventsCodeGenerationContext& context)>
      customCodeGenerator;
  std::vector<gd::String> includeFiles;
};
 
class GD_CORE_API ExpressionMetadata : public gd::AbstractFunctionMetadata {
 public:
  ExpressionMetadata(const gd::String& returnType,
                     const gd::String& extensionNamespace,
                     const gd::String& name,
                     const gd::String& fullname,
                     const gd::String& description,
                     const gd::String& group,
                     const gd::String& smallicon);
 
  ExpressionMetadata()
      : returnType("unknown"), shown(false), isPrivate(false), relevantContext("Any"){};
 
  virtual ~ExpressionMetadata(){};
 
  ExpressionMetadata& SetHidden() override;
 
  ExpressionMetadata& SetGroup(const gd::String& str) {
    group = str;
    return *this;
  }
 
  const gd::String& GetHelpPath() const { return helpPath; }
 
  ExpressionMetadata& SetHelpPath(const gd::String& path) {
    helpPath = path;
    return *this;
  }
 
  bool IsPrivate() const { return isPrivate; }
 
  ExpressionMetadata& SetPrivate() override {
    isPrivate = true;
    return *this;
  }
 
  bool IsRelevantForLayoutEvents() const {
    return relevantContext == "Any" || relevantContext == "Layout";
  }
 
  bool IsRelevantForFunctionEvents() const {
    return relevantContext == "Any" || relevantContext == "Function";
  }
 
  bool IsRelevantForAsynchronousFunctionEvents() const {
    return relevantContext == "Any" || relevantContext == "Function" ||
           relevantContext == "AsynchronousFunction";
  }
 
  bool IsRelevantForCustomObjectEvents() const {
    return relevantContext == "Any" || relevantContext == "Object";
  }
 
  ExpressionMetadata &SetRelevantForLayoutEventsOnly() override {
    relevantContext = "Layout";
    return *this;
  }
 
  ExpressionMetadata &SetRelevantForFunctionEventsOnly() override {
    relevantContext = "Function";
    return *this;
  }
 
  ExpressionMetadata &SetRelevantForAsynchronousFunctionEventsOnly() override {
    relevantContext = "AsynchronousFunction";
    return *this;
  }
 
  ExpressionMetadata &SetRelevantForCustomObjectEventsOnly() override {
    relevantContext = "Object";
    return *this;
  }
 
  gd::ExpressionMetadata &
  AddParameter(const gd::String &type, const gd::String &label,
               const gd::String &supplementaryInformation = "",
               bool parameterIsOptional = false) override;
 
  gd::ExpressionMetadata &
  AddCodeOnlyParameter(const gd::String &type,
                       const gd::String &supplementaryInformation) override;
 
  ExpressionMetadata &SetDefaultValue(const gd::String &defaultValue) override {
    if (!parameters.empty())
      parameters.back().SetDefaultValue(defaultValue);
    return *this;
  };
 
  ExpressionMetadata &
  SetParameterLongDescription(const gd::String &longDescription) override {
    if (!parameters.empty())
      parameters.back().SetLongDescription(longDescription);
    return *this;
  };
 
  ExpressionMetadata &SetParameterExtraInfo(
      const gd::String &extraInfo) override {
    if (!parameters.empty()) parameters.back().SetExtraInfo(extraInfo);
    return *this;
  }
 
  ExpressionMetadata& SetRequiresBaseObjectCapability(
      const gd::String& capability);
 
  const gd::String& GetRequiredBaseObjectCapability() const {
    return requiredBaseObjectCapability;
  };
 
  bool IsShown() const { return shown; }
  const gd::String& GetReturnType() const { return returnType; }
  const gd::String& GetFullName() const { return fullname; }
  const gd::String& GetDescription() const { return description; }
  const gd::String& GetGroup() const { return group; }
  const gd::String& GetSmallIconFilename() const { return smallIconFilename; }
  const gd::ParameterMetadata& GetParameter(std::size_t id) const {
    return parameters[id];
  };
  gd::ParameterMetadata& GetParameter(std::size_t id) {
    return parameters[id];
  };
  std::size_t GetParametersCount() const { return parameters.size(); };
  const std::vector<gd::ParameterMetadata>& GetParameters() const {
    return parameters;
  };
 
  std::vector<gd::ParameterMetadata> parameters;
 
  
  ExpressionMetadata& SetFunctionName(
      const gd::String& functionName) override {
    codeExtraInformation.functionCallName = functionName;
    return *this;
  }
 
 
  const gd::String &GetFunctionName() {
    return codeExtraInformation.functionCallName;
  }
  ExpressionMetadata& SetStatic() {
    codeExtraInformation.staticFunction = true;
    return *this;
  }
 
  ExpressionMetadata& SetIncludeFile(
      const gd::String& includeFile) override {
    codeExtraInformation.includeFiles.clear();
    codeExtraInformation.includeFiles.push_back(includeFile);
    return *this;
  }
 
  ExpressionMetadata& AddIncludeFile(
      const gd::String& includeFile) override {
    if (std::find(codeExtraInformation.includeFiles.begin(), codeExtraInformation.includeFiles.end(), includeFile) ==
        codeExtraInformation.includeFiles.end())
      codeExtraInformation.includeFiles.push_back(includeFile);
 
    return *this;
  }
 
  const std::vector<gd::String>& GetIncludeFiles() const override {
    return codeExtraInformation.includeFiles;
  };
 
  ExpressionMetadata& SetCustomCodeGenerator(
      std::function<gd::String(const std::vector<gd::Expression>& parameters,
                               gd::EventsCodeGenerator& codeGenerator,
                               gd::EventsCodeGenerationContext& context)>
          codeGenerator) {
    codeExtraInformation.hasCustomCodeGenerator = true;
    codeExtraInformation.customCodeGenerator = codeGenerator;
    return *this;
  }
 
  ExpressionMetadata& RemoveCustomCodeGenerator() {
    codeExtraInformation.hasCustomCodeGenerator = false;
    std::function<gd::String(const std::vector<gd::Expression>& parameters,
                             gd::EventsCodeGenerator& codeGenerator,
                             gd::EventsCodeGenerationContext& context)>
        emptyFunction;
    codeExtraInformation.customCodeGenerator = emptyFunction;
    return *this;
  }
 
  bool HasCustomCodeGenerator() const { return codeExtraInformation.hasCustomCodeGenerator; }
 
  ExpressionMetadata& GetCodeExtraInformation() {
    return *this;
  }
 
  ExpressionCodeGenerationInformation codeExtraInformation;
 
 private:
  gd::String returnType;
  gd::String fullname;
  gd::String description;
  gd::String helpPath;
  gd::String group;
  bool shown;
 
  gd::String smallIconFilename;
  gd::String extensionNamespace;
  bool isPrivate;
  gd::String requiredBaseObjectCapability;
  gd::String relevantContext;
};
 
}  // namespace gd