How to remove from an etl::intrusive_list

[pwsoftwaredesigns]

I have been manually writing intrusive list code in my applications. I wanted to write a template classes to perform all the logic of an intrusive list instead of doing it manually over and over. But I discovered that ETL already has an intrusive_list type that seems to do what I want. I understand how an item is added to the list.

However, I can't figure out how to remove an item from the list. Using the remove method isn't quite right because it requires the underlying type has operator== (which doesn't check that the items being remove is the same item, only that it is logically equivalent). If I were writing an intrusive list myself, the "remove" method would take a pointer (or reference) to the node, it would then search the list to make sure the node is actually a part of the list, then remove the item from the list by changing the intrusive links.

Is there a way to do this with etl::intrusive_list?

[jwellbelove]

I originally wrote the intrusive containers to act as much like their non-intrusive counterparts as possible.
It would be simple to add an overload of the remove member function that took a reference to an intrusive node.
This would undoubtedly be relevant to the other intrusive containers.

[jwellbelove]

My bad, I just realised that the const_reference type sent to remove is a link node.

[jwellbelove]

I think that remove is doing the correct thing here. The remove function in std::list/etl::list removes all nodes that have the specified 'value'. The expectation for etl::intrusive_list is that == will compare the 'data' portion of the intrusive link (maybe not properly documented) .

The function that maybe should be overloaded is erase.

[jwellbelove]

using Link = etl::bidirectional_link<0>;

class Node : public Link
{
public:

  ItemNDCNode()
    : data(0)
  {
  }

  int data;
};

bool operator ==(const Node& lhs, const Node& rhs)
{
  return lhs.data == rhs.data;
}

[jwellbelove]

I propose that this member function is added.

It takes a reference to a node.

If the node is in the list it either returns a pointer to the next node in the list
or ETL_NULLPTR if the node was the last in the list.

If the node is not in the list it returns ETL_NULLPTR.

    //*************************************************************************
    /// Erases the specified node.
    //*************************************************************************
    node_type* erase(node_type& node)
    {
      node_type* result = ETL_NULLPTR;

      if (this->is_link_in_list(node))
      {
        link_type& link   = static_cast<link_type&>(node);
        link_type* p_next = link.etl_next;

        this->remove_link(link);

        if (p_next != &this->terminal_link)
        {
          result = static_cast<node_type*>(p_next);
        }
      }

      return result;
    }

[chenlijun99]

Hi. Would it be possible to have a less safe erase operation that assumes that the node is already in the intrusive_list?
Oftentimes, when I use intrusive_list, it is because the node could be placed in several lists at different times and I already have other means to know in which list the node is.

[chenlijun99]

Perhaps we can just make the disconnect_link method public.