InstructionMetadata.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 <algorithm>
#include <functional>
#include <map>
#include <memory>
 
#include "GDCore/Events/Instruction.h"
#include "GDCore/String.h"
#include "ParameterMetadata.h"
#include "ParameterOptions.h"
 
namespace gd {
class Project;
class Layout;
class EventsCodeGenerator;
class EventsCodeGenerationContext;
class SerializerElement;
}  // namespace gd
 
namespace gd {
 
class GD_CORE_API InstructionMetadata : public gd::AbstractFunctionMetadata {
 public:
  InstructionMetadata(const gd::String &extensionNamespace,
                      const gd::String &name,
                      const gd::String &fullname,
                      const gd::String &description,
                      const gd::String &sentence,
                      const gd::String &group,
                      const gd::String &icon,
                      const gd::String &smallIcon);
 
  InstructionMetadata();
 
  virtual ~InstructionMetadata(){};
 
  const gd::String &GetFullName() const { return fullname; }
  const gd::String &GetDescription() const { return description; }
  const gd::String &GetSentence() const { return sentence; }
  const gd::String &GetGroup() const { return group; }
  ParameterMetadata &GetParameter(size_t i) { return parameters[i]; }
  const ParameterMetadata &GetParameter(size_t i) const {
    return parameters[i];
  }
  size_t GetParametersCount() const { return parameters.size(); }
  const std::vector<ParameterMetadata> &GetParameters() const {
    return parameters;
  }
  const gd::String &GetIconFilename() const { return iconFilename; }
  const gd::String &GetSmallIconFilename() const { return smallIconFilename; }
  bool CanHaveSubInstructions() const { return canHaveSubInstructions; }
 
  const gd::String &GetHelpPath() const { return helpPath; }
 
  InstructionMetadata &SetHelpPath(const gd::String &path) {
    helpPath = path;
    return *this;
  }
 
  bool IsPrivate() const { return isPrivate; }
 
  InstructionMetadata &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";
  }
 
  InstructionMetadata &SetRelevantForLayoutEventsOnly() override {
    relevantContext = "Layout";
    return *this;
  }
 
  InstructionMetadata &SetRelevantForFunctionEventsOnly() override {
    relevantContext = "Function";
    return *this;
  }
 
  InstructionMetadata &SetRelevantForAsynchronousFunctionEventsOnly() override {
    relevantContext = "AsynchronousFunction";
    return *this;
  }
 
  InstructionMetadata &SetRelevantForCustomObjectEventsOnly() override {
    relevantContext = "Object";
    return *this;
  }
 
  bool IsAsync() const {
    return !codeExtraInformation.asyncFunctionCallName.empty();
  }
 
  bool IsOptionallyAsync() const {
    return IsAsync() && !codeExtraInformation.functionCallName.empty();
  }
 
  InstructionMetadata &SetCanHaveSubInstructions() {
    canHaveSubInstructions = true;
    return *this;
  }
 
  InstructionMetadata &SetHidden() override {
    hidden = true;
    return *this;
  }
 
  InstructionMetadata &SetGroup(const gd::String &str) {
    group = str;
    return *this;
  }
 
  bool IsHidden() const { return hidden; }
 
  InstructionMetadata &AddParameter(
      const gd::String &type,
      const gd::String &label,
      const gd::String &supplementaryInformation = "",
      bool parameterIsOptional = false) override;
 
  InstructionMetadata &AddCodeOnlyParameter(
      const gd::String &type, const gd::String &supplementaryInformation) override;
 
  InstructionMetadata &SetDefaultValue(const gd::String &defaultValue_) override {
    if (!parameters.empty()) parameters.back().SetDefaultValue(defaultValue_);
    return *this;
  };
 
  InstructionMetadata &SetParameterLongDescription(
      const gd::String &longDescription) override {
    if (!parameters.empty())
      parameters.back().SetLongDescription(longDescription);
    return *this;
  }
 
  InstructionMetadata &SetParameterExtraInfo(const gd::String &extraInfo) override {
    if (!parameters.empty()) parameters.back().SetExtraInfo(extraInfo);
    return *this;
  }
 
  InstructionMetadata &UseStandardOperatorParameters(
      const gd::String &type, const ParameterOptions &options);
 
  InstructionMetadata &UseStandardRelationalOperatorParameters(
      const gd::String &type, const ParameterOptions &options);
 
  InstructionMetadata &SetIsObjectInstruction() {
    isObjectInstruction = true;
    return *this;
  }
 
  InstructionMetadata &SetIsBehaviorInstruction() {
    isBehaviorInstruction = true;
    return *this;
  }
 
  bool IsObjectInstruction() const { return isObjectInstruction; }
 
  bool IsBehaviorInstruction() const { return isBehaviorInstruction; }
 
  InstructionMetadata &SetRequiresBaseObjectCapability(
      const gd::String &capability);
 
  const gd::String &GetRequiredBaseObjectCapability() const {
    return requiredBaseObjectCapability;
  }
 
  InstructionMetadata &MarkAsSimple() {
    usageComplexity = 2;
    return *this;
  }
 
  InstructionMetadata &MarkAsAdvanced() {
    usageComplexity = 7;
    return *this;
  }
 
  InstructionMetadata &MarkAsComplex() {
    usageComplexity = 9;
    return *this;
  }
 
  int GetUsageComplexity() const { return usageComplexity; }
 
  class ExtraInformation { 
   public:
    enum AccessType { Reference, MutatorAndOrAccessor, Mutators };
    ExtraInformation() : accessType(Reference), hasCustomCodeGenerator(false){};
    virtual ~ExtraInformation(){};
 
    // TODO Move these attributes to InstructionMetadata.
    gd::String functionCallName;
    gd::String asyncFunctionCallName;
    gd::String type;
    AccessType accessType;
    gd::String optionalAssociatedInstruction;
    std::map<gd::String, gd::String> optionalMutators;
    bool hasCustomCodeGenerator;
    std::function<gd::String(Instruction &instruction,
                              gd::EventsCodeGenerator &codeGenerator,
                              gd::EventsCodeGenerationContext &context)>
        customCodeGenerator;
    std::vector<gd::String> includeFiles;
  };
  ExtraInformation codeExtraInformation;  
 
  InstructionMetadata &SetFunctionName(const gd::String &functionName_) override {
    codeExtraInformation.functionCallName = functionName_;
    return *this;
  }
 
  InstructionMetadata &SetAsyncFunctionName(const gd::String &functionName_) {
    codeExtraInformation.asyncFunctionCallName = functionName_;
    return *this;
  }
 
  const gd::String &GetFunctionName() {
    return codeExtraInformation.functionCallName;
  }
 
  const gd::String &GetAsyncFunctionName() {
    return codeExtraInformation.asyncFunctionCallName;
  }
 
  InstructionMetadata &SetManipulatedType(const gd::String &type_) {
    codeExtraInformation.type = type_;
    return *this;
  }
 
  InstructionMetadata &SetGetter(const gd::String &getter) {
    codeExtraInformation.optionalAssociatedInstruction = getter;
    codeExtraInformation.accessType = codeExtraInformation.MutatorAndOrAccessor;
    return *this;
  }
 
  InstructionMetadata &SetMutators(
      const std::map<gd::String, gd::String> &mutators) {
    codeExtraInformation.optionalMutators = mutators;
    codeExtraInformation.accessType = codeExtraInformation.Mutators;
    return *this;
  }
 
  InstructionMetadata &SetIncludeFile(const gd::String &includeFile) override {
    codeExtraInformation.includeFiles.clear();
    codeExtraInformation.includeFiles.push_back(includeFile);
    return *this;
  }
 
  InstructionMetadata &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;
  };
 
  InstructionMetadata &SetCustomCodeGenerator(
      std::function<gd::String(Instruction &instruction,
                                gd::EventsCodeGenerator &codeGenerator,
                                gd::EventsCodeGenerationContext &context)>
          codeGenerator) {
    codeExtraInformation.hasCustomCodeGenerator = true;
    codeExtraInformation.customCodeGenerator = codeGenerator;
    return *this;
  }
 
  InstructionMetadata &RemoveCustomCodeGenerator() {
    codeExtraInformation.hasCustomCodeGenerator = false;
    std::function<gd::String(Instruction & instruction,
                              gd::EventsCodeGenerator & codeGenerator,
                              gd::EventsCodeGenerationContext & context)>
        emptyFunction;
    codeExtraInformation.customCodeGenerator = emptyFunction;
    return *this;
  }
 
  bool HasCustomCodeGenerator() const { return codeExtraInformation.hasCustomCodeGenerator; }
 
  InstructionMetadata &GetCodeExtraInformation() { return *this; }
 
  std::vector<ParameterMetadata> parameters;
 
 private:
  gd::String fullname;
  gd::String description;
  gd::String helpPath;
  gd::String sentence;
  gd::String group;
  gd::String iconFilename;
  gd::String smallIconFilename;
  bool canHaveSubInstructions;
  gd::String extensionNamespace;
  bool hidden;
  int usageComplexity;  
  bool isPrivate;
  bool isObjectInstruction;
  bool isBehaviorInstruction;
  gd::String requiredBaseObjectCapability;
  gd::String relevantContext;
};
 
}  // namespace gd