public static <T> ResourceIterable<T> asResourceIterable( final Iterable<T> iterable ) { if ( iterable instanceof ResourceIterable<?> ) { return (ResourceIterable<T>) iterable; } return () -> asResourceIterator( iterable.iterator() ); }
@Override ResourceIterator<Relationship> doExpand( Path path, BranchState state ) { return asResourceIterator( expander.expand( path, state ).iterator() ); }
@Override protected ResourceIterator<Relationship> createNestedIterator( DirectionAndTypes item ) { return asResourceIterator( node.getRelationships( item.direction, item.types ).iterator() ); } };
@Override public ResourceIterator<File> snapshotFiles() { return asResourceIterator( iterator( storeFile ) ); }
@Override public ResourceIterator<T> iterator() { return new LimitingResourceIterator<>( Iterators.asResourceIterator( source.iterator() ), limit ); } }
@Override protected ResourceIterator<Relationship> expandRelationshipsWithoutChecks( PathExpander expander ) { Iterable expandIterable = expander.expand( this, this ); return Iterators.asResourceIterator( expandIterable.iterator() ); }
/** * @return store files, namely the single "neostore.labelscanstore.db" store file. */ @Override public ResourceIterator<File> snapshotStoreFiles() { return asResourceIterator( iterator( storeFile ) ); }
protected ResourceIterator expandRelationshipsWithoutChecks( PathExpander expander ) { return asResourceIterator( expander.expand( this, BranchState.NO_STATE ).iterator() ); }
@Override protected ResourceIterator<Relationship> createNestedIterator( Node node ) { lastPath.setEndNode( node ); return Iterators.asResourceIterator( expander.expand( lastPath, BranchState.NO_STATE ).iterator() ); } };
@Override ResourceIterator<Relationship> doExpand( Path path, BranchState state ) { return asResourceIterator( path.endNode().getRelationships( direction ).iterator() ); }
private static Answer<ResourceIterator<File>> newResourceIterator( final File theFile ) { return invocationOnMock -> asResourceIterator(iterator( theFile )); }
private static ResourceIterator<File> scanStoreFilesAre( LabelScanStore labelScanStore, String[] fileNames ) { ArrayList<File> files = new ArrayList<>(); mockFiles( fileNames, files, false ); ResourceIterator<File> snapshot = spy( asResourceIterator( files.iterator() ) ); when( labelScanStore.snapshotStoreFiles() ).thenReturn( snapshot ); return snapshot; }
private static ResourceIterator<File> indexFilesAre( IndexingService indexingService, String[] fileNames ) throws IOException { ArrayList<File> files = new ArrayList<>(); mockFiles( fileNames, files, false ); ResourceIterator<File> snapshot = spy( asResourceIterator( files.iterator() ) ); when( indexingService.snapshotIndexFiles() ).thenReturn( snapshot ); return snapshot; }
@Override ResourceIterator<Relationship> doExpand( Path path, BranchState state ) { final Node node = path.endNode(); ResourceIterator<Relationship> resourceIterator = asResourceIterator( node.getRelationships().iterator() ); return newResourceIterator( new FilteringIterator<>( resourceIterator, rel -> { Exclusion exclude = exclusion.get( rel.getType().name() ); exclude = (exclude == null) ? defaultExclusion : exclude; return exclude.accept( node, rel ); } ), resourceIterator ); }
@Override ResourceIterator<Relationship> doExpand( Path path, BranchState state ) { final Node node = path.endNode(); if ( directions.length == 1 ) { DirectionAndTypes direction = directions[0]; return asResourceIterator( node.getRelationships( direction.direction, direction.types ).iterator() ); } else { return new NestingResourceIterator<Relationship, DirectionAndTypes>( new ArrayIterator<>( directions ) ) { @Override protected ResourceIterator<Relationship> createNestedIterator( DirectionAndTypes item ) { return asResourceIterator( node.getRelationships( item.direction, item.types ).iterator() ); } }; } }
private ResourceIterator<File> listReadOnlyStoreFiles() throws IOException { // In read-only mode we don't need to take a snapshot, because the index will not be modified. final Collection<File> files = new ArrayList<>(); makeSureAllIndexesAreInstantiated(); for ( IndexReference index : getAllIndexes() ) { File indexDirectory = getFileDirectory( baseStorePath, index.getIdentifier() ); IndexSearcher searcher = index.getSearcher(); try ( IndexReader indexReader = searcher.getIndexReader() ) { DirectoryReader directoryReader = (DirectoryReader) indexReader; IndexCommit commit = directoryReader.getIndexCommit(); for ( String fileName : commit.getFileNames() ) { files.add( new File( indexDirectory, fileName ) ); } } } return Iterators.asResourceIterator( files.iterator() ); }
@Test void shouldNotCloseDuringIteration() { // Given ResourceIterator<Long> it1 = spy( asResourceIterator( iterator( 1L, 2L, 3L ) ) ); ResourceIterator<Long> it2 = spy( asResourceIterator( iterator( 5L, 6L, 7L ) ) ); CombiningResourceIterator<Long> combingIterator = new CombiningResourceIterator<>( iterator(it1, it2) ); // When I iterate through it, things come back in the right order assertThat( Iterators.asList( combingIterator ), equalTo(asList( 1L, 2L, 3L, 5L, 6L, 7L )) ); // Then verify(it1, never()).close(); verify(it2, never()).close(); }
@Test void shouldHandleSingleItemIterators() { // Given ResourceIterator<Long> it1 = asResourceIterator( iterator( 1L ) ); ResourceIterator<Long> it2 = asResourceIterator( iterator( 5L, 6L, 7L ) ); CombiningResourceIterator<Long> combingIterator = new CombiningResourceIterator<>( iterator(it1, it2) ); // When I iterate through it, things come back in the right order assertThat( Iterators.asList( combingIterator ), equalTo(asList( 1L, 5L, 6L, 7L )) ); } }
@Test void closesAllIteratorsOnShutdown() { // Given ResourceIterator<Long> it1 = spy( asResourceIterator( iterator( 1L, 2L, 3L ) ) ); ResourceIterator<Long> it2 = spy( asResourceIterator( iterator( 5L, 6L, 7L ) ) ); CombiningResourceIterator<Long> combingIterator = new CombiningResourceIterator<>( iterator(it1, it2) ); // Given I iterate through half of it int iterations = 4; while ( iterations-- > 0 ) { combingIterator.next(); } // When combingIterator.close(); // Then verify(it1).close(); verify(it2).close(); }
private void deleteRelationshipsFromNode( Node root, int numberOfRelationships ) { int deleted = 0; try ( ResourceIterator<Relationship> iterator = asResourceIterator( root.getRelationships().iterator() ) ) { while ( iterator.hasNext() ) { Relationship relationship = iterator.next(); relationship.delete(); deleted++; if ( deleted == numberOfRelationships ) { break; } } } }