Merge pull request #3633 from simonbyrne/byteorder

RFC: ByteOrder types for io

base/complex.jl

@@ -75,16 +75,6 @@ end
 show(io::IO, z::Complex) = complex_show(io, z, false)
 showcompact(io::IO, z::Complex) = complex_show(io, z, true)
 
-function read{T<:Real}(s::IO, ::Type{Complex{T}})
-    r = read(s,T)
-    i = read(s,T)
-    Complex{T}(r,i)
-end
-function write(s::IO, z::Complex)
-    write(s,real(z))
-    write(s,imag(z))
-end
-
 
 ## singleton type for imaginary unit constant ##
 

base/exports.jl

@@ -1055,6 +1055,10 @@ export
     hton,
     ltoh,
     ntoh,
+    HostByteOrder,
+    ReverseByteOrder,
+    LittleByteOrder,
+    NetworkByteOrder,
     mmap,
     mmap_array,
     mmap_bitarray,
@@ -1263,4 +1267,4 @@ export
     @sprintf,
     @deprecate,
     @boundscheck,
-    @inbounds
+    @inbounds

base/io.jl

@@ -6,14 +6,26 @@
 
 ## byte-order mark, ntoh & hton ##
 
+abstract ByteOrder
+
+type HostByteOrder <: ByteOrder 
+end
+
+type ReverseByteOrder <: ByteOrder 
+end
+
 const ENDIAN_BOM = reinterpret(Uint32,uint8([1:4]))[1]
 
 if ENDIAN_BOM == 0x01020304
+    typealias NetworkByteOrder HostByteOrder 
+    typealias LittleByteOrder ReverseByteOrder 
     ntoh(x) = identity(x)
     hton(x) = identity(x)
     ltoh(x) = bswap(x)
     htol(x) = bswap(x)
 elseif ENDIAN_BOM == 0x04030201
+    typealias NetworkByteOrder ReverseByteOrder
+    typealias LittleByteOrder HostByteOrder
     ntoh(x) = bswap(x)
     hton(x) = bswap(x)
     ltoh(x) = identity(x)
@@ -30,28 +42,31 @@ write(s::IO, x::Uint8) = error(typeof(s)," does not support byte I/O")
 write(io::IO, x) = throw(MethodError(write, (io, x)))
 write(io::IO, xs...) = for x in xs write(io, x) end
 
-if ENDIAN_BOM == 0x01020304
-    function write(s::IO, x::Integer)
-        sz = sizeof(x)
-        for n = sz:-1:1
-            write(s, uint8((x>>>((n-1)<<3))))
-        end
-        sz
+function write(s::IO, x::Integer,::Type{NetworkByteOrder})
+    sz = sizeof(x)
+    for n = sz:-1:1
+        write(s, uint8((x>>>((n-1)<<3))))
     end
-else
-    function write(s::IO, x::Integer)
-        sz = sizeof(x)
-        for n = 1:sz
-            write(s, uint8((x>>>((n-1)<<3))))
-        end
-        sz
+    sz
+end
+function write(s::IO, x::Integer,::Type{LittleByteOrder})
+    sz = sizeof(x)
+    for n = 1:sz
+        write(s, uint8((x>>>((n-1)<<3))))
     end
+    sz
 end
 
-write(s::IO, x::Bool)    = write(s, uint8(x))
-#write(s::IO, x::Float16) = write(s, reinterpret(Int16,x))
-write(s::IO, x::Float32) = write(s, reinterpret(Int32,x))
-write(s::IO, x::Float64) = write(s, reinterpret(Int64,x))
+write(s::IO, x::Bool) = write(s, uint8(x))
+#write{O<:ByteOrder}(s::IO, x::Float16, ::Type{O}) = write(s, reinterpret(Int16,x), O)
+write{O<:ByteOrder}(s::IO, x::Float32, ::Type{O}) = write(s, reinterpret(Int32,x), O)
+write{O<:ByteOrder}(s::IO, x::Float64, ::Type{O}) = write(s, reinterpret(Int64,x), O)
+function write{O<:ByteOrder}(s::IO, z::Complex, ::Type{O})
+    write(s,real(z),O)
+    write(s,imag(z),O)
+end
+
+write(s::IO, x::Number) = write(s, x, HostByteOrder)
 
 function write(s::IO, a::AbstractArray)
     nb = 0
@@ -60,6 +75,14 @@ function write(s::IO, a::AbstractArray)
     end
     nb
 end
+function write{O<:ByteOrder}(s::IO, a::AbstractArray, ::Type{O})
+    nb = 0
+    for i = 1:length(a)
+        nb += write(s, a[i],O)
+    end
+    nb
+end
+
 
 function write(s::IO, c::Char)
     if c < 0x80
@@ -88,32 +111,61 @@ end
 # all subtypes should implement this
 read(s::IO, x::Type{Uint8}) = error(typeof(s)," does not support byte I/O")
 
-function read{T <: Integer}(s::IO, ::Type{T})
+function read{T <: Integer}(s::IO, ::Type{T},::Type{LittleByteOrder})
     x = zero(T)
     for n = 1:sizeof(x)
         x |= (convert(T,read(s,Uint8))<<((n-1)<<3))
     end
     return x
 end
 
+function read{T <: Integer}(s::IO, ::Type{T},::Type{NetworkByteOrder})
+    x = zero(T)
+    for n = sizeof(x):-1:1
+        x |= (convert(T,read(s,Uint8))<<((n-1)<<3))
+    end
+    return x
+end
+
 read(s::IO, ::Type{Bool})    = (read(s,Uint8)!=0)
-read(s::IO, ::Type{Float32}) = box(Float32,unbox(Int32,read(s,Int32)))
-read(s::IO, ::Type{Float64}) = box(Float64,unbox(Int64,read(s,Int64)))
+read{O<:ByteOrder}(s::IO, ::Type{Float32}, ::Type{O}) = reinterpret(Float32,read(s,Int32,O))
+read{O<:ByteOrder}(s::IO, ::Type{Float64}, ::Type{O}) = reinterpret(Float64,read(s,Int64,O))
+function read{T<:Real,O<:ByteOrder}(s::IO, ::Type{Complex{T}}, ::Type{O})
+    r = read(s,T,O)
+    i = read(s,T,O)
+    Complex{T}(r,i)
+end
+
+read{N<:Number}(s::IO, ::Type{N}) = read(s,N,HostByteOrder)
+
 
 read{T}(s::IO, t::Type{T}, d1::Int, dims::Int...) =
     read(s, t, tuple(d1,dims...))
 read{T}(s::IO, t::Type{T}, d1::Integer, dims::Integer...) =
     read(s, t, map(int,tuple(d1,dims...)))
-
 read{T}(s::IO, ::Type{T}, dims::Dims) = read(s, Array(T, dims))
-
 function read{T}(s::IO, a::Array{T})
     for i = 1:length(a)
         a[i] = read(s, T)
     end
     return a
 end
 
+read{T,O<:ByteOrder}(s::IO, t::Type{T}, ::Type{O}, d1::Int, dims::Int...) =
+    read(s, t, O, tuple(d1,dims...))
+read{T,O<:ByteOrder}(s::IO, t::Type{T}, ::Type{O}, d1::Integer, dims::Integer...) =
+    read(s, t, O, map(int,tuple(d1,dims...)))
+read{T,O<:ByteOrder}(s::IO, ::Type{T}, ::Type{O}, dims::Dims) = read(s, Array(T, dims), O)
+
+function read{T,O<:ByteOrder}(s::IO, a::Array{T}, ::Type{O})
+    for i = 1:length(a)
+        a[i] = read(s, T, O)
+    end
+    return a
+end
+
+
+
 function read(s::IO, ::Type{Char})
     ch = read(s, Uint8)
     if ch < 0x80
@@ -495,4 +547,6 @@ end
 # BitArray I/O
 
 write(s::IO, B::BitArray) = write(s, B.chunks)
+write{O<:ByteOrder}(s::IO, B::BitArray, ::Type{O}) = write(s, B.chunks, O)
 read(s::IO, B::BitArray) = read(s, B.chunks)
+read{O<:ByteOrder}(s::IO, B::BitArray, ::Type{O}) = read(s, B.chunks, O)