SHARE
TWEET

Untitled

a guest Aug 17th, 2019 98 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. import java.io.Serializable;
  2. import java.util.*;
  3. import java.util.function.Function;
  4.  
  5. public class Foo<E> implements Deque<E>, Serializable {
  6.     private static final long serialVersionUID = 0L;
  7.  
  8.     private final Node sentinel = sentinelInit();
  9.     private final Iterable<Node> nodes = (Iterable<Node> & Serializable) () -> new Iterator<Node>() {
  10.         @SuppressWarnings("UnusedDeclaration")
  11.         private static final long serialVersionUID = 0L;
  12.  
  13.         private Node next = sentinel.next;
  14.  
  15.         @Override
  16.         public boolean hasNext() {
  17.             return next != sentinel;
  18.         }
  19.  
  20.         @Override
  21.         public Node next() {
  22.             if (!hasNext()) {
  23.                 throw new NoSuchElementException();
  24.             }
  25.             Node old = next;
  26.             next = next.next;
  27.             return old;
  28.         }
  29.  
  30.         @Override
  31.         public void remove() {
  32.              if (next.previous == sentinel) {
  33.                 throw new IllegalStateException();
  34.             }
  35.             removeNode(next.previous);
  36.         }
  37.     };
  38.  
  39.     @Override
  40.     public boolean isEmpty() {
  41.         return false;
  42.     }
  43.  
  44.     @Override
  45.     public Object[] toArray() {
  46.         return new Object[0];
  47.     }
  48.  
  49.     @Override
  50.     public <T> T[] toArray(T[] a) {
  51.         return null;
  52.     }
  53.  
  54.     @Override
  55.     public boolean containsAll(Collection<?> c) {
  56.         return false;
  57.     }
  58.  
  59.     @Override
  60.     public boolean removeAll(Collection<?> c) {
  61.         return false;
  62.     }
  63.  
  64.     @Override
  65.     public boolean retainAll(Collection<?> c) {
  66.         return false;
  67.     }
  68.  
  69.     @Override
  70.     public void clear() {
  71.  
  72.     }
  73.  
  74.     @Override
  75.     public void addFirst(E e) {
  76.  
  77.     }
  78.  
  79.     @Override
  80.     public void addLast(E e) {
  81.  
  82.     }
  83.  
  84.     @Override
  85.     public boolean offerLast(E e) {
  86.         return false;
  87.     }
  88.  
  89.     @Override
  90.     public E removeFirst() {
  91.         return null;
  92.     }
  93.  
  94.     @Override
  95.     public E removeLast() {
  96.         return null;
  97.     }
  98.  
  99.     @Override
  100.     public E pollFirst() {
  101.         return null;
  102.     }
  103.  
  104.     @Override
  105.     public E getFirst() {
  106.         return null;
  107.     }
  108.  
  109.     @Override
  110.     public E getLast() {
  111.         return null;
  112.     }
  113.  
  114.     @Override
  115.     public E peekFirst() {
  116.         return null;
  117.     }
  118.  
  119.     @Override
  120.     public boolean removeFirstOccurrence(Object o) {
  121.         return false;
  122.     }
  123.  
  124.     @Override
  125.     public boolean removeLastOccurrence(Object o) {
  126.         return false;
  127.     }
  128.  
  129.     @Override
  130.     public E remove() {
  131.         return null;
  132.     }
  133.  
  134.     @Override
  135.     public E element() {
  136.        return null;
  137.     }
  138.  
  139.     @Override
  140.     public void push(E e) {
  141.  
  142.     }
  143.  
  144.     @Override
  145.     public E pop() {
  146.         return null;
  147.     }
  148.  
  149.     @Override
  150.     public boolean contains(Object o) {
  151.         return false;
  152.     }
  153.  
  154.     @Override
  155.     public boolean offerFirst(E e) {
  156.         return false;
  157.     }
  158.  
  159.     @Override
  160.     public E pollLast() {
  161.         return null;
  162.     }
  163.  
  164.     @Override
  165.     public E peekLast() {
  166.         return null;
  167.     }
  168.  
  169.     @Override
  170.     public boolean offer(E e) {
  171.         Node node = new Node(e);
  172.         sentinel.previous.next = node;
  173.         node.previous = sentinel.previous;
  174.         sentinel.previous = node;
  175.         node.next = sentinel;
  176.         return true;
  177.     }
  178.  
  179.     @Override
  180.     public E poll() {
  181.         return null;
  182.     }
  183.  
  184.     @Override
  185.     public E peek() {
  186.         return null;
  187.     }
  188.  
  189.     @Override
  190.     public boolean remove(Object o) {
  191.         for (Node node : nodes) {
  192.             if (node.value.equals(o)) {
  193.                 removeNode(node);
  194.                 return true;
  195.             }
  196.         }
  197.         return false;
  198.     }
  199.  
  200.     @Override
  201.     public int size() {
  202.         return 0;
  203.     }
  204.  
  205.     @Override
  206.     public Iterator<E> descendingIterator() {
  207.         return null;
  208.     }
  209.  
  210.     @Override
  211.     public Iterator<E> iterator() {
  212.         return new Iterator<E>() {
  213.             private final Iterator<Node> backingIter = nodes.iterator();
  214.  
  215.             @Override
  216.             public boolean hasNext() {
  217.                 return backingIter.hasNext();
  218.             }
  219.  
  220.             @Override
  221.             public E next() {
  222.                 return backingIter.next().value;
  223.             }
  224.  
  225.             @Override
  226.             public void remove() {
  227.                 backingIter.remove();
  228.             }
  229.         };
  230.     }
  231.  
  232.     private Node sentinelInit() {
  233.         Node sentinel = new Node();
  234.         sentinel.next = sentinel;
  235.         sentinel.previous = sentinel;
  236.         return sentinel;
  237.     }
  238.  
  239.     private void removeNode(Node node) {
  240.         node.previous.next = node.next;
  241.         node.next.previous = node.previous;
  242.     }
  243.  
  244.     private class Node implements Serializable {
  245.         private static final long serialVersionUID = 0L;
  246.         public E value;
  247.         public Node next;
  248.         public Node previous;
  249.  
  250.         public Node(E value) {
  251.             this.value = value;
  252.         }
  253.  
  254.         public Node() {
  255.             this(null);
  256.         }
  257.     }
  258.  
  259.     public static <I, O> List<O> map(Function<? super I, O> function, Iterable<I> objects) {
  260.         ArrayList<O> returned = new ArrayList<>();
  261.         for (I obj : objects) {
  262.             returned.add(function.apply(obj));
  263.         }
  264.         return returned;
  265.     }
  266.  
  267.     @Override
  268.     public boolean addAll(Collection<? extends E> c) {
  269.         boolean ret = false;
  270.         for (boolean changed : map(this::add, c)) {
  271.             if (changed) {
  272.                 ret = true;
  273.             }
  274.         }
  275.         return ret;
  276.     }
  277.  
  278.     @Override
  279.     public boolean add(E e) {
  280.         if (!offer(e)) {
  281.             throw new IllegalStateException();
  282.         }
  283.         return true;
  284.     }
  285.  
  286.     public static void main(String[] args) {
  287.         Foo<String> list = new Foo<>();
  288.         System.out.println("Constructed list");
  289.         list.addAll(Arrays.asList("a", "B", "c"));
  290.         System.out.println("Added a, B and c.");
  291.         list.forEach(System.out::println);
  292.         list.remove("B");
  293.         list.forEach(System.out::println);
  294.     }
  295. }
  296.      
  297. C:IdeaJava8FoooutproductionFoofoo>"C:Program FilesJavajdk1.8.0_20binjavap.exe" Foo$1.class
  298. Compiled from "Foo.java"
  299. class foo.Foo$1 implements java.util.Iterator<foo.Foo<E>.Node> {
  300.   final foo.Foo this$0;
  301.   foo.Foo$1(foo.Foo);
  302.   public boolean hasNext();
  303.   public foo.Foo<E>.Node next();
  304.   public void remove();
  305. }
  306.      
  307. public java.lang.Object next();
  308.      
  309. private final Iterable<Node> nodes = (Iterable<Node> & Serializable) () -> new Iterator<Node>() {
  310.     @SuppressWarnings("UnusedDeclaration")
  311.     private static final long serialVersionUID = 0L;
  312.  
  313.     private Node snext = sentinel.next;  // refactor `next` to `snext`
  314.     ...
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top