Deprecate outdated containers and implement using standard library

examples/stm32_f4ve/gui/main.cpp

@@ -22,7 +22,6 @@
 #include <modm/ui/display/image.hpp>
 #include <modm/driver/touch/ads7843.hpp>
 #include <modm/container.hpp>
-#include <modm/utils/allocator.hpp>
 
 #include <modm/ui/gui.hpp>
 

examples/stm32f4_discovery/open407v-d/gui/main.cpp

@@ -21,7 +21,6 @@
 #include <modm/ui/display/image.hpp>
 #include <modm/driver/touch/ads7843.hpp>
 #include <modm/container.hpp>
-#include <modm/utils/allocator.hpp>
 
 #include <modm/ui/gui.hpp>
 

src/modm/container/doubly_linked_list.hpp

@@ -4,6 +4,7 @@
  * Copyright (c) 2012, Niklas Hauser
  * Copyright (c) 2013, Sascha Schade
  * Copyright (c) 2014, Daniel Krebs
+ * Copyright (c) 2023, Christopher Durand
  *
  * This file is part of the modm project.
  *
@@ -16,9 +17,7 @@
 #ifndef MODM_DOUBLY_LINKED_LIST_HPP
 #define MODM_DOUBLY_LINKED_LIST_HPP
 
-#include <stdint.h>
-#include <modm/utils/allocator.hpp>
-#include <iterator>
+#include <list>
 
 namespace modm
 {
@@ -30,177 +29,133 @@ namespace modm
  * \author Fabian Greif
  * \ingroup modm_container
  */
- template <typename T, typename Allocator = allocator::Dynamic<T> >
- class DoublyLinkedList
+ template <typename T, typename Allocator = std::allocator<T>>
+ class [[deprecated("Use std::list instead")]] DoublyLinkedList
  {
  public:
- DoublyLinkedList(const Allocator& allocator = Allocator());
+ using const_iterator = std::list<T>::const_iterator;
+ using iterator = std::list<T>::iterator;
+ using Size = std::size_t;
 
- ~DoublyLinkedList();
+ DoublyLinkedList(const Allocator& allocator = Allocator())
+ : data_{std::move(allocator)}
+ {}
 
  /// check if there are any nodes in the list
- inline bool
- isEmpty() const;
+ bool
+ isEmpty() const
+ {
+ return data_.empty();
+ }
 
- /**
- * \brief Get number of items in the list
- *
- * Very slow for a long list as it needs to iterate through all
- * items in the list.
- */
+ /// Get number of items in the list
  std::size_t
- getSize() const;
+ getSize() const
+ {
+ return data_.size();
+ }
 
  /// Insert in front
  bool
- prepend(const T& value);
+ prepend(const T& value)
+ {
+ data_.push_front(value);
+ return true;
+ }
 
  /// Insert at the end of the list
- void
- append(const T& value);
+ bool
+ append(const T& value)
+ {
+ data_.push_back(value);
+ return true;
+ }
 
  /// Remove the first entry
  void
- removeFront();
+ removeFront()
+ {
+ data_.pop_front();
+ }
 
  void
- removeBack();
-
- /**
- * \return the first node in the list
- */
- inline const T&
- getFront() const;
-
- /**
- * \return the last node in the list
- */
- inline const T&
- getBack() const;
-
- protected:
- struct Node
+ removeBack()
  {
- T value;
-
- Node *previous;
- Node *next;
- };
+ data_.pop_back();
+ }
 
- // The stored instance is not actually of type Allocator. Instead we
- // rebind the type to Allocator<Node<T>>. Node<T> is not the same
- // size as T (it's one pointer larger), and specializations on T may go
- // unused because Node<T> is being bound instead.
- typedef typename Allocator::template rebind< Node >::other NodeAllocator;
-
- NodeAllocator nodeAllocator;
-
- Node *front;
- Node *back;
+ T&
+ getFront()
+ {
+ return data_.front();
+ }
 
- public:
- #pragma GCC diagnostic push
- #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
  /**
- * \brief Forward iterator
- *
- * \todo decrement operator doesn't work correctly
+ * \return the first node in the list
  */
- class iterator : public std::iterator<std::forward_iterator_tag, T>
+ const T&
+ getFront() const
  {
- friend class DoublyLinkedList;
- friend class const_iterator;
-
- public:
- /// Default constructor
- iterator();
- iterator(const iterator& other);
-
- iterator& operator = (const iterator& other);
- iterator& operator ++ ();
- iterator& operator -- ();
- bool operator == (const iterator& other) const;
- bool operator != (const iterator& other) const;
- T& operator * ();
- T* operator -> ();
-
- private:
- iterator(Node* node);
+ return data_.front();
+ }
 
- Node* node;
- };
+ T&
+ getBack()
+ {
+ return data_.back();
+ }
 
  /**
- * \brief forward const iterator
- *
- * \todo decrement operator doesn't work correctly
+ * \return the last node in the list
  */
- class const_iterator : public std::iterator<std::forward_iterator_tag, T>
- {
- friend class DoublyLinkedList;
-
- public:
- /// Default constructor
- const_iterator();
-
- /**
- * \brief Copy constructor
- *
- * Used to convert a normal iterator to a const iterator.
- * The other way is not possible.
- */
- const_iterator(const iterator& other);
-
- /**
- * \brief Copy constructor
- */
- const_iterator(const const_iterator& other);
-
- const_iterator& operator = (const const_iterator& other);
- const_iterator& operator ++ ();
- const_iterator& operator -- ();
- bool operator == (const const_iterator& other) const;
- bool operator != (const const_iterator& other) const;
- const T& operator * () const;
- const T* operator -> () const;
-
- private:
- const_iterator(const Node* node);
-
- const Node* node;
- };
- #pragma GCC diagnostic pop
+ const T&
+ getBack() const
+ {
+ return data_.back();
+ }
 
  /**
- * Returns a read/write iterator that points to the first element in  the
+ * Returns a read/write iterator that points to the first element in the
  * list. Iteration is done in ordinary element order.
  */
  iterator
- begin();
+ begin()
+ {
+ return data_.begin();
+ }
 
  /**
  * Returns a read-only (constant) iterator that points to the
  * first element in the list. Iteration is done in ordinary
  * element order.
  */
  const_iterator
- begin() const;
+ begin() const
+ {
+ return data_.begin();
+ }
 
  /**
  * Returns a read/write iterator that points one past the last
  * element in the list. Iteration is done in ordinary element
  * order.
  */
  iterator
- end();
+ end()
+ {
+ return data_.end();
+ }
 
  /**
  * Returns a read-only (constant) iterator that points one past
  * the last element in the list. Iteration is done in ordinary
  * element order.
  */
  const_iterator
- end() const;
+ end() const
+ {
+ return data_.end();
+ }
 
  /**
  * Deletes element pointed to by iterator and returns an iterator
@@ -209,20 +164,36 @@ namespace modm
  * Warning: you must not use the iterator after calling erase()
  */
  iterator
- erase(iterator position);
-
- private:
- friend class const_iterator;
- friend class iterator;
+ erase(iterator position)
+ {
+ if (position != data_.end()) {
+ return data_.erase(position);
+ } else {
+ return data_.end();
+ }
+ }
 
- DoublyLinkedList(const DoublyLinkedList& other);
+ /**
+ * Insert data after position iterator.
+ *
+ * This behavior is compatible with modm::LinkedList but different
+ * compared to std::list which inserts before the position iterator
+ * argument.
+ */
+ bool
+ insert(iterator position, const T& value)
+ {
+ if (position == data_.end()) {
+ data_.push_back(value);
+ } else {
+ data_.insert(std::next(position), value);
+ }
+ return true;
+ }
 
-  DoublyLinkedList&
- operator = (const DoublyLinkedList& other);
+ private:
+ std::list<T, Allocator> data_;
  };
 }
 
-#include "doubly_linked_list_impl.hpp"
-#include "doubly_linked_list_iterator_impl.hpp"
-
 #endif // MODM_DOUBLY_LINKED_LIST_HPP