EventsCodeGenerationContext.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 <set>
 
#include "GDCore/String.h"
 
namespace gd {
 
class GD_CORE_API EventsCodeGenerationContext {
  friend class EventsCodeGenerator;
 
 public:
  EventsCodeGenerationContext(unsigned int* maxDepthLevel_ = nullptr)
      : maxDepthLevel(maxDepthLevel_){};
  virtual ~EventsCodeGenerationContext(){};
 
  void InheritsFrom(EventsCodeGenerationContext& parent);
 
  void InheritsAsAsyncCallbackFrom(EventsCodeGenerationContext& parent);
 
  void Reuse(EventsCodeGenerationContext& parent);
 
  void ForbidReuse() { reuseExplicitlyForbidden = true; }
 
  bool CanReuse() const {
    return !reuseExplicitlyForbidden && parent != nullptr;
  }
 
  size_t GetContextDepth() const { return contextDepth; }
 
  const EventsCodeGenerationContext* GetParentContext() const { return parent; }
 
  void SetCurrentObject(const gd::String& objectName) {
    currentObject = objectName;
  };
 
  void SetNoCurrentObject() { currentObject = ""; };
 
  const gd::String& GetCurrentObject() const { return currentObject; };
 
  void ObjectsListNeeded(const gd::String& objectName);
 
  void ObjectsListNeededOrEmptyIfJustDeclared(const gd::String& objectName);
 
  void EmptyObjectsListNeeded(const gd::String& objectName);
 
  bool ObjectAlreadyDeclaredByParents(const gd::String& objectName) const {
    return (alreadyDeclaredObjectsLists.find(objectName) !=
            alreadyDeclaredObjectsLists.end());
  };
 
  std::set<gd::String> GetAllObjectsToBeDeclared() const;
 
  const std::set<gd::String>& GetObjectsListsToBeDeclared() const {
    return objectsListsToBeDeclared;
  };
 
  const std::set<gd::String>& GetObjectsListsToBeEmptyIfJustDeclared()
      const {
    return objectsListsOrEmptyToBeDeclared;
  };
 
  const std::set<gd::String>& GetObjectsListsToBeDeclaredEmpty() const {
    return emptyObjectsListsToBeDeclared;
  };
 
  const std::set<gd::String>& GetObjectsListsAlreadyDeclaredByParents() const {
    return alreadyDeclaredObjectsLists;
  };
 
  unsigned int GetLastDepthObjectListWasNeeded(
      const gd::String& objectName) const;
 
  bool IsSameObjectsList(const gd::String& objectName,
                         const EventsCodeGenerationContext& otherContext) const;
 
  void EnterCustomCondition() { customConditionDepth++; };
 
  void LeaveCustomCondition() { customConditionDepth--; };
 
  size_t GetCurrentConditionDepth() const { return customConditionDepth; }
 
  const std::set<gd::String>& GetAllDeclaredObjectsAcrossChildren() {
    return allObjectsListToBeDeclaredAcrossChildren;
  };
 
  bool ShouldUseAsyncObjectsList(const gd::String& objectName) const;
 
  bool IsInsideAsync() const { return asyncDepth != 0; };
 
  bool IsAsyncCallback() const { return parent != nullptr && parent->asyncDepth != asyncDepth; }
 
  void SetFollowedByElseEvent(bool followed) {
    followedByElseEvent = followed;
  }
 
  bool IsFollowedByElseEvent() const { return followedByElseEvent; }
 
  bool IsToBeDeclared(const gd::String& objectName) {
    return objectsListsToBeDeclared.find(objectName) !=
               objectsListsToBeDeclared.end() ||
           objectsListsOrEmptyToBeDeclared.find(objectName) !=
               objectsListsOrEmptyToBeDeclared.end() ||
           emptyObjectsListsToBeDeclared.find(objectName) !=
               emptyObjectsListsToBeDeclared.end();
  };
 
 private:
  void NotifyAsyncParentsAboutDeclaredObject(const gd::String& objectName);
 
  std::set<gd::String>
      alreadyDeclaredObjectsLists;  
  std::set<gd::String>
      objectsListsToBeDeclared;  
  std::set<gd::String>
      objectsListsOrEmptyToBeDeclared;  
  std::set<gd::String>
      emptyObjectsListsToBeDeclared;  
  std::set<gd::String>
      allObjectsListToBeDeclaredAcrossChildren;  
 
  std::map<gd::String, unsigned int>
      depthOfLastUse;  
  gd::String
      currentObject;  
  unsigned int contextDepth = 0;  
  unsigned int customConditionDepth =
      0;  
  unsigned int asyncDepth =
      0;  
  unsigned int* maxDepthLevel;  
  const EventsCodeGenerationContext* parent =
      nullptr;  
  EventsCodeGenerationContext* nearestAsyncParent =
      nullptr;  
  bool reuseExplicitlyForbidden =
      false;  
  bool followedByElseEvent =
      false;  
};
 
}  // namespace gd