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.convert2.transforms
10 
11 import com.typesafe.scalalogging.LazyLogging
12 import org.geotools.api.filter.expression.PropertyName
13 import org.geotools.factory.CommonFactoryFinder
14 import org.geotools.filter.expression.{PropertyAccessor, PropertyAccessorFactory}
15 import org.geotools.util.factory.Hints
16 import org.locationtech.geomesa.convert2.transforms.CqlFunctionFactory.{CqlTransformerFunction, arrayIndexProperty}
17 import org.locationtech.geomesa.convert2.transforms.Expression.Literal
18 import org.locationtech.geomesa.convert2.transforms.TransformerFunction.NamedTransformerFunction
19 
20 class CqlFunctionFactory extends TransformerFunctionFactory with LazyLogging {
21 
22   import scala.collection.JavaConverters._
23 
24   override val functions: Seq[TransformerFunction] = {
25     val builder = Seq.newBuilder[TransformerFunction]
26 
27     CommonFactoryFinder.getFunctionFactories(null).asScala.toSeq.foreach { factory =>
28       val names = try {
29         // only import default cql functions (without namespaces)
30         // exclude 'categorize', as it doesn't parse into a function correctly
31         factory.getFunctionNames.asScala.filter(f => f.getFunctionName.getNamespaceURI == null && f.getName != "Categorize")
32       } catch {
33         // if CQL classes aren't on the classpath, these functions won't be available
34         case e: NoClassDefFoundError =>
35           logger.warn(s"Couldn't create cql function factory '${factory.getClass.getName}': ${e.toString}")
36           Seq.empty
37       }
38       names.foreach { f =>
39         val name = f.getFunctionName.toString
40         val expressions = Array.tabulate(f.getArguments.size())(arrayIndexProperty)
41         try { builder += new CqlTransformerFunction(name, expressions) } catch {
42           case e: Exception => logger.warn(s"Couldn't create cql function '$name': ${e.toString}")
43         }
44       }
45     }
46     builder.result()
47   }
48 }
49 
50 object CqlFunctionFactory {
51 
52   private val ff = CommonFactoryFinder.getFilterFactory
53 
54   // use alphas for the array indices, as used by the ArrayPropertyAccessor, below
55   private def arrayIndexProperty(i: Int): PropertyName = ff.property(('a' + i).toChar.toString)
56 
57   class CqlTransformerFunction(name: String, expressions: Array[_ <: org.geotools.api.filter.expression.Expression])
58       extends NamedTransformerFunction(Seq(s"cql:$name")) {
59 
60     private val fn = ff.function(name, expressions: _*)
61 
62     override def apply(args: Array[AnyRef]): AnyRef = fn.evaluate(args)
63 
64     override def getInstance(args: List[Expression]): CqlTransformerFunction = {
65       // remap literals to cql literals so that they can be optimized (e.g. prepared geometries, etc)
66       val expressions = Array.tabulate(fn.getFunctionName.getArguments.size()) { i =>
67         if (i < args.length && args(i).isInstanceOf[Literal[_]]) {
68           ff.literal(args(i).asInstanceOf[Literal[_]].value)
69         } else {
70           arrayIndexProperty(i)
71         }
72       }
73       new CqlTransformerFunction(name, expressions)
74     }
75   }
76 
77   /**
78     * For accessing 'properties' of arrays (instead of simple features)
79     */
80   class ArrayPropertyAccessorFactory extends PropertyAccessorFactory {
81     override def createPropertyAccessor(typ: Class[_],
82                                         xpath: String,
83                                         target: Class[_],
84                                         hints: Hints): PropertyAccessor = {
85       if (typ.isArray) { new ArrayPropertyAccessor } else { null }
86     }
87   }
88 
89   /**
90     * Accessing properties of an array. Indices are expected to be lower-case letters,
91     * where 'a' indicates the first element, b the second, etc. We use alphas because
92     * integers are interpreted as literals, not properties.
93     */
94   class ArrayPropertyAccessor extends PropertyAccessor {
95 
96     override def canHandle(obj: Any, xpath: String, target: Class[_]): Boolean = {
97       val i = toIndex(xpath)
98       i >= 0 && i < obj.asInstanceOf[Array[Any]].length
99     }
100 
101     override def set[T](obj: Any, xpath: String, value: T, target: Class[T]): Unit =
102       obj.asInstanceOf[Array[Any]].update(toIndex(xpath), value)
103 
104     override def get[T](obj: Any, xpath: String, target: Class[T]): T =
105       obj.asInstanceOf[Array[Any]].apply(toIndex(xpath)).asInstanceOf[T]
106 
107     private def toIndex(xpath: String): Int = {
108       if (xpath.length == 1) {
109         xpath.charAt(0) - 'a'
110       } else {
111         -1
112       }
113     }
114   }
115 }