EventsFunctionsExtension.h

/*
 * GDevelop Core
 * Copyright 2008-2016 Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
#pragma once
 
#include <vector>
 
#include "GDCore/Extensions/Metadata/DependencyMetadata.h"
#include "GDCore/Extensions/Metadata/SourceFileMetadata.h"
#include "GDCore/Project/EventsBasedBehavior.h"
#include "GDCore/Project/EventsBasedObject.h"
#include "GDCore/Project/EventsFunctionsContainer.h"
#include "GDCore/Project/EventsFunctionsExtensionChangelog.h"
#include "GDCore/Project/TestsContainer.h"
#include "GDCore/Project/VariablesContainer.h"
#include "GDCore/String.h"
#include "GDCore/Tools/SerializableWithNameList.h"
 
namespace gd {
class SerializerElement;
class Project;
}  // namespace gd
 
namespace gd {
// TODO Remove the EventsFunctionsContainer inheritance and make it an attribute.
// This will allow to get EventsFunctionsContainer the same way for extensions,
// objects and behaviors.
class GD_CORE_API EventsFunctionsExtension {
 public:
  EventsFunctionsExtension();
  EventsFunctionsExtension(const EventsFunctionsExtension&);
  EventsFunctionsExtension& operator=(const EventsFunctionsExtension& rhs);
  virtual ~EventsFunctionsExtension(){};
 
  EventsFunctionsExtension* Clone() const {
    return new EventsFunctionsExtension(*this);
  };
 
  const gd::String& GetVersion() const { return version; };
  EventsFunctionsExtension& SetVersion(const gd::String& version_) {
    version = version_;
    return *this;
  }
 
  const gd::String& GetNamespace() const { return extensionNamespace; };
  EventsFunctionsExtension& SetNamespace(const gd::String& namespace_) {
    extensionNamespace = namespace_;
    return *this;
  }
 
  const gd::String& GetShortDescription() const { return shortDescription; };
  EventsFunctionsExtension& SetShortDescription(
      const gd::String& shortDescription_) {
    shortDescription = shortDescription_;
    return *this;
  }
 
  const gd::String& GetDescription() const { return description; };
  EventsFunctionsExtension& SetDescription(const gd::String& description_) {
    description = description_;
    return *this;
  }
 
  const gd::String& GetDimension() const { return dimension; };
  EventsFunctionsExtension& SetDimension(const gd::String& dimension_) {
    dimension = dimension_;
    return *this;
  }
 
  const gd::String& GetName() const { return name; };
  EventsFunctionsExtension& SetName(const gd::String& name_) {
    name = name_;
    return *this;
  }
 
  const gd::String& GetFullName() const { return fullName; };
  EventsFunctionsExtension& SetFullName(const gd::String& fullName_) {
    fullName = fullName_;
    return *this;
  }
 
  const gd::String& GetCategory() const { return category; };
  EventsFunctionsExtension& SetCategory(const gd::String& category_) {
    category = category_;
    return *this;
  }
 
  const std::vector<gd::String>& GetTags() const { return tags; };
  std::vector<gd::String>& GetTags() { return tags; };
 
  const std::vector<gd::String>& GetAuthorIds() const { return authorIds; };
  std::vector<gd::String>& GetAuthorIds() { return authorIds; };
 
  const gd::String& GetAuthor() const { return author; };
  EventsFunctionsExtension& SetAuthor(const gd::String& author_) {
    author = author_;
    return *this;
  }
 
  const gd::String& GetPreviewIconUrl() const { return previewIconUrl; };
  EventsFunctionsExtension& SetPreviewIconUrl(
      const gd::String& previewIconUrl_) {
    previewIconUrl = previewIconUrl_;
    return *this;
  }
 
  const gd::String& GetIconUrl() const { return iconUrl; };
  EventsFunctionsExtension& SetIconUrl(const gd::String& iconUrl_) {
    iconUrl = iconUrl_;
    return *this;
  }
 
  const gd::String& GetHelpPath() const { return helpPath; };
 
  EventsFunctionsExtension& SetHelpPath(const gd::String& helpPath_) {
    helpPath = helpPath_;
    return *this;
  }
 
  const gd::String& GetGDevelopVersion() const { return gdevelopVersion; };
 
  EventsFunctionsExtension& SetGDevelopVersion(const gd::String& gdevelopVersion_) {
    gdevelopVersion = gdevelopVersion_;
    return *this;
  }
 
  gd::SerializableWithNameList<EventsBasedBehavior>& GetEventsBasedBehaviors() {
    return eventsBasedBehaviors;
  }
 
  const gd::SerializableWithNameList<EventsBasedBehavior>&
  GetEventsBasedBehaviors() const {
    return eventsBasedBehaviors;
  }
 
  gd::SerializableWithNameList<EventsBasedObject>& GetEventsBasedObjects() {
    return eventsBasedObjects;
  }
 
  const gd::SerializableWithNameList<EventsBasedObject>&
  GetEventsBasedObjects() const {
    return eventsBasedObjects;
  }
 
  gd::TestsContainer& GetTests() { return tests; }
 
  const gd::TestsContainer& GetTests() const { return tests; }
 
  virtual void SetOrigin(const gd::String& originName_,
                         const gd::String& originIdentifier_) {
    originName = originName_;
    originIdentifier = originIdentifier_;
  }
 
  virtual const gd::String& GetOriginName() const { return originName; }
  virtual const gd::String& GetOriginIdentifier() const {
    return originIdentifier;
  }
 
  EventsFunctionsContainer& GetEventsFunctions() {
    return eventsFunctionsContainer;
  }
 
  const EventsFunctionsContainer& GetEventsFunctions() const {
    return eventsFunctionsContainer;
  }
 
 
  gd::DependencyMetadata& AddDependency() {
    gd::DependencyMetadata dependency;
    dependencies.push_back(dependency);
    return dependencies.back();
  };
 
  void RemoveDependencyAt(size_t index) {
    dependencies.erase(dependencies.begin() + index);
  };
 
  std::vector<gd::DependencyMetadata>& GetAllDependencies() {
    return dependencies;
  };
 
  const std::vector<gd::DependencyMetadata>& GetAllDependencies() const {
    return dependencies;
  };
 
 
 
  inline const gd::VariablesContainer& GetGlobalVariables() const {
    return globalVariables;
  }
 
  inline gd::VariablesContainer& GetGlobalVariables() { return globalVariables; }
 
  inline const gd::VariablesContainer& GetSceneVariables() const {
    return sceneVariables;
  }
 
  inline gd::VariablesContainer& GetSceneVariables() { return sceneVariables; }
 
 
 
  void SerializeTo(gd::SerializerElement& element, bool isExternal = false) const;
 
  void SerializeToExternal(gd::SerializerElement& element) const {
    SerializeTo(element, true);
  }
 
  void UnserializeFrom(gd::Project& project,
                       const gd::SerializerElement& element);
 
  void UnserializeExtensionDeclarationFrom(
      gd::Project& project,
      const gd::SerializerElement& element);
 
  void UnserializeExtensionDefaultVariantsFrom(gd::Project &project,
                                            const SerializerElement &element);
 
  void UnserializeExtensionImplementationFrom(
      gd::Project& project,
      const gd::SerializerElement& element);
 
  static bool IsExtensionLifecycleEventsFunction(
      const gd::String& eventsFunctionName);
 
 
  gd::SourceFileMetadata& AddSourceFile() {
    gd::SourceFileMetadata sourceFile;
    sourceFiles.push_back(sourceFile);
    return sourceFiles.back();
  };
 
  void RemoveSourceFileAt(size_t index) {
    sourceFiles.erase(sourceFiles.begin() + index);
  };
 
  std::vector<gd::SourceFileMetadata>& GetAllSourceFiles() {
    return sourceFiles;
  };
 
  const std::vector<gd::SourceFileMetadata>& GetAllSourceFiles() const {
    return sourceFiles;
  };
 
 
 private:
  void Init(const gd::EventsFunctionsExtension& other);
 
  void SerializeDependencyTo(const gd::DependencyMetadata& dependency,
                             gd::SerializerElement& serializer) const {
    serializer.SetStringAttribute("type", dependency.GetDependencyType());
    serializer.SetStringAttribute("exportName", dependency.GetExportName());
    serializer.SetStringAttribute("name", dependency.GetName());
    serializer.SetStringAttribute("version", dependency.GetVersion());
  }
 
  gd::DependencyMetadata UnserializeDependencyFrom(
      gd::SerializerElement& serializer) {
    gd::DependencyMetadata dependency;
    dependency.SetDependencyType(serializer.GetStringAttribute("type"));
    dependency.SetExportName(serializer.GetStringAttribute("exportName"));
    dependency.SetName(serializer.GetStringAttribute("name"));
    dependency.SetVersion(serializer.GetStringAttribute("version"));
    return dependency;
  }
 
  gd::String version;
  gd::String extensionNamespace;
  gd::String shortDescription;
  gd::String description;
  gd::String dimension;
  gd::String name;
  gd::String fullName;
  gd::String category;
  std::vector<gd::String> tags;
  std::vector<gd::String> authorIds;
  gd::String author;
  gd::String previewIconUrl;
  gd::String originName;
  gd::String originIdentifier;
  gd::String iconUrl;
  gd::String helpPath;  
  gd::String gdevelopVersion;
  gd::EventsFunctionsExtensionChangelog changelog;
  gd::SerializableWithNameList<EventsBasedBehavior> eventsBasedBehaviors;
  gd::SerializableWithNameList<EventsBasedObject> eventsBasedObjects;
  std::vector<gd::DependencyMetadata> dependencies;
  std::vector<gd::SourceFileMetadata> sourceFiles;
 
  gd::EventsFunctionsContainer eventsFunctionsContainer;
  gd::VariablesContainer globalVariables;
  gd::VariablesContainer sceneVariables;
  gd::TestsContainer tests;  
};
 
}  // namespace gd