Class CacheImpl

packages/effect/src/internal/cache.ts:312–683

})

class CacheImpl<in out Key, in out Value, in out Error> implements Cache.Cache<Key, Value, Error> {
  readonly [CacheTypeId] = cacheVariance
  readonly [ConsumerCacheTypeId] = consumerCacheVariance
  readonly cacheState: CacheState<Key, Value, Error>
  constructor(
    readonly capacity: number,
    readonly context: Context.Context<any>,
    readonly fiberId: FiberId.FiberId,
    readonly lookup: Cache.Lookup<Key, Value, Error, any>,
    readonly timeToLive: (exit: Exit.Exit<Value, Error>) => Duration.DurationInput
  ) {
    this.cacheState = initialCacheState()
  }

  get(key: Key): Effect.Effect<Value, Error> {
    return core.map(this.getEither(key), Either.merge)
  }

  get cacheStats(): Effect.Effect<Cache.CacheStats> {
    return core.sync(() =>
      makeCacheStats({
        hits: this.cacheState.hits,
        misses: this.cacheState.misses,
        size: MutableHashMap.size(this.cacheState.map)
      })
    )
  }

  getOption(key: Key): Effect.Effect<Option.Option<Value>, Error> {
    return core.suspend(() =>
      Option.match(MutableHashMap.get(this.cacheState.map, key), {
        onNone: () => {
          const mapKey = makeMapKey(key)
          this.trackAccess(mapKey)
          this.trackMiss()
          return core.succeed(Option.none<Value>())
        },
        onSome: (value) => this.resolveMapValue(value)
      })
    )
  }

  getOptionComplete(key: Key): Effect.Effect<Option.Option<Value>> {
    return core.suspend(() =>
      Option.match(MutableHashMap.get(this.cacheState.map, key), {
        onNone: () => {
          const mapKey = makeMapKey(key)
          this.trackAccess(mapKey)
          this.trackMiss()
          return core.succeed(Option.none<Value>())
        },
        onSome: (value) => this.resolveMapValue(value, true) as Effect.Effect<Option.Option<Value>>
      })
    )
  }

  contains(key: Key): Effect.Effect<boolean> {
    return core.sync(() => MutableHashMap.has(this.cacheState.map, key))