IntPath (graph 2.7.2 API)

java.lang.Object
- com.mastfrog.graph.IntPath

All Implemented Interfaces:

Serializable, Comparable<IntPath>, Iterable<Integer>
```
public final class IntPath
extends Object
implements Comparable<IntPath>, Iterable<Integer>, Serializable
```
A finite path between two elements in a graph.

Author:

Tim Boudreau

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class IntPath.Builder
A builder for IntPaths.

Nested Classes
Modifier and Type	Class and Description
`static class`	`IntPath.Builder` A builder for IntPaths.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`IntPath`	`appending(int value)` Create a new path appending the passed value.
`IntPath`	`appending(IntPath other)` Create a new IntPath of this one concatenated with another.
`static IntPath.Builder`	`builder()` Create a builder for int paths.
`static IntPath.Builder`	`builder(int first)` Create a builder for int paths.
`boolean`	`canJoin(IntPath other)` Returns true if the other path's start is this one's end or vice-versa.
`IntPath`	`childPath()` Create a new path, lopping off the first element.
`int`	`compareTo(IntPath o)`
`boolean`	`contains(int val)` Determine if this path contains the passed value.
`boolean`	`contains(IntPath path)` Determine if this path contains the subsequence in the passed path, or is equal to it.
`boolean`	`containsRepeatedNodes()` Returns true if at least one node in this path occurs more than once in it.
`int`	`end()`
`boolean`	`endsWith(IntPath other)` Determine if this path ends with (or is equal to) another path.
`boolean`	`equals(Object o)`
`int`	`first()` Get the first path element
`int`	`firstOverlappingElement(IntPath other)` Returns the index in this IntPath of the first path element also present in the other, or -1 if there is none.
`void`	`forEachInt(IntConsumer c)` Iterate all elements of the path, passing them to the passed consumer.
`void`	`forEachIntReversed(IntConsumer c)` Iterate all elements of the path in reverse order, passing them to the passed consumer.
`int`	`get(int index)` Get the path element at the specified index.
`int`	`hashCode()`
`int`	`indexOf(int val)` Get the first occurrence of the passed value in this path.
`int`	`indexOf(int from, int val)` Get the first occurrence of the passed value in this path.
`boolean`	`intersects(IntPath other)` Determine if this IntPath contains some nodes in common with another.
`boolean`	`isEdge()`
`boolean`	`isEmpty()` Determine if this path is empty.
`boolean`	`isNotAPath()` Determine if this path does not represent an actual path - if it has one element or less.
`int[]`	`items()` Get the contents of this path as an int[].
`void`	`iterate(IntConsumer cons)` Deprecated. use the better-named `forEachInt()`
`Iterator<Integer>`	`iterator()`
`IntPath`	`join(IntPath other)` Join this path with another path, prepending or appending depending on whether this one's start and the other's end are the same, or the other's start and this one's end are the same.
`IntPath`	`join(IntPath other, boolean eliminateOverlap)` Join this path with another path, if they share a start/end pair, without duplicating elements; if `eliminateOverlap` is passed, then whichever the latter path is in the result, it will be truncated so as not to include any elements also present in the other - this is commonly needed when computing sets of paths that have no partial overlap; returns null if the start/end pairs of neither match.
`int`	`last()` Get the last path element
`int`	`lastIndexOf(int val)` Get the first occurrence of the passed value in this path.
`int`	`lastIndexOf(int from, int val)` Get the last occurrence of the passed value in this path.
`int`	`lastOverlappingElement(IntPath other)` Returns the index in this IntPath of the first path element also present in the other, or -1 if there is none.
`static IntPath`	`of(Collection<? extends Integer> ints)`
`static IntPath`	`of(int... items)` Create an IntPath from an array of ints.
`static IntPath`	`ofUnsafe(int... items)` Create an IntPath from an array of ints, using the passed array directly rather than copying it.
`IntPath`	`parentPath()` Create a new path, lopping off the last element.
`static IntPath`	`parse(String val)` Creates an IntPath from a comma-delimited list of integers (which may contain whitespace), such as the output of `toString()`.
`IntPath`	`prepending(int value)` Create a new path prepending the passed value.
`IntPath`	`prepending(IntPath other)` Create a new IntPath of this one concatenated with another.
`IntPath`	`reversed()` Create a new path whose elements are this one's in reverse order.
`int`	`size()` Get the number of elements in this path.
`int`	`start()`
`boolean`	`startsWith(IntPath other)` Determine if this path starts with (or is equal to) another path.
`IntPath`	`subPath(int start, int end)` Get a subpath.
`int`	`sum()`
`Bits`	`toBits()` Get all nodes in this path as a Bits useful for intersection testing.
`IntPath.Builder`	`toBuilder()` Create a builder initialized from this path.
`<T> ObjectPath<T>`	`toObjectPath(IndexedResolvable<T> indexed)` Create an ObjectPath from this IntPath.
`<T> ObjectPath<T>`	`toObjectPath(List<T> indexed)` Create an ObjectPath from this IntPath.
`<T extends Comparable<T>> ObjectPath<T>`	`toObjectPath(T... indexed)` Create an ObjectPath from this IntPath.
`String`	`toString()`
`int`	`visitAllSubPaths(int minLength, Consumer<IntPath> c)` Visit every possible child path of this path which is smaller than this path but greater than or equal to the passed minimum length.
`int`	`visitSubPathsOfLength(int length, Consumer<IntPath> c)` Visit every possible child path of this path which is smaller than this path but greater than or equal to the passed minimum length.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Method Detail
  - of
```
public static IntPath of(Collection<? extends Integer> ints)
```
  - parse
```
public static IntPath parse(String val)
```
    Creates an IntPath from a comma-delimited list of integers (which may contain whitespace), such as the output of toString().
    
    Parameters:
    
    val - A string
    
    Returns:
    
    A path
    
    Throws:
    
    NumberFormatException - If the text contains non-comma, non-whitespace, non-digit characters
  - prepending
```
public IntPath prepending(IntPath other)
```
    Create a new IntPath of this one concatenated with another.
    
    Parameters:
    
    other - The other path
    
    Returns:
    
    A new IntPath
  - canJoin
```
public boolean canJoin(IntPath other)
```
    Returns true if the other path's start is this one's end or vice-versa.
    
    Parameters:
    
    other - Another path
    
    Returns:
    
    True if these paths share an end/start pair
  - join
```
public IntPath join(IntPath other)
```
    Join this path with another path, prepending or appending depending on whether this one's start and the other's end are the same, or the other's start and this one's end are the same. Returns null if they cannot be joined.
    
    Parameters:
    
    other - Another path
    
    Returns:
    
    A path or null
  - firstOverlappingElement
```
public int firstOverlappingElement(IntPath other)
```
    Returns the index in this IntPath of the first path element also present in the other, or -1 if there is none.
    
    Parameters:
    
    other - Another path
    
    Returns:
    
    An index into this path, or -1
  - lastOverlappingElement
```
public int lastOverlappingElement(IntPath other)
```
    Returns the index in this IntPath of the first path element also present in the other, or -1 if there is none.
    
    Parameters:
    
    other - Another path
    
    Returns:
    
    An index into this path, or -1
  - join
```
public IntPath join(IntPath other,
                    boolean eliminateOverlap)
```
    Join this path with another path, if they share a start/end pair, without duplicating elements; if eliminateOverlap is passed, then whichever the latter path is in the result, it will be truncated so as not to include any elements also present in the other - this is commonly needed when computing sets of paths that have no partial overlap; returns null if the start/end pairs of neither match.
    Examples:
    - Joining 1,2,3 with 3,4,5, gets 1,2,3,4,5
    - Joining 3,4,5, with 1,2,3 also gets 1,2,3,4,5
    - Joining 3,4,5,1,2 with 1,2,3 also gets 1,2,3,4,5,1,2 if elimimnateOverlap is false
    - Joining 3,4,5,1,2 with 1,2,3 also gets 1,2,3,4,5 if elimimnateOverlap is true
    - Joining 1,2,3 with 4,5,6 gets null because they don't share a start or an end
    - Ambiguous cases such as 1,2,1 and 1,3,4,1 are joined with the argument prepended to this path, resulting in 1,3,4,1,2,1
    - In overlap elimination, only the first overlapping element is considered, so joining 1,1,1,2 and 2,2,2,1 gets 1,1,1,2,2,2
    Parameters:
    
    other - Another path
    
    eliminateOverlap - If true, truncate one of the paths when concatenating, as described above
    
    Returns:
    
    An IntPath or null
  - appending
```
public IntPath appending(IntPath other)
```
    Create a new IntPath of this one concatenated with another.
    
    Parameters:
    
    other - The other path
    
    Returns:
    
    A new IntPath
  - prepending
```
public IntPath prepending(int value)
```
    Create a new path prepending the passed value.
    
    Parameters:
    
    value - A value
    
    Returns:
    
    this
    
    Throws:
    
    IllegalArgumentException - if the value is negative
  - appending
```
public IntPath appending(int value)
```
    Create a new path appending the passed value.
    
    Parameters:
    
    value - A value
    
    Returns:
    
    this
    
    Throws:
    
    IllegalArgumentException - if the value is negative
  - forEachInt
```
public void forEachInt(IntConsumer c)
```
    Iterate all elements of the path, passing them to the passed consumer.
    
    Parameters:
    
    c - A consumer
  - forEachIntReversed
```
public void forEachIntReversed(IntConsumer c)
```
    Iterate all elements of the path in reverse order, passing them to the passed consumer.
    
    Parameters:
    
    c - A consumer
  - first
```
public int first()
```
    Get the first path element
    
    Returns:
    
    The first path element
    
    Throws:
    
    IndexOutOfBoundsException - if out of range
  - last
```
public int last()
```
    Get the last path element
    
    Returns:
    
    The first path element
    
    Throws:
    
    IndexOutOfBoundsException - if out of range
  - of
```
public static IntPath of(int... items)
```
    Create an IntPath from an array of ints.
    
    Parameters:
    
    items - An array of ints
    
    Returns:
    
    An int path
  - ofUnsafe
```
public static IntPath ofUnsafe(int... items)
```
    Create an IntPath from an array of ints, using the passed array directly rather than copying it.
    
    Parameters:
    
    items - An array of ints
    
    Returns:
    
    An int path
  - builder
```
public static IntPath.Builder builder()
```
    Create a builder for int paths.
    
    Returns:
    
    A builder
  - builder
```
public static IntPath.Builder builder(int first)
```
    Create a builder for int paths.
    
    Parameters:
    
    first - The first element
    
    Returns:
    
    A builder
  - toBuilder
```
public IntPath.Builder toBuilder()
```
    Create a builder initialized from this path.
    
    Returns:
    
    a builder
  - childPath
```
public IntPath childPath()
```
    Create a new path, lopping off the first element.
    
    Returns:
    
    A new path, or this path if this path is empty
  - parentPath
```
public IntPath parentPath()
```
    Create a new path, lopping off the last element.
    
    Returns:
    
    A new path
  - reversed
```
public IntPath reversed()
```
    Create a new path whose elements are this one's in reverse order.
    
    Returns:
    
    A new path
  - startsWith
```
public boolean startsWith(IntPath other)
```
    Determine if this path starts with (or is equal to) another path.
    
    Parameters:
    
    other - Another path
    
    Returns:
  - endsWith
```
public boolean endsWith(IntPath other)
```
    Determine if this path ends with (or is equal to) another path.
    
    Parameters:
    
    other - Another path
    
    Returns:
  - intersects
```
public boolean intersects(IntPath other)
```
    Determine if this IntPath contains some nodes in common with another.
    
    Parameters:
    
    other - Another IntPath
    
    Returns:
    
    True if they contain some of teh same nodes
  - toBits
```
public Bits toBits()
```
    Get all nodes in this path as a Bits useful for intersection testing.
    
    Returns:
    
    A Bits
  - visitAllSubPaths
```
public int visitAllSubPaths(int minLength,
                            Consumer<IntPath> c)
```
    Visit every possible child path of this path which is smaller than this path but greater than or equal to the passed minimum length.
    
    Parameters:
    
    minLength - The length
    
    c - A consumer
    
    Returns:
    
    The number of paths that were visited
  - visitSubPathsOfLength
```
public int visitSubPathsOfLength(int length,
                                 Consumer<IntPath> c)
```
    Visit every possible child path of this path which is smaller than this path but greater than or equal to the passed minimum length.
    
    Parameters:
    
    length - The length
    
    c - A consumer
    
    Returns:
    
    The number of paths that were visited
  - containsRepeatedNodes
```
public boolean containsRepeatedNodes()
```
    Returns true if at least one node in this path occurs more than once in it.
    
    Returns:
    
    True if there are repetitions
  - subPath
```
public IntPath subPath(int start,
                       int end)
```
    Get a subpath.
    
    Parameters:
    
    start - The start index, inclusive
    
    end - The end index, exclusive
    
    Returns:
    
    A path
    
    Throws:
    
    IllegalArgumentException - if the arguments are out of range or invalid
  - start
```
public int start()
```
  - end
```
public int end()
```
  - contains
```
public boolean contains(IntPath path)
```
    Determine if this path contains the subsequence in the passed path, or is equal to it.
    
    Parameters:
    
    path - A path
    
    Returns:
    
    true if this path contains the passed one
  - indexOf
```
public int indexOf(int val)
```
    Get the first occurrence of the passed value in this path.
    
    Parameters:
    
    val - An integer path element
    
    Returns:
    
    the index or -1
  - indexOf
```
public int indexOf(int from,
                   int val)
```
    Get the first occurrence of the passed value in this path.
    
    Parameters:
    
    from - The index to start searching at
    
    val - An integer path element
    
    Returns:
    
    the index or -1
  - lastIndexOf
```
public int lastIndexOf(int from,
                       int val)
```
    Get the last occurrence of the passed value in this path.
    
    Parameters:
    
    from - The index to stop searching at
    
    val - An integer path element
    
    Returns:
    
    the index or -1
  - lastIndexOf
```
public int lastIndexOf(int val)
```
    Get the first occurrence of the passed value in this path.
    
    Parameters:
    
    val - An integer path element
    
    Returns:
    
    the index or -1
  - contains
```
public boolean contains(int val)
```
    Determine if this path contains the passed value.
    
    Parameters:
    
    val - A value
    
    Returns:
    
    true if it is present
  - isEmpty
```
public boolean isEmpty()
```
    Determine if this path is empty.
    
    Returns:
    
    True if it is empty
  - size
```
public int size()
```
    Get the number of elements in this path.
    
    Returns:
    
    The number of elements
  - isNotAPath
```
public boolean isNotAPath()
```
    Determine if this path does not represent an actual path - if it has one element or less.
    
    Returns:
    
    True if this path does not have an endpoint and may or may not have a start point
  - isEdge
```
public boolean isEdge()
```
  - get
```
public int get(int index)
```
    Get the path element at the specified index.
    
    Parameters:
    
    index - The index within the path
    
    Returns:
    
    The index or -1 if not present
  - items
```
public int[] items()
```
    Get the contents of this path as an int[].
    
    Returns:
    
    An array
  - iterate
```
@Deprecated
public void iterate(IntConsumer cons)
```
    Deprecated. use the better-named forEachInt()
    
    Iterate the contents.
    
    Parameters:
    
    cons -
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - sum
```
public final int sum()
```
  - toObjectPath
```
public <T> ObjectPath<T> toObjectPath(List<T> indexed)
```
    Create an ObjectPath from this IntPath.
    
    Type Parameters:
    
    T - The object type
    
    Parameters:
    
    indexed - A list of objects
    
    Returns:
    
    An object path
  - toObjectPath
```
@SafeVarargs
public final <T extends Comparable<T>> ObjectPath<T> toObjectPath(T... indexed)
```
    Create an ObjectPath from this IntPath.
    
    Type Parameters:
    
    T - The object type
    
    Parameters:
    
    indexed - An array of comparable items
    
    Returns:
    
    An object path
  - toObjectPath
```
public <T> ObjectPath<T> toObjectPath(IndexedResolvable<T> indexed)
```
    Create an ObjectPath from this IntPath.
    
    Type Parameters:
    
    T - The object type
    
    Parameters:
    
    indexed - An IndexedResolvable (has static methods to wrap lists, etc.)
    
    Returns:
    
    An object path
  - compareTo
```
public int compareTo(IntPath o)
```
    Specified by:
    
    compareTo in interface Comparable<IntPath>
  - iterator
```
public Iterator<Integer> iterator()
```
    Specified by:
    
    iterator in interface Iterable<Integer>

Class IntPath

Nested Class Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Method Detail

of

parse

prepending

canJoin

join

firstOverlappingElement

lastOverlappingElement

join

appending

prepending

appending

forEachInt

forEachIntReversed

first

last

of

ofUnsafe

builder

builder

toBuilder

childPath

parentPath

reversed

startsWith

endsWith

intersects

toBits

visitAllSubPaths

visitSubPathsOfLength

containsRepeatedNodes

subPath

start

end

contains

indexOf

indexOf

lastIndexOf

lastIndexOf

contains

isEmpty

size

isNotAPath

isEdge

get

items

iterate

equals

hashCode

toString

sum

toObjectPath

toObjectPath

toObjectPath

compareTo

iterator