struct Char::Reader
Overview
A Char::Reader
allows iterating a String
by Chars.
As soon as you instantiate a Char::Reader
it will decode the first
char in the String
, which can be accessed by invoking #current_char
.
At this point #pos
, the current position in the string, will equal zero.
Successive calls to #next_char
return the next chars in the string,
advancing #pos
.
NOTE The null character '\0'
will be returned in #current_char
when
the end is reached (as well as when the string is empty). Thus, #has_next?
will return false
only when #pos
is equal to the string's bytesize, in which
case #current_char
will always be '\0'
.
NOTE For performance reasons, Char::Reader
has value semantics, so care
must be taken when a reader is declared as a local variable and passed to
another method:
def lstrip(reader)
until reader.current_char.whitespace?
reader.next_char
end
reader
end
# caller's internal state is untouched
reader = Char::Reader.new(" abc")
lstrip(reader)
reader.current_char # => ' '
# to modify caller's internal state, the method must return a new reader
reader = lstrip(reader)
reader.current_char # => 'a'
Included Modules
Defined in:
char/reader.crConstructors
-
.new(string : String, pos = 0)
Creates a reader with the specified string positioned at byte index pos.
-
.new(*, at_end string : String)
Creates a reader that will be positioned at the last char of the given string.
Instance Method Summary
-
#current_char : Char
Returns the current character, or
'\0'
if the reader is at the end of the string. -
#current_char? : Char | Nil
Returns the current character.
-
#current_char_width : Int32
Returns the size of the
#current_char
(in bytes) as if it were encoded in UTF-8. - #each(&) : Nil
-
#error : UInt8 | Nil
If there was an error decoding the current char because of an invalid UTF-8 byte sequence, returns the byte that produced the invalid encoding.
-
#has_next? : Bool
Returns
true
if the reader is not at the end of the string. -
#has_previous? : Bool
Returns
true
if the reader is not at the beginning of the string. -
#next_char : Char
Reads the next character in the string.
-
#next_char? : Char | Nil
Tries to read the next character in the string.
- #peek_next_char : Char
-
#pos : Int32
Returns the byte position of the current character.
-
#pos=(pos : Int32)
Sets
#pos
to pos. -
#previous_char : Char
Reads the previous character in the string.
-
#previous_char? : Char | Nil
Tries to read the previous character in the string.
-
#string : String
Returns the reader's String.
Instance methods inherited from module Enumerable(Char)
accumulate(initial : U) : Array(U) forall Uaccumulate : Array(T)
accumulate(initial : U, &block : U, T -> U) : Array(U) forall U
accumulate(&block : T, T -> T) : Array(T) accumulate, all?(& : T -> ) : Bool
all?(pattern) : Bool
all? : Bool all?, any?(& : T -> ) : Bool
any?(pattern) : Bool
any? : Bool any?, chunks(&block : T -> U) forall U chunks, compact_map(& : T -> _) compact_map, count(& : T -> ) : Int32
count(item) : Int32 count, cycle(n, & : T -> ) : Nil
cycle(& : T -> ) : Nil cycle, each(& : T -> ) each, each_cons(count : Int, reuse = false, &) each_cons, each_cons_pair(& : T, T -> ) : Nil each_cons_pair, each_slice(count : Int, reuse = false, &) each_slice, each_step(n : Int, *, offset : Int = 0, & : T -> ) : Nil each_step, each_with_index(offset = 0, &) each_with_index, each_with_object(obj : U, & : T, U -> ) : U forall U each_with_object, empty? : Bool empty?, find(if_none = nil, & : T -> ) find, find!(& : T -> ) : T find!, first(&)
first(count : Int) : Array(T)
first : T first, first? : T | Nil first?, flat_map(& : T -> _) flat_map, group_by(& : T -> U) forall U group_by, in_groups_of(size : Int, filled_up_with : U = nil) forall U
in_groups_of(size : Int, filled_up_with : U = nil, reuse = false, &) forall U in_groups_of, in_slices_of(size : Int) : Array(Array(T)) in_slices_of, includes?(obj) : Bool includes?, index(& : T -> ) : Int32 | Nil
index(obj) : Int32 | Nil index, index!(& : T -> ) : Int32
index!(obj) : Int32 index!, index_by(& : T -> U) : Hash(U, T) forall U index_by, join(io : IO, separator = "") : Nil
join(separator, io : IO) : Nil
join(separator = "") : String
join(io : IO, separator = "", & : T, IO -> )
join(separator, io : IO, &)
join(separator = "", & : T -> ) join, map(& : T -> U) : Array(U) forall U map, map_with_index(offset = 0, & : T, Int32 -> U) : Array(U) forall U map_with_index, max(count : Int) : Array(T)
max : T max, max? : T | Nil max?, max_by(& : T -> U) : T forall U max_by, max_by?(& : T -> U) : T | Nil forall U max_by?, max_of(& : T -> U) : U forall U max_of, max_of?(& : T -> U) : U | Nil forall U max_of?, min(count : Int) : Array(T)
min : T min, min? : T | Nil min?, min_by(& : T -> U) : T forall U min_by, min_by?(& : T -> U) : T | Nil forall U min_by?, min_of(& : T -> U) : U forall U min_of, min_of?(& : T -> U) : U | Nil forall U min_of?, minmax : Tuple(T, T) minmax, minmax? : Tuple(T | Nil, T | Nil) minmax?, minmax_by(& : T -> U) : Tuple(T, T) forall U minmax_by, minmax_by?(& : T -> U) : Tuple(T, T) | Tuple(Nil, Nil) forall U minmax_by?, minmax_of(& : T -> U) : Tuple(U, U) forall U minmax_of, minmax_of?(& : T -> U) : Tuple(U, U) | Tuple(Nil, Nil) forall U minmax_of?, none?(& : T -> ) : Bool
none?(pattern) : Bool
none? : Bool none?, one?(& : T -> ) : Bool
one?(pattern) : Bool
one? : Bool one?, partition(& : T -> ) : Tuple(Array(T), Array(T))
partition(type : U.class) forall U partition, present? : Bool present?, product(initial : Number)
product
product(initial : Number, & : T -> )
product(& : T -> _) product, reduce(memo, &)
reduce(&) reduce, reduce?(&) reduce?, reject(& : T -> )
reject(type : U.class) forall U
reject(pattern) : Array(T) reject, sample(n : Int, random : Random = Random::DEFAULT) : Array(T)
sample(random : Random = Random::DEFAULT) : T sample, select(& : T -> )
select(type : U.class) : Array(U) forall U
select(pattern) : Array(T) select, size : Int32 size, skip(count : Int) skip, skip_while(& : T -> ) : Array(T) skip_while, sum(initial)
sum
sum(initial, & : T -> )
sum(& : T -> ) sum, take_while(& : T -> ) : Array(T) take_while, tally(hash)
tally : Hash(T, Int32) tally, tally_by(hash, &)
tally_by(&block : T -> U) : Hash(U, Int32) forall U tally_by, to_a : Array(T)
to_a(& : T -> U) : Array(U) forall U to_a, to_h
to_h(& : T -> Tuple(K, V)) forall K, V to_h, to_set : Set(T)
to_set(&block : T -> U) : Set(U) forall U to_set, zip(*others : Indexable | Iterable | Iterator, &)
zip(*others : Indexable | Iterable | Iterator) zip, zip?(*others : Indexable | Iterable | Iterator, &)
zip?(*others : Indexable | Iterable | Iterator) zip?
Class methods inherited from module Enumerable(Char)
element_type(x)
element_type
Instance methods inherited from struct Struct
==(other) : Bool
==,
hash(hasher)
hash,
inspect(io : IO) : Nil
inspect,
pretty_print(pp) : Nil
pretty_print,
to_s(io : IO) : Nil
to_s
Instance methods inherited from struct Value
==(other : JSON::Any)==(other : YAML::Any)
==(other) ==, dup dup
Instance methods inherited from class Object
! : Bool
!,
!=(other)
!=,
!~(other)
!~,
==(other)
==,
===(other : JSON::Any)===(other : YAML::Any)
===(other) ===, =~(other) =~, as(type : Class) as, as?(type : Class) as?, class class, dup dup, hash(hasher)
hash hash, in?(collection : Object) : Bool
in?(*values : Object) : Bool in?, inspect(io : IO) : Nil
inspect : String inspect, is_a?(type : Class) : Bool is_a?, itself itself, nil? : Bool nil?, not_nil!(message)
not_nil! not_nil!, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, responds_to?(name : Symbol) : Bool responds_to?, tap(&) tap, to_json(io : IO) : Nil
to_json : String to_json, to_pretty_json(indent : String = " ") : String
to_pretty_json(io : IO, indent : String = " ") : Nil to_pretty_json, to_s(io : IO) : Nil
to_s : String to_s, to_yaml(io : IO) : Nil
to_yaml : String to_yaml, try(&) try, unsafe_as(type : T.class) forall T unsafe_as
Class methods inherited from class Object
from_json(string_or_io, root : String)from_json(string_or_io) from_json, from_yaml(string_or_io : String | IO) from_yaml
Constructor Detail
Creates a reader with the specified string positioned at byte index pos.
Creates a reader that will be positioned at the last char of the given string.
Instance Method Detail
Returns the current character, or '\0'
if the reader is at the end of
the string.
reader = Char::Reader.new("ab")
reader.current_char # => 'a'
reader.next_char
reader.current_char # => 'b'
reader.next_char
reader.current_char # => '\0'
Returns the current character.
Returns nil
if the reader is at the end of the string.
Returns the size of the #current_char
(in bytes) as if it were encoded in UTF-8.
reader = Char::Reader.new("aƩ")
reader.current_char_width # => 1
reader.next_char
reader.current_char_width # => 2
Yields successive characters from #string
starting from #pos
.
reader = Char::Reader.new("abc")
reader.next_char
reader.each do |c|
puts c.upcase
end
B
C
If there was an error decoding the current char because
of an invalid UTF-8 byte sequence, returns the byte
that produced the invalid encoding. Returns 0
if the char would've been
out of bounds. Otherwise returns nil
.
Returns true
if the reader is not at the end of the string.
NOTE This only means #next_char
will successfully increment #pos
; if
the reader is already at the last character, #next_char
will return the
terminating null byte because there isn't really a next character.
reader = Char::Reader.new("ab")
reader.has_next? # => true
reader.next_char # => 'b'
reader.has_next? # => true
reader.next_char # => '\0'
reader.has_next? # => false
Returns true
if the reader is not at the beginning of the string.
Reads the next character in the string.
If the reader is at the end of the string after incrementing #pos
,
returns '\0'
. If the reader is already at the end beforehand, raises
IndexError
.
reader = Char::Reader.new("abc")
reader.next_char # => 'b'
reader.next_char # => 'c'
reader.next_char # => '\0'
reader.next_char # raise IndexError
Tries to read the next character in the string.
If the reader is at the end of the string before or after incrementing
#pos
, returns nil
.
reader = Char::Reader.new("abc")
reader.next_char? # => 'b'
reader.next_char? # => 'c'
reader.next_char? # => nil
reader.current_char # => '\0'
Returns the next character in the #string
without incrementing #pos
.
Returns '\0'
if the reader is at the last character of the string.
Raises IndexError
if the reader is at the end.
reader = Char::Reader.new("ab")
reader.peek_next_char # => 'b'
reader.current_char # => 'a'
Returns the byte position of the current character.
reader = Char::Reader.new("ab")
reader.pos # => 0
reader.next_char
reader.pos # => 1
Sets #pos
to pos.
reader = Char::Reader.new("abc")
reader.next_char
reader.next_char
reader.pos = 0
reader.current_char # => 'a'
Reads the previous character in the string.
Raises IndexError
if the reader is already at the beginning of the
string. Otherwise decrements #pos
.
reader = Char::Reader.new(at_end: "abc")
reader.previous_char # => 'b'
reader.previous_char # => 'a'
reader.previous_char # raises IndexError
Tries to read the previous character in the string.
Returns nil
if the reader is already at the beginning of the string.
Otherwise decrements #pos
.
reader = Char::Reader.new(at_end: "abc")
reader.previous_char? # => 'b'
reader.previous_char? # => 'a'
reader.previous_char? # => nil