1 /***********************************************************************
2  * Copyright (c) 2013-2024 Commonwealth Computer Research, Inc.
3  * All rights reserved. This program and the accompanying materials
4  * are made available under the terms of the Apache License, Version 2.0
5  * which accompanies this distribution and is available at
6  * http://www.opensource.org/licenses/apache2.0.php.
7  ***********************************************************************/
8 
9 package org.locationtech.geomesa.filter
10 
11 import scala.collection.GenTraversableOnce
12 
13 /**
14   * Holds values extracted from a filter. Values may be empty, in which case nothing was extracted from
15   * the filter. May be marked as 'disjoint', which means that mutually exclusive values were extracted
16   * from the filter. This may be checked to short-circuit queries that will not result in any hits.
17   *
18   * @param values values extracted from the filter. If nothing was extracted, will be empty
19   * @param precise values exactly match the filter, or may return false positives
20   * @param disjoint mutually exclusive values were extracted, e.g. 'a < 1 && a > 2'
21   * @tparam T type parameter
22   */
23 case class FilterValues[+T](values: Seq[T], precise: Boolean = true, disjoint: Boolean = false) {
24   def map[U](f: T => U): FilterValues[U] = FilterValues(values.map(f), precise, disjoint)
25   def flatMap[U](f: T => GenTraversableOnce[U]): FilterValues[U] = FilterValues(values.flatMap(f), precise, disjoint)
26   def foreach[U](f: T => U): Unit = values.foreach(f)
27   def forall(p: T => Boolean): Boolean = values.forall(p)
28   def exists(p: T => Boolean): Boolean = values.exists(p)
29   def filter(f: T => Boolean): FilterValues[T] = FilterValues(values.filter(f), precise, disjoint)
30   def nonEmpty: Boolean = values.nonEmpty || disjoint
31   def isEmpty: Boolean = !nonEmpty
32 }
33 
34 object FilterValues {
35 
36   def empty[T]: FilterValues[T] = FilterValues[T](Seq.empty)
37 
38   def disjoint[T]: FilterValues[T] = FilterValues[T](Seq.empty, disjoint = true)
39 
40   def or[T](join: (Seq[T], Seq[T]) => Seq[T])(left: FilterValues[T], right: FilterValues[T]): FilterValues[T] = {
41     (left.disjoint, right.disjoint) match {
42       case (false, false) => FilterValues(join(left.values, right.values), left.precise && right.precise)
43       case (false, true)  => left
44       case (true,  false) => right
45       case (true,  true)  => FilterValues.disjoint
46     }
47   }
48 
49   def and[T](intersect: (T, T) => Option[T])(left: FilterValues[T], right: FilterValues[T]): FilterValues[T] = {
50     if (left.disjoint || right.disjoint) {
51       FilterValues.disjoint
52     } else if (left.isEmpty) {
53       right
54     } else if (right.isEmpty) {
55       left
56     } else {
57       val intersections = left.values.flatMap(v => right.values.flatMap(intersect(_, v)))
58       if (intersections.isEmpty) {
59         FilterValues.disjoint
60       } else {
61         FilterValues(intersections.distinct, left.precise && right.precise)
62       }
63     }
64   }
65 }