EventsFunction.h

/*
 * GDevelop Core
 * Copyright 2008-2016 Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
#if defined(GD_IDE_ONLY)
#ifndef GDCORE_EVENTSFUNCTION_H
#define GDCORE_EVENTSFUNCTION_H
 
#include <vector>
 
#include "GDCore/Events/EventsList.h"
#include "GDCore/Project/ObjectGroupsContainer.h"
#include "GDCore/String.h"
#include "GDCore/Extensions/Metadata/ValueTypeMetadata.h"
// TODO: In theory (for separation of concerns between Project and
// extensions/events), this include should be removed and gd::ParameterMetadata
// replaced by a new gd::EventsFunctionParameter class.
#include "GDCore/Extensions/Metadata/InstructionMetadata.h"
namespace gd {
class SerializerElement;
class Project;
class EventsFunctionsContainer;
}  // namespace gd
 
namespace gd {
 
class GD_CORE_API EventsFunction {
 public:
  EventsFunction();
  virtual ~EventsFunction(){};
 
  EventsFunction* Clone() const { return new EventsFunction(*this); };
 
  const gd::String& GetDescription() const { return description; };
 
  EventsFunction& SetDescription(const gd::String& description_) {
    description = description_;
    return *this;
  }
 
  const gd::String& GetName() const { return name; };
 
  EventsFunction& SetName(const gd::String& name_) {
    name = name_;
    return *this;
  }
 
  const gd::String& GetFullName() const { return fullName; };
 
  EventsFunction& SetFullName(const gd::String& fullName_) {
    fullName = fullName_;
    return *this;
  }
 
  const gd::String& GetSentence() const { return sentence; };
 
  EventsFunction& SetSentence(const gd::String& sentence_) {
    sentence = sentence_;
    return *this;
  }
 
  const gd::String& GetGroup() const { return group; };
 
  EventsFunction& SetGroup(const gd::String& group_) {
    group = group_;
    return *this;
  }
 
  const gd::String& GetGetterName() const { return getterName; };
 
  EventsFunction& SetGetterName(const gd::String& getterName_) {
    getterName = getterName_;
    return *this;
  }
 
  EventsFunction& SetExpressionType(const gd::ValueTypeMetadata& type) {
    expressionType = type;
    return *this;
  }
 
  const gd::ValueTypeMetadata& GetExpressionType() const { return expressionType; }
 
  gd::ValueTypeMetadata& GetExpressionType() { return expressionType; }
 
  enum FunctionType {
      Action,
      Condition,
      Expression,
      ExpressionAndCondition,
      ActionWithOperator };
 
  EventsFunction& SetFunctionType(FunctionType type) {
    functionType = type;
    return *this;
  }
 
  FunctionType GetFunctionType() const { return functionType; }
 
  bool IsAction() const {
    return functionType == gd::EventsFunction::Action || 
           functionType == gd::EventsFunction::ActionWithOperator;
 }
 
  bool IsExpression() const {
    return functionType == gd::EventsFunction::Expression ||
           functionType == gd::EventsFunction::ExpressionAndCondition;
 }
 
  bool IsCondition() const {
    return functionType == gd::EventsFunction::Condition ||
           functionType == gd::EventsFunction::ExpressionAndCondition;
 }
 
  bool IsPrivate() const { return isPrivate; }
 
  EventsFunction& SetPrivate(bool _isPrivate) {
    isPrivate = _isPrivate;
    return *this;
  }
 
  bool IsAsync() const { return isAsync; }
 
  EventsFunction& SetAsync(bool _isAsync) {
    isAsync = _isAsync;
    return *this;
  }
 
  const gd::EventsList& GetEvents() const { return events; };
 
  gd::EventsList& GetEvents() { return events; };
 
  const std::vector<gd::ParameterMetadata>& GetParametersForEvents(
      const gd::EventsFunctionsContainer& functionsContainer) const;
 
  const std::vector<gd::ParameterMetadata>& GetParameters() const {
    return parameters;
  };
 
  std::vector<gd::ParameterMetadata>& GetParameters() { return parameters; };
 
  ObjectGroupsContainer& GetObjectGroups() { return objectGroups; }
 
  const ObjectGroupsContainer& GetObjectGroups() const { return objectGroups; }
 
 
  void SerializeTo(gd::SerializerElement& element) const;
 
  void UnserializeFrom(gd::Project& project,
                       const gd::SerializerElement& element);
 
 private:
  gd::String name;
  gd::String fullName;
  gd::String description;
  gd::String sentence;
  gd::String group;
  gd::String getterName;
  gd::ValueTypeMetadata expressionType;
  gd::EventsList events;
  FunctionType functionType;
  std::vector<gd::ParameterMetadata> parameters;
  mutable std::vector<gd::ParameterMetadata> actionWithOperationParameters;
  gd::ObjectGroupsContainer objectGroups;
  bool isPrivate = false;
  bool isAsync = false;
};
 
}  // namespace gd
 
#endif  // GDCORE_EVENTSFUNCTION_H
#endif