com.autonomousapps.services.InMemoryCache.kt Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of dependency-analysis-gradle-plugin Show documentation

Analyzes dependency usage in Android and JVM projects

There is a newer version: 2.0.2

Show newest version

@file:Suppress("UnstableApiUsage")

package com.autonomousapps.services

import com.autonomousapps.internal.AnalyzedJar
import com.autonomousapps.internal.AnnotationProcessor
import com.github.benmanes.caffeine.cache.Cache
import com.github.benmanes.caffeine.cache.Caffeine
import org.gradle.api.GradleException
import org.gradle.api.services.BuildService
import org.gradle.api.services.BuildServiceParameters
import java.util.concurrent.ConcurrentSkipListMap
import java.util.concurrent.atomic.AtomicBoolean

abstract class InMemoryCache : BuildService {
  private val jars: MutableMap = ConcurrentSkipListMap()
  private val classes: MutableMap = ConcurrentSkipListMap()

  internal fun updateJars(jarName: String) {
    jars.merge(jarName, 1) { oldValue, increment -> oldValue + increment }
  }

  internal fun updateClasses(className: String) {
    classes.merge(className, 1) { oldValue, increment -> oldValue + increment }
  }

  internal fun jars(): Map = jars
  internal fun classes(): Map = classes

  internal val largestJarCount by lazy { jars.maxBy { it.value } }
  internal val largestClassesCount by lazy { classes.maxBy { it.value } }

  /*
   * Errors.
   */

  private val errors = mutableListOf()

  internal fun error(t: Throwable) {
    errors.add(t)
  }

  internal fun errors(): List = errors

  internal val hasThrown = AtomicBoolean(false)

  /*
   * Caches.
   */

  private inline fun  newCache(maxSize: Long = maxSize()): Cache {
    val builder = Caffeine.newBuilder()
    if (maxSize >= 0) builder.maximumSize(maxSize)
    return builder.build()
  }

  // TODO document and/or provide DSL
  private fun maxSize(): Long {
    val sysProp = System.getProperty("dependency.analysis.cache.max")
    return try {
      sysProp?.toLong() ?: -1
    } catch (e: Exception) {
      throw GradleException("$sysProp is not a valid cache size. Provide a long value", e)
    }
  }

  private val analyzedJars: Cache = newCache()
  private val constantMembers: Cache> = newCache()
  private val inlineMembers: Cache> = newCache()
  private val procs: Cache = newCache()

  internal fun analyzedJar(name: String): AnalyzedJar? = analyzedJars.asMap()[name]

  internal fun analyzedJars(name: String, analyzedJar: AnalyzedJar) {
    analyzedJars.asMap().putIfAbsent(name, analyzedJar)

  }

  fun constantMember(identifier: String): Set? = constantMembers.asMap()[identifier]

  internal fun constantMembers(identifier: String, constants: Set) {
    constantMembers.asMap().putIfAbsent(identifier, constants)
  }

  fun inlineMember(name: String): List? = inlineMembers.asMap()[name]

  fun inlineMembers(name: String, members: List) {
    inlineMembers.asMap().putIfAbsent(name, members)
  }

  fun proc(procName: String): AnnotationProcessor? = procs.asMap()[procName]

  fun procs(procName: String, proc: AnnotationProcessor) {
    procs.asMap().putIfAbsent(procName, proc)
  }
}