fun substring(from: Int, count: Int): SELFTYPE is abstract
# Iterates on the substrings of self if any
- fun substrings: Iterator[Text] is abstract
+ fun substrings: Iterator[FlatText] is abstract
# Is the current Text empty (== "")
#
# assert "ff".to_hex == 255
fun to_hex: Int do return a_to(16)
+ # If `self` contains only digits <= '7', return the corresponding integer.
+ #
+ # assert "714".to_oct == 460
+ fun to_oct: Int do return a_to(8)
+
+ # If `self` contains only '0' et '1', return the corresponding integer.
+ #
+ # assert "101101".to_bin == 45
+ fun to_bin: Int do return a_to(2)
+
# If `self` contains only digits and letters, return the corresponding integer in a given base
#
# assert "120".a_to(3) == 15
end
return true
end
-
+
# Removes the whitespaces at the beginning of self
#
# assert " \n\thello \n\t".l_trim == "hello \n\t"
return s.to_s
end
+ # Copies `n` bytes from `self` at `src_offset` into `dest` starting at `dest_offset`
+ #
+ # Basically a high-level synonym of NativeString::copy_to
+ #
+ # REQUIRE: `n` must be large enough to contain `len` bytes
+ #
+ # var ns = new NativeString(8)
+ # "Text is String".copy_to_native(ns, 8, 2, 0)
+ # assert ns.to_s_with_length(8) == "xt is St"
+ #
+ fun copy_to_native(dest: NativeString, n, src_offset, dest_offset: Int) do
+ var mypos = src_offset
+ var itspos = dest_offset
+ while n > 0 do
+ dest[itspos] = self.chars[mypos]
+ itspos += 1
+ mypos += 1
+ n -= 1
+ end
+ end
+
end
# All kinds of array-based text representations.
# copy locally the char* as Nit Strings are immutable.
private fun fast_cstring: NativeString is abstract
- redef var length: Int = 0
+ redef var length = 0
redef fun output
do
end
redef fun flatten do return self
+
+ redef fun copy_to_native(dest, n, src_offset, dest_offset) do
+ items.copy_to(dest, n, src_offset, dest_offset)
+ end
end
# Abstract class for the SequenceRead compatible
# assert "helloworld".insert_at(" ", 5) == "hello world"
fun insert_at(s: String, pos: Int): SELFTYPE is abstract
- redef fun substrings: Iterator[String] is abstract
+ redef fun substrings is abstract
# Returns a reversed version of self
#
# assert "Hello World!".to_lower == "hello world!"
fun to_lower : SELFTYPE is abstract
- # Takes a camel case `self` and converts it to snake case
+ # Takes a camel case `self` and converts it to snake case
#
# assert "randomMethodId".to_snake_case == "random_method_id"
#
prev_is_upper = false
end
end
-
+
return new_str.to_s
end
- # Takes a snake case `self` and converts it to camel case
+ # Takes a snake case `self` and converts it to camel case
#
# assert "random_method_id".to_camel_case == "randomMethodId"
#
# Indes in _items of the last item of the string
private var index_to: Int is noinit
- redef var chars: SequenceRead[Char] = new FlatStringCharView(self) is lazy
+ redef var chars = new FlatStringCharView(self) is lazy
redef fun [](index)
do
index_to = to
end
- redef fun to_cstring: NativeString
- do
+ redef fun to_cstring do
if real_items != null then
return real_items.as(not null)
else
capacity = c
end
- redef fun to_s: String
- do
+ redef fun to_s do
written = true
if length == 0 then items = new NativeString(1)
return new FlatString.with_infos(items, length, 0, length - 1)
end
end
+redef class Byte
+ # C function to calculate the length of the `NativeString` to receive `self`
+ private fun byte_to_s_len: Int is extern "native_byte_length_str"
+
+ # C function to convert an nit Int to a NativeString (char*)
+ private fun native_byte_to_s(nstr: NativeString, strlen: Int) is extern "native_byte_to_s"
+
+ # Displayable byte in its hexadecimal form (0x..)
+ #
+ # assert 1.to_b.to_s == "0x01"
+ # assert (-123).to_b.to_s == "0x85"
+ redef fun to_s do
+ var nslen = byte_to_s_len
+ var ns = new NativeString(nslen + 1)
+ ns[nslen] = '\0'
+ native_byte_to_s(ns, nslen + 1)
+ return ns.to_s_with_length(nslen)
+ end
+end
+
redef class Int
# Wrapper of strerror C function
# Concatenate elements.
redef fun to_s
do
+ return plain_to_s
+ end
+
+ # Concatenate element without separators
+ fun plain_to_s: String
+ do
var s = new FlatBuffer
for e in self do if e != null then s.append(e.to_s)
return s.to_s
redef class Array[E]
# Fast implementation
- redef fun to_s
+ redef fun plain_to_s
do
var l = length
if l == 0 then return ""