The document provides a Java implementation of a doubly linked list called 'ciscdoublylinkedlist', which includes methods for basic list operations such as adding, removing, and checking the size of the list. The code employs a private inner class 'node' to handle the individual elements of the linked list. It defines several methods with appropriate error handling for null elements and index out-of-bounds cases.

1. Please complete all the code as per instructions in Java programming import org.w3c.dom.Node;
import javax.xml.crypto.NodeSetData; import java.awt.*; import java.util.Iterator; import
java.util.NoSuchElementException; /** * This class implements an acyclic (non-cyclic), doubly-
linked list. * @param */ public class CiscDoublyLinkedList implements CiscList { /** * A
reference to the first node in the list (or null if list is empty). */ private Node head; /** * A
reference to the last node int the list (or null if list is empty). */ private Node tail; /** * Number
of elements in the list. */ private int size; /** * Returns the number of elements in this list. * * *
@return the number of elements in this list */ @Override public int size() { return size; } /** *
Returns {@code true} if this list contains no elements. * * * @return {@code true} if this list
contains no elements */ @Override public boolean isEmpty() { if (size == 0){ return true; }
return false; } /** * Returns {@code true} if this list contains the specified element (compared
using the {@code equals} method). * * * @param o element whose presence in this list is to be
tested * @return {@code true} if this list contains the specified element * @throws
NullPointerException if the specified element is null */ @Override public boolean
contains(Object o) { if(o == null) { throw new NullPointerException(); } Node node = head;
while(node != null) { if(node.data.equals(o)){ return true; } node = node.next; } return false; }
/** * Returns the index of the first occurrence of the specified element in this list, or -1 if this list
does not * contain the element (compared using the {@code equals} method). * * * @param o
element to search for * @return the index of the first occurrence of the specified element in this
list, or -1 if this list does not * contain the element * @throws NullPointerException if the
specified element is null */ @Override public int indexOf(Object o) { if (o == null){ throw new
NullPointerException(); } for(int i =0; i = size){ throw new IndexOutOfBoundsException(); }
return null; } /** * Appends the specified element to the end of this list. * * *
Lists may place the specified element at arbitrary locations if desired. In particular, an ordered
list will * insert the specified element at its sorted location. List classes should clearly specify in
their documentation * how elements will be added to the list if different from the default
behavior (end of this list). * * @param e element to be appended to this list * @return {@code
true} * @throws NullPointerException if the specified element is null */ @Override public
boolean add(E e) { if(e == null){ throw new NullPointerException(); } return false; } /** *
Replaces the element at the specified position in this list with the specified element. * * *
@param index index of the element to replace * @param element element to be stored at the
specified position * @return the element previously at the specified position * @throws
NullPointerException if the specified element is null * @throws IndexOutOfBoundsException if
the index is out of range */ @Override public E set(int index, E element) { if (element == null){
throw new NullPointerException(); } if (index<0 || index>=size){ throw new
IndexOutOfBoundsException(); } return null; } /** * Returns an array containing all of the
elements in this list in proper sequence (from first to last element). * * *
The returned array will be "safe" in that no references to it are maintained by this list. (In other
words, * this method must allocate a new array even if this list is backed by an array). The caller
is thus free to modify * the returned array. * * @return an array containing all of the elements in
this list in proper sequence */ @Override public Object[] toArray() { Object[] array = (Object[])
new Object[size]; int index = 0; for (Node node = head; node!=null;){ array[index] = node;
index++; } return array; } /** * Removes the first occurrence of the specified element from this
list, if it is present. If this list does not * contain the element, it is unchanged. Returns {@code

2. true} if this list contained the specified element. * * * @param o element to be removed from
this list, if present * @return {@code true} if this list contained the specified element * @throws
NullPointerException if the specified element is null */ @Override public boolean
remove(Object o) { if (o == null){ throw new NullPointerException(); } return false; } /** *
Removes the element at the specified position in this list. Shifts any subsequent elements to the
left * (subtracts one from their indices). Returns the element that was removed from the list. * *
* @param index the index of the element to be removed * @return the element previously at the
specified position * @throws IndexOutOfBoundsException if the index is out of range */
@Override public E remove(int index) { if (index<0 || index>=size){ throw new
IndexOutOfBoundsException(); } return null; } /** * Inserts the specified element at the
specified position in this list. Shifts the element * currently at that position (if any) and any
subsequent elements to the right (adds one to their indices). * * * @param index index at which
the specified element is to be inserted * @param element element to be inserted * @throws
NullPointerException if the specified element is null * @throws IndexOutOfBoundsException if
the index is out of range */ @Override public void add(int index, E element) { if (element ==
null){ throw new NullPointerException(); } if (index<0 || index >= size){ throw new
IndexOutOfBoundsException(); } } /** * Appends all elements in the specified list to the end of
this list, in the order that they are returned by the * specified list's iterator. * * * @param c list
containing elements to be added to this list * @return {@code true} if this list changed as a
result of the call * @throws NullPointerException if the specified list is null */ @Override public
boolean addAll(CiscList extends E> c) { return false; } /** * Returns an iterator over the
elements in this list in proper sequence. * * * @return an iterator over the elements in this list in
proper sequence */ @Override public Iterator iterator() { return null; } private static class
CiscDoublyLinkedListIterator implements Iterator { /** * A reference to the node containing the
next element to return. */ private Node nextNode; /** * Constructs an iterator beginning at the
specified node. */ public CiscDoublyLinkedListIterator(Node head) { } /** * Returns {@code
true} if the iteration has more elements. * (In other words, returns {@code true} if {@link
#next} would * return an element rather than throwing an exception.) * * @return {@code true}
if the iteration has more elements */ @Override public boolean hasNext() { return false; } /** *
Returns the next element in the iteration. * * @return the next element in the iteration * @throws
NoSuchElementException if the iteration has no more elements */ @Override public E next() {
return null; } } private static class Node { private E data; private Node next; private Node prev;
private Node(E data, Node next, Node prev) { this.data = data; this.next = next; this.prev = prev;
} } }