ObjectsContainer.h

/*
 * GDevelop Core
 * Copyright 2008-2016 Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
#pragma once
 
#include <memory>
#include <vector>
#include <set>
#include "GDCore/Project/MemoryTrackedRegistry.h"
#include "GDCore/String.h"
#include "GDCore/Project/ObjectGroupsContainer.h"
#include "GDCore/Project/ObjectFolderOrObject.h"
namespace gd {
class Object;
class Project;
class SerializerElement;
}  // namespace gd
#undef GetObject  // Disable an annoying macro
 
namespace gd {
 
class GD_CORE_API ObjectsContainer {
 public:
  enum SourceType {
      Unknown,
      Global,
      Scene,
      Object,
      Function,
  };
 
  ObjectsContainer(const SourceType sourceType);
  virtual ~ObjectsContainer();
 
  ObjectsContainer(const ObjectsContainer&);
  ObjectsContainer& operator=(const ObjectsContainer& rhs);
 
  SourceType GetSourceType() const { return sourceType; }
 
 
  bool HasObjectNamed(const gd::String& name) const;
 
  gd::Object& GetObject(const gd::String& name);
 
  const gd::Object& GetObject(const gd::String& name) const;
 
  gd::Object& GetObject(std::size_t index);
 
  const gd::Object& GetObject(std::size_t index) const;
 
  std::size_t GetObjectPosition(const gd::String& name) const;
 
  std::size_t GetObjectsCount() const;
 
  gd::Object& InsertNewObject(const gd::Project& project,
                              const gd::String& objectType,
                              const gd::String& name,
                              std::size_t position);
  gd::Object& InsertNewObjectInFolder(
      const gd::Project& project,
      const gd::String& objectType,
      const gd::String& name,
      gd::ObjectFolderOrObject& objectFolderOrObject,
      std::size_t position);
 
  gd::Object& InsertObject(const gd::Object& object, std::size_t position);
 
  void RemoveObject(const gd::String& name);
 
  void MoveObject(std::size_t oldIndex, std::size_t newIndex);
 
  void MoveObjectFolderOrObjectToAnotherContainerInFolder(
      gd::ObjectFolderOrObject& objectFolderOrObject,
      gd::ObjectsContainer& newContainer,
      gd::ObjectFolderOrObject& newParentFolder,
      std::size_t newPosition);
 
  void Clear();
 
  std::vector<std::unique_ptr<gd::Object> >& GetObjects() {
    return initialObjects;
  }
 
  const std::vector<std::unique_ptr<gd::Object> >& GetObjects() const {
    return initialObjects;
  }
 
  std::set<gd::String> GetAllObjectNames() const;
 
  std::vector<const ObjectFolderOrObject*> GetAllObjectFolderOrObjects() const;
 
  gd::ObjectFolderOrObject& GetRootFolder() {
      return *rootFolder;
  }
 
  void AddMissingObjectsInRootFolder();
 
 
  void SerializeObjectsTo(SerializerElement& element) const;
 
  void UnserializeObjectsFrom(gd::Project& project,
                              const SerializerElement& element);
  void SerializeFoldersTo(SerializerElement& element) const;
 
  void UnserializeFoldersFrom(gd::Project& project,
                              const SerializerElement& element);
 
 
  ObjectGroupsContainer& GetObjectGroups() { return objectGroups; }
 
  const ObjectGroupsContainer& GetObjectGroups() const { return objectGroups; }
 
 
 protected:
  std::vector<std::unique_ptr<gd::Object> >
      initialObjects;  
  gd::ObjectGroupsContainer objectGroups;
 
 private:
  SourceType sourceType = Unknown;
  std::unique_ptr<gd::ObjectFolderOrObject> rootFolder;
  gd::MemoryTracked _memoryTracked{this, "ObjectsContainer"};
 
  void Init(const ObjectsContainer& other);
};
 
}  // namespace gd