Add the ability to constrain a Bounds

Author: dlindhol

core/src/main/scala/latis/util/Bounds.scala

@@ -23,6 +23,34 @@ final case class Bounds[T] private (val lower: T, val upper: T)(ord: Ordering[T]
     // NaN greater than other values but the less than test will be false.
     ord.gteq(value, lower) && (ord.lt(value, upper) || (inclusive && ord.equiv(value, upper)))
   }
+
+  /**
+   * Constrains the lower bound.
+   *
+   * This optionally returns a new Bounds if the given value is greater than
+   * the current lower bound. Otherwise, it returns itself. If the bounds
+   * become invalid: lower > upper, this will return None.
+   *
+   * @param value the potentially new lower bound
+   */
+  def constrainLower(value: T): Option[Bounds[T]] = {
+    if (ord.gt(value, lower)) Bounds.of(value, upper)(ord) //TODO: why can't we use ">"?
+    else Some(this)
+  }
+
+  /**
+   * Constrains the upper bound.
+   *
+   * This optionally returns a new Bounds if the given value is less than the
+   * current upper bound. Otherwise, it returns itself. If the bounds become
+   * invalid: lower > upper, this will return None.
+   *
+   * @param value the potentially new upper bound
+   */
+  def constrainUpper(value: T): Option[Bounds[T]] = {
+    if (ord.lt(value, upper)) Bounds.of(lower, value)(ord)
+    else Some(this)
+  }
 }
 
 object Bounds {

core/src/test/scala/latis/util/BoundsSuite.scala

@@ -68,9 +68,49 @@ class BoundsSuite extends FunSuite {
   test("extract bounds") {
     bounds match {
       case Bounds(l, u) =>
-        assert(l == -1)
-        assert(u == 2)
-      case _ => fail("")
+        assert(l == -1D)
+        assert(u == 2D)
     }
   }
+
+  test("constrain lower bound") {
+    bounds.constrainLower(0).get match {
+      case Bounds(v, _) => assert(v == 0D)
+    }
+  }
+
+  test("don't constrain lower bound") {
+    bounds.constrainLower(-2).get match {
+      case Bounds(v, _) => assert(v == -1D)
+    }
+  }
+
+  test("constrain upper bound") {
+    println(bounds.constrainUpper(1))
+    bounds.constrainUpper(1).get match {
+      case Bounds(_, v) => assert(v == 1D)
+    }
+  }
+
+  test("don't constrain upper bound") {
+    bounds.constrainUpper(3).get match {
+      case Bounds(_, v) => assert(v == 2D)
+    }
+  }
+
+  test("lower constraint greater that upper bound") {
+    assert(bounds.constrainLower(3).isEmpty)
+  }
+
+  test("upper constraint lower that lower bound") {
+    assert(bounds.constrainUpper(-2).isEmpty)
+  }
+
+  test("Bound equality") {
+    assert(bounds == Bounds.of(-1, 2).get)
+  }
+
+  test("to string") {
+    assert(Bounds.of('a', 'c').get.toString == "Bounds(a,c)")
+  }
 }