private fun first_byte: Int do return 0
- private fun last_byte: Int do return bytelen - 1
+ private fun last_byte: Int do return _bytelen - 1
# Cache of the latest position (char) explored in the string
var position: Int = 0
# Cached position (bytes) in the NativeString underlying the String
var bytepos: Int = first_byte is lateinit
- # Index of the character `index` in `items`
+ # Index of the character `index` in `_items`
private fun char_to_byte_index(index: Int): Int do
var ln = length
assert index >= 0
assert index < ln
+ var pos = _position
# Find best insertion point
var delta_begin = index
var delta_end = (ln - 1) - index
- var delta_cache = (position - index).abs
+ var delta_cache = (pos - index).abs
var min = delta_begin
- var its = items
+ var its = _items
if delta_cache < min then min = delta_cache
if delta_end < min then min = delta_end
ns_i = first_byte
my_i = 0
else if min == delta_cache then
- ns_i = bytepos
- my_i = position
+ ns_i = _bytepos
+ my_i = pos
else
ns_i = its.find_beginning_of_char_at(last_byte)
my_i = length - 1
ns_i = its.char_to_byte_index_cached(index, my_i, ns_i)
- position = index
- bytepos = ns_i
+ _position = index
+ _bytepos = ns_i
return ns_i
end
private fun byte_to_char_index(index: Int): Int do
- var ln = bytelen
+ var ln = _bytelen
assert index >= 0
- assert index < bytelen
+ assert index < ln
+ var pos = _bytepos
# Find best insertion point
var delta_begin = index
var delta_end = (ln - 1) - index
- var delta_cache = (bytepos - index).abs
+ var delta_cache = (pos - index).abs
var min = delta_begin
- var its = items
+ var its = _items
if delta_cache < min then min = delta_cache
if delta_end < min then min = delta_end
ns_i = first_byte
my_i = 0
else if min == delta_cache then
- ns_i = bytepos
- my_i = position
+ ns_i = pos
+ my_i = _position
else
ns_i = its.find_beginning_of_char_at(last_byte)
my_i = length - 1
my_i = its.byte_to_char_index_cached(index, my_i, ns_i)
- position = my_i
- bytepos = index
+ _position = my_i
+ _bytepos = index
return my_i
end
- redef fun [](index) do return items.char_at(char_to_byte_index(index))
+ redef fun [](index) do return _items.char_at(char_to_byte_index(index))
end
# Immutable strings of characters.
super FlatText
super String
- # Index at which `self` begins in `items`, inclusively
+ # Index at which `self` begins in `_items`, inclusively
redef var first_byte is noinit
- # Index at which `self` ends in `items`, inclusively
+ # Index at which `self` ends in `_items`, inclusively
redef var last_byte is noinit
redef var chars = new FlatStringCharView(self) is lazy
redef var bytes = new FlatStringByteView(self) is lazy
redef var length is lazy do
- if bytelen == 0 then return 0
- var st = first_byte
- var its = items
+ if _bytelen == 0 then return 0
+ var st = _first_byte
+ var its = _items
var ln = 0
- var lst = last_byte
+ var lst = _last_byte
while st <= lst do
st += its.length_of_char_at(st)
ln += 1
redef fun reversed
do
- var b = new FlatBuffer.with_capacity(bytelen + 1)
+ var b = new FlatBuffer.with_capacity(_bytelen + 1)
for i in [length - 1 .. 0].step(-1) do
b.add self[i]
end
return s
end
- redef fun fast_cstring do return items.fast_cstring(first_byte)
+ redef fun fast_cstring do return _items.fast_cstring(_first_byte)
redef fun substring(from, count)
do
var bytefrom = char_to_byte_index(from)
var byteto = char_to_byte_index(end_index)
- byteto += items.length_of_char_at(byteto) - 1
+ var its = _items
+ byteto += its.length_of_char_at(byteto) - 1
- var s = new FlatString.full(items, byteto - bytefrom + 1, bytefrom, byteto, count)
+ var s = new FlatString.full(its, byteto - bytefrom + 1, bytefrom, byteto, count)
return s
end
redef fun to_upper
do
- var outstr = new FlatBuffer.with_capacity(self.bytelen + 1)
+ var outstr = new FlatBuffer.with_capacity(self._bytelen + 1)
var mylen = length
var pos = 0
redef fun to_lower
do
- var outstr = new FlatBuffer.with_capacity(self.bytelen + 1)
+ var outstr = new FlatBuffer.with_capacity(self._bytelen + 1)
var mylen = length
var pos = 0
# Low-level creation of a new string with minimal data.
#
- # `items` will be used as is, without copy, to retrieve the characters of the string.
+ # `_items` will be used as is, without copy, to retrieve the characters of the string.
# Aliasing issues is the responsibility of the caller.
private init with_infos(items: NativeString, bytelen, from, to: Int)
do
- self.items = items
- self.bytelen = bytelen
- first_byte = from
- last_byte = to
+ self._items = items
+ self._bytelen = bytelen
+ _first_byte = from
+ _last_byte = to
end
# Low-level creation of a new string with all the data.
#
- # `items` will be used as is, without copy, to retrieve the characters of the string.
+ # `_items` will be used as is, without copy, to retrieve the characters of the string.
# Aliasing issues is the responsibility of the caller.
private init full(items: NativeString, bytelen, from, to, length: Int)
do
- self.items = items
+ self._items = items
self.length = length
- self.bytelen = bytelen
- first_byte = from
- last_byte = to
+ self._bytelen = bytelen
+ _first_byte = from
+ _last_byte = to
end
redef fun to_cstring do
if real_items != null then return real_items.as(not null)
- var new_items = new NativeString(bytelen + 1)
- self.items.copy_to(new_items, bytelen, first_byte, 0)
- new_items[bytelen] = 0u8
+ var blen = _bytelen
+ var new_items = new NativeString(blen + 1)
+ _items.copy_to(new_items, blen, _first_byte, 0)
+ new_items[blen] = 0u8
real_items = new_items
return new_items
end
if self.object_id == other.object_id then return true
- var my_length = bytelen
+ var my_length = _bytelen
- if other.bytelen != my_length then return false
+ if other._bytelen != my_length then return false
- var my_index = first_byte
- var its_index = other.first_byte
+ var my_index = _first_byte
+ var its_index = other._first_byte
var last_iteration = my_index + my_length
- var itsitems = other.items
- var myitems = self.items
+ var its_items = other._items
+ var my_items = self._items
while my_index < last_iteration do
- if myitems[my_index] != itsitems[its_index] then return false
+ if my_items[my_index] != its_items[its_index] then return false
my_index += 1
its_index += 1
end
if self.object_id == other.object_id then return false
- var my_length = self.bytelen
- var its_length = other.bytelen
+ var my_length = self._bytelen
+ var its_length = other._bytelen
var max = if my_length < its_length then my_length else its_length
redef fun +(o) do
var s = o.to_s
var slen = s.bytelen
- var mlen = bytelen
+ var mlen = _bytelen
var nlen = mlen + slen
- var mits = items
- var mifrom = first_byte
+ var mits = _items
+ var mifrom = _first_byte
if s isa FlatText then
- var sits = s.items
+ var sits = s._items
var sifrom = s.first_byte
var ns = new NativeString(nlen + 1)
mits.copy_to(ns, mlen, mifrom, 0)
end
redef fun *(i) do
- var mybtlen = bytelen
+ var mybtlen = _bytelen
var new_bytelen = mybtlen * i
var mylen = length
var newlen = mylen * i
+ var its = _items
+ var fb = _first_byte
var ns = new NativeString(new_bytelen + 1)
ns[new_bytelen] = 0u8
var offset = 0
while i > 0 do
- items.copy_to(ns, bytelen, first_byte, offset)
+ its.copy_to(ns, mybtlen, fb, offset)
offset += mybtlen
i -= 1
end
if hash_cache == null then
# djb2 hash algorithm
var h = 5381
- var i = first_byte
+ var i = _first_byte
- var myitems = items
+ var my_items = _items
+ var max = _last_byte
- while i <= last_byte do
- h = (h << 5) + h + myitems[i].to_i
+ while i <= max do
+ h = (h << 5) + h + my_items[i].to_i
i += 1
end
init with_pos(tgt: FlatString, pos: Int)
do
- init(tgt, tgt.items, pos + tgt.first_byte)
+ init(tgt, tgt._items, pos + tgt._first_byte)
end
- redef fun is_ok do return curr_pos >= target.first_byte
+ redef fun is_ok do return curr_pos >= target._first_byte
redef fun item do return target_items[curr_pos]
redef fun next do curr_pos -= 1
- redef fun index do return curr_pos - target.first_byte
+ redef fun index do return curr_pos - target._first_byte
end
init with_pos(tgt: FlatString, pos: Int)
do
- init(tgt, tgt.items, pos + tgt.first_byte)
+ init(tgt, tgt._items, pos + tgt._first_byte)
end
- redef fun is_ok do return curr_pos <= target.last_byte
+ redef fun is_ok do return curr_pos <= target._last_byte
redef fun item do return target_items[curr_pos]
redef fun next do curr_pos += 1
- redef fun index do return curr_pos - target.first_byte
+ redef fun index do return curr_pos - target._first_byte
end
redef fun [](index)
do
- # Check that the index (+ first_byte) is not larger than last_byte
+ # Check that the index (+ _first_byte) is not larger than _last_byte
# In other terms, if the index is valid
assert index >= 0
var target = self.target
- assert (index + target.first_byte) <= target.last_byte
- return target.items[index + target.first_byte]
+ var ind = index + target._first_byte
+ assert ind <= target._last_byte
+ return target._items[ind]
end
redef fun iterator_from(start) do return new FlatStringByteIterator.with_pos(target, start)
redef var bytes = new FlatBufferByteView(self) is lazy
- redef var bytelen = 0
-
redef var length = 0
private var char_cache: Int = -1
private var capacity = 0
- redef fun fast_cstring do return items.fast_cstring(0)
+ redef fun fast_cstring do return _items.fast_cstring(0)
redef fun substrings do return new FlatSubstringsIter(self)
# the Copy-On-Write flag `written` is set at true.
private fun reset do
var nns = new NativeString(capacity)
- items.copy_to(nns, bytelen, 0, 0)
- items = nns
+ if _bytelen != 0 then _items.copy_to(nns, _bytelen, 0, 0)
+ _items = nns
written = false
end
# Shifts the content of the buffer by `len` bytes to the right, starting at byte `from`
#
- # Internal only, does not modify bytelen or length, this is the caller's responsability
+ # Internal only, does not modify _bytelen or length, this is the caller's responsability
private fun rshift_bytes(from: Int, len: Int) do
- var oit = items
- var nit = items
- if bytelen + len > capacity then
+ var oit = _items
+ var nit = _items
+ var bt = _bytelen
+ if bt + len > capacity then
capacity = capacity * 2 + 2
nit = new NativeString(capacity)
oit.copy_to(nit, 0, 0, from)
end
- oit.copy_to(nit, bytelen - from, from, from + len)
+ oit.copy_to(nit, bt - from, from, from + len)
end
# Shifts the content of the buffer by `len` bytes to the left, starting at `from`
#
- # Internal only, does not modify bytelen or length, this is the caller's responsability
+ # Internal only, does not modify _bytelen or length, this is the caller's responsability
private fun lshift_bytes(from: Int, len: Int) do
- items.copy_to(items, bytelen - from, from, from - len)
+ var it = _items
+ it.copy_to(it, _bytelen - from, from, from - len)
end
redef fun []=(index, item)
add item
return
end
- var ip = items.char_to_byte_index(index)
- var c = items.char_at(ip)
+ var it = _items
+ var ip = it.char_to_byte_index(index)
+ var c = it.char_at(ip)
var clen = c.u8char_len
var itemlen = item.u8char_len
var size_diff = itemlen - clen
else if size_diff < 0 then
lshift_bytes(ip + clen, -size_diff)
end
- bytelen += size_diff
+ _bytelen += size_diff
bytepos += size_diff
- items.set_char_at(ip, item)
+ it.set_char_at(ip, item)
end
redef fun add(c)
if written then reset
is_dirty = true
var clen = c.u8char_len
- enlarge(bytelen + clen)
- items.set_char_at(bytelen, c)
- bytelen += clen
+ var bt = _bytelen
+ enlarge(bt + clen)
+ _items.set_char_at(bt, c)
+ _bytelen += clen
length += 1
end
redef fun clear do
is_dirty = true
if written then reset
- bytelen = 0
+ _bytelen = 0
length = 0
end
# The COW flag can be set at false here, since
# it does a copy of the current `Buffer`
written = false
+ var bln = _bytelen
var a = new NativeString(c+1)
- if bytelen > 0 then items.copy_to(a, bytelen, 0, 0)
- items = a
+ if bln > 0 then
+ var it = _items
+ if bln > 0 then it.copy_to(a, bln, 0, 0)
+ end
+ _items = a
capacity = c
end
redef fun to_s
do
written = true
- if bytelen == 0 then items = new NativeString(1)
- return new FlatString.full(items, bytelen, 0, bytelen - 1, length)
+ var bln = _bytelen
+ if bln == 0 then _items = new NativeString(1)
+ return new FlatString.full(_items, bln, 0, bln - 1, length)
end
redef fun to_cstring
do
if is_dirty then
- var new_native = new NativeString(bytelen + 1)
- new_native[bytelen] = 0u8
- if length > 0 then items.copy_to(new_native, bytelen, 0, 0)
+ var bln = _bytelen
+ var new_native = new NativeString(bln + 1)
+ new_native[bln] = 0u8
+ if length > 0 then _items.copy_to(new_native, bln, 0, 0)
real_items = new_native
is_dirty = false
end
# Low-level creation a new buffer with given data.
#
- # `items` will be used as is, without copy, to store the characters of the buffer.
+ # `_items` will be used as is, without copy, to store the characters of the buffer.
# Aliasing issues is the responsibility of the caller.
#
- # If `items` is shared, `written` should be set to true after the creation
+ # If `_items` is shared, `written` should be set to true after the creation
# so that a modification will do a copy-on-write.
private init with_infos(items: NativeString, capacity, bytelen, length: Int)
do
- self.items = items
+ self._items = items
self.capacity = capacity
- self.bytelen = bytelen
+ self._bytelen = bytelen
self.length = length
end
# Create a new string copied from `s`.
init from(s: Text)
do
- items = new NativeString(s.bytelen)
+ _items = new NativeString(s.bytelen)
if s isa FlatText then
- items = s.items
+ _items = s._items
else
- for i in substrings do i.as(FlatString).items.copy_to(items, i.bytelen, 0, 0)
+ for i in substrings do i.as(FlatString)._items.copy_to(_items, i._bytelen, 0, 0)
end
- bytelen = s.bytelen
+ _bytelen = s.bytelen
length = s.length
- capacity = s.bytelen
+ _capacity = _bytelen
written = true
end
init with_capacity(cap: Int)
do
assert cap >= 0
- items = new NativeString(cap + 1)
+ _items = new NativeString(cap + 1)
capacity = cap
- bytelen = 0
+ _bytelen = 0
end
redef fun append(s)
if s.is_empty then return
is_dirty = true
var sl = s.bytelen
- enlarge(bytelen + sl)
+ var nln = _bytelen + sl
+ enlarge(nln)
if s isa FlatText then
- s.items.copy_to(items, sl, s.first_byte, bytelen)
+ s._items.copy_to(_items, sl, s.first_byte, _bytelen)
else
for i in s.substrings do append i
return
end
- bytelen += sl
+ _bytelen = nln
length += s.length
end
if from < 0 then from = 0
if (from + count) > length then count = length - from
if count != 0 then
- var bytefrom = items.char_to_byte_index(from)
- var byteto = items.char_to_byte_index(count + from - 1)
- byteto += items.char_at(byteto).u8char_len - 1
+ var its = _items
+ var bytefrom = its.char_to_byte_index(from)
+ var byteto = its.char_to_byte_index(count + from - 1)
+ byteto += its.char_at(byteto).u8char_len - 1
var byte_length = byteto - bytefrom + 1
var r_items = new NativeString(byte_length)
- items.copy_to(r_items, byte_length, bytefrom, 0)
+ its.copy_to(r_items, byte_length, bytefrom, 0)
return new FlatBuffer.with_infos(r_items, byte_length, byte_length, count)
else
return new Buffer
written = false
var ns = new FlatBuffer.with_capacity(capacity)
for i in chars.reverse_iterator do ns.add i
- items = ns.items
+ _items = ns._items
end
redef fun times(repeats)
do
- var x = new FlatString.full(items, bytelen, 0, bytelen - 1, length)
+ var bln = _bytelen
+ var x = new FlatString.full(_items, bln, 0, bln - 1, length)
for i in [1 .. repeats[ do
append(x)
end
init with_pos(tgt: FlatBuffer, pos: Int)
do
- init(tgt, tgt.items, pos)
+ init(tgt, tgt._items, pos)
end
redef fun index do return curr_pos
redef type SELFTYPE: FlatBuffer
- redef fun [](index) do return target.items[index]
+ redef fun [](index) do return target._items[index]
redef fun iterator_from(pos) do return new FlatBufferByteIterator.with_pos(target, pos)
init with_pos(tgt: FlatBuffer, pos: Int)
do
- init(tgt, tgt.items, pos)
+ init(tgt, tgt._items, pos)
end
redef fun index do return curr_pos
- redef fun is_ok do return curr_pos < target.bytelen
+ redef fun is_ok do return curr_pos < target._bytelen
redef fun item do return target_items[curr_pos]
while i < mypos do
var tmp = na[i]
if tmp isa FlatString then
- var tpl = tmp.bytelen
- tmp.items.copy_to(ns, tpl, tmp.first_byte, off)
+ var tpl = tmp._bytelen
+ tmp._items.copy_to(ns, tpl, tmp._first_byte, off)
off += tpl
else
for j in tmp.substrings do
var s = j.as(FlatString)
- var slen = s.bytelen
- s.items.copy_to(ns, slen, s.first_byte, off)
+ var slen = s._bytelen
+ s._items.copy_to(ns, slen, s._first_byte, off)
off += slen
end
end
while i < mypos do
var tmp = na[i]
if tmp isa FlatString then
- var tpl = tmp.bytelen
- tmp.items.copy_to(ns, tpl, tmp.first_byte, off)
+ var tpl = tmp._bytelen
+ tmp._items.copy_to(ns, tpl, tmp._first_byte, off)
off += tpl
else
for j in tmp.substrings do
var s = j.as(FlatString)
- var slen = s.bytelen
- s.items.copy_to(ns, slen, s.first_byte, off)
+ var slen = s._bytelen
+ s._items.copy_to(ns, slen, s._first_byte, off)
off += slen
end
end
var e = i.item
s.append("{k or else "<null>"}{couple_sep}{e or else "<null>"}")
- # Concat other items
+ # Concat other _items
i.next
while i.is_ok do
s.append(sep)
var flat_last_pos_start: Int = -1
redef var to_cstring is lazy do
- var len = bytelen
+ var len = _bytelen
var ns = new NativeString(len + 1)
ns[len] = 0u8
var off = 0
for i in substrings do
- var ilen = i.bytelen
- i.as(FlatString).items.copy_to(ns, ilen, i.as(FlatString).first_byte, off)
+ var ilen = i._bytelen
+ i.as(FlatString)._items.copy_to(ns, ilen, i.as(FlatString)._first_byte, off)
off += ilen
end
return ns
var right: String
init do
- length = left.length + right.length
- bytelen = left.bytelen + right.bytelen
+ var l = _left
+ var r = _right
+ length = l.length + r.length
+ _bytelen = l.bytelen + r.bytelen
end
redef fun output do
- left.output
- right.output
+ _left.output
+ _right.output
end
redef fun iterator do return new RopeCharIterator(self)
loop
if s isa FlatString then break
s = s.as(Concat)
- var lft = s.left
+ var lft = s._left
var llen = lft.length
if i >= llen then
- s = s.right
+ s = s._right
i -= llen
else
- s = s.left
+ s = lft
end
end
flat_last_pos_start = st - i
end
redef fun substring(from, len) do
- var llen = left.length
+ var lft = _left
+ var llen = lft.length
if from < llen then
- if from + len < llen then return left.substring(from,len)
+ if from + len < llen then return lft.substring(from,len)
var lsublen = llen - from
- return left.substring_from(from) + right.substring(0, len - lsublen)
+ return lft.substring_from(from) + _right.substring(0, len - lsublen)
else
- return right.substring(from - llen, len)
+ return _right.substring(from - llen, len)
end
end
- redef fun reversed do return new Concat(right.reversed, left.reversed)
+ redef fun reversed do return new Concat(_right.reversed, _left.reversed)
redef fun insert_at(s, pos) do
- if pos > left.length then
- return left + right.insert_at(s, pos - left.length)
+ var lft = _left
+ if pos > lft.length then
+ return lft + _right.insert_at(s, pos - lft.length)
end
- return left.insert_at(s, pos) + right
+ return lft.insert_at(s, pos) + _right
end
- redef fun to_upper do return new Concat(left.to_upper, right.to_upper)
+ redef fun to_upper do return new Concat(_left.to_upper, _right.to_upper)
- redef fun to_lower do return new Concat(left.to_lower, right.to_lower)
+ redef fun to_lower do return new Concat(_left.to_lower, _right.to_lower)
redef fun +(o) do
var s = o.to_s
if s isa Concat then
return new Concat(self, s)
else
- var r = right
+ var r = _right
var rlen = r.bytelen
if rlen + slen > maxlen then return new Concat(self, s)
- return new Concat(left, r + s)
+ return new Concat(_left, r + s)
end
end
var it = subs.item
if n > it.length then
var cplen = it.length - st
- it.items.copy_to(dest, cplen, st, off)
+ it._items.copy_to(dest, cplen, st, off)
off += cplen
n -= cplen
else
- it.items.copy_to(dest, n, st, off)
+ it._items.copy_to(dest, n, st, off)
n = 0
end
subs.next
end
if not iter.ldone then
iter.ldone = true
- iter = new RopeCharIteratorPiece(rnod.left, false, false, iter)
+ iter = new RopeCharIteratorPiece(rnod._left, false, false, iter)
else if not iter.rdone then
iter.rdone = true
- iter = new RopeCharIteratorPiece(rnod.right, false, false, iter)
+ iter = new RopeCharIteratorPiece(rnod._right, false, false, iter)
else
iter = iter.prev
end
self.str = str
ns = new NativeString(maxlen)
buf_size = maxlen
- bytelen = str.length
+ _bytelen = str.length
dumped = 0
end
assert i >= 0 and i <= length
if i == length then add c
if i < str.length then
- bytelen += c.u8char_len - str[i].u8char_len
+ _bytelen += c.u8char_len - str[i].u8char_len
var s = str
var l = s.substring(0, i)
var r = s.substring_from(i + 1)
else
ns.copy_to(ns, rpos - st_nxt, st_nxt, st_nxt + delta)
end
- bytelen += delta
+ _bytelen += delta
rpos += delta
end
ns.set_char_at(index, c)
redef fun clear do
str = ""
- bytelen = 0
+ _bytelen = 0
rpos = 0
dumped = 0
if written then
return
end
if s isa FlatText then
- var oits = s.items
+ var oits = s._items
var from = s.first_byte
var remsp = buf_size - rpos
if slen <= remsp then
# TODO: Fix when supporting UTF-8
ns[rp] = c.ascii.to_b
rp += 1
- bytelen += 1
+ _bytelen += 1
rpos = rp
end
redef fun +(o) do
var s = o.to_s
var slen = s.bytelen
- var mlen = bytelen
+ var mlen = _bytelen
if slen == 0 then return self
if mlen == 0 then return s
var nlen = slen + mlen
if s isa FlatString then
if nlen > maxlen then return new Concat(self, s)
- var mits = items
- var sifrom = s.first_byte
- var mifrom = first_byte
- var sits = s.items
+ var mits = _items
+ var sifrom = s._first_byte
+ var mifrom = _first_byte
+ var sits = s._items
var ns = new NativeString(nlen + 1)
mits.copy_to(ns, mlen, mifrom, 0)
sits.copy_to(ns, slen, sifrom, mlen)
return new FlatString.full(ns, nlen, 0, nlen - 1, length + s.length)
else if s isa Concat then
- var sl = s.left
+ var sl = s._left
var sllen = sl.bytelen
if sllen + mlen > maxlen then return new Concat(self, s)
- return new Concat(self + sl, s.right)
+ return new Concat(self + sl, s._right)
else
abort
end
private class RopeCharIteratorPiece
# The encapsulated node of the `Rope`
var node: String
- # Was its left child (if any) visited ?
+ # Was its _left child (if any) visited ?
var ldone: Bool
- # Was its right child (if any) visited ?
+ # Was its _right child (if any) visited ?
var rdone: Bool
# The previous node in the list.
var prev: nullable RopeCharIteratorPiece
var subs: IndexedIterator[FlatString]
init(root: Concat) is old_style_init do
- pos = root.bytelen - 1
+ pos = root._bytelen - 1
subs = new ReverseRopeSubstrings(root)
var s = subs.item
- ns = s.items
- pns = s.last_byte
+ ns = s._items
+ pns = s._last_byte
end
init from(root: Concat, pos: Int) do
self.pos = pos
subs = new ReverseRopeSubstrings.from(root, pos)
var s = subs.item
- ns = s.items
+ ns = s._items
pns = pos - subs.index
end
subs.next
if not subs.is_ok then return
var s = subs.item
- ns = s.items
- pns = s.last_byte
+ ns = s._items
+ pns = s._last_byte
end
end
init(root: Concat) is old_style_init do
subs = new RopeSubstrings(root)
pns = 0
- ns = subs.item.items
+ ns = subs.item._items
max = root.length - 1
pos = 0
end
subs = new RopeSubstrings.from(root, pos)
pns = pos - subs.index
self.pos = pos
- ns = subs.item.items
+ ns = subs.item._items
max = root.length - 1
end
redef fun next do
pns += 1
pos += 1
- if pns < subs.item.bytelen then return
+ if pns < subs.item._bytelen then return
if not subs.is_ok then return
subs.next
if not subs.is_ok then return
- ns = subs.item.items
+ ns = subs.item._items
pns = 0
end
end
var lnod: String = root
loop
if lnod isa Concat then
- lnod = lnod.right
+ lnod = lnod._right
r = new RopeCharIteratorPiece(lnod, false, true, r)
else
str = lnod.as(FlatString)
var off = pos
loop
if rnod isa Concat then
- if off >= rnod.left.length then
- off -= rnod.left.length
- rnod = rnod.right
+ if off >= rnod._left.length then
+ off -= rnod._left.length
+ rnod = rnod._right
r = new RopeCharIteratorPiece(rnod, false, true, r)
else
r.ldone = true
- rnod = rnod.left
+ rnod = rnod._left
r = new RopeCharIteratorPiece(rnod, false, true, r)
end
else
end
if not curr.rdone then
curr.rdone = true
- curr = new RopeCharIteratorPiece(currit.right, false, false, curr)
+ curr = new RopeCharIteratorPiece(currit._right, false, false, curr)
continue
end
if not curr.ldone then
curr.ldone = true
- curr = new RopeCharIteratorPiece(currit.left, false, false, curr)
+ curr = new RopeCharIteratorPiece(currit._left, false, false, curr)
continue
end
curr = curr.prev
var rnod: String = root
loop
if rnod isa Concat then
- rnod = rnod.left
+ rnod = rnod._left
r = new RopeCharIteratorPiece(rnod, true, false, r)
else
str = rnod.as(FlatString)
var off = pos
loop
if rnod isa Concat then
- if off >= rnod.left.length then
+ if off >= rnod._left.length then
r.rdone = true
- off -= rnod.left.length
- rnod = rnod.right
+ off -= rnod._left.length
+ rnod = rnod._right
r = new RopeCharIteratorPiece(rnod, true, false, r)
else
- rnod = rnod.left
+ rnod = rnod._left
r = new RopeCharIteratorPiece(rnod, true, false, r)
end
else
break
end
if not it.ldone then
- rnod = rnod.left
+ rnod = rnod._left
it.ldone = true
it = new RopeCharIteratorPiece(rnod, false, false, it)
else if not it.rdone then
it.rdone = true
- rnod = rnod.right
+ rnod = rnod._right
it = new RopeCharIteratorPiece(rnod, false, false, it)
else
it = it.prev
redef fun [](i) do
var nod: String = target
loop
- if nod isa FlatString then return nod.items[i]
+ if nod isa FlatString then return nod._items[i]
if not nod isa Concat then abort
- if nod.left.bytelen >= i then
- nod = nod.right
+ var lft = nod._left
+ if lft.bytelen >= i then
+ nod = nod._right
else
- nod = nod.left
+ nod = lft
end
end
end
# Init the iterator from a RopeBuffer.
init(t: RopeBuffer) is old_style_init do
ns = t.ns
- maxpos = t.bytelen
+ maxpos = t._bytelen
sit = t.str.bytes.iterator
pns = t.dumped
index = 0
# Init the iterator from a RopeBuffer starting from `pos`.
init from(t: RopeBuffer, pos: Int) do
ns = t.ns
- maxpos = t.bytelen
+ maxpos = t._bytelen
sit = t.str.bytes.iterator_from(pos)
pns = pos - t.str.length
index = pos
init(tgt: RopeBuffer) is old_style_init do
sit = tgt.str.bytes.reverse_iterator
pns = tgt.rpos - 1
- index = tgt.bytelen - 1
+ index = tgt._bytelen - 1
ns = tgt.ns
end
nitlanguage / nit.git / commitdiff