SerializableWithNameList.h

/*
 * GDevelop Core
 * Copyright 2008-present Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
 
#ifndef GDCORE_SerializableWithNameList
#define GDCORE_SerializableWithNameList
#include <memory>
#include <vector>
#include "GDCore/String.h"
namespace gd {
class Project;
class SerializerElement;
}  // namespace gd
 
namespace gd {
 
template <typename T>
class SerializableWithNameList {
 public:
  SerializableWithNameList();
  SerializableWithNameList(const SerializableWithNameList<T>&);
  virtual ~SerializableWithNameList(){};
  SerializableWithNameList<T>& operator=(
      const SerializableWithNameList<T>& rhs);
 
  T& Insert(const T& element, size_t position = (size_t)-1);
 
  void Insert(const SerializableWithNameList<T>& otherEvents,
              size_t begin,
              size_t end,
              size_t position = (size_t)-1);
 
  T& InsertNew(const gd::String& name, size_t position = (size_t)-1);
 
  size_t GetCount() const { return elements.size(); };
 
  T& Get(const gd::String& name);
 
  const T& Get(const gd::String& name) const;
 
  T& Get(size_t index) { return *elements[index]; };
 
  const T& Get(size_t index) const { return *elements[index]; };
 
  void Remove(const gd::String& name);
 
  void Remove(size_t index);
 
  bool IsEmpty() const { return elements.empty(); };
 
  void Clear() { return elements.clear(); };
 
  void Move(std::size_t oldIndex, std::size_t newIndex);
 
  bool Has(const gd::String& name) const;
 
  std::size_t GetPosition(const T& element) const;
 
 
  size_t size() const { return GetCount(); }
 
  bool empty() const { return IsEmpty(); }
 
  T& operator[](size_t index) { return Get(index); };
 
  const T& operator[](size_t index) const { return Get(index); };
 
  T& at(size_t index) { return Get(index); };
 
  const T& at(size_t index) const { return Get(index); };
 
 
  const std::vector<std::unique_ptr<T>>& GetInternalVector() const {
    return elements;
  };
 
  std::vector<std::unique_ptr<T>>& GetInternalVector() { return elements; };
 
  void SerializeElementsTo(const gd::String& elementName,
                           SerializerElement& element) const;
 
  void UnserializeElementsFrom(const gd::String& elementName,
                               gd::Project& project,
                               const SerializerElement& element);
 
  void UnserializeElementsFrom(const gd::String& elementName,
                               const SerializerElement& element);
 
  void ProgressivelyUnserializeElementsFrom(const gd::String& elementName,
                               gd::Project& project,
                               const SerializerElement& element);
 
 protected:
  std::vector<std::unique_ptr<T>> elements;
 
  void Init(const SerializableWithNameList<T>& other);
};
 
}  // namespace gd
 
#include "SerializableWithNameList.inl"
 
#endif