code: protected List<String> initializeArgumentRecursive(BasicDoubleLinkedNode<CliArgumentContainer> node,
        Map<String, BasicDoubleLinkedNode<CliArgumentContainer>> argumentMap) {
  
      CliArgumentContainer argumentContainer = node.getValue();
      InitializationState state = argumentContainer.getState();
      if (!state.isInitialized()) {
        if (state.isInitializing()) {
          // cycle detected
          List<String> cycle = new ArrayList<>();
          cycle.add(argumentContainer.getId());
          return cycle;
        } else {
          state.setInitializing();
        }
        CliArgument cliArgument = argumentContainer.getArgument();
        String nextTo = cliArgument.addCloseTo();
        assert (!CliArgument.ID_FIRST.equals(nextTo) && !CliArgument.ID_LAST.equals(nextTo));
        BasicDoubleLinkedNode<CliArgumentContainer> nextToNode = argumentMap.get(nextTo);
        if (nextToNode == null) {
          throw new CliArgumentReferenceMissingException(argumentContainer);
        }
        boolean addAfter = cliArgument.addAfter();
        List<String> cycle = initializeArgumentRecursive(nextToNode, argumentMap);
        if (cycle != null) {
          return cycle;
        }
        if (addAfter) {
          nextToNode.insertAsNext(node);
        } else {
          nextToNode.insertAsPrevious(node);
        }
        state.setInitialized();
      }
      return null;
    }
docs: This method initializes the {@link BasicDoubleLinkedNode node} {@link BasicDoubleLinkedNode#getValue() containing}
  an {@link CliArgumentContainer} in order to determine the appropriate order of the {@link CliArgument}s.
  
  @param node is the node to initialize (link into the node-list).
  @param argumentMap maps the {@link CliArgumentContainer#getId() id} to the according argument-node.
  @return a {@link List} of {@link CliArgumentContainer#getId() CLI argument IDs} (in reverse order) of a cyclic
  dependency that was detected, or {@code null} if the initialization was successful.