add contents

Author: bicycle1885

REQUIRE

@@ -1 +1 @@
-julia 0.5
+julia 0.6.0-rc1

src/TranscodingStreams.jl

@@ -1,5 +1,11 @@
 module TranscodingStreams
 
-# package code goes here
+export TranscodingStream
+
+include("codec.jl")
+include("state.jl")
+include("stream.jl")
+include("io.jl")
+include("identity.jl")
 
 end # module

src/codec.jl

@@ -0,0 +1,121 @@
+# Codec Interfaces
+# ================
+
+abstract type Codec end
+
+abstract type Mode end
+struct ReadMode  <: Mode end
+struct WriteMode <: Mode end
+
+primitive type ProcCode 8 end
+const PROC_INIT   = reinterpret(ProcCode, 0x00)
+const PROC_OK     = reinterpret(ProcCode, 0x01)
+const PROC_FINISH = reinterpret(ProcCode, 0x02)
+
+
+# Start
+# -----
+
+"""
+    start(::Type{ReadMode}, 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)
+    return nothing
+end
+
+"""
+    start(::Type{WriteMode}, 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)
+    return nothing
+end
+
+
+# Process
+# -------
+
+"""
+    process(::Type{ReadMode}, codec::Codec, source::IO, output::Ptr{UInt8}, nbytes::Int)::Tuple{Int,ProcCode}
+
+Transcode data using `codec` with read mode.
+
+      <>    >-----(process)----->  [........]
+    source          codec            output
+
+This method reads some data from `source` and write the transcoded data to
+`output` at most `nbytes`, and then returns the number of written bytes and an
+appropriate return code.  It will be called repeatedly to incrementally
+transcode input data from `source`. It can assume `output` points to a valid
+memory position and `nbytes` are positive.  The intermediate result of
+transcoding is indicated by the return value of it.  If processing works
+properly and there are still data to write, it must return the number of written
+bytes and `PROC_OK`.  If processing finishes and there are no remaining data to
+write, it must return the number of written bytes and `PROC_FINISH`. Therefore,
+after finishing reading data from `source` and all (possibly buffered) data are
+written to `output`, it is expected to return `(0, PROC_FINISH)` forever.
+
+This method may throw an exception when transcoding fails. For example, when
+`codec` is a decompression algorithm, it may throw an exception if it reads
+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)
+    error("codec $(codec) does not implement read mode")
+end
+
+"""
+    process(::Type{WriteMode}, codec::Codec, sink::IO, input::Ptr{UInt8}, nbytes::Int)::Tuple{Int,ProcCode}
+
+Transcode data using `codec` with write mode.
+
+      <>    <-----(transcode)-----<  [.......]
+     sink            codec             input
+
+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)
+    error("codec $(codec) does not implement write mode")
+end
+
+
+# Finish
+# ------
+
+"""
+    finish(::Type{ReadMode}, 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)
+    return nothing
+end
+
+"""
+    finish(::Type{WriteMode}, 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)
+    return nothing
+end

src/identity.jl

@@ -0,0 +1,18 @@
+# Identity Codec
+# ==============
+
+struct Identity <: Codec end
+
+function process(::Type{ReadMode}, ::Identity, stream::IO, data::Ptr{UInt8}, nbytes::Int)::Tuple{Int,ProcCode}
+    n = unsafe_read(stream, data, nbytes)
+    if eof(stream)
+        return n, PROC_FINISH
+    else
+        return n, PROC_OK
+    end
+end
+
+function process(::Type{WriteMode}, ::Identity, stream::IO, data::Ptr{UInt8}, nbytes::Int)::Tuple{Int,ProcCode}
+    n = unsafe_write(stream, data, nbytes)
+    return Int(n), PROC_OK
+end

src/io.jl

@@ -0,0 +1,16 @@
+function unsafe_read(stream::IO, ptr::Ptr{UInt8}, nbytes::Int)::Int
+    nread = 0
+    navail = nb_available(stream)
+    if navail == 0 && nbytes > 0 && !eof(stream)
+        b = read(stream, UInt8)
+        unsafe_store!(ptr, b)
+        ptr += 1
+        nbytes -= 1
+        nread += 1
+        navail = nb_available(stream)
+    end
+    n = min(navail, nbytes)
+    Base.unsafe_read(stream, ptr, n)
+    nread += n
+    return nread
+end

src/state.jl

@@ -0,0 +1,65 @@
+# Transcoding State
+# =================
+
+mutable struct State
+    # current mode (:init, :read, :write, or :closed)
+    mode::Symbol
+
+    # buffered data
+    data::Vector{UInt8}
+
+    # the starting position of the buffered data
+    position::Int
+
+    # the ending position + 1 of the buffered data
+    fposition::Int
+
+    # the last return code of `process`
+    proc::ProcCode
+
+    function State(size::Integer)
+        @assert size > 0
+        return new(:init, Vector{UInt8}(size), 1, 1, PROC_INIT)
+    end
+end
+
+function bufferptr(state::State)
+    return pointer(state.data, state.position)
+end
+
+function buffersize(state::State)
+    return state.fposition - state.position
+end
+
+function isemptybuf(state::State)
+    return buffersize(state) == 0
+end
+
+function marginptr(state::State)
+    return pointer(state.data, state.fposition)
+end
+
+function marginsize(state::State)
+    return endof(state.data) - state.fposition + 1
+end
+
+function isfullbuf(state::State)
+    return marginsize(state) == 0
+end
+
+function makemargin!(state::State, minsize::Int)::Int
+    if buffersize(state) == 0
+        state.position = state.fposition = 1
+    end
+    if marginsize(state) < minsize && state.position > 0
+        bufsize = buffersize(state)
+        copy!(state.data, 1, state.data, state.position, bufsize)
+        state.position = 1
+        state.fposition = 1 + bufsize
+    end
+    if marginsize(state) < minsize
+        resize!(state.data, state.fposition + minsize - 1)
+    end
+    @assert marginsize(state) ≥ minsize
+    return marginsize(state)
+end