`{
#include <stdio.h>
+#include <string.h>
`}
###############################################################################
redef type OTHER: Text
- # Type of the view on self (.chars)
- type SELFVIEW: StringCharView
-
# Type of self (used for factorization of several methods, ex : substring_from, empty...)
type SELFTYPE: Text
# Gets a view on the chars of the Text object
#
# assert "hello".chars.to_a == ['h', 'e', 'l', 'l', 'o']
- fun chars: SELFVIEW is abstract
+ fun chars: SequenceRead[Char] is abstract
# Number of characters contained in self.
#
var iter = self.chars.iterator_from(pos)
while iter.is_ok do
if iter.item == c then return iter.index
+ iter.next
end
return -1
end
if hash_cache == null then
# djb2 hash algorithm
var h = 5381
- var i = length - 1
for char in self.chars do
- h = (h * 32) + h + char.ascii
- i -= 1
+ h = h.lshift(5) + h + char.ascii
end
hash_cache = h
# Real items, used as cache for to_cstring is called
private var real_items: nullable NativeString = null
- redef var length: Int
+ redef var length: Int = 0
init do end
# Abstract class for the SequenceRead compatible
# views on String and Buffer objects
-abstract class StringCharView
+private abstract class StringCharView
super SequenceRead[Char]
type SELFTYPE: Text
redef fun iterator: IndexedIterator[Char] do return self.iterator_from(0)
- # Gets a new Iterator starting at position `pos`
- #
- # var iter = "abcd".chars.iterator_from(2)
- # assert iter.to_a == ['c', 'd']
- fun iterator_from(pos: Int): IndexedIterator[Char] is abstract
-
- # Gets an iterator starting at the end and going backwards
- #
- # var reviter = "hello".chars.reverse_iterator
- # assert reviter.to_a == ['o', 'l', 'l', 'e', 'h']
- fun reverse_iterator: IndexedIterator[Char] do return self.reverse_iterator_from(self.length - 1)
-
- # Gets an iterator on the chars of self starting from `pos`
- #
- # var reviter = "hello".chars.reverse_iterator_from(2)
- # assert reviter.to_a == ['l', 'e', 'h']
- fun reverse_iterator_from(pos: Int): IndexedIterator[Char] is abstract
-
- redef fun has(c: Char): Bool
- do
- for i in self do
- if i == c then return true
- end
- return false
- end
-
- redef fun ==(other)
- do
- if other == null then return false
- if not other isa StringCharView then return false
- var other_chars = other.iterator
- for i in self do
- if i != other_chars.item then return false
- other_chars.next
- end
- return true
- end
+ redef fun reverse_iterator do return self.reverse_iterator_from(self.length - 1)
end
# View on Buffer objects, extends Sequence
# for mutation operations
-abstract class BufferCharView
+private abstract class BufferCharView
super StringCharView
super Sequence[Char]
# Indes in _items of the last item of the string
private var index_to: Int
- redef var chars: SELFVIEW = new FlatStringCharView(self)
+ redef var chars: SequenceRead[Char] = new FlatStringCharView(self)
################################################
# AbstractString specific methods #
################################################
- redef fun [](index) do
- 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]
- end
-
redef fun reversed
do
var native = calloc_string(self.length + 1)
- var reviter = chars.reverse_iterator
+ var length = self.length
+ var items = self.items
var pos = 0
- while reviter.is_ok do
- native[pos] = reviter.item
+ var ipos = length-1
+ while pos < length do
+ native[pos] = items[ipos]
pos += 1
- reviter.next
+ ipos -= 1
end
return native.to_s_with_length(self.length)
end
redef fun hash
do
if hash_cache == null then
- # djb2 hash algorythm
+ # djb2 hash algorithm
var h = 5381
- var i = length - 1
+ var i = index_from
var myitems = items
- var strStart = index_from
-
- i += strStart
- while i >= strStart do
- h = (h * 32) + h + self.items[i].ascii
- i -= 1
+ while i <= index_to do
+ h = h.lshift(5) + h + myitems[i].ascii
+ i += 1
end
hash_cache = h
# Check that the index (+ index_from) is not larger than indexTo
# In other terms, if the index is valid
assert index >= 0
+ var target = self.target
assert (index + target.index_from) <= target.index_to
return target.items[index + target.index_from]
end
abstract class Buffer
super Text
- redef type SELFVIEW: BufferCharView
redef type SELFTYPE: Buffer
# Specific implementations MUST set this to `true` in order to invalidate caches
return super
end
+ # In Buffers, the internal sequence of character is mutable
+ # Thus, `chars` can be used to modify the buffer.
+ redef fun chars: Sequence[Char] is abstract
end
# Mutable strings of characters.
redef type SELFTYPE: FlatBuffer
- redef var chars: SELFVIEW = new FlatBufferCharView(self)
+ redef var chars: Sequence[Char] = new FlatBufferCharView(self)
- private var capacity: Int
+ private var capacity: Int = 0
redef fun []=(index, item)
do
redef fun enlarge(cap)
do
- is_dirty = true
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)
+ if length > 0 then items.copy_to(a, length, 0, 0)
items = a
capacity = c
- items.copy_to(a, length, 0, 0)
end
redef fun to_s: String
if is_dirty then
var new_native = calloc_string(length + 1)
new_native[length] = '\0'
- items.copy_to(new_native, length, 0, 0)
+ if length > 0 then items.copy_to(new_native, length, 0, 0)
real_items = new_native
is_dirty = false
end
end
# Create a new empty string.
- init do with_capacity(5)
+ init do end
init from(s: Text)
do
redef fun append(s)
do
+ if s.is_empty then return
is_dirty = true
var sl = s.length
if capacity < length + sl then enlarge(length + sl)
end
return new_buf
end
+
+ redef fun to_upper
+ do
+ var new_buf = new FlatBuffer.with_capacity(self.length)
+ for i in self.chars do
+ new_buf.add(i.to_upper)
+ end
+ return new_buf
+ end
+
+ redef fun to_lower
+ do
+ var new_buf = new FlatBuffer.with_capacity(self.length)
+ for i in self.chars do
+ new_buf.add(i.to_lower)
+ end
+ return new_buf
+ end
end
private class FlatBufferReverseIterator
init with_pos(tgt: FlatBuffer, pos: Int)
do
target = tgt
- target_items = tgt.items
+ if tgt.length > 0 then target_items = tgt.items
curr_pos = pos
end
init with_pos(tgt: FlatBuffer, pos: Int)
do
target = tgt
- target_items = tgt.items
+ if tgt.length > 0 then target_items = tgt.items
curr_pos = pos
end
end
redef class Int
+
+ # Wrapper of strerror C function
+ private fun strerror_ext: NativeString is extern `{
+ return strerror(recv);
+ `}
+
+ # Returns a string describing error number
+ fun strerror: String do return strerror_ext.to_s
+
# Fill `s` with the digits in base `base` of `self` (and with the '-' sign if 'signed' and negative).
# assume < to_c max const of char
private fun fill_buffer(s: Buffer, base: Int, signed: Bool)
#
# assert [1, 2, 3].join(":") == "1:2:3"
# assert [1..3].join(":") == "1:2:3"
- fun join(sep: String): String
+ fun join(sep: Text): String
do
if is_empty then return ""
nitlanguage / nit.git / blobdiff