Drop guava

Author: christophercurrie

build.sbt

@@ -23,8 +23,6 @@ libraryDependencies ++= Seq(
     "com.fasterxml.jackson.core" % "jackson-annotations" % "2.5.0",
     "com.fasterxml.jackson.core" % "jackson-databind" % "2.5.0",
     "com.thoughtworks.paranamer" % "paranamer" % "2.6",
-    "com.google.code.findbugs" % "jsr305" % "2.0.1",
-    "com.google.guava" % "guava" % "18.0",
     // test dependencies
     "com.fasterxml.jackson.datatype" % "jackson-datatype-joda" % "2.5.0" % "test",
     "com.fasterxml.jackson.datatype" % "jackson-datatype-guava" % "2.5.0" % "test",

src/main/scala/com/fasterxml/jackson/module/scala/experimental/ScalaObjectMapper.scala

@@ -7,8 +7,6 @@ import com.fasterxml.jackson.core._
 import com.fasterxml.jackson.databind._
 import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper
 import com.fasterxml.jackson.databind.jsonschema.JsonSchema
-import com.fasterxml.jackson.module.scala.util.Implicits._
-import com.google.common.cache.{CacheBuilder, LoadingCache}
 
 trait ScalaObjectMapper {
   self: ObjectMapper =>
@@ -55,32 +53,30 @@ trait ScalaObjectMapper {
    * type (typically <code>java.lang.Class</code>), but without explicit
    * context.
    */
-  private[this] val typeCache: LoadingCache[Manifest[_], JavaType] =
-    CacheBuilder.newBuilder().maximumSize(DEFAULT_CACHE_SIZE).build { m: Manifest[_] =>
-      val clazz = m.runtimeClass
-      if(isArray(clazz)) {
-        //It looks like getting the component type is the best we can do, at
-        //least if we also want to support 2.9.x - scala 2.10.x adds full
-        //type info in the typeArguments field of an Array's manifest.
-        getTypeFactory.constructArrayType(clazz.getComponentType)
-      } else if(isMapLike(clazz)) {
-        val typeArguments = m.typeArguments.map(constructType(_)).toArray
-        if(typeArguments.length != 2) {
-          throw new IllegalArgumentException("Need exactly 2 type parameters for map like types ("+clazz.getName+")")
-        }
-        getTypeFactory.constructMapLikeType(clazz, typeArguments(0), typeArguments(1))
-      } else if(isCollectionLike(clazz)) {
-        val typeArguments = m.typeArguments.map(constructType(_)).toArray
-        if(typeArguments.length != 1) {
-          throw new IllegalArgumentException("Need exactly 1 type parameter for collection like types ("+clazz.getName+")")
-        }
-        getTypeFactory.constructCollectionLikeType(clazz, typeArguments(0))
-      } else {
-        val typeArguments = m.typeArguments.map(constructType(_)).toArray
-        getTypeFactory.constructParametrizedType(clazz, clazz, typeArguments: _*)
+  def constructType[T](implicit m: Manifest[T]): JavaType = {
+    val clazz = m.runtimeClass
+    if(isArray(clazz)) {
+      //It looks like getting the component type is the best we can do, at
+      //least if we also want to support 2.9.x - scala 2.10.x adds full
+      //type info in the typeArguments field of an Array's manifest.
+      getTypeFactory.constructArrayType(clazz.getComponentType)
+    } else if(isMapLike(clazz)) {
+      val typeArguments = m.typeArguments.map(constructType(_)).toArray
+      if(typeArguments.length != 2) {
+        throw new IllegalArgumentException("Need exactly 2 type parameters for map like types ("+clazz.getName+")")
       }
+      getTypeFactory.constructMapLikeType(clazz, typeArguments(0), typeArguments(1))
+    } else if(isCollectionLike(clazz)) {
+      val typeArguments = m.typeArguments.map(constructType(_)).toArray
+      if(typeArguments.length != 1) {
+        throw new IllegalArgumentException("Need exactly 1 type parameter for collection like types ("+clazz.getName+")")
+      }
+      getTypeFactory.constructCollectionLikeType(clazz, typeArguments(0))
+    } else {
+      val typeArguments = m.typeArguments.map(constructType(_)).toArray
+      getTypeFactory.constructParametrizedType(clazz, clazz, typeArguments: _*)
     }
-  def constructType[T](implicit m: Manifest[T]): JavaType = typeCache.get(m)
+  }
 
   /*
    **********************************************************

src/main/scala/com/fasterxml/jackson/module/scala/introspect/BeanIntrospector.scala

@@ -23,12 +23,12 @@
 
 package com.fasterxml.jackson.module.scala.introspect
 
-import com.thoughtworks.paranamer.BytecodeReadingParanamer
-import scala.reflect.NameTransformer
-import java.lang.reflect.{Modifier, Field, Constructor, Method}
-import com.google.common.cache.{LoadingCache, CacheBuilder}
+import java.lang.reflect.{Constructor, Field, Method, Modifier}
+
+import com.thoughtworks.paranamer.{BytecodeReadingParanamer, CachingParanamer}
+
 import scala.annotation.tailrec
-import com.fasterxml.jackson.module.scala.util.Implicits._
+import scala.reflect.NameTransformer
 
 //TODO: This might be more efficient/type safe if we used Scala reflection here
 //but we have to support 2.9.x and 2.10.x - once the scala reflection APIs
@@ -37,22 +37,10 @@ import com.fasterxml.jackson.module.scala.util.Implicits._
 
 object BeanIntrospector {
 
-  private [this] val paranamer = new BytecodeReadingParanamer
-  private [this] val ctorParamNamesCache: LoadingCache[Constructor[_],Array[String]] =
-    // TODO: consider module configuration of the cache
-    CacheBuilder.newBuilder
-      .maximumSize(DEFAULT_CACHE_SIZE)
-      .build(paranamer.lookupParameterNames(_: Constructor[_]).map(NameTransformer.decode))
+  private [this] val paranamer = new CachingParanamer(new BytecodeReadingParanamer)
 
   private def getCtorParams(ctor: Constructor[_]): Array[String] =
-    try
-    {
-      ctorParamNamesCache.get(ctor)
-    }
-    catch
-    {
-      case _: Exception => Array.empty
-    }
+    paranamer.lookupParameterNames(ctor, false).map(NameTransformer.decode)
 
   def apply[T <: AnyRef](implicit mf: Manifest[_]): BeanDescriptor = apply[T](mf.runtimeClass)
 

src/main/scala/com/fasterxml/jackson/module/scala/introspect/ScalaAnnotationIntrospectorModule.scala

@@ -3,39 +3,43 @@ package introspect
 
 import com.fasterxml.jackson.annotation.JsonCreator
 import com.fasterxml.jackson.databind.PropertyName
+import com.fasterxml.jackson.databind.`type`.ClassKey
 import com.fasterxml.jackson.databind.introspect._
+import com.fasterxml.jackson.databind.util.LRUMap
 import com.fasterxml.jackson.module.scala.util.Implicits._
-import com.google.common.cache.{CacheBuilder, LoadingCache}
 
 import scala.collection.JavaConverters._
 
 object ScalaAnnotationIntrospector extends JacksonAnnotationIntrospector
 {
-  val descriptors: LoadingCache[Class[_], BeanDescriptor] =
-    CacheBuilder.newBuilder()
-      .maximumSize(DEFAULT_CACHE_SIZE)
-      .build(BeanIntrospector.apply (_:Class[_]))
+  private [this] val _descriptorCache = new LRUMap[ClassKey, BeanDescriptor](16, 100)
 
-  val classes: LoadingCache[Class[_], AnnotatedClass] =
-    CacheBuilder.newBuilder()
-      .maximumSize(DEFAULT_CACHE_SIZE)
-      .build(AnnotatedClass.constructWithoutSuperTypes(_:Class[_], this, null))
+  private def _descriptorFor(clz: Class[_]): BeanDescriptor = {
+    val key = new ClassKey(clz)
+    var result = _descriptorCache.get(key)
+    if (result == null) {
+      result = BeanIntrospector(clz)
+      _descriptorCache.put(key, result)
+    }
+
+    result
+  }
 
   private def annotatedClassFor(am: AnnotatedMember): AnnotatedClass =
-    classes.get(am.getDeclaringClass)
+    am.getContextClass
 
   private def fieldName(af: AnnotatedField): Option[String] = {
-    val d = descriptors.get(af.getDeclaringClass)
+    val d = _descriptorFor(af.getDeclaringClass)
     d.properties.find(p => p.field.exists(_ == af.getAnnotated)).map(_.name)
   }
 
   private def methodName(am: AnnotatedMethod): Option[String] = {
-    val d = descriptors.get(am.getDeclaringClass)
+    val d = _descriptorFor(am.getDeclaringClass)
     d.properties.find(p => (p.getter ++ p.setter).exists(_ == am.getAnnotated)).map(_.name)
   }
 
   private def paramName(ap: AnnotatedParameter): Option[String] = {
-    val d = descriptors.get(ap.getDeclaringClass)
+    val d = _descriptorFor(ap.getDeclaringClass)
     d.properties.find(p => p.param.exists { cp =>
       cp.constructor == ap.getOwner.getAnnotated && cp.index == ap.getIndex
     }).map(_.name)
@@ -44,7 +48,7 @@ object ScalaAnnotationIntrospector extends JacksonAnnotationIntrospector
   private def paramFor(a: Annotated): Option[AnnotatedParameter] = {
     a match {
       case am: AnnotatedMember =>
-        val d = descriptors.get(am.getDeclaringClass)
+        val d = _descriptorFor(am.getDeclaringClass)
         val prop = d.properties.find(p =>
           (p.field ++ p.getter ++ p.setter ++ p.param).exists(_  == a.getAnnotated)
         )
@@ -72,7 +76,7 @@ object ScalaAnnotationIntrospector extends JacksonAnnotationIntrospector
   override def hasCreatorAnnotation(a: Annotated): Boolean = {
     a match {
       case ac: AnnotatedConstructor =>
-        val d = descriptors.get(ac.getDeclaringClass)
+        val d = _descriptorFor(ac.getDeclaringClass)
         d.properties.exists(p => p.param.exists(_.constructor == ac.getAnnotated))
       case _ => false
     }

src/main/scala/com/fasterxml/jackson/module/scala/util/CacheLoaders.scala

@@ -1,7 +1,6 @@
 package com.fasterxml.jackson.module.scala.util
 
 object Implicits
-  extends CacheLoaders
-  with    Classes
+  extends Classes
   with    Options
   with    Strings

src/main/scala/com/fasterxml/jackson/module/scala/util/Implicits.scala

@@ -3,10 +3,8 @@ package module.scala
 package ser
 
 import java.io.ByteArrayOutputStream
-import javax.annotation.Nonnull
-
-import databind.{ObjectMapper, PropertyNamingStrategy}
 
+import com.fasterxml.jackson.databind.{ObjectMapper, PropertyNamingStrategy}
 import com.google.common.base.Optional
 import org.junit.runner.RunWith
 import org.scalatest.junit.JUnitRunner
@@ -15,8 +13,8 @@ import org.scalatest.{Matchers, Outcome, fixture}
 import scala.beans.BeanProperty
 
 class PojoWrittenInScala {
-  @Nonnull @BeanProperty var optFoo: Optional[String] = Optional.absent()
-  @Nonnull @BeanProperty var bar: Int = 0
+  @BeanProperty var optFoo: Optional[String] = Optional.absent()
+  @BeanProperty var bar: Int = 0
 }
 
 @RunWith(classOf[JUnitRunner])