Sqooba / scala-timeseries-lib / 106

pending completion

Build # 106

Build Type

push

travis-ci-com

Committed by

Shastick

Commit Message

<a href="https://github.com/Sqooba/scala-timeseries-lib/commit/7781c8de3">Split time series entity things among libraries.

GitOrigin-RevId: </a><a class="double-link" href="https://github.com/Sqooba/scala-timeseries-lib/commit/a981870eb">a981870eb</a>

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

955 of 1045 relevant lines covered (91.39%)

1.83 hits per line

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

70.0

/src/main/scala/io/sqooba/oss/timeseries/immutable/TimeDomain.scala

package io.sqooba.oss.timeseries.immutable

import scala.math.{max, min}

/**
  * This trait represents the definition of a time series' domain
  *
  * By convention, a `TimeDomain` is a set of timestamps (`Long`) inclusive on its left,
  * and exclusive on its right.
  */
sealed trait TimeDomain {

  /**
    * Checks if the timestamp given is part of the domain
    *
    * @param p The timestamp to check
    * @return `true` if the timestamp is part of the domain, `false` otherwise
    */
  def contains(p: Long): Boolean

  /**
    * Returns the union of two domains without considering potential //holes// in it
    *
    * Using '#' if the element is in the domain and '-' otherwise, a union would be
    * ```
    * ###-----
    * ------##
    * ==========
    * ###---##
    * ```
    *
    * The looseUnion of these two domains is "########".
    *
    * @param other The other domain
    * @return The union of these two domains
    */
  def looseUnion(other: TimeDomain): TimeDomain

  /**
    * Returns the intersection of two domains
    *
    * @param other The other domain
    * @return The intersection of the two domains
    */
  def intersect(other: TimeDomain): TimeDomain

  /**
    * @return The size of the time-domain
    */
  def size: Long

}

object TimeDomain {

  /**
    * A //safe// constructor of `TimeDomain` which returns the correct underlying representation.
    * If the interval is empty, then an `EmptyTimeDomain` is returned.
    *
    * @param start The starting point of the domain (included)
    * @param until The ending point of the domain (not included)
    * @return A `ContiguousTimeDomain` if the domain contains at least one point, an `EmptyDomain` otherwise
    */
  def fromUnsafeInterval(start: Long, until: Long): TimeDomain =
    if (start < until) {
      ContiguousTimeDomain(start, until)
    } else {
      EmptyTimeDomain
    }

}

case class ContiguousTimeDomain(start: Long, until: Long) extends TimeDomain {

  assert(start < until, "A ContiguousTimeDomain can not be empty")

  def contains(p: Long): Boolean = p >= start && p < until

  def looseUnion(other: TimeDomain): TimeDomain =
    other match {
      case EmptyTimeDomain => this
      case ContiguousTimeDomain(otherStart, otherUntil) =>
        ContiguousTimeDomain(min(start, otherStart), max(until, otherUntil))
    }

  def intersect(other: TimeDomain): TimeDomain =
    other match {
      case EmptyTimeDomain => EmptyTimeDomain
      case ContiguousTimeDomain(otherStart, otherUntil) =>
        TimeDomain.fromUnsafeInterval(max(start, otherStart), min(until, otherUntil))
    }

  def size: Long = until - start

}

case object EmptyTimeDomain extends TimeDomain {

  def contains(p: Long): Boolean = false

  def looseUnion(other: TimeDomain): TimeDomain = other

  def intersect(other: TimeDomain): TimeDomain = this

  def size: Long = 0

}

1	package io.sqooba.oss.timeseries.immutable
2
3	import scala.math.{max, min}
4
5	/**
6	* This trait represents the definition of a time series' domain
7	*
8	* By convention, a `TimeDomain` is a set of timestamps (`Long`) inclusive on its left,
9	* and exclusive on its right.
10	*/
11	sealed trait TimeDomain {
12
13	/**
14	* Checks if the timestamp given is part of the domain
15	*
16	* @param p The timestamp to check
17	* @return `true` if the timestamp is part of the domain, `false` otherwise
18	*/
19	def contains(p: Long): Boolean
20
21	/**
22	* Returns the union of two domains without considering potential //holes// in it
23	*
24	* Using '#' if the element is in the domain and '-' otherwise, a union would be
25	* ```
26	* ###-----
27	* ------##
28	* ==========
29	* ###---##
30	* ```
31	*
32	* The looseUnion of these two domains is "########".
33	*
34	* @param other The other domain
35	* @return The union of these two domains
36	*/
37	def looseUnion(other: TimeDomain): TimeDomain
38
39	/**
40	* Returns the intersection of two domains
41	*
42	* @param other The other domain
43	* @return The intersection of the two domains
44	*/
45	def intersect(other: TimeDomain): TimeDomain
46
47	/**
48	* @return The size of the time-domain
49	*/
50	def size: Long
51
52	}
53
54	object TimeDomain {
55
56	/**
57	* A //safe// constructor of `TimeDomain` which returns the correct underlying representation.
58	* If the interval is empty, then an `EmptyTimeDomain` is returned.
59	*
60	* @param start The starting point of the domain (included)
61	* @param until The ending point of the domain (not included)
62	* @return A `ContiguousTimeDomain` if the domain contains at least one point, an `EmptyDomain` otherwise
63	*/
64	def fromUnsafeInterval(start: Long, until: Long): TimeDomain =
65	if (start < until) {	2✔
66	ContiguousTimeDomain(start, until)	2✔
67	} else {
68	EmptyTimeDomain	2✔
69	}
70
71	}
72
73	case class ContiguousTimeDomain(start: Long, until: Long) extends TimeDomain {
74
75	assert(start < until, "A ContiguousTimeDomain can not be empty")	×
76
77	def contains(p: Long): Boolean = p >= start && p < until	2✔
78
79	def looseUnion(other: TimeDomain): TimeDomain =
80	other match {
81	case EmptyTimeDomain => this
82	case ContiguousTimeDomain(otherStart, otherUntil) =>
83	ContiguousTimeDomain(min(start, otherStart), max(until, otherUntil))	2✔
84	}
85
86	def intersect(other: TimeDomain): TimeDomain =
87	other match {
88	case EmptyTimeDomain => EmptyTimeDomain
89	case ContiguousTimeDomain(otherStart, otherUntil) =>
90	TimeDomain.fromUnsafeInterval(max(start, otherStart), min(until, otherUntil))	2✔
91	}
92
93	def size: Long = until - start	2✔
94
95	}
96
97	case object EmptyTimeDomain extends TimeDomain {
98
99	def contains(p: Long): Boolean = false	×
100
101	def looseUnion(other: TimeDomain): TimeDomain = other
102
103	def intersect(other: TimeDomain): TimeDomain = this
104
105	def size: Long = 0	×
106
107	}

Sqooba / scala-timeseries-lib / 106

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