Merge search into findfirst/findnext

Author: nalimilan

base/deprecated.jl

@@ -2116,6 +2116,25 @@ end
 finalizer(f::Ptr{Void}, o::Ptr{Void}) = invoke(finalizer, Tuple{Ptr{Void}, Any}, f, o)
 finalizer(f::Ptr{Void}, o::Function) = invoke(finalizer, Tuple{Ptr{Void}, Any}, f, o)
 
+@deprecate search(str::Union{String,SubString}, re::Regex, idx::Integer) findnext(re, str, idx)
+@deprecate search(str::Union{String,SubString}, re::Regex) findfirst(re, str)
+@deprecate search(s::AbstractString, r::Regex, idx::Integer) findnext(r, s, idx)
+@deprecate search(s::AbstractString, r::Regex) findfirst(r, s)
+@deprecate search(s::String, c::Char, i::Integer) findnext(equalto(c), s, i)
+@deprecate search(s::String, c::Char) findfirst(equalto(c), s)
+# FIXME: no replacement to search for a multibyte char in a ByteArray
+@deprecate search(a::Union{String,ByteArray}, b::Union{Int8,UInt8}, i::Integer = 1) findnext(equalto(b), a, i)
+@deprecate search(a::String, b::Union{Int8,UInt8}, i::Integer = 1) findnext(equalto(Char(b)), a, i)
+@deprecate search(a::ByteArray, b::Char, i::Integer = 1) findnext(equalto(Unt8(b)), a, i)
+
+@deprecate search(s::AbstractString, c::Union{Tuple{Vararg{Char}},AbstractVector{Char},Set{Char}}, i::Integer) findnext(x -> x in c, s, i)
+@deprecate search(s::AbstractString, c::Union{Tuple{Vararg{Char}},AbstractVector{Char},Set{Char}}) findfirst(x -> x in c, s, i)
+@deprecate search(s::AbstractString, t::AbstractString, i::Integer) findnext(t, s, i)
+@deprecate search(s::AbstractString, t::AbstractString) findfirst(t, s)
+
+@deprecate search(buf::IOBuffer, delim::UInt8) findfirst(equalto(delim), buf)
+@deprecate search(buf::Base.GenericIOBuffer, delim::UInt8) findfirst(equalto(delim), buf)
+
 # END 0.7 deprecations
 
 # BEGIN 1.0 deprecations

base/docs/utils.jl

@@ -373,7 +373,7 @@ completions(name::Symbol) = completions(string(name))
 # Searching and apropos
 
 # Docsearch simply returns true or false if an object contains the given needle
-docsearch(haystack::AbstractString, needle) = !isempty(search(haystack, needle))
+docsearch(haystack::AbstractString, needle) = !isempty(findfirst(needle, haystack))
 docsearch(haystack::Symbol, needle) = docsearch(string(haystack), needle)
 docsearch(::Void, needle) = false
 function docsearch(haystack::Array, needle)

base/exports.jl

@@ -775,7 +775,6 @@ export
     rsearchindex,
     rsplit,
     rstrip,
-    search,
     searchindex,
     show,
     showcompact,

base/iobuffer.jl

@@ -365,18 +365,18 @@ read(io::GenericIOBuffer) = read!(io,StringVector(nb_available(io)))
 readavailable(io::GenericIOBuffer) = read(io)
 read(io::GenericIOBuffer, nb::Integer) = read!(io,StringVector(min(nb, nb_available(io))))
 
-function search(buf::IOBuffer, delim::UInt8)
+function findfirst(delim::EqualTo{UInt8}, buf::IOBuffer)
     p = pointer(buf.data, buf.ptr)
-    q = @gc_preserve buf ccall(:memchr,Ptr{UInt8},(Ptr{UInt8},Int32,Csize_t),p,delim,nb_available(buf))
+    q = @gc_preserve buf ccall(:memchr,Ptr{UInt8},(Ptr{UInt8},Int32,Csize_t),p,delim.x,nb_available(buf))
     nb::Int = (q == C_NULL ? 0 : q-p+1)
     return nb
 end
 
-function search(buf::GenericIOBuffer, delim::UInt8)
+function findfirst(delim::EqualTo{UInt8}, buf::GenericIOBuffer)
     data = buf.data
     for i = buf.ptr : buf.size
         @inbounds b = data[i]
-        if b == delim
+        if b == delim.x
             return i - buf.ptr + 1
         end
     end

base/libgit2/types.jl

@@ -893,7 +893,7 @@ function Base.split(ce::ConfigEntry)
     key = unsafe_string(ce.name)
 
     # Determine the positions of the delimiters
-    subsection_delim = search(key, '.')
+    subsection_delim = findfirst(equalto('.'), key)
     name_delim = rsearch(key, '.')
 
     section = SubString(key, 1, subsection_delim - 1)

base/methodshow.jl

@@ -11,7 +11,7 @@ function argtype_decl(env, n, sig::DataType, i::Int, nargs, isva::Bool) # -> (ar
         n = n.args[1]  # handle n::T in arg list
     end
     s = string(n)
-    i = search(s,'#')
+    i = findfirst(equalto('#'), s)
     if i > 0
         s = s[1:i-1]
     end

base/precompile.jl

@@ -583,7 +583,6 @@ precompile(Tuple{typeof(Base.LineEdit.complete_line), Base.REPL.REPLCompletionPr
 precompile(Tuple{getfield(Base, Symbol("#kw##parse")), Array{Any, 1}, typeof(Base.parse), String})
 precompile(Tuple{typeof(Base.isvalid), Base.RevString{String}, Int64})
 precompile(Tuple{typeof(Base.nextind), Base.RevString{String}, Int64})
-precompile(Tuple{typeof(Base.search), Base.RevString{String}, Array{Char, 1}, Int64})
 precompile(Tuple{typeof(Base.rsearch), String, Array{Char, 1}, Int64})
 precompile(Tuple{getfield(Base.REPLCompletions, Symbol("#kw##find_start_brace")), Array{Any, 1}, typeof(Base.REPLCompletions.find_start_brace), String})
 precompile(Tuple{typeof(Core.Inference.isbits), Tuple{Void, Void, Void}})
@@ -1217,7 +1216,7 @@ precompile(Tuple{typeof(Base.Distributed.setup_launched_worker), Base.Distribute
 precompile(Tuple{typeof(Base.connect), Base.Distributed.LocalManager, Int64, Base.Distributed.WorkerConfig})
 precompile(Tuple{typeof(Base.Distributed.read_worker_host_port), Base.Pipe})
 precompile(Tuple{typeof(Base.isreadable), Base.PipeEndpoint})
-precompile(Tuple{typeof(Base.search), Base.GenericIOBuffer{Array{UInt8, 1}}, UInt8})
+precompile(Tuple{typeof(Base.findfirst), UInt8, Base.GenericIOBuffer{Array{UInt8, 1}}})
 precompile(Tuple{typeof(Base.start_reading), Base.PipeEndpoint})
 precompile(Tuple{typeof(Base.wait_readbyte), Base.PipeEndpoint, UInt8})
 precompile(Tuple{typeof(Base.readuntil), Base.PipeEndpoint, UInt8})

base/regex.jl

@@ -285,7 +285,8 @@ end
 matchall(re::Regex, str::SubString, overlap::Bool=false) =
     matchall(re, String(str), overlap)
 
-function search(str::Union{String,SubString}, re::Regex, idx::Integer)
+# TODO: return only start index and update deprecation
+function findnext(re::Regex, str::Union{String,SubString}, idx::Integer)
     if idx > nextind(str,endof(str))
         throw(BoundsError())
     end
@@ -294,10 +295,10 @@ function search(str::Union{String,SubString}, re::Regex, idx::Integer)
     PCRE.exec(re.regex, str, idx-1, opts, re.match_data) ?
         ((Int(re.ovec[1])+1):prevind(str,Int(re.ovec[2])+1)) : (0:-1)
 end
-search(s::AbstractString, r::Regex, idx::Integer) = throw(ArgumentError(
+findnext(r::Regex, s::AbstractString, idx::Integer) = throw(ArgumentError(
     "regex search is only available for the String type; use String(s) to convert"
 ))
-search(s::AbstractString, r::Regex) = search(s,r,start(s))
+findfirst(r::Regex, s::AbstractString) = findnext(r,s,start(s))
 
 struct SubstitutionString{T<:AbstractString} <: AbstractString
     string::T

base/repl/LineEdit.jl

@@ -512,7 +512,7 @@ function edit_move_down(buf::IOBuffer)
     npos = rsearch(buf.data[1:buf.size], '\n', position(buf))
     # We're interested in character count, not byte count
     offset = length(String(buf.data[(npos+1):(position(buf))]))
-    npos2 = search(buf.data[1:buf.size], '\n', position(buf)+1)
+    npos2 = findnext(equalto(UInt8('\n')), buf.data[1:buf.size], position(buf)+1)
     if npos2 == 0 #we're in the last line
         return false
     end
@@ -1615,7 +1615,7 @@ function move_line_end(s::MIState)
 end
 function move_line_end(buf::IOBuffer)
     eof(buf) && return
-    pos = search(buf.data, '\n', position(buf)+1)
+    pos = findnext(equalto(UInt8('\n')), buf.data, position(buf)+1)
     if pos == 0
         move_input_end(buf)
         return

base/repl/REPL.jl

@@ -584,7 +584,7 @@ function history_search(hist::REPLHistoryProvider, query_buffer::IOBuffer, respo
     !skip_current && searchdata == response_str[a:b] && return true
 
     searchfunc, searchstart, skipfunc = backwards ? (rsearch, b, prevind) :
-                                                    (search,  a, nextind)
+                                                    (findfirst,  a, nextind)
     skip_current && (searchstart = skipfunc(response_str, searchstart))
 
     # Start searching
@@ -601,7 +601,7 @@ function history_search(hist::REPLHistoryProvider, query_buffer::IOBuffer, respo
     idxs = backwards ? ((hist.cur_idx-1):-1:1) : ((hist.cur_idx+1):length(hist.history))
     for idx in idxs
         h = hist.history[idx]
-        match = searchfunc(h, searchdata)
+        match = searchfunc === findfirst ? findfirst(searchdata, h) : rsearch(h, searchdata)
         if match != 0:-1 && h != response_str && haskey(hist.mode_mapping, hist.modes[idx])
             truncate(response_buffer, 0)
             write(response_buffer, h)
@@ -855,7 +855,7 @@ function setup_interface(
             sbuffer = LineEdit.buffer(s)
             curspos = position(sbuffer)
             seek(sbuffer, 0)
-            shouldeval = (nb_available(sbuffer) == curspos && search(sbuffer, UInt8('\n')) == 0)
+            shouldeval = (nb_available(sbuffer) == curspos && findfirst(equalto(UInt8('\n')), sbuffer) == 0)
             seek(sbuffer, curspos)
             if curspos == 0
                 # if pasting at the beginning, strip leading whitespace

base/repl/REPLCompletions.jl

@@ -405,7 +405,7 @@ function afterusing(string::String, startpos::Int)
     str = string[1:prevind(string,startpos)]
     isempty(str) && return false
     rstr = reverse(str)
-    r = search(rstr, r"\s(gnisu|tropmi)\b")
+    r = findfirst(r"\s(gnisu|tropmi)\b", rstr)
     isempty(r) && return false
     fr = reverseind(str, last(r))
     return ismatch(r"^\b(using|import)\s*((\w+[.])*\w+\s*,\s*)*$", str[fr:end])
@@ -458,7 +458,7 @@ function dict_identifier_key(str,tag)
         # Avoid `isdefined(::Array, ::Symbol)`
         isa(obj, Array) && return (nothing, nothing, nothing)
     end
-    begin_of_key = first(search(str, r"\S", nextind(str, end_of_identifier) + 1)) # 1 for [
+    begin_of_key = first(findnext(r"\S", str, nextind(str, end_of_identifier) + 1)) # 1 for [
     begin_of_key==0 && return (true, nothing, nothing)
     partial_key = str[begin_of_key:end]
     (isa(obj, Associative) && length(obj) < 1e6) || return (true, nothing, nothing)

base/stream.jl

@@ -260,13 +260,13 @@ end
 
 function wait_readbyte(x::LibuvStream, c::UInt8)
     if isopen(x) # fast path
-        search(x.buffer, c) > 0 && return
+        findfirst(equalto(c), x.buffer) > 0 && return
     else
         return
     end
     preserve_handle(x)
     try
-        while isopen(x) && search(x.buffer, c) <= 0
+        while isopen(x) && findfirst(equalto(c), x.buffer) <= 0
             start_reading(x) # ensure we are reading
             wait(x.readnotify)
         end
@@ -1185,7 +1185,7 @@ end
 show(io::IO, s::BufferStream) = print(io,"BufferStream() bytes waiting:",nb_available(s.buffer),", isopen:", s.is_open)
 
 function wait_readbyte(s::BufferStream, c::UInt8)
-    while isopen(s) && search(s.buffer,c) <= 0
+    while isopen(s) && findfirst(equalto(c), x.buffer) <= 0
         wait(s.r_c)
     end
 end