org.typelevel.jawn.util

Character sequence representing a lazily-calculated substring.

This class has three constructors:

• Slice(s) wraps a string, ensuring that future operations (e.g. subSequence) will construct slices instead of strings.

• Slice(s, start, limit) is the default, and ensures that:

1. start >= 0 2. limit >= start 3. limit <= s.length

• Slice.unsafe(s, start, limit) is for situations where the above bounds-checking has already occurred. Only use this if you are absolutely sure your arguments satisfy the above invariants.

Slice's subSequence returns another slice. This means that when wrapping a very large string, garbage collection on the underlying string will not occur until all slices are freed.

Slice's universal equality is only defined with regard to other slices. This means comparing a Slice with other CharSequence values (including String) will always return false.

Slices are serializable. However! They use the default Java serialization layout, which is not that efficient, and could be a disaster in cases where a large shared string might be serialized many times in different slices.

Parse the given character sequence as a single Long value (64-bit signed integer) in decimal (base-10).

Other than "0", leading zeros are not allowed, nor are leading plusses. At most one leading minus is allowed. The value "-0" is allowed, and is interpreted as 0.

Stated more precisely, accepted values:

• conform to the pattern: -?(0|([1-9][0-9]*))
• are within [-9223372036854775808, 9223372036854775807]

This method will throw an InvalidLong exception on invalid input.

Parse the given character sequence as a single Long value (64-bit signed integer) in decimal (base-10).

For valid inputs, this method produces the same values as parseLong. However, by avoiding input validation it is up to 50% faster.

For inputs which parseLong throws an error on, parseLongUnsafe may (or may not) throw an error, or return a bogus value. This method makes no guarantees about how it handles invalid input.

This method should only be used on sequences which have already been parsed (e.g. by a Jawn parser). When in doubt, use parseLong(cs), which is still significantly faster than java.lang.Long.parseLong(cs.toString).