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 trueif the reader is not at the end of the string.
- 
        #has_previous? : Bool
        
          Returns trueif 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 #posto 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!, find_value(if_none = nil, & : T -> ) find_value, 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
Macros inherited from class Object
  
  
    
      class_getter(*names, &block)
    class_getter, 
    
  
    
      class_getter!(*names)
    class_getter!, 
    
  
    
      class_getter?(*names, &block)
    class_getter?, 
    
  
    
      class_property(*names, &block)
    class_property, 
    
  
    
      class_property!(*names)
    class_property!, 
    
  
    
      class_property?(*names, &block)
    class_property?, 
    
  
    
      class_setter(*names)
    class_setter, 
    
  
    
      def_clone
    def_clone, 
    
  
    
      def_equals(*fields)
    def_equals, 
    
  
    
      def_equals_and_hash(*fields)
    def_equals_and_hash, 
    
  
    
      def_hash(*fields)
    def_hash, 
    
  
    
      delegate(*methods, to object)
    delegate, 
    
  
    
      forward_missing_to(delegate)
    forward_missing_to, 
    
  
    
      getter(*names, &block)
    getter, 
    
  
    
      getter!(*names)
    getter!, 
    
  
    
      getter?(*names, &block)
    getter?, 
    
  
    
      property(*names, &block)
    property, 
    
  
    
      property!(*names)
    property!, 
    
  
    
      property?(*names, &block)
    property?, 
    
  
    
      setter(*names)
    setter
    
  
    
  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 # => 2Yields successive characters from #string starting from #pos.
reader = Char::Reader.new("abc")
reader.next_char
reader.each do |c|
  puts c.upcase
endB
CIf 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? # => falseReads 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 IndexErrorTries 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 # => 1Sets #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 IndexErrorTries 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