Upgrade to support julia 0.6, 0.7, 1.0

Author: Chris Foster

REQUIRE

@@ -1,2 +1,2 @@
-julia 0.5
-Compat 0.19.0
+julia 0.6 2.0
+Compat 1.0.1

src/io.jl

@@ -46,7 +46,7 @@ ply_type_name(::Float64)  = "float64"
 
 const PlyNativeType = Union{UInt8,UInt16,UInt32,UInt64,Int8,Int16,Int32,Int64,Float32,Float64}
 
-ply_type_name{T<:PlyNativeType}(A::AbstractArray{T}) = ply_type_name(T)
+ply_type_name(A::AbstractArray{T}) where {T<:PlyNativeType} = ply_type_name(T)
 
 ply_type_name(A::AbstractArray) = !isempty(A) ? ply_type_name(A[1]) :
                                   error("Unknown ply element type name for empty array of type $(typeof(A))")
@@ -124,13 +124,13 @@ function write_header_field(stream::IO, prop::ArrayProperty)
     println(stream, "property $(ply_type_name(prop.data)) $(prop.name)")
 end
 
-function write_header_field{T,Names<:PropNameList}(stream::IO, prop::ArrayProperty{T,Names})
+function write_header_field(stream::IO, prop::ArrayProperty{T,Names}) where {T,Names<:PropNameList}
     for n in prop.name
         println(stream, "property $(ply_type_name(prop.data)) $(n)")
     end
 end
 
-function write_header_field{S}(stream::IO, prop::ListProperty{S})
+function write_header_field(stream::IO, prop::ListProperty{S}) where {S}
     println(stream, "property list $(ply_type_name(S)) $(ply_type_name(prop.data)) $(prop.name)")
 end
 
@@ -165,7 +165,7 @@ end
 #-------------------------------------------------------------------------------
 # ASCII IO for properties and elements
 
-function parse_ascii{T}(::Type{T}, io::IO)
+function parse_ascii(::Type{T}, io::IO) where {T}
     # FIXME: sadly unbuffered, will probably have terrible performance.
     buf = UInt8[]
     while !eof(io)
@@ -181,10 +181,10 @@ function parse_ascii{T}(::Type{T}, io::IO)
     parse(T, String(buf))
 end
 
-function read_ascii_value!{T}(stream::IO, prop::ArrayProperty{T}, index)
+function read_ascii_value!(stream::IO, prop::ArrayProperty{T}, index) where {T}
     prop.data[index] = parse_ascii(T, stream)
 end
-function read_ascii_value!{S,T}(stream::IO, prop::ListProperty{S,T}, index)
+function read_ascii_value!(stream::IO, prop::ListProperty{S,T}, index) where {S,T}
     N = parse_ascii(S, stream)
     prop.start_inds[index+1] = prop.start_inds[index] + N
     for i=1:N
@@ -198,20 +198,20 @@ end
 
 #--------------------------------------------------
 # property IO
-function read_binary_value!{T}(stream::IO, prop::ArrayProperty{T}, index)
+function read_binary_value!(stream::IO, prop::ArrayProperty{T}, index) where {T}
     prop.data[index] = read(stream, T)
 end
-function read_binary_value!{S,T}(stream::IO, prop::ListProperty{S,T}, index)
+function read_binary_value!(stream::IO, prop::ListProperty{S,T}, index) where {S,T}
     N = read(stream, S)
     prop.start_inds[index+1] = prop.start_inds[index] + N
-    inds = read(stream, T, Int(N))
+    inds = read!(stream, Vector{T}(undef, Int(N)))
     append!(prop.data, inds)
 end
 
 function write_binary_value(stream::IO, prop::ArrayProperty, index)
     write(stream, prop.data[index])
 end
-function write_binary_value{S}(stream::IO, prop::ListProperty{S}, index)
+function write_binary_value(stream::IO, prop::ListProperty{S}, index) where {S}
     len = prop.start_inds[index+1] - prop.start_inds[index]
     write(stream, convert(S, len))
     esize = sizeof(eltype(prop.data))
@@ -230,7 +230,7 @@ end
 function write_ascii_value(stream::IO, prop::ArrayProperty, index)
     print(stream, prop.data[index])
 end
-function write_ascii_value{T<:AbstractArray}(stream::IO, prop::ArrayProperty{T}, index)
+function write_ascii_value(stream::IO, prop::ArrayProperty{<:AbstractArray}, index)
     p = prop.data[index]
     for i = 1:length(p)
         if i != 1
@@ -290,7 +290,7 @@ end
 # for elements constructed of simple arrays with homogenous type -
 # serialization speed generally seems to be limited by the many individual
 # calls to write() with small buffers.
-function write_binary_values{T}(stream::IO, elen, props::ArrayProperty{T}...)
+function write_binary_values(stream::IO, elen, props::ArrayProperty{T}...) where {T}
     batchsize = 100
     numprops = length(props)
     buf = Matrix{T}(numprops, batchsize)

src/types.jl

@@ -18,22 +18,22 @@ const PropNameList = Union{AbstractVector,Tuple}
 A ply `property \$T \$name`, modelled as an abstract vector, with a name which
 can be retrieved using `plyname()`.
 """
-type ArrayProperty{T,Name} <: AbstractVector{T}
+mutable struct ArrayProperty{T,Name} <: AbstractVector{T}
     name::Name
     data::Vector{T}
 end
 
 #=
 # FIXME: Ambiguous constructor
-function ArrayProperty{T}(names::PropNameList, data::AbstractVector{T})
+function ArrayProperty(names::PropNameList, data::AbstractVector{T}) where {T}
     if length(names) != length(T)
         error("Number of property names in $names does not match length($T)")
     end
     ArrayProperty(names, data)
 end
 =#
 
-ArrayProperty{T}(name::AbstractString, ::Type{T}) = ArrayProperty(String(name), Vector{T}())
+ArrayProperty(name::AbstractString, ::Type{T}) where {T} = ArrayProperty(String(name), Vector{T}())
 
 Base.summary(prop::ArrayProperty) = "$(length(prop))-element $(typeof(prop)) \"$(plyname(prop))\""
 
@@ -59,13 +59,13 @@ plyname(prop::ArrayProperty) = prop.name
 A ply `property list \$S \$T \$name`, modelled as a abstract vector of vectors,
 with a name which can be retrieved using `plyname()`.
 """
-type ListProperty{S,T} <: AbstractVector{Vector{T}}
+mutable struct ListProperty{S,T} <: AbstractVector{Vector{T}}
     name::String
     start_inds::Vector{Int}
     data::Vector{T}
 end
 
-ListProperty{S,T}(name, ::Type{S}, ::Type{T}) = ListProperty{S,T}(String(name), ones(Int,1), Vector{T}())
+ListProperty(name, ::Type{S}, ::Type{T}) where {S,T} = ListProperty{S,T}(String(name), ones(Int,1), Vector{T}())
 
 function ListProperty(name::AbstractString, a::AbstractVector)
     # Construct list from an array of arrays
@@ -109,7 +109,7 @@ the array interface, or looked up by indexing with a string.
 The expected length `len` is used if it is set, otherwise the length shared by
 the property vectors is used.
 """
-type PlyElement
+mutable struct PlyElement
     name::String
     prior_len::Int  # Length as expected, or as read from file
     properties::Vector
@@ -154,10 +154,14 @@ function Base.getindex(element::PlyElement, prop_name)
 end
 
 # List methods
-Base.start(elem::PlyElement) = start(elem.properties)
-Base.next(elem::PlyElement, state) = next(elem.propertes, state)
-Base.done(elem::PlyElement, state) = done(elem.propertes, state)
-Base.push!(elem::PlyElement, prop) = (push!(elem.properties, prop); elem)
+if VERSION >= v"0.7"
+    Base.iterate(elem::PlyElement, s...) = iterate(elem.properties, s...)
+else
+    Base.start(elem::PlyElement) = start(elem.properties)
+    Base.next(elem::PlyElement, state) = next(elem.propertes, state)
+    Base.done(elem::PlyElement, state) = done(elem.propertes, state)
+    Base.push!(elem::PlyElement, prop) = (push!(elem.properties, prop); elem)
+end
 
 # Ply methods
 plyname(elem::PlyElement) = elem.name
@@ -169,7 +173,7 @@ plyname(elem::PlyElement) = elem.name
 
 A ply comment.
 """
-immutable PlyComment
+struct PlyComment
     comment::String
     location::Int # index of previous element
 end
@@ -188,7 +192,7 @@ contents of the header.  Ply elements and comments can be added using
 `push!()`, elements can be iterated over with the standard iterator
 interface, and looked up by indexing with a string.
 """
-type Ply
+mutable struct Ply
     elements::Vector{PlyElement}
     comments::Vector{PlyComment}
 end
@@ -218,7 +222,10 @@ function Base.getindex(ply::Ply, elem_name::AbstractString)
 end
 
 Base.length(ply::Ply) = length(ply.elements)
-Base.start(ply::Ply) = start(ply.elements)
-Base.next(ply::Ply, state) = next(ply.elements, state)
-Base.done(ply::Ply, state) = done(ply.elements, state)
-
+if VERSION >= v"0.7"
+    Compat.iterate(ply::Ply, s...) = iterate(ply.elements, s...)
+else
+    Base.start(ply::Ply) = start(ply.elements)
+    Base.next(ply::Ply, state) = next(ply.elements, state)
+    Base.done(ply::Ply, state) = done(ply.elements, state)
+end

test/REQUIRE

@@ -1 +1,2 @@
 StaticArrays
+Compat

test/runtests.jl

@@ -1,7 +1,7 @@
 using PlyIO
 using StaticArrays
-using Base.Test
 using Compat
+using Compat.Test
 
 @testset "PlyIO" begin