package kamon.tag
import java.util.Optional
import java.lang.{Boolean => JBoolean, Long => JLong, String => JString}
import kamon.tag.TagSet.Lookup
import scala.reflect.ClassTag
object Lookups {
/**
* Finds a value associated to the provided key and returns it. If the key is not present then a null is returned.
*/
def any(key: JString) = new Lookup[Any] {
override def execute(storage: TagSet.Storage): Any =
findAndTransform(key, storage, _any, null)
}
/**
* Finds a String value associated to the provided key and returns it. If the key is not present or the value
* associated with they is not a String then a null is returned.
*/
def plain(key: JString) = new Lookup[JString] {
override def execute(storage: TagSet.Storage): JString =
findAndTransform(key, storage, _plainString, null)
}
/**
* Finds a String value associated to the provided key and returns it, wrapped in an Option[String]. If the key is
* not present or the value associated with they is not a String then a None is returned.
*/
def option(key: JString) = new Lookup[Option[JString]] {
override def execute(storage: TagSet.Storage): Option[JString] =
findAndTransform(key, storage, _stringOption, None)
}
/**
* Finds a String value associated to the provided key and returns it, wrapped in an Optional[String]. If the key
* is not present or the value associated with they is not a String then Optional.empty() is returned.
*/
def optional(key: JString) = new Lookup[Optional[String]] {
override def execute(storage: TagSet.Storage): Optional[String] =
findAndTransform(key, storage, _stringOptional, Optional.empty())
}
/**
* Finds the value associated to the provided key and coerces it to a String representation. If the key is not
* present then "unknown" (as a String) will be returned. If the value associated with the key is not a String then
* the value of the key will be transformed into a String and returned.
*
* This lookup type is guaranteed to return a non-null String representation of value.
*/
def coerce(key: String) = new Lookup[String] {
override def execute(storage: TagSet.Storage): String = {
val value = storage.get(key)
if(value == null)
"unknown"
else
value.toString
}
}
/**
* Finds a Boolean value associated to the provided key and returns it. If the key is not present or the value
* associated with they is not a Boolean then a null is returned.
*/
def plainBoolean(key: String) = new Lookup[JBoolean] {
override def execute(storage: TagSet.Storage): JBoolean =
findAndTransform(key, storage, _plainBoolean, null)
}
/**
* Finds a Boolean value associated to the provided key and returns it, wrapped in an Option[Boolean]. If the key
* is not present or the value associated with they is not a Boolean then a None is returned.
*/
def booleanOption(key: String) = new Lookup[Option[JBoolean]] {
override def execute(storage: TagSet.Storage): Option[JBoolean] =
findAndTransform(key, storage, _booleanOption, None)
}
/**
* Finds a Boolean value associated to the provided key and returns it, wrapped in an Optional[Boolean]. If the key
* is not present or the value associated with they is not a Boolean then Optional.empty() is returned.
*/
def booleanOptional(key: String) = new Lookup[Optional[JBoolean]] {
override def execute(storage: TagSet.Storage): Optional[JBoolean] =
findAndTransform(key, storage, _booleanOptional, Optional.empty())
}
/**
* Finds a Long value associated to the provided key and returns it. If the key is not present or the value
* associated with they is not a Long then a null is returned.
*/
def plainLong(key: String) = new Lookup[JLong] {
override def execute(storage: TagSet.Storage): JLong =
findAndTransform(key, storage, _plainLong, null)
}
/**
* Finds a Long value associated to the provided key and returns it, wrapped in an Option[Long]. If the key is
* not present or the value associated with they is not a Long then a None is returned.
*/
def longOption(key: String) = new Lookup[Option[JLong]] {
override def execute(storage: TagSet.Storage): Option[JLong] =
findAndTransform(key, storage, _longOption, None)
}
/**
* Finds a Long value associated to the provided key and returns it, wrapped in an Optional[Long]. If the key
* is not present or the value associated with they is not a Long then Optional.empty() is returned.
*/
def longOptional(key: String) = new Lookup[Optional[JLong]] {
override def execute(storage: TagSet.Storage): Optional[JLong] =
findAndTransform(key, storage, _longOptional, Optional.empty())
}
////////////////////////////////////////////////////////////////
// Transformation helpers for the lookup DSL //
////////////////////////////////////////////////////////////////
@inline
private def findAndTransform[T, R](key: String, storage: TagSet.Storage, transform: R => T, default: T)
(implicit ct: ClassTag[R]): T = {
// This assumes that this code will only be used to lookup values from a Tags instance
// for which the underlying map always has "null" as the default value.
val value = storage.get(key)
if(value == null || !ct.runtimeClass.isInstance(value))
default
else
transform(value.asInstanceOf[R])
}
private val _any = (a: Any) => a
private val _plainString = (a: JString) => a
private val _stringOption = (a: JString) => Option(a)
private val _stringOptional = (a: JString) => Optional.of(a)
private val _plainLong = (a: JLong) => a
private val _longOption = (a: JLong) => Option(a)
private val _longOptional = (a: JLong) => Optional.of(a)
private val _plainBoolean = (a: JBoolean) => a
private val _booleanOption = (a: JBoolean) => Option(a)
private val _booleanOptional = (a: JBoolean) => Optional.of(a)
}