loggersoft.kotlin.streams.StreamAdapterInput.kt Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of binary-streams Show documentation
Implementation of I/O binary streams for Kotlin.
There is a newer version: 0.33
/*
 * Copyright (C) 2018 Alexander Kornilov ([email protected])
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package loggersoft.kotlin.streams

import java.lang.IllegalStateException
import java.math.BigInteger

/**
 * Provides [Stream] interface from [StreamInput].
 *
 * @author Alexander Kornilov ([email protected]).
 */
class StreamAdapterInput(private val input: StreamInput): AbstractStream() {

    /**
     * @see BasicStream.isSeekable
     */
    override val isSeekable: Boolean
        get() = false

    /**
     * @see BasicStream.isFixedSize
     */
    override val isFixedSize: Boolean
        get() = input.isFixedSize

    /**
     * @see BasicStream.isSupportLimit
     */
    override val isSupportLimit: Boolean
        get() = input.isSupportLimit

    override var defaultByteOrder: ByteOrder
        get() = input.defaultByteOrder
        set(_) = Unit

    override var defaultStringEncoding: StringEncoding
        get() = input.defaultStringEncoding
        set(_) = Unit

    override var limit: Long
        get() = input.limit
        set(_) = Unit

    override var position: Long
        get() = input.position
        set(_) = Unit

    override val isReadable: Boolean
        get() = true

    override val isWritable: Boolean
        get() = false

    /**
     * @see BasicStream.size
     */
    override val size: Long
        get() = input.size

    /**
     * @see BasicStream.bytesAvailable
     */
    override val bytesAvailable: Long
        get() = input.bytesAvailable

    /**
     * @see BasicStream.isEof
     */
    override val isEof: Boolean
        get() = input.isEof

    override val isNetwork: Boolean
        get() = input.isNetwork

    override var isClosed: Boolean
        get() = input.isClosed
        set(_) = Unit

    override var readBufferSize: Int
        get() = -1
        set(_) = Unit

    override var writeBufferSize: Int
        get() = -1
        set(_) = Unit

    override var readTimeout: Int
        get() = -1
        set(_) = Unit

    override var writeTimeout: Int
        get() = -1
        set(_) = Unit

    override val canFetchMore: StreamInput.FetchHint
        get() = input.canFetchMore

    override fun skip(bytes: Long): Long = input.skip(bytes)

    override fun canRead(bytes: Int): Boolean = input.canRead(bytes)

    override fun readBytes(buffer: ByteArray, size: Int, offset: Int): Int
            = input.readBytes(buffer, size, offset)

    override fun readByte(): Byte = input.readByte()

    override fun readByteUnsigned(): Int = input.readByteUnsigned()

    override fun readInt(bytes: Int, signed: Boolean, byteOrder: ByteOrder): Long
            = input.readInt(bytes, signed, byteOrder)

    override fun readLong(bytes: Int, signed: Boolean, byteOrder: ByteOrder): BigInteger
            = input.readLong(bytes, signed, byteOrder)

    override fun readShort(byteOrder: ByteOrder): Short = input.readShort(byteOrder)

    override fun readInt(byteOrder: ByteOrder): Int = input.readInt(byteOrder)

    override fun readLong(byteOrder: ByteOrder): Long = input.readLong(byteOrder)

    override fun readFloat(byteOrder: ByteOrder): Float = input.readFloat(byteOrder)

    override fun readDouble(byteOrder: ByteOrder): Double = input.readDouble(byteOrder)

    override fun readChar(encoding: StringEncoding, byteOrder: ByteOrder): Int
            = input.readChar(encoding, byteOrder)

    override fun readString(encoding: StringEncoding, length: Int, byteOrder: ByteOrder): String
            = input.readString(encoding, length, byteOrder)

    override fun readLine(encoding: StringEncoding, byteOrder: ByteOrder): String
            = input.readLine(encoding, byteOrder)

    override fun forLines(encoding: StringEncoding, byteOrder: ByteOrder, block: (lines: Sequence) -> Unit)
            = input.forLines(encoding, byteOrder, block)

    override fun useLines(encoding: StringEncoding, byteOrder: ByteOrder, block: (lines: Sequence) -> Unit)
            = input.useLines(encoding, byteOrder, block)

    /**
     * @see java.io.Flushable.flush
     */
    override fun flush() = Unit

    /**
     * @see java.io.Closeable.close
     */
    override fun close() = input.close()

    override fun canWrite(bytes: Int): Boolean = false

    override fun writeBytes(buffer: ByteArray, size: Int, offset: Int) = throw IllegalStateException()

    override fun writeByte(value: Byte) = throw IllegalStateException()

    override fun writeInt(value: Long, bytes: Int, byteOrder: ByteOrder) = throw IllegalStateException()

    override fun writeLong(value: BigInteger, bytes: Int, byteOrder: ByteOrder) = throw IllegalStateException()

    override fun writeShort(value: Short, byteOrder: ByteOrder) = throw IllegalStateException()

    override fun writeInt(value: Int, byteOrder: ByteOrder) = throw IllegalStateException()

    override fun writeLong(value: Long, byteOrder: ByteOrder) = throw IllegalStateException()

    override fun writeFloat(value: Float, byteOrder: ByteOrder) = throw IllegalStateException()

    override fun writeDouble(value: Double, byteOrder: ByteOrder) = throw IllegalStateException()

    override fun writeChar(value: Int, encoding: StringEncoding, byteOrder: ByteOrder) = throw IllegalStateException()

    override fun writeBom(encoding: StringEncoding, byteOrder: ByteOrder) = throw IllegalStateException()

    override fun writeString(value: String, encoding: StringEncoding, startIndex: Int, size: Int, byteOrder: ByteOrder, needTerminator: Boolean): Int
            = throw IllegalStateException()

    override fun writeLine(value: String, encoding: StringEncoding, byteOrder: ByteOrder): Int
            = throw IllegalStateException()
}