rename state to mode (#19)

Author: bicycle1885

docs/src/index.md

@@ -165,7 +165,7 @@ Error handling
 You may encounter an error while processing data with this package. For example,
 your compressed data may be corrupted or truncated and the decompression codec
 cannot handle it properly. In this case, the codec informs the stream of the
-error and the stream goes to an unrecoverable state. In this state, the only
+error and the stream goes to an unrecoverable mode. In this mode, the only
 possible operations are `isopen` and `close`. Other operations, such as `read`
 or `write`, will result in an argument error exception. Resources allocated in
 the codec will be released by the stream and hence you must not call the

src/codec.jl

@@ -28,8 +28,8 @@ and `startproc` have a default implementation.
 Your codec type is denoted by `C` and its object by `codec`.
 
 Errors that occur in these methods are supposed to be unrecoverable and the
-stream will go to the panic state. Only `Base.isopen` and `Base.close` are
-available in that state.
+stream will go to the panic mode. Only `Base.isopen` and `Base.close` are
+available in that mode.
 
 ### `expectedsize`
 
@@ -59,20 +59,20 @@ you need to release the memory before throwing an exception.
 
 The `finalize(codec::C)::Void` method takes `codec` and returns `nothing`.  This
 is called once and only only once just before the transcoding stream goes to the
-close state (i.e. when `Base.close` is called) or just after `startproc` or
+close mode (i.e. when `Base.close` is called) or just after `startproc` or
 `process` throws an exception. Other errors that happen inside the stream (e.g.
 `EOFError`) will not call this method. Therefore, you may finalize `codec` (e.g.
 freeing memory) with this method. If finalization fails for some reason, it may
 throw an exception. You should release the allocated memory in codec before
 returning or throwing an exception in `finalize` because otherwise nobody cannot
 release the memory. Even when an exception is thrown while finalizing a stream,
-the stream will become the close state for safety.
+the stream will become the close mode for safety.
 
 ### `startproc`
 
-The `startproc(codec::C, state::Symbol, error::Error)::Symbol` method takes
-`codec`, `state` and `error`, and returns a status code. This is called just
-before the stream starts reading or writing data. `state` is either `:read` or
+The `startproc(codec::C, mode::Symbol, error::Error)::Symbol` method takes
+`codec`, `mode` and `error`, and returns a status code. This is called just
+before the stream starts reading or writing data. `mode` is either `:read` or
 `:write` and then the stream starts reading or writing, respectively.  The
 return code must be `:ok` if `codec` is ready to read or write data.  Otherwise,
 it must be `:error` and the `error` argument must be set to an exception object.
@@ -146,13 +146,13 @@ function finalize(codec::Codec)::Void
 end
 
 """
-    startproc(codec::Codec, state::Symbol, error::Error)::Symbol
+    startproc(codec::Codec, mode::Symbol, error::Error)::Symbol
 
-Start data processing with `codec` of `state`.
+Start data processing with `codec` of `mode`.
 
 The default method does nothing and returns `:ok`.
 """
-function startproc(codec::Codec, state::Symbol, error::Error)::Symbol
+function startproc(codec::Codec, mode::Symbol, error::Error)::Symbol
     return :ok
 end
 

src/noop.jl

@@ -39,7 +39,7 @@ function TranscodingStream(codec::Noop, stream::IO; bufsize::Integer=DEFAULT_BUF
 end
 
 function Base.unsafe_read(stream::NoopStream, output::Ptr{UInt8}, nbytes::UInt)
-    changestate!(stream, :read)
+    changemode!(stream, :read)
     buffer = stream.state.buffer1
     p = output
     p_end = output + nbytes
@@ -62,7 +62,7 @@ function Base.unsafe_read(stream::NoopStream, output::Ptr{UInt8}, nbytes::UInt)
 end
 
 function Base.unsafe_write(stream::NoopStream, input::Ptr{UInt8}, nbytes::UInt)
-    changestate!(stream, :write)
+    changemode!(stream, :write)
     buffer = stream.state.buffer1
     if marginsize(buffer) ≥ nbytes
         unsafe_copy!(marginptr(buffer), input, nbytes)
@@ -89,7 +89,7 @@ end
 # buffer for efficiency.
 
 function fillbuffer(stream::NoopStream)
-    changestate!(stream, :read)
+    changemode!(stream, :read)
     buffer = stream.state.buffer1
     @assert buffer === stream.state.buffer2
     nfilled::Int = 0
@@ -103,7 +103,7 @@ function fillbuffer(stream::NoopStream)
 end
 
 function flushbuffer(stream::NoopStream)
-    changestate!(stream, :write)
+    changemode!(stream, :write)
     buffer = stream.state.buffer1
     @assert buffer === stream.state.buffer2
     nflushed::Int = 0
@@ -117,7 +117,7 @@ function flushbuffer(stream::NoopStream)
 end
 
 function flushbufferall(stream::NoopStream)
-    @assert stream.state.state == :write
+    @assert stream.state.mode == :write
     buffer = stream.state.buffer1
     bufsize = buffersize(buffer)
     while buffersize(buffer) > 0

src/state.jl

@@ -4,18 +4,18 @@
 """
 Stream state.
 
-A state will be one of the following states:
+A state will be one of the following modes:
 
-- `:idle` : initial and intermediate state, no buffered data.
+- `:idle` : initial and intermediate mode, no buffered data.
 - `:read` : ready to read data, data may be buffered.
 - `:write`: ready to write data, data may be buffered.
 - `:close`: closed, no buffered data.
 - `:panic`: an exception has been thrown in codec, data may be buffered but we
             cannot do anything.
 """
 mutable struct State
-    # current stream state
-    state::Symbol
+    # current stream mode
+    mode::Symbol
 
     # return code of the last method call (:ok or :end)
     code::Symbol