具有通用节点类型的双链表

Question

I need a doubly linked list that can work on different node implementations. Note that I do not want nodes that contain generic data, like DoublyLinkedNode<T> , but something like DoublyLinkedList<N extends DoublyLinkedNode<T>> .

To be precise, I use the list in the general case with standard nodes, but in other parts of my program I need nodes with additional fields. So I implemented the general node as

public class DoublyLinkedNode<T> {
    DoublyLinkedNode<T> before, after;
    T value;
}

and the special type as

public class DoublyLinkedSpecialNode<T, S> extends DoublyLinkedNode<T> {
    S specialValue;
}

Now in my DoublyLinkedList implementation I want to be able to handle both cases at one, because all the code basically fiddles around with the pointers that are obviously common to both implementations.

This gives a few requirements:

1) When I use the special node, I want to be able to return it as the DoublyLinkedSpecialNode type to be able to access the additional fields.

2) The list must use a DoublyLinkedNode type to access the pointers of the nodes.

3) The list is assigning the pointed-to nodes to other nodes, eg head = node.after; , so the type of the pointers in the special node must be the same as the type in the list.

Extending the list makes no sense because then I could not change the return type of the methods. Therefore I tried two ideas without success:

The already mentioned solution: Generic node type that extends from DLN

The list would look like this:

public class DoublyLinkedList<T, N extends DoublyLinkedNode<T>> {
    N head, tail;
    N tail() {
        return tail; // OK
    }
    void remove(N node) {
        if (head == node) {
            head = node.after; // Type error
        }
...

This solution conflicts with requirement 3), because in the list the type is an N that extends from DLN, but in the node implementation N the pointer is of the type of the base class/interface DLN (the pointer type could theoretically be more general than N).

Base DLN instead of generics

In this case the list works on the base class node and accepts the subclasses because of polymorphism:

public class DoublyLinkedList<T> {
    DoublyLinkedNode<T> head, tail;
    DoublyLinkedNode<T> tail() {
        return tail; 
    }
    void remove(DoublyLinkedNode<T> node) {
        if (head == node) {
            head = node.after; // OK
        }
...

But tail() can only return nodes as the general type, conflicting with 1). I would prefer not to use casting, because I assume it's bad practice (?) but also because the implementation is performance critical. There surely is a better way?

Answer 1

I found another solution that is okay-ish, not very performant but more elegant than the last solution.

The idea ist to use only one type of nodes, and wrap the varying content in a generic container. The DLN code looks like this:

public class DoublyLinkedNode<C> {
    DoublyLinkedNode<C> before, after;
    C content;

    public static class ValueContent<T> {
        T value;
    }

    public static class ValueSpecialContent<T, S> extends ValueContent<T> {
        S specialValue;
    }
}

The list implementation then looks something like this:

public class DoublyLinkedList<C> {
    DoublyLinkedNode<C> head, tail;

    public DoublyLinkedNode<C> head() {
        return head;
    }

    void remove(DoublyLinkedNode<C> node) {
        if (head == node) {
            head = node.after;
...

And I can access the special field from the calling class like this:

DoublyLinkedList<SpecialContent<SpecialType>> list;
SpecialType s = list.head().content.specialValue;

There is some overhead because each node has to instantiate that container class, but I think it's still better than casting. I have to check the performance impact.