# insertAll method

1. @override

void insertAll(

1. int index,
2. Iterable<E> iterable

)
override

Inserts all objects of `iterable` at position `index` in this list.

This increases the length of the list by the length of `iterable` and shifts all later objects towards the end of the list.

The list must be growable. The `index` value must be non-negative and no greater than length.

    final numbers = <int>[1, 2, 3, 4];
    final insertItems = [10, 11];
    numbers.insertAll(2, insertItems);
    print(numbers); // [1, 2, 10, 11, 3, 4]

## Implementation

    @override
    void insertAll(int index, Iterable<E> iterable) {
      if (index < 0 || index > _length) {
        throw RangeError.index(index, this, 'index', null, _length);
      }
      if (iterable.isEmpty) return;

      final temp = iterable.toList();

      if (index == _length) {
        addAll(temp);
        return;
      }
      if (index == 0) {
        final firstNewNode = _Node(temp.first);
        _Node<E>? currentNewNode = firstNewNode;
        for (int i = 1; i < temp.length; i++) {
          final newNode = _Node(temp[i]);
          currentNewNode!.next = newNode;
          newNode.prev = currentNewNode;
          currentNewNode = newNode;
        }
        currentNewNode!.next = _head;
        _head!.prev = currentNewNode;
        _head = firstNewNode;
        _length += temp.length;
        return;
      }

      final nodeAtIndex = _getNodeAt(index)!;
      final prevNode = nodeAtIndex.prev!;

      _Node<E>? firstNewNode;
      _Node<E>? lastNewNode;

      for (final element in temp) {
        final newNode = _Node(element);
        firstNewNode ??= newNode;

        if (lastNewNode != null) {
          lastNewNode.next = newNode;
          newNode.prev = lastNewNode;
        }
        lastNewNode = newNode;
      }

      prevNode.next = firstNewNode;
      firstNewNode!.prev = prevNode;
      lastNewNode!.next = nodeAtIndex;
      nodeAtIndex.prev = lastNewNode;
      _length += temp.length;
    }