Range (flexmark-java sequence utilities 0.62.2 API)

java.lang.Object
- com.vladsch.flexmark.util.sequence.Range

Direct Known Subclasses:

TagRange
```
public class Range
extends Object
```

Field Summary

Fields
Modifier and Type Field and Description

static Range EMPTY

static Range NULL

Fields
Modifier and Type	Field and Description
`static Range`	`EMPTY`
`static Range`	`NULL`

Constructor Summary

Constructors
Modifier Constructor and Description

protected Range(int start, int end)
Create range

protected Range(@NotNull Range other)

Constructors
Modifier	Constructor and Description
`protected`	`Range(int start, int end)` Create range
`protected`	`Range(@NotNull Range other)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`@NotNull BasedSequence`	`basedSafeSubSequence(@NotNull CharSequence charSequence)`
`@NotNull BasedSequence`	`basedSubSequence(@NotNull CharSequence charSequence)`
`@NotNull CharSequence`	`charSubSequence(@NotNull CharSequence charSequence)`
`int`	`compare(@NotNull Range other)`
`int`	`component1()`
`int`	`component2()`
`boolean`	`contains(int index)`
`boolean`	`contains(int start, int end)`
`boolean`	`contains(@NotNull Range other)`
`boolean`	`doesContain(int index)`
`boolean`	`doesContain(int start, int end)`
`boolean`	`doesContain(@NotNull Range other)`
`boolean`	`doesNotOverlap(@NotNull Range other)`
`boolean`	`doesNotOverlapNorAdjacent(@NotNull Range other)`
`boolean`	`doesNotOverlapOrAdjacent(@NotNull Range other)`
`boolean`	`doesOverlap(@NotNull Range other)`
`boolean`	`doesOverlapOrAdjacent(@NotNull Range other)`
`boolean`	`doesProperlyContain(@NotNull Range other)`
`static @NotNull Range`	`emptyOf(int position)`
`Range`	`endMinus(int delta)`
`Range`	`endPlus(int delta)`
`boolean`	`equals(Object o)`
`@NotNull Range`	`exclude(@NotNull Range other)`
`@NotNull Range`	`expandToInclude(int start, int end)`
`@NotNull Range`	`expandToInclude(@NotNull Range other)`
`int`	`getEnd()`
`int`	`getEndOffset()`
`int`	`getSpan()`
`int`	`getStart()`
`int`	`getStartOffset()`
`int`	`hashCode()`
`@NotNull Range`	`include(int pos)`
`@NotNull Range`	`include(int start, int end)`
`@NotNull Range`	`include(@NotNull Range other)`
`@NotNull Range`	`intersect(@NotNull Range other)`
`boolean`	`isAdjacent(int index)`
`boolean`	`isAdjacent(@NotNull Range other)`
`boolean`	`isAdjacentAfter(int index)`
`boolean`	`isAdjacentAfter(@NotNull Range other)`
`boolean`	`isAdjacentBefore(int index)`
`boolean`	`isAdjacentBefore(@NotNull Range other)`
`boolean`	`isContainedBy(int start, int end)`
`boolean`	`isContainedBy(@NotNull Range other)`
`boolean`	`isEmpty()`
`boolean`	`isEnd(int index)`
`boolean`	`isEqual(@NotNull Range other)`
`boolean`	`isLast(int index)`
`boolean`	`isNotEmpty()`
`boolean`	`isNotNull()`
`boolean`	`isNull()`
`boolean`	`isProperlyContainedBy(int start, int end)`
`boolean`	`isProperlyContainedBy(@NotNull Range other)`
`boolean`	`isStart(int index)`
`boolean`	`isValidIndex(int index)`
`boolean`	`leadBy(int index)`
`boolean`	`leads(int index)`
`static @NotNull Range`	`of(int start, int end)`
`static @NotNull Range`	`ofLength(int start, int length)`
`boolean`	`overlaps(@NotNull Range other)`
`boolean`	`overlapsOrAdjacent(@NotNull Range other)`
`boolean`	`properlyContains(@NotNull Range other)`
`@NotNull RichSequence`	`richSafeSubSequence(@NotNull CharSequence charSequence)`
`@NotNull RichSequence`	`richSubSequence(@NotNull CharSequence charSequence)`
`@NotNull CharSequence`	`safeSubSequence(@NotNull CharSequence charSequence)`
`Range`	`shiftLeft(int delta)`
`Range`	`shiftRight(int delta)`
`Range`	`startMinus(int delta)`
`Range`	`startPlus(int delta)`
`@NotNull BasedSequence`	`subSequence(@NotNull CharSequence charSequence)` Deprecated. use `basedSubSequence(CharSequence)` instead
`String`	`toString()`
`boolean`	`trailedBy(int index)`
`boolean`	`trails(int index)`
`Range`	`withEnd(int end)`
`Range`	`withRange(int start, int end)`
`Range`	`withStart(int start)`

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

Field Detail

NULL
```
public static final Range NULL
```

EMPTY
```
public static final Range EMPTY
```

Constructor Detail

Range

protected Range(int start,
                int end)

Create range

Parameters:: start - start; end - end

Range

protected Range(@NotNull
                @NotNull Range other)

Method Detail

of

@NotNull
public static @NotNull Range of(int start,
                                         int end)

emptyOf

@NotNull
public static @NotNull Range emptyOf(int position)

ofLength

@NotNull
public static @NotNull Range ofLength(int start,
                                               int length)

getStart
```
public int getStart()
```

getEnd
```
public int getEnd()
```

component1
```
public int component1()
```

component2
```
public int component2()
```

getStartOffset
```
public int getStartOffset()
```

getEndOffset
```
public int getEndOffset()
```

withStart
```
public Range withStart(int start)
```

withEnd
```
public Range withEnd(int end)
```

endMinus
```
public Range endMinus(int delta)
```

endPlus
```
public Range endPlus(int delta)
```

startMinus
```
public Range startMinus(int delta)
```

startPlus
```
public Range startPlus(int delta)
```

withRange

public Range withRange(int start,
                       int end)

shiftLeft
```
public Range shiftLeft(int delta)
```

shiftRight
```
public Range shiftRight(int delta)
```

getSpan
```
public int getSpan()
```

isNull
```
public boolean isNull()
```

isNotNull
```
public boolean isNotNull()
```

isEmpty
```
public boolean isEmpty()
```

isNotEmpty
```
public boolean isNotEmpty()
```

contains

public boolean contains(@NotNull
                        @NotNull Range other)

doesContain

public boolean doesContain(@NotNull
                           @NotNull Range other)

contains
```
public boolean contains(int index)
```

doesContain

public boolean doesContain(int index)

contains

public boolean contains(int start,
                        int end)

doesContain

public boolean doesContain(int start,
                           int end)

overlaps

public boolean overlaps(@NotNull
                        @NotNull Range other)

doesOverlap

public boolean doesOverlap(@NotNull
                           @NotNull Range other)

doesNotOverlap

public boolean doesNotOverlap(@NotNull
                              @NotNull Range other)

overlapsOrAdjacent

public boolean overlapsOrAdjacent(@NotNull
                                  @NotNull Range other)

doesOverlapOrAdjacent

public boolean doesOverlapOrAdjacent(@NotNull
                                     @NotNull Range other)

doesNotOverlapOrAdjacent

public boolean doesNotOverlapOrAdjacent(@NotNull
                                        @NotNull Range other)

doesNotOverlapNorAdjacent

public boolean doesNotOverlapNorAdjacent(@NotNull
                                         @NotNull Range other)

properlyContains

public boolean properlyContains(@NotNull
                                @NotNull Range other)

doesProperlyContain

public boolean doesProperlyContain(@NotNull
                                   @NotNull Range other)

isAdjacent
```
public boolean isAdjacent(int index)
```

isAdjacentAfter

public boolean isAdjacentAfter(int index)

isAdjacentBefore

public boolean isAdjacentBefore(int index)

isAdjacent

public boolean isAdjacent(@NotNull
                          @NotNull Range other)

isAdjacentBefore

public boolean isAdjacentBefore(@NotNull
                                @NotNull Range other)

isAdjacentAfter

public boolean isAdjacentAfter(@NotNull
                               @NotNull Range other)

isContainedBy

public boolean isContainedBy(@NotNull
                             @NotNull Range other)

isContainedBy

public boolean isContainedBy(int start,
                             int end)

isProperlyContainedBy

public boolean isProperlyContainedBy(@NotNull
                                     @NotNull Range other)

isProperlyContainedBy

public boolean isProperlyContainedBy(int start,
                                     int end)

isEqual

public boolean isEqual(@NotNull
                       @NotNull Range other)

isValidIndex

public boolean isValidIndex(int index)

isStart
```
public boolean isStart(int index)
```

isEnd
```
public boolean isEnd(int index)
```

isLast
```
public boolean isLast(int index)
```

leadBy
```
public boolean leadBy(int index)
```

leads
```
public boolean leads(int index)
```

trailedBy
```
public boolean trailedBy(int index)
```

trails
```
public boolean trails(int index)
```

intersect

@NotNull
public @NotNull Range intersect(@NotNull
                                         @NotNull Range other)

exclude

@NotNull
public @NotNull Range exclude(@NotNull
                                       @NotNull Range other)

compare

public int compare(@NotNull
                   @NotNull Range other)

include

@NotNull
public @NotNull Range include(@NotNull
                                       @NotNull Range other)

include

@NotNull
public @NotNull Range include(int pos)

include

@NotNull
public @NotNull Range include(int start,
                                       int end)

expandToInclude

@NotNull
public @NotNull Range expandToInclude(@NotNull
                                               @NotNull Range other)

expandToInclude

@NotNull
public @NotNull Range expandToInclude(int start,
                                               int end)

subSequence
```
@NotNull
 @Deprecated
public @NotNull BasedSequence subSequence(@NotNull
                                                                @NotNull CharSequence charSequence)
```
Deprecated. use basedSubSequence(CharSequence) instead

Return a based subsequence of sequence given by this range

Parameters:

charSequence - char sequence from which to extract the range

Returns:

resulting based subsequence

basedSubSequence

@NotNull
public @NotNull BasedSequence basedSubSequence(@NotNull
                                                        @NotNull CharSequence charSequence)

basedSafeSubSequence

@NotNull
public @NotNull BasedSequence basedSafeSubSequence(@NotNull
                                                            @NotNull CharSequence charSequence)

richSubSequence

@NotNull
public @NotNull RichSequence richSubSequence(@NotNull
                                                      @NotNull CharSequence charSequence)

richSafeSubSequence

@NotNull
public @NotNull RichSequence richSafeSubSequence(@NotNull
                                                          @NotNull CharSequence charSequence)

charSubSequence

@NotNull
public @NotNull CharSequence charSubSequence(@NotNull
                                                      @NotNull CharSequence charSequence)

safeSubSequence

@NotNull
public @NotNull CharSequence safeSubSequence(@NotNull
                                                      @NotNull CharSequence charSequence)

toString
```
public String toString()
```
Overrides:

toString in class Object

equals
```
public boolean equals(Object o)
```
Overrides:

equals in class Object

hashCode
```
public int hashCode()
```
Overrides:

hashCode in class Object

Class Range

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

NULL

EMPTY

Constructor Detail

Range

Range

Method Detail

of

emptyOf

ofLength

getStart

getEnd

component1

component2

getStartOffset

getEndOffset

withStart

withEnd

endMinus

endPlus

startMinus

startPlus

withRange

shiftLeft

shiftRight

getSpan

isNull

isNotNull

isEmpty

isNotEmpty

contains

doesContain

contains

doesContain

contains

doesContain

overlaps

doesOverlap

doesNotOverlap

overlapsOrAdjacent

doesOverlapOrAdjacent

doesNotOverlapOrAdjacent

doesNotOverlapNorAdjacent

properlyContains

doesProperlyContain

isAdjacent

isAdjacentAfter

isAdjacentBefore

isAdjacent

isAdjacentBefore

isAdjacentAfter

isContainedBy

isContainedBy

isProperlyContainedBy

isProperlyContainedBy

isEqual

isValidIndex

isStart

isEnd

isLast

leadBy

leads

trailedBy

trails

intersect

exclude

compare

include

include

include

expandToInclude

expandToInclude

subSequence

basedSubSequence

basedSafeSubSequence