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.utils.geotools.converters
10 
11 import com.typesafe.scalalogging.StrictLogging
12 import org.geotools.api.filter.expression.Expression
13 import org.geotools.data.util.InterpolationConverterFactory
14 import org.geotools.util.factory.GeoTools
15 import org.geotools.util.{Converter, Converters}
16 
17 import java.util.concurrent.ConcurrentHashMap
18 import scala.reflect.ClassTag
19 import scala.util.control.NonFatal
20 
21 /**
22   * Replacement for geotools `Converters`, which caches the converters for each pair of (from -> to) instead of
23   * re-creating them each time.
24   */
25 object FastConverter extends StrictLogging {
26 
27   import scala.collection.JavaConverters._
28 
29   private val factories = Converters.getConverterFactories(GeoTools.getDefaultHints).asScala.toArray.filter {
30     // exclude jai-related factories as it's not usually on the classpath
31     case _: InterpolationConverterFactory => false
32     case _ => true
33   }
34 
35   private val cache = new ConcurrentHashMap[(Class[_], Class[_]), Array[Converter]]
36 
37   /**
38     * Convert the value into the given type
39     *
40     * @param value value to convert
41     * @param binding type to convert to
42     * @tparam T type binding
43     * @return converted value, or null if it could not be converted
44     */
45   def convert[T](value: Any, binding: Class[T]): T = {
46     if (value == null) {
47       return null.asInstanceOf[T]
48     }
49 
50     val clas = value.getClass
51     if (clas == binding) {
52       return value.asInstanceOf[T]
53     }
54 
55     val converters = getConverters(clas, binding)
56 
57     var i = 0
58     while (i < converters.length) {
59       try {
60         val result = converters(i).convert(value, binding)
61         if (result != null) {
62           return result
63         }
64       } catch {
65         case NonFatal(e) =>
66           logger.trace(s"Error converting $value (of type ${value.getClass.getName}) " +
67               s"to ${binding.getName} using converter ${converters(i).getClass.getName}:", e)
68       }
69       i += 1
70     }
71 
72     val msg = s"Could not convert '$value' (of type ${value.getClass.getName}) to ${binding.getName}"
73     logger.warn(msg)
74     logger.debug(msg, new Exception())
75 
76     null.asInstanceOf[T]
77   }
78 
79 
80   /**
81    * Convert the value into one of the given type
82    *
83    * @param value value to convert
84    * @param bindings type to convert to, in order of preference
85    * @tparam T type binding
86    * @return converted value, or null if it could not be converted
87    */
88   def convertFirst[T](value: Any, bindings: Iterator[Class[_ <: T]]): T = {
89     if (value == null) {
90       return null.asInstanceOf[T]
91     }
92 
93     val clas = value.getClass
94 
95     while (bindings.hasNext) {
96       val binding = bindings.next
97       if (clas == binding) {
98         return value.asInstanceOf[T]
99       }
100 
101       val converters = getConverters(clas, binding)
102 
103       var i = 0
104       while (i < converters.length) {
105         try {
106           val result = converters(i).convert(value, binding)
107           if (result != null) {
108             return result
109           }
110         } catch {
111           case NonFatal(e) =>
112             logger.trace(s"Error converting $value (of type ${value.getClass.getName}) " +
113                 s"to ${binding.getName} using converter ${converters(i).getClass.getName}:", e)
114         }
115         i += 1
116       }
117     }
118 
119     logger.warn(
120       s"Could not convert '$value' (of type ${value.getClass.getName}) " +
121           s"to any of ${bindings.map(_.getName).mkString(", ")}")
122 
123     null.asInstanceOf[T]
124   }
125 
126   /**
127     * Convert the value into the given type, returning the default if it could not be converted or is null
128     *
129     * @param value value to convert
130     * @param default value to return if convert results in null
131     * @param ct class tag
132     * @tparam T type to convert to
133     * @return
134     */
135   def convertOrElse[T <: AnyRef](value: Any, default: => T)(implicit ct: ClassTag[T]): T = {
136     val attempt = convert(value, ct.runtimeClass.asInstanceOf[Class[T]])
137     if (attempt == null) { default } else { attempt }
138   }
139 
140   /**
141     * Evaluate and convert an expression
142     *
143     * @param expression expression to evaluate
144     * @param binding type to convert to
145     * @tparam T type binding
146     * @return converted value, or null if it could not be converted
147     */
148   def evaluate[T](expression: Expression, binding: Class[T]): T = convert(expression.evaluate(null), binding)
149 
150   /**
151    * Gets a cached converter, loading it if necessary
152    *
153    * @param from from
154    * @param to to
155    * @return
156    */
157   private def getConverters(from: Class[_], to: Class[_]): Array[Converter] = {
158     var converters = cache.get((from, to))
159 
160     if (converters == null) {
161       if (from.eq(to) || from == to || to.isAssignableFrom(from)) {
162         converters = Array(IdentityConverter)
163       } else {
164         converters = factories.flatMap(factory => Option(factory.createConverter(from, to, null)))
165         if (to == classOf[String]) {
166           converters = converters :+ ToStringConverter // add toString as a final fallback
167         }
168       }
169       cache.put((from, to), converters)
170     }
171 
172     converters
173   }
174 
175   private object IdentityConverter extends Converter {
176     override def convert[T](source: Any, target: Class[T]): T = source.asInstanceOf[T]
177   }
178 
179   private object ToStringConverter extends Converter {
180     override def convert[T](source: Any, target: Class[T]): T = source.toString.asInstanceOf[T]
181   }
182 }