Bump version (#10)

To reflect the breaking change in 83b4218

CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+This project follows semantic versioning (semver) 2.0.
+Any new features, or breaking changes, will be written in this file.
+Bugfixes, internal refactors, documentation improvements and style changes will
+not be mentioned here, because they do not impact how the package is to be used.
+
+## 0.3.0
+### Breaking changes
+* Change the bounds checking behaviour of the find* functions to match those of
+  `Vector`. In particular, previously, `findnext(pred, mem, -5)` would be
+  equivalent to searching from index 1, and similarly, `findprev(pred, mem,
+  lastindex(mem) + 10)` would be equialent to searching from `lastindex(mem)`.
+  Now, searching from an index before the first valid index throws a `BoundsError`.
+  Findfirst searching from `i > lastindex(mem)`, and findlast searching from
+  `i < 1` will still simply return `nothing`, just like searching vectors.
+
+### Other changes
+* Add optimised versions of `findprev` and `findlast`, searching bytes
+* Add optimised version of `find*(iszero, bytes)` methods
+* Add optimised generic `find*` methods
+* Add functions `split_first`, `split_last`, `split_at` and `split_unaligned`
+* Add a more correct implementation of `Base.mightalias` for memory views and
+  some types of arrays
+
+
+

Project.toml

@@ -1,6 +1,6 @@
 name = "MemoryViews"
 uuid = "a791c907-b98b-4e44-8f4d-e4c2362c6b2f"
-version = "0.2.2"
+version = "0.3.0"
 authors = ["Jakob Nybo Nissen <[email protected]>"]
 
 [weakdeps]

src/basic.jl

@@ -60,7 +60,10 @@ Base.elsize(::Type{<:MemoryView{T}}) where {T} = Base.elsize(Memory{T})
 Base.sizeof(x::MemoryView) = Base.elsize(typeof(x)) * length(x)
 Base.strides(::MemoryView) = (1,)
 
-function Base.mightalias(a::MemoryView, b::MemoryView)
+# For two distinct element types, they can't alias
+Base.mightalias(::MemoryView, ::MemoryView) = false
+
+function Base.mightalias(a::MemoryView{T}, b::MemoryView{T}) where {T}
     (isempty(a) | isempty(b)) && return false
     parent(a) === parent(b) || return false
     (p1, p2) = (pointer(a), pointer(b))
@@ -72,6 +75,19 @@ function Base.mightalias(a::MemoryView, b::MemoryView)
     end
 end
 
+# We don't include strings here because this union is used for mightalias
+# checks, which are done implicitly, and we don't want to construct memory
+# views from strings implicitly, since that currently allocates.
+const KNOWN_MEM_BACKED = Union{Array, Memory, ContiguousSubArray}
+
+function Base.mightalias(a::MemoryView, b::KNOWN_MEM_BACKED)
+    Base.mightalias(a, ImmutableMemoryView(b))
+end
+
+function Base.mightalias(a::KNOWN_MEM_BACKED, b::MemoryView)
+    Base.mightalias(ImmutableMemoryView(a), b)
+end
+
 function Base.getindex(v::MemoryView, idx::AbstractUnitRange)
     # This branch is necessary, because the memoryref can't point out of bounds.
     # So if the user gives an empty slice that is out of bounds, the boundscheck

test/runtests.jl

@@ -96,6 +96,12 @@ end
     @test Base.mightalias(MemoryView(v), MemoryView(v2))
     @test Base.mightalias(MemoryView(v), MemoryView(view(v, 7:8)))
     @test !Base.mightalias(MemoryView(v1), MemoryView(view(v, 7:8)))
+
+    v1 = [1, 2, 3]
+    v2 = UInt[1, 2, 3]
+    @test !Base.mightalias(v1, v2)
+    @test Base.mightalias(MemoryView(v1)[2:2], v1)
+    @test Base.mightalias(view(v1, 2:3), MemoryView(v1))
 end
 
 # Span of views