org.neo4j.kernel.impl.traversal.BidirectionalTraverserIterator Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of neo4j-kernel Show documentation
Show all versions of neo4j-kernel Show documentation
Neo4j kernel is a lightweight, embedded Java database designed to
store data structured as graphs rather than tables. For more
information, see http://neo4j.org.
/*
* Copyright (c) "Neo4j"
* Neo4j Sweden AB [http://neo4j.com]
*
* This file is part of Neo4j.
*
* Neo4j is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see foundPaths;
private SideSelector selector;
private final Map sides = new EnumMap<>( Direction.class );
private final BidirectionalUniquenessFilter uniqueness;
private static class Side
{
private final MonoDirectionalTraversalDescription description;
Side( MonoDirectionalTraversalDescription description )
{
this.description = description;
}
}
BidirectionalTraverserIterator( MonoDirectionalTraversalDescription start,
MonoDirectionalTraversalDescription end,
SideSelectorPolicy sideSelector,
org.neo4j.graphdb.traversal.BranchCollisionPolicy collisionPolicy,
PathEvaluator collisionEvaluator, int maxDepth,
Iterable startNodes, Iterable endNodes )
{
this.sides.put( Direction.OUTGOING, new Side( start ) );
this.sides.put( Direction.INCOMING, new Side( end ) );
this.uniqueness = makeSureStartAndEndHasSameUniqueness( start, end );
// A little chicken-and-egg problem. This happens when constructing the start/end
// selectors and they initially call evaluate() and isUniqueFirst, where the selector is used.
// Solved this way for now, to have it return the start side to begin with.
this.selector = fixedSide( Direction.OUTGOING );
BranchSelector startSelector = start.branchOrdering.create(
new AsOneStartBranch( this, startNodes, start.initialState, start.uniqueness ), start.expander );
this.selector = fixedSide( Direction.INCOMING );
BranchSelector endSelector = end.branchOrdering.create(
new AsOneStartBranch( this, endNodes, end.initialState, start.uniqueness ), end.expander );
this.selector = sideSelector.create( startSelector, endSelector, maxDepth );
this.collisionDetector = collisionPolicy.create( collisionEvaluator, uniqueness::checkFull );
}
private static BidirectionalUniquenessFilter makeSureStartAndEndHasSameUniqueness( MonoDirectionalTraversalDescription
start,
MonoDirectionalTraversalDescription end )
{
if ( !start.uniqueness.equals( end.uniqueness ) )
{
throw new IllegalArgumentException( "Start and end uniqueness factories differ, they need to be the " +
"same currently. Start side has " + start.uniqueness + ", end side has " + end.uniqueness );
}
boolean parameterDiffers = start.uniquenessParameter == null || end.uniquenessParameter == null ?
start.uniquenessParameter != end.uniquenessParameter :
!start.uniquenessParameter.equals( end.uniquenessParameter );
if ( parameterDiffers )
{
throw new IllegalArgumentException( "Start and end uniqueness parameters differ, they need to be the " +
"same currently. Start side has " + start.uniquenessParameter + ", " +
"end side has " + end.uniquenessParameter );
}
UniquenessFilter uniqueness = start.uniqueness.create( start.uniquenessParameter );
if ( !(uniqueness instanceof BidirectionalUniquenessFilter) )
{
throw new IllegalArgumentException( "You must supply a BidirectionalUniquenessFilter, " +
"not just a UniquenessFilter." );
}
return (BidirectionalUniquenessFilter) uniqueness;
}
private static SideSelector fixedSide( final Direction direction )
{
return new SideSelector()
{
@Override
public TraversalBranch next( TraversalContext metadata )
{
throw new UnsupportedOperationException();
}
@Override
public Direction currentSide()
{
return direction;
}
};
}
@Override
protected Path fetchNextOrNull()
{
if ( foundPaths != null )
{
if ( foundPaths.hasNext() )
{
numberOfPathsReturned++;
return foundPaths.next();
}
foundPaths = null;
}
TraversalBranch result;
while ( true )
{
result = selector.next( this );
if ( result == null )
{
return null;
}
Iterable pathCollisions = collisionDetector.evaluate( result, selector.currentSide() );
if ( pathCollisions != null )
{
foundPaths = pathCollisions.iterator();
if ( foundPaths.hasNext() )
{
numberOfPathsReturned++;
return foundPaths.next();
}
}
}
}
private Side currentSideDescription()
{
return sides.get( selector.currentSide() );
}
@Override
public Evaluation evaluate( TraversalBranch branch, BranchState state )
{
return currentSideDescription().description.evaluator.evaluate( branch, state );
}
@Override
public boolean isUniqueFirst( TraversalBranch branch )
{
return uniqueness.checkFirst( branch );
}
@Override
public boolean isUnique( TraversalBranch branch )
{
return uniqueness.check( branch );
}
}