# This method is usually faster than `search_in` if what is
# required is only the index.
# Note: in most implementation, `search_in` is implemented with this method.
- protected fun search_index_in(s: String, from: Int): Int is abstract
+ protected fun search_index_in(s: Text, from: Int): Int is abstract
# Search `self` into `s` from a certain position.
# Return null if not found.
# If only the index of the first character if required, see `search_index_in`.
#
# Note: Is used by `String::search`, `String::search_from`, and others.
- protected fun search_in(s: String, from: Int): nullable Match is abstract
+ protected fun search_in(s: Text, from: Int): nullable Match is abstract
# Search all `self` occurrences into `s`.
#
# assert 'z'.search_all_in("hello world").length == 0
#
# Note: Is used by `String::search_all`.
- protected fun search_all_in(s: String): Array[Match]
+ protected fun search_all_in(s: Text): Array[Match]
do
var res = new Array[Match] # Result
var match = search_in(s, 0)
# assert 'z'.split_in("hello world").join("|") == "hello world"
#
# Note: is used by `String::split`
- protected fun split_in(s: String): Array[Match]
+ protected fun split_in(s: Text): Array[Match]
do
var res = new Array[Match] # Result
var i = 0 # Cursor
while match != null do
# Compute the splited part length
var len = match.from - i
- res.add(new Match(s, i, len))
+ res.add(new Match(s.to_s, i, len))
i = match.after
match = search_in(s, i)
end
# Add the last part
- res.add(new Match(s, i, s.length - i))
+ res.add(new Match(s.to_s, i, s.length - i))
return res
end
end
if to < 0 then
return null
else
- return new Match(s, to, _length)
+ return new Match(s.to_s, to, _length)
end
end
init(motif: String)
do
_motif = motif
- _length = motif.length
+ _length = _motif.length
_gs = new Array[Int].with_capacity(_length)
_bc_table = new ArrayMap[Char, Int]
compute_gs
redef fun ==(o) do return o isa BM_Pattern and o._motif == _motif
end
-# Matches are a part of a `String` found ba a `Pattern`.
+# Matches are a part of a `Text` found by a `Pattern`.
class Match
# The base string matched
- readable var _string: String
+ var string: String
# The starting position in the string
- readable var _from: Int
+ var from: Int
# The length of the matching part
- readable var _length: Int
+ var length: Int
# The position of the first character just after the matching part.
# May be out of the base string
- fun after: Int do return _from + _length
+ fun after: Int do return from + length
# The contents of the matching part
- redef fun to_s do return _string.substring(_from, _length)
+ redef fun to_s do return string.substring(from,length)
# Matches `len` characters of `s` from `f`.
init(s: String, f: Int, len: Int)
assert positive_length: len >= 0
assert valid_from: f >= 0
assert valid_after: f + len <= s.length
- _string = s
- _from = f
- _length = len
+ string = s
+ from = f
+ length = len
end
end
if pos < 0 then
return null
else
- return new Match(s, pos, 1)
+ return new Match(s.to_s, pos, 1)
end
end
end
-redef class String
+redef class Text
super Pattern
redef fun search_index_in(s, from)
if pos < 0 then
return null
else
- return new Match(s, pos, length)
+ return new Match(s.to_s, pos, length)
end
end
# Split `self` using `p` as separator.
#
# assert "hello world".split('o') == ["hell", " w", "rld"]
- fun split(p: Pattern): Array[String]
+ fun split(p: Pattern): Array[SELFTYPE]
do
var matches = p.split_in(self)
- var res = new Array[String].with_capacity(matches.length)
+ var res = new Array[SELFTYPE].with_capacity(matches.length)
for m in matches do res.add(m.to_s)
return res
end
# @deprecated alias for `split`
- fun split_with(p: Pattern): Array[String] do return self.split(p)
+ fun split_with(p: Pattern): Array[SELFTYPE] do return self.split(p)
# Replace all occurences of a pattern with a string
#
# assert "hlelo".replace("le", "el") == "hello"
# assert "hello".replace('l', "") == "heo"
- fun replace(p: Pattern, string: String): String
+ fun replace(p: Pattern, string: SELFTYPE): SELFTYPE
do
return self.split_with(p).join(string)
end
# Escape the four characters `<`, `>`, `&`, and `"` with their html counterpart
#
# assert "a&b->\"x\"".html_escape == "a&b->"x""
- fun html_escape: String
+ fun html_escape: SELFTYPE
do
var ret = self
if ret.chars.has('&') then ret = ret.replace('&', "&")