# High-level abstraction for all text representations
abstract class Text
- super AbstractArrayRead[Char]
# Gets a view on the chars of the Text object
fun chars: StringCharView is abstract
+ # Number of characters contained in self.
+ fun length: Int is abstract
+
# Create a substring.
#
# assert "abcd".substring(1, 2) == "bc"
# In this case, `from += count` and `count -= from`.
fun substring(from: Int, count: Int): String is abstract
- redef fun is_empty: Bool do return self.length == 0
+ # Is the current Text empty (== "")
+ # assert "".is_empty
+ # assert not "foo".is_empty
+ fun is_empty: Bool do return self.length == 0
+
+ # Gets the first char of the Text
+ #
+ # DEPRECATED : Use self.chars.first instead
+ fun first: Char do return self.chars[0]
- redef fun index_of(c: Char): Int
+ # Access a character at `index` in the string.
+ #
+ # assert "abcd"[2] == 'c'
+ #
+ # DEPRECATED : Use self.chars.[] instead
+ fun [](index: Int): Char do return self.chars[index]
+
+ # Gets the index of the first occurence of 'c'
+ #
+ # Returns -1 if not found
+ #
+ # DEPRECATED : Use self.chars.index_of instead
+ fun index_of(c: Char): Int
do
return index_of_from(c, 0)
end
- redef fun last: Char do return self.chars[length-1]
+ # Gets the last char of self
+ #
+ # DEPRECATED : Use self.chars.last instead
+ fun last: Char do return self.chars[length-1]
- redef fun index_of_from(c: Char, pos: Int): Int
+ # Gets the index of the first occurence of ´c´ starting from ´pos´
+ #
+ # Returns -1 if not found
+ #
+ # DEPRECATED : Use self.chars.index_of_from instead
+ fun index_of_from(c: Char, pos: Int): Int
do
var iter = self.chars.iterator_from(pos)
while iter.is_ok do
return -1
end
- redef fun last_index_of(c: Char): Int
+ # Gets the last index of char ´c´
+ #
+ # Returns -1 if not found
+ #
+ # DEPRECATED : Use self.chars.last_index_of instead
+ fun last_index_of(c: Char): Int
do
return last_index_of_from(c, length - 1)
end
- redef fun last_index_of_from(item: Char, pos: Int): Int
+ # The index of the last occurrence of an element starting from pos (in reverse order).
+ # Example :
+ # assert "/etc/bin/test/test.nit".last_index_of_from('/', length-1) == 13
+ # assert "/etc/bin/test/test.nit".last_index_of_from('/', 12) == 8
+ #
+ # Returns -1 if not found
+ #
+ # DEPRECATED : Use self.chars.last_index_of_from instead
+ fun last_index_of_from(item: Char, pos: Int): Int
do
var iter = self.chars.reverse_iterator_from(pos)
while iter.is_ok do
return -1
end
- redef fun iterator: Iterator[Char]
+ # Gets an iterator on the chars of self
+ #
+ # DEPRECATED : Use self.chars.iterator instead
+ fun iterator: Iterator[Char]
do
return self.chars.iterator
end
- redef fun has(c: Char): Bool
+ # Is 'c' contained in self ?
+ #
+ # DEPRECATED : Use self.chars.has instead
+ fun has(c: Char): Bool
do
return self.chars.has(c)
end
- redef fun to_a: Array[Char] do return chars.to_a
+ # Gets an Array containing the chars of self
+ #
+ # DEPRECATED : Use self.chars.to_a instead
+ fun to_a: Array[Char] do return chars.to_a
# Create a substring from `self` beginning at the `from` position
#
# assert "Hello World!".to_upper == "HELLO WORLD!"
fun to_upper: String
do
- var s = new Buffer.with_capacity(length)
+ var s = new FlatBuffer.with_capacity(length)
for i in self.chars do s.add(i.to_upper)
return s.to_s
end
# assert "Hello World!".to_lower == "hello world!"
fun to_lower : String
do
- var s = new Buffer.with_capacity(length)
+ var s = new FlatBuffer.with_capacity(length)
for i in self.chars do s.add(i.to_lower)
return s.to_s
end
# Mangle a string to be a unique string only made of alphanumeric characters
fun to_cmangle: String
do
- var res = new Buffer
+ var res = new FlatBuffer
var underscore = false
for c in self.chars do
if (c >= 'a' and c <= 'z') or (c >='A' and c <= 'Z') then
# assert "\n\"'\\".escape_to_c == "\\n\\\"\\'\\\\"
fun escape_to_c: String
do
- var b = new Buffer
+ var b = new FlatBuffer
for c in self.chars do
if c == '\n' then
b.append("\\n")
# assert "ab|\{\}".escape_more_to_c("|\{\}") == "ab\\|\\\{\\\}"
fun escape_more_to_c(chars: String): String
do
- var b = new Buffer
+ var b = new FlatBuffer
for c in escape_to_c do
if chars.chars.has(c) then
b.add('\\')
# assert u[0].ascii == 10 # (the ASCII value of the "new line" character)
fun unescape_nit: String
do
- var res = new Buffer.with_capacity(self.length)
+ var res = new FlatBuffer.with_capacity(self.length)
var was_slash = false
for c in self do
if not was_slash then
abstract class AbstractString
super Text
- readable private var _items: NativeString
+ private var items: NativeString
- redef var _length: Int
+ redef var length: Int
init do end
do
var i = 0
while i < length do
- _items[i].output
+ items[i].output
i += 1
end
end
redef type OTHER: String
# Index in _items of the start of the string
- readable var _index_from: Int
+ private var index_from: Int
# Indes in _items of the last item of the string
- readable var _index_to: Int
+ private var index_to: Int
redef var chars: StringCharView = new FlatStringCharView(self)
assert index >= 0
# Check that the index (+ index_from) is not larger than indexTo
# In other terms, if the index is valid
- assert (index + _index_from) <= _index_to
- return _items[index + _index_from]
+ assert (index + index_from) <= index_to
+ return items[index + index_from]
end
redef fun substring(from: Int, count: Int): String
from = 0
end
- var realFrom = _index_from + from
+ var realFrom = index_from + from
- if (realFrom + count) > _index_to then return new String.with_infos(_items, _index_to - realFrom + 1, realFrom, _index_to)
+ if (realFrom + count) > index_to then return new String.with_infos(items, index_to - realFrom + 1, realFrom, index_to)
if count == 0 then return ""
var to = realFrom + count - 1
- return new String.with_infos(_items, to - realFrom + 1, realFrom, to)
+ return new String.with_infos(items, to - realFrom + 1, realFrom, to)
end
-
redef fun to_upper: String
do
- var outstr = calloc_string(self._length + 1)
+ var outstr = calloc_string(self.length + 1)
var out_index = 0
- var myitems = self._items
- var index_from = self._index_from
- var max = self._index_to
+ var myitems = self.items
+ var index_from = self.index_from
+ var max = self.index_to
while index_from <= max do
outstr[out_index] = myitems[index_from].to_upper
outstr[self.length] = '\0'
- return outstr.to_s_with_length(self._length)
+ return outstr.to_s_with_length(self.length)
end
redef fun to_lower : String
do
- var outstr = calloc_string(self._length + 1)
+ var outstr = calloc_string(self.length + 1)
var out_index = 0
- var myitems = self._items
- var index_from = self._index_from
- var max = self._index_to
+ var myitems = self.items
+ var index_from = self.index_from
+ var max = self.index_to
while index_from <= max do
outstr[out_index] = myitems[index_from].to_lower
outstr[self.length] = '\0'
- return outstr.to_s_with_length(self._length)
+ return outstr.to_s_with_length(self.length)
end
redef fun trim: String
do
- if self._length == 0 then return self
+ if self.length == 0 then return self
# find position of the first non white space char (ascii < 32) from the start of the string
- var start_pos = self._index_from
- while _items[start_pos].ascii <= 32 do
+ var start_pos = self.index_from
+ while items[start_pos].ascii <= 32 do
start_pos += 1
- if start_pos == _index_to + 1 then return ""
+ if start_pos == index_to + 1 then return ""
end
# find position of the first non white space char from the end of the string
- var end_pos = _index_to
- while _items[end_pos].ascii <= 32 do
+ var end_pos = index_to
+ while items[end_pos].ascii <= 32 do
end_pos -= 1
- if end_pos == start_pos then return _items[start_pos].to_s
+ if end_pos == start_pos then return items[start_pos].to_s
end
start_pos -= index_from
end_pos -= index_from
redef fun output
do
- var i = self._index_from
- var imax = self._index_to
+ var i = self.index_from
+ var imax = self.index_to
while i <= imax do
- _items[i].output
+ items[i].output
i += 1
end
end
private init with_infos(items: NativeString, len: Int, from: Int, to: Int)
do
- self._items = items
- _length = len
- _index_from = from
- _index_to = to
+ self.items = items
+ length = len
+ index_from = from
+ index_to = to
end
# Return a null terminated char *
fun to_cstring: NativeString
do
- if _index_from > 0 or _index_to != items.cstring_length - 1 then
- var newItems = calloc_string(_length + 1)
- self.items.copy_to(newItems, _length, _index_from, 0)
+ if index_from > 0 or index_to != items.cstring_length - 1 then
+ var newItems = calloc_string(length + 1)
+ self.items.copy_to(newItems, length, index_from, 0)
newItems[length] = '\0'
return newItems
end
- return _items
+ return items
end
redef fun ==(other)
if self.object_id == other.object_id then return true
- var my_length = _length
+ var my_length = length
- if other._length != my_length then return false
+ if other.length != my_length then return false
- var my_index = _index_from
- var its_index = other._index_from
+ var my_index = index_from
+ var its_index = other.index_from
var last_iteration = my_index + my_length
- var itsitems = other._items
- var myitems = self._items
+ var itsitems = other.items
+ var myitems = self.items
while my_index < last_iteration do
if myitems[my_index] != itsitems[its_index] then return false
var my_curr_char : Char
var its_curr_char : Char
- var curr_id_self = self._index_from
- var curr_id_other = other._index_from
+ var curr_id_self = self.index_from
+ var curr_id_other = other.index_from
- var my_items = self._items
- var its_items = other._items
+ var my_items = self.items
+ var its_items = other.items
- var my_length = self._length
- var its_length = other._length
+ var my_length = self.length
+ var its_length = other.length
var max_iterations = curr_id_self + my_length
# assert "hello " + "world!" == "hello world!"
fun +(s: String): String
do
- var my_length = self._length
- var its_length = s._length
+ var my_length = self.length
+ var its_length = s.length
var total_length = my_length + its_length
var target_string = calloc_string(my_length + its_length + 1)
- self._items.copy_to(target_string, my_length, _index_from, 0)
- s._items.copy_to(target_string, its_length, s._index_from, my_length)
+ self.items.copy_to(target_string, my_length, index_from, 0)
+ s.items.copy_to(target_string, its_length, s.index_from, my_length)
target_string[total_length] = '\0'
do
assert i >= 0
- var my_length = self._length
+ var my_length = self.length
var final_length = my_length * i
- var my_items = self._items
+ var my_items = self.items
var target_string = calloc_string((final_length) + 1)
do
# djb2 hash algorythm
var h = 5381
- var i = _length - 1
+ var i = length - 1
- var myitems = _items
- var strStart = _index_from
+ var myitems = items
+ var strStart = index_from
i += strStart
while i >= strStart do
- h = (h * 32) + h + self._items[i].ascii
+ h = (h * 32) + h + self.items[i].ascii
i -= 1
end
# Check that the index (+ index_from) is not larger than indexTo
# In other terms, if the index is valid
assert index >= 0
- assert (index + target._index_from) <= target._index_to
- return target._items[index + target._index_from]
+ assert (index + target.index_from) <= target.index_to
+ return target.items[index + target.index_from]
end
redef fun iterator_from(start) do return new FlatStringIterator.with_pos(target, start)
end
+abstract class Buffer
+ super Text
+
+ # Modifies the char contained at pos `index`
+ #
+ # DEPRECATED : Use self.chars.[]= instead
+ fun []=(index: Int, item: Char) is abstract
+
+ # Adds a char `c` at the end of self
+ #
+ # DEPRECATED : Use self.chars.add instead
+ fun add(c: Char) is abstract
+
+ # Clears the buffer
+ fun clear is abstract
+
+ # Enlarges the subsequent array containing the chars of self
+ fun enlarge(cap: Int) is abstract
+
+ # Adds the content of string `s` at the end of self
+ fun append(s: String) is abstract
+
+ redef fun chars: BufferCharView is abstract
+end
+
# Mutable strings of characters.
-class Buffer
+class FlatBuffer
super AbstractString
super Comparable
super StringCapable
+ super Buffer
redef type OTHER: String
- redef var chars: BufferCharView = new FlatBufferCharView(self)
+ redef var chars: FlatBufferCharView = new FlatBufferCharView(self)
- # Modifies the char contained at pos `index`
- #
- # DEPRECATED : Use self.chars.[]= instead
- fun []=(index: Int, item: Char)
+ var capacity: Int
+
+ redef fun []=(index, item)
do
if index == length then
add(item)
return
end
assert index >= 0 and index < length
- _items[index] = item
+ items[index] = item
end
- # Adds a char `c` at the end of self
- #
- # DEPRECATED : Use self.chars.add instead
- fun add(c: Char)
+ redef fun add(c)
do
- if _capacity <= length then enlarge(length + 5)
- _items[length] = c
- _length += 1
+ if capacity <= length then enlarge(length + 5)
+ items[length] = c
+ length += 1
end
- # Clears the buffer
- fun clear do _length = 0
+ redef fun clear do length = 0
- # Enlarges the subsequent array containing the chars of self
- fun enlarge(cap: Int)
+ redef fun enlarge(cap)
do
- var c = _capacity
+ var c = capacity
if cap <= c then return
while c <= cap do c = c * 2 + 2
var a = calloc_string(c+1)
- _items.copy_to(a, length, 0, 0)
- _items = a
- _capacity = c
+ items.copy_to(a, length, 0, 0)
+ items = a
+ capacity = c
items.copy_to(a, length, 0, 0)
end
do
var l = length
var a = calloc_string(l+1)
- _items.copy_to(a, l, 0, 0)
+ items.copy_to(a, l, 0, 0)
# Ensure the afterlast byte is '\0' to nul-terminated char *
a[length] = '\0'
init from(s: String)
do
- _capacity = s.length + 1
- _length = s.length
- _items = calloc_string(_capacity)
- s.items.copy_to(_items, _length, s._index_from, 0)
+ capacity = s.length + 1
+ length = s.length
+ items = calloc_string(capacity)
+ s.items.copy_to(items, length, s.index_from, 0)
end
# Create a new empty string with a given capacity.
do
assert cap >= 0
# _items = new NativeString.calloc(cap)
- _items = calloc_string(cap+1)
- _capacity = cap
- _length = 0
+ items = calloc_string(cap+1)
+ capacity = cap
+ length = 0
end
- # Adds the content of string `s` at the end of self
- fun append(s: String)
+ redef fun append(s)
do
var sl = s.length
if capacity < length + sl then enlarge(length + sl)
s.items.copy_to(items, sl, s.index_from, length)
- _length += sl
+ length += sl
end
redef fun ==(o)
do
- if not o isa Buffer then return false
+ if not o isa FlatBuffer then return false
var l = length
if o.length != l then return false
var i = 0
- var it = _items
- var oit = o._items
+ var it = items
+ var oit = o.items
while i < l do
if it[i] != oit[i] then return false
i += 1
return true
end
- readable private var _capacity: Int
-
# Copies the content of self in `dest`
fun copy(start: Int, len: Int, dest: Buffer, new_start: Int)
do
if from < 0 then from = 0
if count > length then count = length
if from < count then
- var r = new Buffer.with_capacity(count - from)
+ var r = new FlatBuffer.with_capacity(count - from)
while from < count do
- r.chars.push(_items[from])
+ r.chars.push(items[from])
from += 1
end
return r.to_s
private class FlatBufferReverseIterator
super IndexedIterator[Char]
- var target: Buffer
+ var target: FlatBuffer
var target_items: NativeString
var curr_pos: Int
- init with_pos(tgt: Buffer, pos: Int)
+ init with_pos(tgt: FlatBuffer, pos: Int)
do
target = tgt
target_items = tgt.items
super BufferCharView
super StringCapable
- redef type SELFTYPE: Buffer
+ redef type SELFTYPE: FlatBuffer
- redef fun [](index) do return target._items[index]
+ redef fun [](index) do return target.items[index]
redef fun []=(index, item)
do
add(item)
return
end
- target._items[index] = item
+ target.items[index] = item
end
redef fun push(c)
private class FlatBufferIterator
super IndexedIterator[Char]
- var target: Buffer
+ var target: FlatBuffer
var target_items: NativeString
var curr_pos: Int
- init with_pos(tgt: Buffer, pos: Int)
+ init with_pos(tgt: FlatBuffer, pos: Int)
do
target = tgt
target_items = tgt.items
fun to_base(base: Int, signed: Bool): String
do
var l = digit_count(base)
- var s = new Buffer.from(" " * l)
+ var s = new FlatBuffer.from(" " * l)
fill_buffer(s, base, signed)
return s.to_s
end
# assert 'x'.to_s == "x"
redef fun to_s
do
- var s = new Buffer.with_capacity(1)
+ var s = new FlatBuffer.with_capacity(1)
s.chars[0] = self
return s.to_s
end
# Concatenate elements.
redef fun to_s
do
- var s = new Buffer
+ var s = new FlatBuffer
for e in self do if e != null then s.append(e.to_s)
return s.to_s
end
do
if is_empty then return ""
- var s = new Buffer # Result
+ var s = new FlatBuffer # Result
# Concat first item
var i = iterator
# Fast implementation
redef fun to_s
do
- var s = new Buffer
+ var s = new FlatBuffer
var i = 0
var l = length
while i < l do
do
if is_empty then return ""
- var s = new Buffer # Result
+ var s = new FlatBuffer # Result
# Concat first item
var i = iterator