Add split_each (#23)

Author: jakobnissen

Project.toml

@@ -1,6 +1,6 @@
 name = "MemoryViews"
 uuid = "a791c907-b98b-4e44-8f4d-e4c2362c6b2f"
-version = "0.3.2"
+version = "0.3.3"
 authors = ["Jakob Nybo Nissen <jakobnybonissen@gmail.com>"]
 
 [weakdeps]

src/MemoryViews.jl

@@ -1,9 +1,15 @@
 module MemoryViews
 
 export MemoryView,
-    ImmutableMemoryView, MutableMemoryView, MemoryKind, IsMemory, NotMemory, inner
+    ImmutableMemoryView,
+    MutableMemoryView,
+    MemoryKind,
+    IsMemory,
+    NotMemory,
+    inner,
+    split_each
 
-public Mutable, Immutable
+public Mutable, Immutable, DelimitedIterator
 
 """
     Unsafe
@@ -90,6 +96,8 @@ end
 const MutableMemoryView{T} = MemoryView{T, Mutable}
 const ImmutableMemoryView{T} = MemoryView{T, Immutable}
 
+_get_mutability(::MemoryView{T, M}) where {T, M} = M
+
 # Mutable mem views can turn into immutable ones, but not vice versa
 ImmutableMemoryView(x) = ImmutableMemoryView(MemoryView(x)::MemoryView)
 function ImmutableMemoryView(x::MutableMemoryView{T}) where {T}
@@ -180,6 +188,7 @@ MemoryKind(::Type{Union{}}) = NotMemory()
 include("construction.jl")
 include("basic.jl")
 include("experimental.jl")
+include("delimited.jl")
 include("base_arrays.jl")
 include("io.jl")
 

src/delimited.jl

@@ -0,0 +1,60 @@
+"""
+Iterator struct created by `split_each`.
+Type and parameters are public, but otherwise the interface is defined by `split_each`, 
+"""
+struct DelimitedIterator{T, M}
+    v::MemoryView{T, M}
+    d::T
+end
+
+Base.IteratorSize(::Type{<:DelimitedIterator}) = Base.SizeUnknown()
+Base.eltype(::Type{DelimitedIterator{T, M}}) where {T, M} = MemoryView{T, M}
+
+function Base.iterate(d::DelimitedIterator, state::Int = 1)
+    len = length(d.v)
+    if state > len
+        # Make sure that an empty view has no elements, but that a view ends
+        # on the delimiter has an empty element at the end
+        return if state > len + 1 || iszero(len)
+            nothing
+        else
+            v = @inbounds d.v[len:(len - 1)]
+            (v, state + 1)
+        end
+    end
+    next = findnext(isequal(d.d), d.v, state)
+    return if isnothing(next)
+        (@inbounds d.v[state:len], len + 2)
+    else
+        (@inbounds d.v[state:(next - 1)], next + 1)
+    end
+end
+
+"""
+    split_each(data, x::T)
+
+Return an iterator over memory-backed data `data` of eltype `T`.
+Returns `MemoryView`s of the same elements as `data`, separated by by `x`.
+Items are compared by `isequal`.
+
+An empty input `data` yields no elements. Empty elements are otherwise
+yielded.
+
+# Examples
+```jldoctest
+julia> split_each(b"abbc", UInt8('b')) |> collect |> print
+ImmutableMemoryView{UInt8}[[0x61], [], [0x63]]
+
+julia> split_each(b"babceb", UInt8('b')) |> collect |> print
+ImmutableMemoryView{UInt8}[[], [0x61], [0x63, 0x65], []]
+
+julia> split_each(UInt8[], UInt8('b')) |> collect |> print
+MutableMemoryView{UInt8}[]
+```
+"""
+function split_each(x, d::T) where {T}
+    v = MemoryView(x)::MemoryView
+    eltype(v) == T || error("MemoryView(x) must be of eltype T")
+    M = _get_mutability(v)
+    return DelimitedIterator{T, M}(v, d)
+end

test/runtests.jl

@@ -4,6 +4,8 @@ using MemoryViews
 using Aqua
 using StringViews: StringView
 
+using MemoryViews: DelimitedIterator, Mutable, Immutable
+
 MemoryViews.MemoryView(s::GenericString) = MemoryView(s.string)
 
 MUT_BACKINGS = Any[
@@ -568,6 +570,21 @@ end
     end
 end
 
+@testset "split_each" begin
+    it = split_each(b"abcdba", 0x00)
+    @test eltype(it) == ImmutableMemoryView{UInt8}
+    @test it isa DelimitedIterator{UInt8, Immutable}
+    it = split_each(["abc", "def", "ghi"], "")
+    @test eltype(it) == MutableMemoryView{String}
+    @test it isa DelimitedIterator{String, Mutable}
+
+    @test collect(split_each(b"", 0x00)) == ImmutableMemoryView{UInt8}[]
+    @test collect(split_each([1, 2, 3, 3, 4, 5, 2, 3], 3)) == [[1, 2], [], [4, 5, 2], []]
+    @test collect(split_each(String[], "")) == String[]
+    @test collect(split_each([1.0, 0.0, 2.0, -0.0, 5], -0.0)) == [[1.0, 0.0, 2.0], [5.0]]
+    @test collect(split_each([Dict()], Dict())) == [[], []]
+end
+
 @testset "Equality" begin
     v = rand(UInt, 10)
     m1 = MemoryView(v)