ArbitraryEventsWorker.h

/*
 * GDevelop Core
 * Copyright 2008-2016 Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
#ifndef GDCORE_ARBITRARYEVENTSWORKER_H
#define GDCORE_ARBITRARYEVENTSWORKER_H
#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 ArbitraryEventsWorker : private EventVisitor {
 public:
  ArbitraryEventsWorker(){};
  virtual ~ArbitraryEventsWorker();
 
  void Launch(gd::EventsList& events) { VisitEventList(events); };
 
 private:
  void VisitEventList(gd::EventsList& events);
  bool VisitEvent(gd::BaseEvent& event) override;
  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 ArbitraryEventsWorkerWithContext
    : public ArbitraryEventsWorker {
 public:
  ArbitraryEventsWorkerWithContext()
      : projectScopedContainers(nullptr){};
  virtual ~ArbitraryEventsWorkerWithContext();
 
  void Launch(gd::EventsList& events,
              const gd::ProjectScopedContainers& projectScopedContainers_) {
    projectScopedContainers = &projectScopedContainers_;
    ArbitraryEventsWorker::Launch(events);
  };
 
  void Launch(gd::EventsList& events) = delete;
 
 protected:
  const gd::ProjectScopedContainers& GetProjectScopedContainers() {
    // Pointers are guaranteed to be not nullptr after
    // Launch was called.
    return *projectScopedContainers;
  };
  const gd::ObjectsContainersList& GetObjectsContainersList() {
    // Pointers are guaranteed to be not nullptr after
    // Launch was called.
    return projectScopedContainers->GetObjectsContainersList();
  };
 
 private:
  const gd::ProjectScopedContainers* projectScopedContainers;
};
 
class GD_CORE_API ReadOnlyArbitraryEventsWorker : private ReadOnlyEventVisitor {
 public:
  ReadOnlyArbitraryEventsWorker() : shouldStopIteration(false) {};
  virtual ~ReadOnlyArbitraryEventsWorker();
 
  void Launch(const gd::EventsList& events) { VisitEventList(events); };
 
protected:
  void StopAnyEventIteration() override;
 
 private:
  void VisitEventList(const gd::EventsList& events);
  void VisitEvent(const gd::BaseEvent& event) override;
  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 ReadOnlyArbitraryEventsWorkerWithContext
    : public ReadOnlyArbitraryEventsWorker {
 public:
  ReadOnlyArbitraryEventsWorkerWithContext()
      : projectScopedContainers(nullptr){};
  virtual ~ReadOnlyArbitraryEventsWorkerWithContext();
 
  void Launch(const gd::EventsList& events,
              const gd::ProjectScopedContainers& projectScopedContainers_) {
    projectScopedContainers = &projectScopedContainers_;
    ReadOnlyArbitraryEventsWorker::Launch(events);
  };
 
  void Launch(gd::EventsList& events) = delete;
 
 protected:
  const gd::ProjectScopedContainers& GetProjectScopedContainers() {
    // Pointers are guaranteed to be not nullptr after
    // Launch was called.
    return *projectScopedContainers;
  };
 
 private:
  const gd::ProjectScopedContainers* projectScopedContainers;
};
 
}  // namespace gd
 
#endif  // GDCORE_ARBITRARYEVENTSWORKER_H