#
# assert "abcd".has_substring("bc",1) == true
# assert "abcd".has_substring("bc",2) == false
+ #
+ # Returns true iff all characters of `str` are presents
+ # at the expected index in `self.`
+ # The first character of `str` being at `pos`, the second
+ # character being at `pos+1` and so on...
+ #
+ # This means that all characters of `str` need to be inside `self`.
+ #
+ # assert "abcd".has_substring("xab", -1) == false
+ # assert "abcd".has_substring("cdx", 2) == false
+ #
+ # And that the empty string is always a valid substring.
+ #
+ # assert "abcd".has_substring("", 2) == true
+ # assert "abcd".has_substring("", 200) == true
fun has_substring(str: String, pos: Int): Bool
do
+ if str.is_empty then return true
+ if pos < 0 or pos + str.length > length then return false
var myiter = self.chars.iterator_from(pos)
var itsiter = str.chars.iterator
while myiter.is_ok and itsiter.is_ok do
# assert "\na\nb\tc\t".trim == "a\nb\tc"
fun trim: SELFTYPE do return (self.l_trim).r_trim
+ # Justify a self in a space of `length`
+ #
+ # `left` is the space ratio on the left side.
+ # * 0.0 for left-justified (no space at the left)
+ # * 1.0 for right-justified (all spaces at the left)
+ # * 0.5 for centered (half the spaces at the left)
+ #
+ # assert "hello".justify(10, 0.0) == "hello "
+ # assert "hello".justify(10, 1.0) == " hello"
+ # assert "hello".justify(10, 0.5) == " hello "
+ #
+ # If `length` is not enough, `self` is returned as is.
+ #
+ # assert "hello".justify(2, 0.0) == "hello"
+ #
+ # REQUIRE: left >= 0.0 and left <= 1.0
+ # ENSURE: `self.length <= length implies result.length == length`
+ # ENSURE: `self.length >= length implies result == self
+ fun justify(length: Int, left: Float): SELFTYPE
+ do
+ var diff = length - self.length
+ if diff <= 0 then return self
+ assert left >= 0.0 and left <= 1.0
+ var before = (diff.to_f * left).to_i
+ return " " * before + self + " " * (diff-before)
+ end
+
# Mangle a string to be a unique string only made of alphanumeric characters
fun to_cmangle: String
do
# assert "\n\"'\\\{\}".escape_to_nit == "\\n\\\"\\'\\\\\\\{\\\}"
fun escape_to_nit: String do return escape_more_to_c("\{\}")
+ # Escape to POSIX Shell (sh).
+ #
+ # Abort if the text contains a null byte.
+ #
+ # assert "\n\"'\\\{\}0".escape_to_sh == "'\n\"'\\''\\\{\}0'"
+ fun escape_to_sh: String do
+ var b = new FlatBuffer
+ b.chars.add '\''
+ for i in [0..length[ do
+ var c = chars[i]
+ if c == '\'' then
+ b.append("'\\''")
+ else
+ assert without_null_byte: c != '\0'
+ b.add(c)
+ end
+ end
+ b.chars.add '\''
+ return b.to_s
+ end
+
+ # Escape to include in a Makefile
+ #
+ # Unfortunately, some characters are not escapable in Makefile.
+ # These characters are `;`, `|`, `\`, and the non-printable ones.
+ # They will be rendered as `"?{hex}"`.
+ fun escape_to_mk: String do
+ var b = new FlatBuffer
+ for i in [0..length[ do
+ var c = chars[i]
+ if c == '$' then
+ b.append("$$")
+ else if c == ':' or c == ' ' or c == '#' then
+ b.add('\\')
+ b.add(c)
+ else if c.ascii < 32 or c == ';' or c == '|' or c == '\\' or c == '=' then
+ b.append("?{c.ascii.to_base(16, false)}")
+ else
+ b.add(c)
+ end
+ end
+ return b.to_s
+ end
+
# Return a string where Nit escape sequences are transformed.
#
# var s = "\\n"
abstract class FlatText
super Text
- private var items: NativeString
+ # Underlying C-String (`char*`)
+ #
+ # Warning : Might be void in some subclasses, be sure to check
+ # if set before using it.
+ private var items: NativeString is noinit
# Real items, used as cache for to_cstring is called
private var real_items: nullable NativeString = null
private var target: SELFTYPE
- private init(tgt: SELFTYPE)
- do
- target = tgt
- end
-
redef fun is_empty do return target.is_empty
redef fun length do return target.length
fun insert_at(s: String, pos: Int): SELFTYPE is abstract
+ redef fun substrings: Iterator[String] is abstract
+
# Returns a reversed version of self
#
# assert "hello".reversed == "olleh"
return new_str.to_s
end
+
+ # Returns a capitalized `self`
+ #
+ # Letters that follow a letter are lowercased
+ # Letters that follow a non-letter are upcased.
+ #
+ # SEE : `Char::is_letter` for the definition of letter.
+ #
+ # assert "jAVASCRIPT".capitalized == "Javascript"
+ # assert "i am root".capitalized == "I Am Root"
+ # assert "ab_c -ab0c ab\nc".capitalized == "Ab_C -Ab0C Ab\nC"
+ fun capitalized: SELFTYPE do
+ if length == 0 then return self
+
+ var buf = new FlatBuffer.with_capacity(length)
+
+ var curr = chars[0].to_upper
+ var prev = curr
+ buf[0] = curr
+
+ for i in [1 .. length[ do
+ prev = curr
+ curr = self[i]
+ if prev.is_letter then
+ buf[i] = curr.to_lower
+ else
+ buf[i] = curr.to_upper
+ end
+ end
+
+ return buf.to_s
+ end
end
private class FlatSubstringsIter
var tgt: nullable FlatText
- init(tgt: FlatText) do self.tgt = tgt
-
redef fun item do
assert is_ok
return tgt.as(not null)
super String
# Index in _items of the start of the string
- private var index_from: Int
+ private var index_from: Int is noinit
# Indes in _items of the last item of the string
- private var index_to: Int
+ private var index_to: Int is noinit
redef var chars: SequenceRead[Char] = new FlatStringCharView(self)
redef fun to_cstring: NativeString
do
- if real_items != null then return real_items.as(not null)
- if index_from > 0 or index_to != items.cstring_length - 1 then
+ if real_items != null then
+ return real_items.as(not null)
+ else
var newItems = calloc_string(length + 1)
self.items.copy_to(newItems, length, index_from, 0)
newItems[length] = '\0'
self.real_items = newItems
return newItems
end
- return items
end
redef fun ==(other)
# Specific implementations MUST set this to `true` in order to invalidate caches
protected var is_dirty = true
+ # Copy-On-Write flag
+ #
+ # If the `Buffer` was to_s'd, the next in-place altering
+ # operation will cause the current `Buffer` to be re-allocated.
+ #
+ # The flag will then be set at `false`.
+ protected var written = false
+
# Modifies the char contained at pos `index`
#
# DEPRECATED : Use self.chars.[]= instead
# assert b == "hello world!"
fun lower is abstract
+ # Capitalizes each word in `self`
+ #
+ # Letters that follow a letter are lowercased
+ # Letters that follow a non-letter are upcased.
+ #
+ # SEE: `Char::is_letter` for the definition of a letter.
+ #
+ # var b = new FlatBuffer.from("jAVAsCriPt")"
+ # b.capitalize
+ # assert b == "Javascript"
+ # b = new FlatBuffer.from("i am root")
+ # b.capitalize
+ # assert b == "I Am Root"
+ # b = new FlatBuffer.from("ab_c -ab0c ab\nc")
+ # b.capitalize
+ # assert b == "Ab_C -Ab0C Ab\nC"
+ fun capitalize do
+ if length == 0 then return
+ var c = self[0].to_upper
+ self[0] = c
+ var prev: Char = c
+ for i in [1 .. length[ do
+ prev = c
+ c = self[i]
+ if prev.is_letter then
+ self[i] = c.to_lower
+ else
+ self[i] = c.to_upper
+ end
+ end
+ end
+
redef fun hash
do
if is_dirty then hash_cache = null
redef fun substrings do return new FlatSubstringsIter(self)
+ # Re-copies the `NativeString` into a new one and sets it as the new `Buffer`
+ #
+ # This happens when an operation modifies the current `Buffer` and
+ # the Copy-On-Write flag `written` is set at true.
+ private fun reset do
+ var nns = new NativeString(capacity)
+ items.copy_to(nns, length, 0, 0)
+ items = nns
+ written = false
+ end
+
redef fun [](index)
do
assert index >= 0
add(item)
return
end
+ if written then reset
assert index >= 0 and index < length
items[index] = item
end
redef fun clear do
is_dirty = true
+ if written then reset
length = 0
end
var c = capacity
if cap <= c then return
while c <= cap do c = c * 2 + 2
+ # The COW flag can be set at false here, since
+ # it does a copy of the current `Buffer`
+ written = false
var a = calloc_string(c+1)
if length > 0 then items.copy_to(a, length, 0, 0)
items = a
redef fun to_s: String
do
- return to_cstring.to_s_with_length(length)
+ written = true
+ if length == 0 then items = new NativeString(1)
+ return new FlatString.with_infos(items, length, 0, length - 1)
end
redef fun to_cstring
redef fun reverse
do
+ written = false
var ns = calloc_string(capacity)
var si = length - 1
var ni = 0
redef fun upper
do
+ if written then reset
var it = items
var id = length - 1
while id >= 0 do
redef fun lower
do
+ if written then reset
var it = items
var id = length - 1
while id >= 0 do
end
redef class Float
- # Pretty print self, print needoed decimals up to a max of 3.
+ # Pretty representation of `self`, with decimals as needed from 1 to a maximum of 3
#
- # assert 12.34.to_s == "12.34"
- # assert (-0120.03450).to_s == "-120.035"
+ # assert 12.34.to_s == "12.34"
+ # assert (-0120.030).to_s == "-120.03"
#
- # see `to_precision` for a different precision.
+ # see `to_precision` for a custom precision.
redef fun to_s do
var str = to_precision( 3 )
if is_inf != 0 or is_nan then return str
return str
end
- # `self` representation with `nb` digits after the '.'.
+ # `String` representation of `self` with the given number of `decimals`
#
- # assert 12.345.to_precision(1) == "12.3"
- # assert 12.345.to_precision(2) == "12.35"
- # assert 12.345.to_precision(3) == "12.345"
- # assert 12.345.to_precision(4) == "12.3450"
- fun to_precision(nb: Int): String
+ # assert 12.345.to_precision(0) == "12"
+ # assert 12.345.to_precision(3) == "12.345"
+ # assert (-12.345).to_precision(3) == "-12.345"
+ # assert (-0.123).to_precision(3) == "-0.123"
+ # assert 0.999.to_precision(2) == "1.00"
+ # assert 0.999.to_precision(4) == "0.9990"
+ fun to_precision(decimals: Int): String
do
if is_nan then return "nan"
return "-inf"
end
- if nb == 0 then return self.to_i.to_s
+ if decimals == 0 then return self.to_i.to_s
var f = self
- for i in [0..nb[ do f = f * 10.0
+ for i in [0..decimals[ do f = f * 10.0
if self > 0.0 then
f = f + 0.5
else
f = f - 0.5
end
var i = f.to_i
- if i == 0 then return "0.0"
- var s = i.to_s
+ if i == 0 then return "0." + "0"*decimals
+
+ # Prepare both parts of the float, before and after the "."
+ var s = i.abs.to_s
var sl = s.length
- if sl > nb then
- var p1 = s.substring(0, s.length-nb)
- var p2 = s.substring(s.length-nb, nb)
- return p1 + "." + p2
+ var p1
+ var p2
+ if sl > decimals then
+ # Has something before the "."
+ p1 = s.substring(0, sl-decimals)
+ p2 = s.substring(sl-decimals, decimals)
else
- return "0." + ("0"*(nb-sl)) + s
+ p1 = "0"
+ p2 = "0"*(decimals-sl) + s
end
+
+ if i < 0 then p1 = "-" + p1
+
+ return p1 + "." + p2
end
# `self` representation with `nb` digits after the '.'.
fun to_s_with_length(length: Int): FlatString
do
assert length >= 0
- return new FlatString.with_infos(self, length, 0, length - 1)
+ var str = new FlatString.with_infos(self, length, 0, length - 1)
+ return str
end
fun to_s_with_copy: FlatString
var length = cstring_length
var new_self = calloc_string(length + 1)
copy_to(new_self, length, 0, 0)
- return new FlatString.with_infos(new_self, length, 0, length - 1)
+ var str = new FlatString.with_infos(new_self, length, 0, length - 1)
+ new_self[length] = '\0'
+ str.real_items = new_self
+ return str
end
end
#
# Note: it caching is not usefull, see `alpha_comparator`
class CachedAlphaComparator
- super Comparator[Object]
+ super Comparator
+ redef type COMPARED: Object
private var cache = new HashMap[Object, String]
# see `alpha_comparator`
private class AlphaComparator
- super Comparator[Object]
+ super Comparator
redef fun compare(a, b) do return a.to_s <=> b.to_s
end
# var a = [1, 2, 3, 10, 20]
# alpha_comparator.sort(a)
# assert a == [1, 10, 2, 20, 3]
-fun alpha_comparator: Comparator[Object] do return once new AlphaComparator
+fun alpha_comparator: Comparator do return once new AlphaComparator
# The arguments of the program as given by the OS
fun args: Sequence[String]
nitlanguage / nit.git / blobdiff