java.util.AbstractSequentialList Java Examples

/**
 * {@inheritDoc}
 *
 * <p>If the multimap is modified while an iteration over the list is in
 * progress (except through the iterator's own {@code add}, {@code set} or
 * {@code remove} operations) the results of the iteration are undefined.
 *
 * <p>The returned list is not serializable and does not have random access.
 */

@Override
public List<V> get(final @Nullable K key) {
  return new AbstractSequentialList<V>() {
    @Override
    public int size() {
      KeyList<K, V> keyList = keyToKeyList.get(key);
      return (keyList == null) ? 0 : keyList.count;
    }

    @Override
    public ListIterator<V> listIterator(int index) {
      return new ValueForKeyIterator(key, index);
    }
  };
}
 

@Override
List<Entry<K, V>> createEntries() {
  @WeakOuter
  class EntriesImpl extends AbstractSequentialList<Entry<K, V>> {
    @Override
    public int size() {
      return size;
    }

    @Override
    public ListIterator<Entry<K, V>> listIterator(int index) {
      return new NodeIterator(index);
    }
  }
  return new EntriesImpl();
}
 

/**
 * {@inheritDoc}
 *
 * <p>If the multimap is modified while an iteration over the list is in
 * progress (except through the iterator's own {@code add}, {@code set} or
 * {@code remove} operations) the results of the iteration are undefined.
 *
 * <p>The returned list is not serializable and does not have random access.
 */

@Override
public List<V> get(final @Nullable K key) {
  return new AbstractSequentialList<V>() {
    @Override
    public int size() {
      KeyList<K, V> keyList = keyToKeyList.get(key);
      return (keyList == null) ? 0 : keyList.count;
    }

    @Override
    public ListIterator<V> listIterator(int index) {
      return new ValueForKeyIterator(key, index);
    }
  };
}
 

public FramedGraph load() {
    Graph graph = TinkerGraph.open();
    final FramedGraph framedGraph = new DelegatingFramedGraph(graph, true, JAVA_TYPE_TYPES);

    // Interfaces
    Vertex collection = makeInterface(graph, Collection.class);
    Vertex list = makeInterface(graph, List.class);
    
    // Classes
    Vertex obj = makeClass(graph, null, Object.class);
    Vertex abstrCollection = makeClass(graph, obj, AbstractCollection.class, collection);
    Vertex abstrList = makeClass(graph, abstrCollection, AbstractList.class, list);
    Vertex abstrSeqList = makeClass(graph, abstrList, AbstractSequentialList.class, list);
    makeClass(graph, abstrList, ArrayList.class, list);
    makeClass(graph, abstrSeqList, LinkedList.class, list, collection);
    
    return framedGraph;
}
 

@Override
List<Entry<K, V>> createEntries() {
  @WeakOuter
  class EntriesImpl extends AbstractSequentialList<Entry<K, V>> {
    @Override
    public int size() {
      return size;
    }

    @Override
    public ListIterator<Entry<K, V>> listIterator(int index) {
      return new NodeIterator(index);
    }
  }
  return new EntriesImpl();
}
 

/**
 * {@inheritDoc}
 *
 * <p>If the multimap is modified while an iteration over the list is in
 * progress (except through the iterator's own {@code add}, {@code set} or
 * {@code remove} operations) the results of the iteration are undefined.
 *
 * <p>The returned list is not serializable and does not have random access.
 */

@Override
public List<V> get(final @Nullable K key) {
  return new AbstractSequentialList<V>() {
    @Override
    public int size() {
      KeyList<K, V> keyList = keyToKeyList.get(key);
      return (keyList == null) ? 0 : keyList.count;
    }

    @Override
    public ListIterator<V> listIterator(int index) {
      return new ValueForKeyIterator(key, index);
    }
  };
}
 

@Override
List<Entry<K, V>> createEntries() {
  @WeakOuter
  class EntriesImpl extends AbstractSequentialList<Entry<K, V>> {
    @Override
    public int size() {
      return size;
    }

    @Override
    public ListIterator<Entry<K, V>> listIterator(int index) {
      return new NodeIterator(index);
    }
  }
  return new EntriesImpl();
}
 

/**
 * {@inheritDoc}
 *
 * <p>If the multimap is modified while an iteration over the list is in
 * progress (except through the iterator's own {@code add}, {@code set} or
 * {@code remove} operations) the results of the iteration are undefined.
 *
 * <p>The returned list is not serializable and does not have random access.
 */

@Override
public List<V> get(final @Nullable K key) {
  return new AbstractSequentialList<V>() {
    @Override
    public int size() {
      KeyList<K, V> keyList = keyToKeyList.get(key);
      return (keyList == null) ? 0 : keyList.count;
    }

    @Override
    public ListIterator<V> listIterator(int index) {
      return new ValueForKeyIterator(key, index);
    }
  };
}
 

@Override
List<Entry<K, V>> createEntries() {
  @WeakOuter
  class EntriesImpl extends AbstractSequentialList<Entry<K, V>> {
    @Override
    public int size() {
      return size;
    }

    @Override
    public ListIterator<Entry<K, V>> listIterator(int index) {
      return new NodeIterator(index);
    }
  }
  return new EntriesImpl();
}
 

/**
 * {@inheritDoc}
 *
 * <p>If the multimap is modified while an iteration over the list is in
 * progress (except through the iterator's own {@code add}, {@code set} or
 * {@code remove} operations) the results of the iteration are undefined.
 *
 * <p>The returned list is not serializable and does not have random access.
 */
@Override
public List<V> get(final @Nullable K key) {
  return new AbstractSequentialList<V>() {
    @Override
    public int size() {
      KeyList<K, V> keyList = keyToKeyList.get(key);
      return (keyList == null) ? 0 : keyList.count;
    }

    @Override
    public ListIterator<V> listIterator(int index) {
      return new ValueForKeyIterator(key, index);
    }
  };
}
 

@Override
List<Entry<K, V>> createEntries() {
  @WeakOuter
  class EntriesImpl extends AbstractSequentialList<Entry<K, V>> {
    @Override
    public int size() {
      return size;
    }

    @Override
    public ListIterator<Entry<K, V>> listIterator(int index) {
      return new NodeIterator(index);
    }
  }
  return new EntriesImpl();
}
 

@Override
List<V> createValues() {
  @WeakOuter
  class ValuesImpl extends AbstractSequentialList<V> {
    @Override
    public int size() {
      return size;
    }

    @Override
    public ListIterator<V> listIterator(int index) {
      final NodeIterator nodeItr = new NodeIterator(index);
      return new TransformedListIterator<Entry<K, V>, V>(nodeItr) {
        @Override
        V transform(Entry<K, V> entry) {
          return entry.getValue();
        }

        @Override
        public void set(V value) {
          nodeItr.setValue(value);
        }
      };
    }
  }
  return new ValuesImpl();
}
 

private Map<String, String> getAbstrListBothDirectionsExtEdges() {
    Map<String, String> edges = new HashMap<>();
    edges.put(AbstractList.class.getName(), AbstractCollection.class.getName());
    edges.put(ArrayList.class.getName(), AbstractList.class.getName());
    edges.put(AbstractSequentialList.class.getName(), AbstractList.class.getName());
    return edges;
}
 

/**
 * {@link java.util.AbstractSequentialList#addAll(int, java.util.Collection)}
 */
public void test_addAll_ILCollection() {
    AbstractSequentialList<String> al = new ASLT<String>();
    String[] someList = { "Aardvark"  ,
                          "Bear"      ,
                          "Chimpanzee",
                          "Duck"      };
    Collection<String> c = Arrays.asList(someList);
    al.addAll(c);
    assertTrue("Should return true", al.addAll(2, c));
}
 

@SuppressWarnings("FeatureEnvy")
@Test
public void testResultsCountGoesDownAfterAddingConcept() {

    final ListView results = searchAndWait("loathing");

    final int resultsCountNoConcept = results.getTotalResultsNum();
    assumeThat("Initial query returned no results", resultsCountNoConcept, greaterThan(0));
    final AbstractSequentialList<Integer> resultCountList = new LinkedList<>();
    resultCountList.add(resultsCountNoConcept);

    final int numberOfRepeats = 2;
    for (int i = 0; i < numberOfRepeats; ++i) {
        final TopicMapView topicMap = goToTopicMap();
        topicMap.clickNthClusterHeading(0);
        Waits.loadOrFadeWait();

        findPage.goToListView();
        results.waitForResultsToLoad();

        resultCountList.add(results.getTotalResultsNum());
    }

    for (int i = 0; i < resultCountList.size() - 1; ++i) {
        LOGGER.info("Search no. " + (i + 1) + " yielded " + resultCountList.get(i) + " results.");
        assertThat("Adding a concept does not increase the result count",
                resultCountList.get(i),
                greaterThanOrEqualTo(resultCountList.get(i + 1)));
    }
}
 

@Override
List<V> createValues() {
  @WeakOuter
  class ValuesImpl extends AbstractSequentialList<V> {
    @Override
    public int size() {
      return size;
    }

    @Override
    public ListIterator<V> listIterator(int index) {
      final NodeIterator nodeItr = new NodeIterator(index);
      return new TransformedListIterator<Entry<K, V>, V>(nodeItr) {
        @Override
        V transform(Entry<K, V> entry) {
          return entry.getValue();
        }

        @Override
        public void set(V value) {
          nodeItr.setValue(value);
        }
      };
    }
  }
  return new ValuesImpl();
}
 

@Override
List<V> createValues() {
  @WeakOuter
  class ValuesImpl extends AbstractSequentialList<V> {
    @Override
    public int size() {
      return size;
    }

    @Override
    public ListIterator<V> listIterator(int index) {
      final NodeIterator nodeItr = new NodeIterator(index);
      return new TransformedListIterator<Entry<K, V>, V>(nodeItr) {
        @Override
        V transform(Entry<K, V> entry) {
          return entry.getValue();
        }

        @Override
        public void set(V value) {
          nodeItr.setValue(value);
        }
      };
    }
  }
  return new ValuesImpl();
}
 

@Override
List<V> createValues() {
  @WeakOuter
  class ValuesImpl extends AbstractSequentialList<V> {
    @Override
    public int size() {
      return size;
    }

    @Override
    public ListIterator<V> listIterator(int index) {
      final NodeIterator nodeItr = new NodeIterator(index);
      return new TransformedListIterator<Entry<K, V>, V>(nodeItr) {
        @Override
        V transform(Entry<K, V> entry) {
          return entry.getValue();
        }

        @Override
        public void set(V value) {
          nodeItr.setValue(value);
        }
      };
    }
  }
  return new ValuesImpl();
}
 

@Override
List<V> createValues() {
  @WeakOuter
  class ValuesImpl extends AbstractSequentialList<V> {
    @Override
    public int size() {
      return size;
    }

    @Override
    public ListIterator<V> listIterator(int index) {
      final NodeIterator nodeItr = new NodeIterator(index);
      return new TransformedListIterator<Entry<K, V>, V>(nodeItr) {
        @Override
        V transform(Entry<K, V> entry) {
          return entry.getValue();
        }

        @Override
        public void set(V value) {
          nodeItr.setValue(value);
        }
      };
    }
  }
  return new ValuesImpl();
}
 

@Test
public void testGetPrettyClassName()
{
    assertEquals( "Array List", TextUtils.getPrettyClassName( ArrayList.class ) );
    assertEquals( "Abstract Sequential List", TextUtils.getPrettyClassName( AbstractSequentialList.class ) );
}
 

/** {@inheritDoc} */
@Override
protected AbstractSequentialList<T> newCollection() {
    return new LinkedList<T>();
}
 

@Override
protected Class<? extends Collection> getExpectedTypeClass() {
  return AbstractSequentialList.class;
}
 

@Override
protected AbstractSequentialList<T> newCollection() {
    return new LinkedList<T>();
}