GenericWaypointManager.h

#pragma once

#include <iostream>

#include "GenericSlicer.h"

namespace WaypointManager {

template<class WaypointType,
         template<class, class...> class ContainerType,
         class MissionItemList,
         class SettingsType>
class GenericWaypointManager
{
public:
    typedef GenericSlicer<WaypointType, ContainerType> Slicer;
    typedef ContainerType<WaypointType>  WaypointList;

    GenericWaypointManager() = delete;
    GenericWaypointManager(Slicer *slicer, SettingsType *settings);

    // Waypoint editing.
    void            setWaypoints(const WaypointList &waypoints);
    void            push_back   (const WaypointType &wp);
    void            push_front  (const WaypointType &wp);
    void            clear       ();
    void            insert      (std::size_t i, const WaypointType &wp);
    std::size_t     size        ()  const;
    WaypointType    &at         (std::size_t i);


    const WaypointList      &waypoints() const;
    const WaypointList      &slice() const;
    const MissionItemList   &missionItems() const;

    virtual bool update() = 0;
    virtual bool next() = 0;
    virtual bool previous() = 0;
    virtual bool reset() = 0;

protected:
    WaypointList        _waypoints;
    WaypointList        _slice;
    MissionItemList     _missionItems;
    Slicer             *_slicer;
    SettingsType       *_settings;
};


template<class WaypointType,
         template<class, class...> class ContainerType,
         class MissionItemList,
         class SettingsType>
GenericWaypointManager<WaypointType,
                       ContainerType,
                       MissionItemList,
                       SettingsType>::GenericWaypointManager(
        Slicer *slicer,
        SettingsType *Settings
        )
  : _slicer(slicer)
  , _settings(_settings)
{}

template<class WaypointType,
         template<class, class...> class ContainerType,
         class MissionItemList,
         class SettingsType>
void GenericWaypointManager<WaypointType,
                            ContainerType,
                            MissionItemList,
                            SettingsType>::push_back(const WaypointType &wp)
{
    _waypoints.push_back(wp);
}

template<class WaypointType,
         template<class, class...> class ContainerType,
         class MissionItemList,
         class SettingsType>
void GenericWaypointManager<WaypointType,
                            ContainerType,
                            MissionItemList,
                            SettingsType>::push_front(
        const WaypointType &wp)
{
    _waypoints.push_front(wp);
}

template<class WaypointType,
         template<class, class...> class ContainerType,
         class MissionItemList,
         class SettingsType>
void GenericWaypointManager<WaypointType,
                            ContainerType,
                            MissionItemList,
                            SettingsType>::clear()
{
    _waypoints.clear();
}

template<class WaypointType,
         template<class, class...> class ContainerType,
         class MissionItemList,
         class SettingsType>
void GenericWaypointManager<WaypointType,
                            ContainerType,
                            MissionItemList,
                            SettingsType>::insert(std::size_t i,
                                                  const WaypointType &wp)
{
    _waypoints.insert(i, wp);
}

template<class WaypointType,
         template<class, class...> class ContainerType,
         class MissionItemList,
         class SettingsType>
std::size_t GenericWaypointManager<WaypointType,
                                   ContainerType,
                                   MissionItemList,
                                   SettingsType>::size() const
{
    return _waypoints.size();
}

template<class WaypointType,
         template<class, class...> class ContainerType,
         class MissionItemList,
         class SettingsType>
WaypointType & GenericWaypointManager<WaypointType,
                                      ContainerType,
                                      MissionItemList,
                                      SettingsType>::at(std::size_t i)
{
    return _waypoints.at(i);
}

template<class WaypointType,
         template<class, class...> class ContainerType,
         class MissionItemList,
         class SettingsType>
const ContainerType<WaypointType>  &GenericWaypointManager<WaypointType,
                                                           ContainerType,
                                                           MissionItemList,
                                                           SettingsType>::waypoints() const
{
    return _waypoints;
}

template<class WaypointType,
         template<class, class...> class ContainerType,
         class MissionItemList,
         class SettingsType>
const ContainerType<WaypointType> &GenericWaypointManager<WaypointType,
                                                          ContainerType,
                                                          MissionItemList,
                                                          SettingsType>::slice() const
{
    return _slice;
}

template<class WaypointType,
         template<class, class...> class ContainerType,
         class MissionItemList,
         class SettingsType>
const MissionItemList &GenericWaypointManager<WaypointType,
                                              ContainerType,
                                              MissionItemList,
                                              SettingsType>::missionItems() const
{
    return _missionItems;
}

template<class WaypointType,
         template<class, class...> class ContainerType,
         class MissionItemList,
         class SettingsType>
void GenericWaypointManager<WaypointType,
                            ContainerType,
                            MissionItemList,
                            SettingsType>::setWaypoints(const ContainerType<WaypointType> &waypoints)
{
    _waypoints = waypoints;
}



} // namespace WaypointManager