ArbitraryEventsWorker.h

/*
 * GDevelop Core
 * Copyright 2008-2016 Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
#pragma once
 
#include <map>
#include <memory>
#include <vector>
#include "GDCore/Events/InstructionsList.h"
#include "GDCore/Events/EventVisitor.h"
#include "GDCore/Project/ProjectScopedContainers.h"
#include "GDCore/String.h"
 
namespace gd {
class Instruction;
class BaseEvent;
class LinkEvent;
class EventsList;
class ObjectsContainer;
class Expression;
class ParameterMetadata;
}  // namespace gd
 
namespace gd {
 
class GD_CORE_API AbstractArbitraryEventsWorker : private EventVisitor {
 public:
  AbstractArbitraryEventsWorker(){};
  virtual ~AbstractArbitraryEventsWorker();
 
protected:
  virtual bool VisitEvent(gd::BaseEvent& event) override;
  void VisitEventList(gd::EventsList& events);
 
 private:
  bool VisitLinkEvent(gd::LinkEvent& linkEvent) override;
  void VisitInstructionList(gd::InstructionsList& instructions,
                            bool areConditions);
  bool VisitInstruction(gd::Instruction& instruction, bool isCondition);
  bool VisitEventExpression(gd::Expression& expression, const gd::ParameterMetadata& metadata);
 
  virtual void DoVisitEventList(gd::EventsList& events){};
 
  virtual bool DoVisitEvent(gd::BaseEvent& event) { return false; };
 
  virtual bool DoVisitLinkEvent(gd::LinkEvent& event) { return false; };
 
  virtual void DoVisitInstructionList(gd::InstructionsList& instructions,
                                      bool areConditions){};
 
  virtual bool DoVisitInstruction(gd::Instruction& instruction,
                                  bool isCondition) {
    return false;
  };
 
  virtual bool DoVisitEventExpression(gd::Expression& expression,
                                      const gd::ParameterMetadata& metadata) {
    return false;
  }
};
 
class GD_CORE_API ArbitraryEventsWorker : public AbstractArbitraryEventsWorker {
public:
  ArbitraryEventsWorker(){};
  virtual ~ArbitraryEventsWorker();
 
  void Launch(gd::EventsList &events) {
    AbstractArbitraryEventsWorker::VisitEventList(events);
  };
 
private:
  bool VisitEvent(gd::BaseEvent &event) override;
};
 
class GD_CORE_API ArbitraryEventsWorkerWithContext
    : public AbstractArbitraryEventsWorker {
 public:
  ArbitraryEventsWorkerWithContext()
      : currentProjectScopedContainers(nullptr){};
  virtual ~ArbitraryEventsWorkerWithContext();
 
  void Launch(gd::EventsList& events,
              const gd::ProjectScopedContainers& projectScopedContainers) {
    currentProjectScopedContainers = &projectScopedContainers;
    AbstractArbitraryEventsWorker::VisitEventList(events);
  };
 
protected:
  const gd::ProjectScopedContainers& GetProjectScopedContainers() {
    // Pointers are guaranteed to be not nullptr after
    // Launch was called.
    return *currentProjectScopedContainers;
  };
  const gd::ObjectsContainersList& GetObjectsContainersList() {
    // Pointers are guaranteed to be not nullptr after
    // Launch was called.
    return currentProjectScopedContainers->GetObjectsContainersList();
  };
 
 private:
  bool VisitEvent(gd::BaseEvent& event) override;
 
  const gd::ProjectScopedContainers* currentProjectScopedContainers;
};
 
class GD_CORE_API AbstractReadOnlyArbitraryEventsWorker : private ReadOnlyEventVisitor {
 public:
  AbstractReadOnlyArbitraryEventsWorker() : shouldStopIteration(false) {};
  virtual ~AbstractReadOnlyArbitraryEventsWorker();
 
protected:
  void StopAnyEventIteration() override;
  virtual void VisitEvent(const gd::BaseEvent& event) override;
 
  void VisitEventList(const gd::EventsList& events);
 
 private:
  void VisitLinkEvent(const gd::LinkEvent& linkEvent) override;
  void VisitInstructionList(const gd::InstructionsList& instructions,
                            bool areConditions);
  void VisitInstruction(const gd::Instruction& instruction, bool isCondition);
  void VisitEventExpression(const gd::Expression& expression, const gd::ParameterMetadata& metadata);
 
  virtual void DoVisitEventList(const gd::EventsList& events){};
 
  virtual void DoVisitEvent(const gd::BaseEvent& event) {};
 
  virtual void DoVisitLinkEvent(const gd::LinkEvent& linkEvent) {};
 
  virtual void DoVisitInstructionList(const gd::InstructionsList& instructions,
                                      bool areConditions){};
 
  virtual void DoVisitInstruction(const gd::Instruction& instruction,
                                  bool isCondition) {};
 
  virtual void DoVisitEventExpression(const gd::Expression& expression,
                                      const gd::ParameterMetadata& metadata) {
  }
 
  bool shouldStopIteration;
};
 
class GD_CORE_API ReadOnlyArbitraryEventsWorker
    : public AbstractReadOnlyArbitraryEventsWorker {
public:
  ReadOnlyArbitraryEventsWorker(){};
  virtual ~ReadOnlyArbitraryEventsWorker();
 
  void Launch(const gd::EventsList &events) {
    AbstractReadOnlyArbitraryEventsWorker::VisitEventList(events);
  };
 
private:
  void VisitEvent(const gd::BaseEvent &event) override;
};
 
class GD_CORE_API ReadOnlyArbitraryEventsWorkerWithContext
    : public AbstractReadOnlyArbitraryEventsWorker {
 public:
  ReadOnlyArbitraryEventsWorkerWithContext()
      : currentProjectScopedContainers(nullptr){};
  virtual ~ReadOnlyArbitraryEventsWorkerWithContext();
 
  void Launch(const gd::EventsList& events,
              const gd::ProjectScopedContainers& projectScopedContainers) {
    currentProjectScopedContainers = &projectScopedContainers;
    AbstractReadOnlyArbitraryEventsWorker::VisitEventList(events);
  };
 
protected:
  const gd::ProjectScopedContainers& GetProjectScopedContainers() {
    // Pointers are guaranteed to be not nullptr after
    // Launch was called.
    return *currentProjectScopedContainers;
  };
 
 private:
  void VisitEvent(const gd::BaseEvent& event) override;
 
  const gd::ProjectScopedContainers* currentProjectScopedContainers;
};
 
}  // namespace gd