rename ReadMode to Read and WriteMode to Write

Author: bicycle1885

src/codec.jl

@@ -4,8 +4,8 @@
 abstract type Codec end
 
 abstract type Mode end
-struct ReadMode  <: Mode end
-struct WriteMode <: Mode end
+struct Read  <: Mode end
+struct Write <: Mode end
 
 primitive type ProcCode 8 end
 const PROC_INIT   = reinterpret(ProcCode, 0x00)
@@ -17,28 +17,28 @@ const PROC_FINISH = reinterpret(ProcCode, 0x02)
 # -----
 
 """
-    start(::Type{ReadMode}, codec::Codec, source::IO)::Void
+    start(::Type{Read}, codec::Codec, source::IO)::Void
 
 Start transcoding using `codec` with read mode.
 
 This method will be called only once before calling `process` first time.
 
 Implementing this method is optional; there is a default method that does nothing.
 """
-function start(::Type{ReadMode}, ::Codec, ::IO)
+function start(::Type{Read}, ::Codec, ::IO)
     return nothing
 end
 
 """
-    start(::Type{WriteMode}, codec::Codec, sink::IO)::Void
+    start(::Type{Write}, codec::Codec, sink::IO)::Void
 
 Start transcoding using `codec` with write mode.
 
 This method will be called only once before calling `process` first time.
 
 Implementing this method is optional; there is a default method that does nothing.
 """
-function start(::Type{WriteMode}, ::Codec, ::IO)
+function start(::Type{Write}, ::Codec, ::IO)
     return nothing
 end
 
@@ -47,7 +47,7 @@ end
 # -------
 
 """
-    process(::Type{ReadMode}, codec::Codec, source::IO, output::Ptr{UInt8}, nbytes::Int)::Tuple{Int,ProcCode}
+    process(::Type{Read}, codec::Codec, source::IO, output::Ptr{UInt8}, nbytes::Int)::Tuple{Int,ProcCode}
 
 Transcode data using `codec` with read mode.
 
@@ -72,12 +72,12 @@ malfomed data from `source`.  However, this method must not throw `EOFError`
 when reading data from `source`.  Also note that it is responsible for this
 method to release resources allocated by `codec` when an exception happens.
 """
-function process(::Type{ReadMode}, codec::Codec, stream::IO, data::Ptr{UInt8}, nbytes::Int)
+function process(::Type{Read}, codec::Codec, stream::IO, data::Ptr{UInt8}, nbytes::Int)
     error("codec $(codec) does not implement read mode")
 end
 
 """
-    process(::Type{WriteMode}, codec::Codec, sink::IO, input::Ptr{UInt8}, nbytes::Int)::Tuple{Int,ProcCode}
+    process(::Type{Write}, codec::Codec, sink::IO, input::Ptr{UInt8}, nbytes::Int)::Tuple{Int,ProcCode}
 
 Transcode data using `codec` with write mode.
 
@@ -86,7 +86,7 @@ Transcode data using `codec` with write mode.
 
 This method reads some data from `input` and write the transcoded bytes to `sink`.
 """
-function process(::Type{WriteMode}, codec::Codec, stream::IO, data::Ptr{UInt8}, nbytes::Int)
+function process(::Type{Write}, codec::Codec, stream::IO, data::Ptr{UInt8}, nbytes::Int)
     error("codec $(codec) does not implement write mode")
 end
 
@@ -95,27 +95,27 @@ end
 # ------
 
 """
-    finish(::Type{ReadMode}, codec::Codec, source::IO)::Void
+    finish(::Type{Read}, codec::Codec, source::IO)::Void
 
 Finish transcoding using `codec` with read mode.
 
 This method will be called only once after calling `process` last time.
 
 Implementing this method is optional; there is a default method that does nothing.
 """
-function finish(::Type{ReadMode}, ::Codec, ::IO)
+function finish(::Type{Read}, ::Codec, ::IO)
     return nothing
 end
 
 """
-    finish(::Type{WriteMode}, codec::Codec, sink::IO)::Void
+    finish(::Type{Write}, codec::Codec, sink::IO)::Void
 
 Finish transcoding using `codec` with write mode.
 
 This method will be called only once after calling `process` last time.
 
 Implementing this method is optional; there is a default method that does nothing.
 """
-function finish(::Type{WriteMode}, ::Codec, ::IO)
+function finish(::Type{Write}, ::Codec, ::IO)
     return nothing
 end

src/identity.jl

@@ -3,7 +3,7 @@
 
 struct Identity <: Codec end
 
-function process(::Type{ReadMode}, ::Identity, stream::IO, data::Ptr{UInt8}, nbytes::Int)::Tuple{Int,ProcCode}
+function process(::Type{Read}, ::Identity, stream::IO, data::Ptr{UInt8}, nbytes::Int)::Tuple{Int,ProcCode}
     n = unsafe_read(stream, data, nbytes)
     if eof(stream)
         return n, PROC_FINISH
@@ -12,7 +12,7 @@ function process(::Type{ReadMode}, ::Identity, stream::IO, data::Ptr{UInt8}, nby
     end
 end
 
-function process(::Type{WriteMode}, ::Identity, stream::IO, data::Ptr{UInt8}, nbytes::Int)::Tuple{Int,ProcCode}
+function process(::Type{Write}, ::Identity, stream::IO, data::Ptr{UInt8}, nbytes::Int)::Tuple{Int,ProcCode}
     n = unsafe_write(stream, data, nbytes)
     return Int(n), PROC_OK
 end

src/stream.jl

@@ -52,10 +52,10 @@ function Base.close(stream::TranscodingStream)
         # pass
     elseif state.mode == :read
         flushbuffer(stream)
-        finish(ReadMode, stream.codec, stream.stream)
+        finish(Read, stream.codec, stream.stream)
     elseif state.mode == :write
         flushbuffer(stream)
-        finish(WriteMode, stream.codec, stream.stream)
+        finish(Write, stream.codec, stream.stream)
     elseif state.mode == :closed
         # pass
     else
@@ -154,7 +154,7 @@ function fillbuffer(stream::TranscodingStream)::Int
     nfilled = 0
     makemargin!(state, 1)
     while !isfullbuf(state) && state.proc != PROC_FINISH
-        n, code = process(ReadMode, stream.codec, stream.stream, marginptr(state), marginsize(state))
+        n, code = process(Read, stream.codec, stream.stream, marginptr(state), marginsize(state))
         state.fposition += n
         state.proc = code
         nfilled += n
@@ -169,7 +169,7 @@ function flushbuffer(stream::TranscodingStream)::Int
     end
     nflushed = 0
     while !isemptybuf(state)
-        n, code = process(WriteMode, stream.codec, stream.stream, bufferptr(state), buffersize(state))
+        n, code = process(Write, stream.codec, stream.stream, bufferptr(state), buffersize(state))
         state.position += n
         state.proc = code
         nflushed += n
@@ -191,18 +191,18 @@ function prepare(stream::TranscodingStream, mode::Symbol)
     flushbuffer(stream)
     if state.mode == :init
     elseif state.mode == :read
-        finish(ReadMode, stream.codec, stream.stream)
+        finish(Read, stream.codec, stream.stream)
     elseif state.mode == :write
-        finish(WriteMode, stream.codec, stream.stream)
+        finish(Write, stream.codec, stream.stream)
     else
         assert(false)
     end
 
     # start
     if mode == :read
-        start(ReadMode, stream.codec, stream.stream)
+        start(Read, stream.codec, stream.stream)
     elseif mode == :write
-        start(WriteMode, stream.codec, stream.stream)
+        start(Write, stream.codec, stream.stream)
     else
         assert(false)
     end