Add some fast methods for IO, and Base arrays (#22)

* Add some fast methods for IO, and Base arrays

* Accept ambiguities

Author: jakobnissen

docs/src/index.md

@@ -33,7 +33,8 @@ const ImmutableMemoryView{T} = MemoryView{T, Immutable}
 
 Immutable memory views are immutable, in that they do not support `setindex!` or other
 mutating methods. The existence of an `ImmutableMemoryView` does not protect its underlying
-data from being mutated through another variable.
+data from being mutated through another variable, or though explicitly unsafe functions,
+such as using raw pointers.
 
 ## Usage
 ### Constructing memory views

src/MemoryViews.jl

@@ -67,7 +67,7 @@ automatically work, even if `MemoryView(x)` returns a mutable view.
 
 It is not possible to mutate memory though an `ImmutableMemoryView`, but the existence
 of the view does not protect the same memory from being mutated though another
-variable.
+variable, or through explicitly unsafe functions.
 
 The precise memory layout of the data in a `MemoryView` follows that of `Memory`.
 This includes the fact that some elements in the array, such as  `String`s,
@@ -130,7 +130,8 @@ else `NotMemory()`. The default implementation `MemoryKind(::Type)` returns `Not
 If `MemoryKind(T) isa IsMemory{M}`, the following must hold:
 1. `M` is a concrete subtype of `MemoryView`. To obtain `M` from an `m::IsMemory{M}`,
     use `inner(m)`.
-2. `MemoryView(T)` is a valid instance of `M`.
+2. `MemoryView(::T)` is a valid instance of `M` (except in cases where there can be invalid
+   instances of `T` that instead errors, e.g. uninitialized instances).
 3. `MemoryView(x) == x` for all instances `x::T`
 
 Some objects can be turned into `MemoryView` without being `IsMemory`.
@@ -179,5 +180,7 @@ MemoryKind(::Type{Union{}}) = NotMemory()
 include("construction.jl")
 include("basic.jl")
 include("experimental.jl")
+include("base_arrays.jl")
+include("io.jl")
 
 end # module

src/base_arrays.jl

@@ -0,0 +1,35 @@
+Base.Vector(x::MemoryView{T}) where {T} = Vector{T}(x)
+
+function Base.Vector{T}(mem::MemoryView{T}) where {T}
+    return copyto!(Vector{T}(undef, length(mem)), mem)
+end
+
+Base.Memory(x::MemoryView{T}) where {T} = Memory{T}(x)
+
+function Base.Memory{T}(x::MemoryView{T}) where {T}
+    return if isempty(x)
+        Memory{T}()
+    else
+        @inbounds copy!(Memory{T}(undef, length(x)), x)
+    end
+end
+
+
+function Base.copyto!(A::Union{Memory{T}, Array{T}}, mem::MemoryView{T}) where {T}
+    copyto!(MemoryView(A), mem)
+    return A
+end
+
+function Base.copy!(A::Union{Memory{T}, Array{T}}, mem::MemoryView{T}) where {T}
+    length(A) == length(mem) || resize!(A, length(mem))
+    copy!(MemoryView(A), mem)
+    return A
+end
+
+function Base.append!(v::Vector{T}, mem::MemoryView{T}) where {T}
+    old_len = length(v)
+    resize!(v, length(v) + length(mem))
+    dst = @inbounds MemoryView(v)[(old_len + 1):end]
+    @inbounds copy!(dst, mem)
+    return v
+end

src/basic.jl

@@ -146,7 +146,7 @@ end
 
 function Base.unsafe_copyto!(dst::MutableMemoryView{T}, src::MemoryView{T}) where {T}
     iszero(length(src)) && return dst
-    @inbounds unsafe_copyto!(dst.ref, src.ref, length(src))
+    @inbounds unsafe_copyto!(dst.ref, src.ref, length(src) % UInt)
     return dst
 end
 

src/io.jl

@@ -0,0 +1,18 @@
+# Note: This implementation intentionally throws ambiguity errors,
+# because the fallback definition for ::IO ::AbstractArray{UInt8}
+# is a performance disaster.
+# This encourages implementors of IOs to implement a method for this.
+function Base.readbytes!(io::IO, v::MutableMemoryView{UInt8}, nb::Integer = length(v))
+    nb = Int(nb)::Int
+    # A view of all the bytes not yet read
+    remaining = @inbounds v[1:min(nb, length(v))]
+    while !isempty(remaining)
+        eof(io) && break
+        # Read at least 1 byte if not EOF, thereby filling the internal buffer.
+        # and read no more than the remaining number of bytes
+        ba = clamp(bytesavailable(io), 1, length(remaining))
+        GC.@preserve v unsafe_read(io, Base.unsafe_convert(Ptr{UInt8}, remaining), ba % UInt)
+        remaining = remaining[(ba + 1):end]
+    end
+    return length(v) - length(remaining)
+end

test/runtests.jl

@@ -593,6 +593,89 @@ end
     @test m2 == m1
 end
 
+@testset "IO" begin
+    # Empty IO
+    buf = IOBuffer()
+    v = fill(0xaa, 25)
+    @test iszero(readbytes!(buf, MemoryView(v)))
+    @test all(==(0xaa), v)
+
+    # Buffer running EOF
+    data = b"Hello, world!"
+    buf = IOBuffer(data)
+    @test readbytes!(buf, MemoryView(v)) == length(data)
+    @test v == vcat(data, fill(0xaa, 25 - length(data)))
+
+    # With nb being lower
+    data = b"Hello, world!"
+    buf = IOBuffer(data)
+    v = fill(0xaa, 25)
+    readbytes!(buf, MemoryView(v), 7)
+    @test v[1:8] == b"Hello, \xaa"
+
+    # With nb being higher than the vector length
+    data = b"Hello, world!"
+    buf = IOBuffer(data)
+    v = fill(0xaa, 8)
+    readbytes!(buf, MemoryView(v), 10)
+    @test v == b"Hello, w"
+end
+
+@testset "Base arrays" begin
+    @testset "Memory construction" begin
+        v = ImmutableMemoryView([5, 2, 1])
+        @test Memory(v) isa Memory{Int}
+        @test Memory(v) == v
+
+        @test Memory{Int}(v) isa Memory{Int}
+        @test Memory{Int}(v) == v
+        @test Memory{Int}(v) !== parent(v)
+
+        @test isempty(Memory{Int}(v[1:0]))
+    end
+
+    @testset "Vector construction" begin
+        v = ImmutableMemoryView(["abc", "def", "hi"])
+        @test Vector(v) isa Vector{String}
+        @test Vector(v) == v
+
+        @test Vector{String}(v) isa Vector{String}
+        @test Vector{String}(v) == v
+
+        @test isempty(Vector{String}(v[1:0]))
+    end
+
+    @testset "Vector/Memory copying" begin
+        v = [5, 1, 3, 6, 7, 2]
+        m = ImmutableMemoryView([6, 2, 1])
+        @test copyto!(v, m) === v
+        @test v == [6, 2, 1, 6, 7, 2]
+
+        @test copy!(v, m) === v
+        @test v == m
+
+        @test_throws MethodError copy!(Memory{Int}(undef, 2), m)
+
+        v = Memory{Int}(undef, 3)
+        @test copy!(v, m) === v
+        @test v == m
+    end
+
+    @testset "Vector append!" begin
+        m = ImmutableMemoryView([7, 2, 1])
+        v = Int[]
+        @test append!(v, m) === v
+        @test v == m
+
+        m = m[1:0]
+        append!(v, m)
+        @test v == [7, 2, 1]
+
+        @test append!(v, MemoryView([2, 1])) === v
+        @test v == [7, 2, 1, 2, 1]
+    end
+end
+
 @testset "MemoryKind" begin
     @test MemoryKind(Vector{Int16}) == IsMemory(MutableMemoryView{Int16})
     @test MemoryKind(typeof(codeunits(view("abc", 2:3)))) ==
@@ -650,4 +733,4 @@ end
     end
 end
 
-Aqua.test_all(MemoryViews)
+Aqua.test_all(MemoryViews; ambiguities = false)