Question

I am writing a custom container class. A constituent object is created independently of the container, and can be a member of no container or multiple containers. The container’s public API should support three operations:

• iteration over all objects
• insertion of a new object
• removal of an existing object

The container does some additional work, and its precise implementation may change.

How can I write the public API to this class so that it remains stable as I change the implementation?

If the container is list-like, efficient removal requires the knowledge of the object’s index; knowing the object itself is no good (I don’t want to search the whole container for the element).

If the container is set-like, there’s nothing equivalent to the index, and I need the object itself.

If the container is like a singly linked list, I need some kind of a reference to the object preceding the object being removed.

If the container is like a doubly linked list, I need a reference to the object itself.

I am thinking to have the removal method take a single argument reference, which has no meaning or use outside of the removal method. The iteration would yield a pair of (object, reference).

Is there any problem with this design? Is there an example or design pattern I can look up?

Ideally, I would rather have the iteration yield a complex object that contains both the original object and the reference, and exhibits the interface of both. But I don’t suppose this is doable?

Answer 1

Here’s what I’ll do unless someone else helps by finding a better solution:

# to get __hash__ and __eq__ return id(self)
class Reference:
  def __init__(self, item):
    self.item = item

class RemovalAPI:
  def add_removal_info(self, item, removal_info):
    try:
      references = item.__reference
    except AttributeError:
      references = item.__reference = {}
    references[Reference(self)] = removal_info

  def get_removal_info(self, item):
    try:
      references = item.__reference
      self_reference = Reference(self)
      return references[self_reference]



class Container(list, RemovalAPI):
  def __iter__(self):
    for i in range(len(self)):
      item = self[i]
      self.add_removal_info(item, i)
      yield item

  def remove(self, item):
    removal_info = self.get_removal_info(item)
    del self[removal_info]

  def insert(self, item):
    self.add_removal_info(item, len(self))
    self.append(item)
    # do whatever post-processing I need
    # ...

If I then decide to change the implementation from list to some other data structure, the public interface can remain unchanged:

class Container(orderedset, RemovalAPI):
  # inheriting __iter__, remove from parent
  def insert(self, item):
    self.add(item)
    # do whatever post-processing I need
    # ...

Or…

class Container(linkedlist, RemovalAPI):
  def __iter__(self):
    it = super().__iter__()
    last_item = None
    for item in it:
      self.add_removal_info(item, last_item)
      yield item

  def remove(self, item):
    removal_info = self.get_removal_info(item)
    if removal_info is None:
      self.remove_first()
    else:
      self.remove_after(removal_info)

  def insert(self, item):
    self.add_removal_info(item, None)
    self.add_to_front(item)
    # do whatever post-processing I need
    # ...