Merge pull request #3 from JuliaStrings/searching

add searching utils

Author: stevengj

README.md

@@ -37,5 +37,5 @@ julia> abc = StringView(0x61:0x63) # and for other array types
 ```
 
 Other optimized (copy-free) operations include I/O, hashing, iteration/indexing,
-comparisons, parsing, and validation.  Working with a `SubString` of a `StringView` is
-similarly efficient.
+comparisons, parsing, searching, and validation.  Working with a `SubString` of
+a `StringView` is similarly efficient.

src/StringViews.jl

@@ -86,8 +86,8 @@ function Base.isascii(s::StringViewAndSub)
     return true
 end
 
-write(io::IO, s::StringViewAndSub) = write(io, codeunits(s))
-print(io::IO, s::StringViewAndSub) = (write(io, s); nothing)
+Base.write(io::IO, s::StringViewAndSub) = write(io, codeunits(s))
+Base.print(io::IO, s::StringViewAndSub) = (write(io, s); nothing)
 
 Base.@propagate_inbounds Base.thisind(s::StringViewAndSub, i::Int) = Base._thisind_str(s, i)
 Base.@propagate_inbounds Base.nextind(s::StringViewAndSub, i::Int) = Base._nextind_str(s, i)
@@ -114,5 +114,7 @@ end
 include("decoding.jl")
 include("regex.jl")
 include("parse.jl")
+include("util.jl")
+include("search.jl")
 
 end # module

src/parse.jl

@@ -108,8 +108,8 @@ function tryparse_internal(::Type{Bool}, sbuff::DenseStringViewAndSub,
     len = endpos - startpos + 1
     p   = pointer(sbuff) + startpos - 1
     GC.@preserve sbuff begin
-        (len == 4) && (0 == Base._memcmp(p, "true", 4)) && (return true)
-        (len == 5) && (0 == Base._memcmp(p, "false", 5)) && (return false)
+        (len == 4) && (0 == _memcmp(p, "true", 4)) && (return true)
+        (len == 5) && (0 == _memcmp(p, "false", 5)) && (return false)
     end
 
     if raise

src/search.jl

@@ -0,0 +1,100 @@
+# optimized string routines copied from julia/base/strings/search.jl
+
+function Base.findnext(pred::Base.Fix2{<:Union{typeof(isequal),typeof(==)},<:AbstractChar},
+                  s::StringViewAndSub, i::Integer)
+    if i < 1 || i > sizeof(s)
+        i == sizeof(s) + 1 && return nothing
+        throw(BoundsError(s, i))
+    end
+    @inbounds isvalid(s, i) || Base.string_index_err(s, i)
+    c = pred.x
+    c ≤ '\x7f' && return Base.nothing_sentinel(Base._search(s, c % UInt8, i))
+    while true
+        i = Base._search(s, Base.first_utf8_byte(c), i)
+        i == 0 && return nothing
+        pred(s[i]) && return i
+        i = nextind(s, i)
+    end
+end
+
+function Base._search(a::StringViewAndSub, b::Union{Int8,UInt8}, i::Integer = 1)
+    if i < 1
+        throw(BoundsError(a, i))
+    end
+    n = sizeof(a)
+    if i > n
+        return i == n+1 ? 0 : throw(BoundsError(a, i))
+    end
+    if a isa DenseStringViewAndSub
+        p = pointer(a)
+        q = GC.@preserve a ccall(:memchr, Ptr{UInt8}, (Ptr{UInt8}, Int32, Csize_t), p+i-1, b, n-i+1)
+        return q == C_NULL ? 0 : Int(q-p+1)
+    else
+        _i = Int(i)
+        while true
+            codeunit(a,_i) == b && return _i
+            (_i += 1) > n && break
+        end
+        return 0
+    end
+end
+
+function Base.findprev(pred::Base.Fix2{<:Union{typeof(isequal),typeof(==)},<:AbstractChar},
+                  s::StringViewAndSub, i::Integer)
+    c = pred.x
+    c ≤ '\x7f' && return Base.nothing_sentinel(Base._rsearch(s, c % UInt8, i))
+    b = Base.first_utf8_byte(c)
+    while true
+        i = Base._rsearch(s, b, i)
+        i == 0 && return nothing
+        pred(s[i]) && return i
+        i = prevind(s, i)
+    end
+end
+
+function Base._rsearch(a::StringViewAndSub, b::Union{Int8,UInt8}, i::Integer = sizeof(a))
+    if i < 1
+        return i == 0 ? 0 : throw(BoundsError(a, i))
+    end
+    n = sizeof(a)
+    if i > n
+        return i == n+1 ? 0 : throw(BoundsError(a, i))
+    end
+    if a isa DenseStringViewAndSub
+        p = pointer(a)
+        q = GC.@preserve a ccall(:memrchr, Ptr{UInt8}, (Ptr{UInt8}, Int32, Csize_t), p, b, i)
+        return q == C_NULL ? 0 : Int(q-p+1)
+    else
+        _i = Int(i)
+        while true
+            codeunit(a,_i) == b && return _i
+            (_i -= 1) < 1 && break
+        end
+        return 0
+    end
+end
+
+# The following functions require julia#37283 in Julia 1.6, which
+# allow us to search byte arrays (applied to codeunits(s)).
+@static if VERSION ≥ v"1.6.0-DEV.1341"
+    function Base._searchindex(s::Union{StringViewAndSub,StringAndSub}, t::Union{StringViewAndSub,StringAndSub}, i::Integer)
+        # Check for fast case of a single byte
+        lastindex(t) == 1 && return something(findnext(isequal(t[1]), s, i), 0)
+        Base._searchindex(codeunits(s), codeunits(t), i)
+    end
+    function Base._rsearchindex(s::Union{StringViewAndSub,StringAndSub}, t::Union{StringViewAndSub,StringAndSub}, i::Integer)
+        # Check for fast case of a single byte
+        if lastindex(t) == 1
+            return something(findprev(isequal(t[1]), s, i), 0)
+        elseif lastindex(t) != 0
+            j = i ≤ ncodeunits(s) ? nextind(s, i)-1 : i
+            return Base._rsearchindex(codeunits(s), codeunits(t), j)
+        elseif i > sizeof(s)
+            return 0
+        elseif i == 0
+            return 1
+        else
+            return i
+        end
+    end
+end

src/util.jl

@@ -0,0 +1,85 @@
+# other optimized string routines copied from julia/base/strings/util.jl
+
+function Base.startswith(a::Union{DenseStringViewAndSub,StringAndSub},
+                         b::Union{DenseStringViewAndSub,StringAndSub})
+    cub = ncodeunits(b)
+    if ncodeunits(a) < cub
+        false
+    elseif _memcmp(a, b, sizeof(b)) == 0
+        nextind(a, cub) == cub + 1
+    else
+        false
+    end
+end
+
+function Base.endswith(a::Union{DenseStringViewAndSub,StringAndSub},
+                       b::Union{DenseStringViewAndSub,StringAndSub})
+    cub = ncodeunits(b)
+    astart = ncodeunits(a) - ncodeunits(b) + 1
+    if astart < 1
+        false
+    elseif GC.@preserve(a, _memcmp(pointer(a, astart), b, sizeof(b))) == 0
+        thisind(a, astart) == astart
+    else
+        false
+    end
+end
+
+function Base.chomp(s::StringViewAndSub)
+    i = lastindex(s)
+    if i < 1 || codeunit(s,i) != 0x0a
+        return @inbounds SubString(s, 1, i)
+    elseif i < 2 || codeunit(s,i-1) != 0x0d
+        return @inbounds SubString(s, 1, prevind(s, i))
+    else
+        return @inbounds SubString(s, 1, prevind(s, i-1))
+    end
+end
+
+Base.replace(str::DenseStringViewAndSub, pat_repl::Pair{<:AbstractChar}; count::Integer=typemax(Int)) =
+    replace(str, isequal(first(pat_repl)) => last(pat_repl); count=count)
+
+Base.replace(str::DenseStringViewAndSub, pat_repl::Pair{<:Union{Tuple{Vararg{<:AbstractChar}},
+                                            AbstractVector{<:AbstractChar},Set{<:AbstractChar}}};
+        count::Integer=typemax(Int)) =
+    replace(str, in(first(pat_repl)) => last(pat_repl), count=count)
+
+_pat_replacer(x) = x
+_free_pat_replacer(x) = nothing
+
+function Base.replace(str::DenseStringViewAndSub, pat_repl::Pair; count::Integer=typemax(Int))
+    pattern, repl = pat_repl
+    count == 0 && return str
+    count < 0 && throw(DomainError(count, "`count` must be non-negative."))
+    n = 1
+    e = lastindex(str)
+    i = a = firstindex(str)
+    pattern = _pat_replacer(pattern)
+    r = something(findnext(pattern,str,i), 0)
+    j, k = first(r), last(r)
+    if j == 0
+        _free_pat_replacer(pattern)
+        return str
+    end
+    out = IOBuffer(sizehint=floor(Int, 1.2sizeof(str)))
+    while j != 0
+        if i == a || i <= k
+            GC.@preserve str unsafe_write(out, pointer(str, i), UInt(j-i))
+            Base._replace(out, repl, str, r, pattern)
+        end
+        if k < j
+            i = j
+            j > e && break
+            k = nextind(str, j)
+        else
+            i = k = nextind(str, k)
+        end
+        r = something(findnext(pattern,str,k), 0)
+        r === 0:-1 || n == count && break
+        j, k = first(r), last(r)
+        n += 1
+    end
+    _free_pat_replacer(pattern)
+    write(out, SubString(str,i))
+    String(take!(out))
+end

test/runtests.jl

@@ -89,6 +89,21 @@ end
     end
 end
 
+@testset "searching" begin
+    for str in (s, ss, abc)
+        sS, n = String(str), lastindex(str)
+        @test startswith(str, "foo") == startswith(sS, "foo")
+        @test endswith(str, "bar") == endswith(sS, "bar")
+        @test replace(str, 'o'=>"xy") == replace(sS, 'o'=>"xy")
+        @test replace(str, ('o','a')=>'x') == replace(sS, ('o','a')=>'x')
+        @test findnext(==('b'), str, 1) === findnext(==('b'), sS, 1)
+        @test findprev(==('b'), str, n) === findprev(==('b'), sS, n)
+        @test findnext(==("ba"), str, 1) === findnext(==("ba"), sS, 1)
+        @test findprev(==("ba"), str, n) === findprev(==("ba"), sS, n)
+    end
+    @test chomp(StringView("foo\n")) == "foo"
+end
+
 @testset "miscellaneous" begin
     @test cmp("foobar","bar") == cmp(s,"bar") == -cmp("bar",s) == cmp(s,StringView("bar"))
     @test s == StringView("foobar") == "foobar" == s == "foobar" != StringView("bar")