EventsBasedObjectVariantsContainer.h

/*
 * GDevelop Core
 * Copyright 2008-present Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
#pragma once
 
#include <vector>
#include "GDCore/Project/EventsBasedObjectVariant.h"
#include "GDCore/String.h"
#include "GDCore/Tools/SerializableWithNameList.h"
 
namespace gd {
class SerializerElement;
}
 
namespace gd {
 
class GD_CORE_API EventsBasedObjectVariantsContainer
    : private SerializableWithNameList<gd::EventsBasedObjectVariant> {
public:
  EventsBasedObjectVariantsContainer() {}
 
  EventsBasedObjectVariantsContainer(const EventsBasedObjectVariantsContainer &other) {
    Init(other);
  }
 
  EventsBasedObjectVariantsContainer &operator=(const EventsBasedObjectVariantsContainer &other) {
    if (this != &other) {
      Init(other);
    }
    return *this;
  }
 
 
  bool HasVariantNamed(const gd::String& name) const {
    return Has(name);
  }
 
  gd::EventsBasedObjectVariant& GetVariant(const gd::String& name) {
    return Get(name);
  }
 
  const gd::EventsBasedObjectVariant& GetVariant(const gd::String& name) const {
    return Get(name);
  }
 
  gd::EventsBasedObjectVariant& GetVariant(std::size_t index) {
    return Get(index);
  }
 
  const gd::EventsBasedObjectVariant& GetVariant(std::size_t index) const {
    return Get(index);
  }
 
  std::size_t GetVariantsCount() const { return GetCount(); }
 
  gd::EventsBasedObjectVariant& InsertNewVariant(const gd::String& name,
                                              std::size_t position) {
    return InsertNew(name, position);
  }
  gd::EventsBasedObjectVariant& InsertVariant(const gd::EventsBasedObjectVariant& object,
                                           std::size_t position) {
    return Insert(object, position);
  }
  void RemoveVariant(const gd::String& name) { return Remove(name); }
  void ClearVariants() { return Clear(); }
  void MoveVariant(std::size_t oldIndex, std::size_t newIndex) {
    return Move(oldIndex, newIndex);
  };
  std::size_t GetVariantPosition(const gd::EventsBasedObjectVariant& eventsFunction) {
    return GetPosition(eventsFunction);
  };
 
  const std::vector<std::unique_ptr<gd::EventsBasedObjectVariant>>& GetInternalVector()
      const {
    return elements;
  };
 
  std::vector<std::unique_ptr<gd::EventsBasedObjectVariant>>& GetInternalVector() {
    return elements;
  };
 
 
  void SerializeVariantsTo(SerializerElement& element) const {
    return SerializeElementsTo("variant", element);
  };
 
  void UnserializeVariantsFrom(gd::Project& project,
                                      const SerializerElement& element) {
    return UnserializeElementsFrom("variant", project, element);
  };
 protected:
  void Init(const gd::EventsBasedObjectVariantsContainer& other) {
    return SerializableWithNameList<gd::EventsBasedObjectVariant>::Init(other);
  };
 
private:
};
 
}  // namespace gd