EventsList.h

/*
 * GDevelop Core
 * Copyright 2008-2016 Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
#if defined(GD_IDE_ONLY)
#ifndef GDCORE_EVENTSLIST_H
#define GDCORE_EVENTSLIST_H
#include <memory>
#include <vector>
#include "GDCore/String.h"
namespace gd {
class Project;
}
namespace gd {
class BaseEvent;
}
namespace gd {
class SerializerElement;
}
 
#undef CreateEvent
 
namespace gd {
 
class GD_CORE_API EventsList {
 public:
  EventsList();
  EventsList(const EventsList&);
  virtual ~EventsList(){};
  EventsList& operator=(const EventsList& rhs);
 
  gd::BaseEvent& InsertEvent(const gd::BaseEvent& event,
                             size_t position = (size_t)-1);
 
  void InsertEvent(std::shared_ptr<gd::BaseEvent> event,
                   size_t position = (size_t)-1);
 
  gd::BaseEvent& InsertNewEvent(gd::Project& project,
                                const gd::String& eventType,
                                size_t position = (size_t)-1);
 
  void InsertEvents(const EventsList& otherEvents,
                    size_t begin,
                    size_t end,
                    size_t position = (size_t)-1);
 
  size_t GetEventsCount() const { return events.size(); };
 
  std::shared_ptr<BaseEvent> GetEventSmartPtr(size_t index) {
    return events[index];
  };
 
  std::shared_ptr<const BaseEvent> GetEventSmartPtr(size_t index) const {
    return events[index];
  };
 
  gd::BaseEvent& GetEvent(size_t index) { return *events[index]; };
 
  const gd::BaseEvent& GetEvent(size_t index) const { return *events[index]; };
 
  void RemoveEvent(const gd::BaseEvent& event);
 
  void RemoveEvent(size_t index);
 
  bool IsEmpty() const { return events.empty(); };
 
  void Clear() { return events.clear(); };
 
 
  bool Contains(const gd::BaseEvent& eventToSearch,
                bool recursive = true) const;
 
  bool MoveEventToAnotherEventsList(const gd::BaseEvent& eventToMove,
                                    gd::EventsList& newEventsList,
                                    std::size_t newPosition);
 
 
  size_t size() const { return GetEventsCount(); }
 
  gd::BaseEvent& operator[](size_t index) { return GetEvent(index); };
 
  const gd::BaseEvent& operator[](size_t index) const {
    return GetEvent(index);
  };
 
 
  void SerializeTo(SerializerElement& element) const;
 
  void UnserializeFrom(gd::Project& project, const SerializerElement& element);
 
 private:
  std::vector<std::shared_ptr<BaseEvent> > events;
 
  void Init(const gd::EventsList& other);
};
 
}  // namespace gd
 
#endif
#endif