Sqooba / scala-timeseries-lib / 116

Build # 116

Build Type

push

travis-ci-com

Committed by OSAG OS Code

Commit Message

<a href="https://github.com/Sqooba/scala-timeseries-lib/commit/<a class=hub.com/Sqooba/scala-timeseries-lib/commit/<a class="double-link" href="https://git"><a class=hub.com/Sqooba/scala-timeseries-lib/commit/<a class="double-link" href="https://git"><a class=hub.com/Sqooba/scala-timeseries-lib/commit/<a class="double-link" href="https://git"><a class=hub.com/Sqooba/scala-timeseries-lib/commit/f7bf4f1fa85ae5e8cbacb8e047070cfc1f92e8b8">f7bf4f1fa">&lt;a href=&quot;https://github.com/Sqooba/scala-timeseries-lib/commit/</a><a class="double-link" href="https://github.com/Sqooba/scala-timeseries-lib/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Sqooba/scala-timeseries-lib/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Sqooba/scala-timeseries-lib/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Sqooba/scala-timeseries-lib/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Sqooba/scala-timeseries-lib/commit/f7bf4f1fa85ae5e8cbacb8e047070cfc1f92e8b8">f7bf4f1fa</a><a href="https://github.com/Sqooba/scala-timeseries-lib/commit/f7bf4f1fa85ae5e8cbacb8e047070cfc1f92e8b8">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/Sqooba/scala-timeseries-lib/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/Sqooba/scala-timeseries-lib/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Sqooba/scala-timeseries-lib/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Sqooba/scala-timeseries-lib/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Sqooba/scala-timeseries-lib/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Sqooba/scala-timeseries-lib/commit/f7bf4f1fa85ae5e8cbacb8e047070cfc1f92e8b8&quot;&gt;f7bf4f1fa&lt;/a&gt;&lt;a href=&quot;https://github.com/Sqooba/scala-timeseries-lib/commit/f7bf4f1fa85ae5e8cbacb8e047070cfc1f92e8b8&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/Sqooba/scala-t... (continued)

Run Details

18 of 18 new or added lines in 4 files covered. (100.0%)

958 of 1055 relevant lines covered (90.81%)

1.82 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.88

/src/main/scala/io/sqooba/oss/timeseries/utils/SliceableByteChannel.scala

package io.sqooba.oss.timeseries.utils

import java.nio.ByteBuffer
import java.nio.channels.SeekableByteChannel

/** IO abstraction used by this library. This extends the SeekableByteChannel
  * with the ability to return a view of a slice of the channel. Additionally,
  * this trait offers some convenience methods for reading byte arrays and other
  * types.
  */
trait SliceableByteChannel extends SeekableByteChannel {

  /** Not supported by SliceableByteChannel. */
  override def truncate(size: Long): SeekableByteChannel =
    throw new UnsupportedOperationException()

  /** Return a view of this channel that is delimited by the given offsets.
    * @param from the offset of the first byte of the slice (inclusive)
    * @param to the offset of the first byte after the slice (exclusive)
    * @return a view on the current channel
    */
  def slice(from: Long, to: Long): SliceableByteChannel

  /** Read an integer from the end of the channel (big-endian byte order).
    * @param offsetToEnd the number of bytes between the end of the integer bytes
    *                    and the end of the channel
    */
  def readIntFromEnd(offsetToEnd: Long): Int =
    ByteBuffer
      .wrap(readBytesFromEnd(offsetToEnd, Integer.BYTES))
      .getInt

  /** Read a block of bytes from the end of the channel.
    * @note This method copies the bytes it reads. In order to avoid a copy you
    *       can use #slice.
    * @param offsetToEnd the number of bytes between the end of the block bytes
    *                    and the end of the channel
    */
  def readBytesFromEnd(offsetToEnd: Long, length: Int): Array[Byte] =
    readBytes(size() - offsetToEnd - length, length)

  /** Read a block of bytes from the channel.
    * @note This method copies the bytes it reads. In order to avoid a copy you
    *       can use #slice.
    */
  def readBytes(offset: Long, length: Int): Array[Byte] = {
    require(offset + length <= size(), "Cannot read past the end of the channel.")

    position(offset)
    val buffer = ByteBuffer.allocate(length)
    require(read(buffer) == length, "There is not enough data on the channel.")

    buffer.flip()
    buffer.array()
  }
}

object SliceableByteChannel {

  /** Wrap the entire SeekableByteChannel in a sliceable one. */
  def apply(channel: SeekableByteChannel): SliceableByteChannel =
    new DefaultSliceableByteChannel(channel, 0, channel.size())
}

/** Default implementation using a SeeakableByteChannel. For the parameter's
  * specifications see method #slice of the trait.
  */
private class DefaultSliceableByteChannel(
    channel: SeekableByteChannel,
    from: Long,
    to: Long
) extends SliceableByteChannel {
  require(from >= 0, "Start of the slice cannot be negative.")
  require(to >= from, "The end of the slice needs to be larger than its start.")
  require(to <= channel.size(), "The end of the slice cannot be larger than the channel.")

  channel.position(from)

  override def slice(fromOffset: Long, toOffset: Long): SliceableByteChannel =
    new DefaultSliceableByteChannel(channel, from + fromOffset, from + toOffset)

  private def remaining: Long = size - position

  override def read(dst: ByteBuffer): Int =
    if (this.remaining == 0) -1
    else {
      if (dst.remaining() > this.remaining) {
        dst.limit(remaining.toInt)
      }
      channel.read(dst)
    }

  override def write(src: ByteBuffer): Int =
    if (this.remaining == 0) -1
    else {
      if (src.remaining() > this.remaining) {
        src.limit(remaining.toInt)
      }
      channel.write(src)
    }

  override def position: Long = channel.position() - from

  override def position(newPosition: Long): SliceableByteChannel = {
    if (newPosition + from > to) {
      throw new IndexOutOfBoundsException(s"The new position $newPosition was larger than the size $size.")
    }
    channel.position(from + newPosition)
    this
  }

  override val size: Long = to - from

  override def isOpen: Boolean = channel.isOpen

  override def close(): Unit = channel.close()
}

1	package io.sqooba.oss.timeseries.utils
2
3	import java.nio.ByteBuffer
4	import java.nio.channels.SeekableByteChannel
5
6	/** IO abstraction used by this library. This extends the SeekableByteChannel
7	* with the ability to return a view of a slice of the channel. Additionally,
8	* this trait offers some convenience methods for reading byte arrays and other
9	* types.
10	*/
11	trait SliceableByteChannel extends SeekableByteChannel {
12
13	/** Not supported by SliceableByteChannel. */
14	override def truncate(size: Long): SeekableByteChannel =
15	throw new UnsupportedOperationException()	2✔
16
17	/** Return a view of this channel that is delimited by the given offsets.
18	* @param from the offset of the first byte of the slice (inclusive)
19	* @param to the offset of the first byte after the slice (exclusive)
20	* @return a view on the current channel
21	*/
22	def slice(from: Long, to: Long): SliceableByteChannel
23
24	/** Read an integer from the end of the channel (big-endian byte order).
25	* @param offsetToEnd the number of bytes between the end of the integer bytes
26	* and the end of the channel
27	*/
28	def readIntFromEnd(offsetToEnd: Long): Int =
29	ByteBuffer
30	.wrap(readBytesFromEnd(offsetToEnd, Integer.BYTES))
31	.getInt	2✔
32
33	/** Read a block of bytes from the end of the channel.
34	* @note This method copies the bytes it reads. In order to avoid a copy you
35	* can use #slice.
36	* @param offsetToEnd the number of bytes between the end of the block bytes
37	* and the end of the channel
38	*/
39	def readBytesFromEnd(offsetToEnd: Long, length: Int): Array[Byte] =
40	readBytes(size() - offsetToEnd - length, length)	2✔
41
42	/** Read a block of bytes from the channel.
43	* @note This method copies the bytes it reads. In order to avoid a copy you
44	* can use #slice.
45	*/
46	def readBytes(offset: Long, length: Int): Array[Byte] = {
47	require(offset + length <= size(), "Cannot read past the end of the channel.")	2✔
48
49	position(offset)	2✔
50	val buffer = ByteBuffer.allocate(length)	2✔
51	require(read(buffer) == length, "There is not enough data on the channel.")	×
52
53	buffer.flip()	2✔
54	buffer.array()	2✔
55	}
56	}
57
58	object SliceableByteChannel {
59
60	/** Wrap the entire SeekableByteChannel in a sliceable one. */
61	def apply(channel: SeekableByteChannel): SliceableByteChannel =
62	new DefaultSliceableByteChannel(channel, 0, channel.size())	2✔
63	}
64
65	/** Default implementation using a SeeakableByteChannel. For the parameter's
66	* specifications see method #slice of the trait.
67	*/
68	private class DefaultSliceableByteChannel(
69	channel: SeekableByteChannel,
70	from: Long,
71	to: Long
72	) extends SliceableByteChannel {
73	require(from >= 0, "Start of the slice cannot be negative.")	2✔
74	require(to >= from, "The end of the slice needs to be larger than its start.")	×
75	require(to <= channel.size(), "The end of the slice cannot be larger than the channel.")	2✔
76
77	channel.position(from)	2✔
78
79	override def slice(fromOffset: Long, toOffset: Long): SliceableByteChannel =
80	new DefaultSliceableByteChannel(channel, from + fromOffset, from + toOffset)	2✔
81
82	private def remaining: Long = size - position	2✔
83
84	override def read(dst: ByteBuffer): Int =
85	if (this.remaining == 0) -1	2✔
86	else {	2✔
87	if (dst.remaining() > this.remaining) {	2✔
88	dst.limit(remaining.toInt)	2✔
89	}
90	channel.read(dst)	2✔
91	}
92
93	override def write(src: ByteBuffer): Int =
94	if (this.remaining == 0) -1	2✔
95	else {	2✔
96	if (src.remaining() > this.remaining) {	2✔
97	src.limit(remaining.toInt)	2✔
98	}
99	channel.write(src)	2✔
100	}
101
102	override def position: Long = channel.position() - from	2✔
103
104	override def position(newPosition: Long): SliceableByteChannel = {
105	if (newPosition + from > to) {	2✔
106	throw new IndexOutOfBoundsException(s"The new position $newPosition was larger than the size $size.")	2✔
107	}
108	channel.position(from + newPosition)	2✔
109	this
110	}
111
112	override val size: Long = to - from	2✔
113
114	override def isOpen: Boolean = channel.isOpen	×
115
116	override def close(): Unit = channel.close()	×
117	}

Sqooba / scala-timeseries-lib / 116

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous