Expiration based on a Value's property? about bitfaster.caching HOT 2 CLOSED

public sealed class ConcurrentTLru<K, V> 
: ConcurrentLruCore<K, V, LongTickCountLruItem<K, V>, TLruLongTicksPolicy<K, V>, TelemetryPolicy<K, V>>
{
}

public sealed class NewConcurrentTLru<K, V>
 : ConcurrentLruCore<K, V, LongTickCountLruItem<K, V>, PerValueTLruLongTicksPolicy<K, V>, TelemetryPolicy<K, V>>
{
    public NewConcurrentTLru(int capacity, Func<V, TimeSpan> getTimeToLive)
     : base(Environment.ProcessorCount, 
        new FavorWarmPartition(capacity), 
        EqualityComparer<K>.Default, 
        new PerValueTLruLongTicksPolicy<K, V>(getTimeToLive), 
        default)
    {
    }
}

public readonly struct PerValueTLruLongTicksPolicy<K, V> : IItemPolicy<K, V, LongTickCountLruItem<K, V>>
{
    private static readonly double stopwatchAdjustmentFactor = Stopwatch.Frequency / (double)TimeSpan.TicksPerSecond;
    private readonly long epoch;
    private readonly Func<V, long> getTimeToLive;

    public PerValueTLruLongTicksPolicy(Func<V, TimeSpan> getTimeToLive)
        : this(v => PerValueTLruLongTicksPolicy<K, V>.ToTicks(getTimeToLive(v)))
    {   
    }

    public PerValueTLruLongTicksPolicy(Func<V, long> getTimeToLive)
    {
        this.epoch = Stopwatch.GetTimestamp();
        this.getTimeToLive = getTimeToLive;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public LongTickCountLruItem<K, V> CreateItem(K key, V value)
    {
        long ttl = this.getTimeToLive(value);
        ttl -= Stopwatch.GetTimestamp() - epoch;
        return new LongTickCountLruItem<K, V>(key, value, ttl);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void Touch(LongTickCountLruItem<K, V> item)
    {
        item.WasAccessed = true;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void Update(LongTickCountLruItem<K, V> item)
    {
        long ttl = this.getTimeToLive(item.Value);
        ttl -= Stopwatch.GetTimestamp() - epoch;
        item.TickCount = ttl;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public bool ShouldDiscard(LongTickCountLruItem<K, V> item)
    {
        if (Stopwatch.GetTimestamp() - item.TickCount > this.epoch)
        {
            return true;
        }

        return false;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public bool CanDiscard()
    {
        return true;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ItemDestination RouteHot(LongTickCountLruItem<K, V> item)
    {
        if (this.ShouldDiscard(item))
        {
            return ItemDestination.Remove;
        }

        if (item.WasAccessed)
        {
            return ItemDestination.Warm;
        }

        return ItemDestination.Cold;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ItemDestination RouteWarm(LongTickCountLruItem<K, V> item)
    {
        if (this.ShouldDiscard(item))
        {
            return ItemDestination.Remove;
        }

        if (item.WasAccessed)
        {
            return ItemDestination.Warm;
        }

        return ItemDestination.Cold;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public ItemDestination RouteCold(LongTickCountLruItem<K, V> item)
    {
        if (this.ShouldDiscard(item))
        {
            return ItemDestination.Remove;
        }

        if (item.WasAccessed)
        {
            return ItemDestination.Warm;
        }

        return ItemDestination.Remove;
    }


    // This no longer makes sense
    public TimeSpan TimeToLive => TimeSpan.Zero;

    public static long ToTicks(TimeSpan timespan)
    {
        return (long)(timespan.Ticks * stopwatchAdjustmentFactor);
    }

    public static TimeSpan FromTicks(long ticks)
    { 
        return TimeSpan.FromTicks((long)(ticks / stopwatchAdjustmentFactor));
    }
}

Func<string, TimeSpan> getTimeToLive = { TimeSpan.FromSeconds(1) };

ICache<int, strimg> lru = new ConcurrentLruBuilder<int, string>()
                .WithExpireAfterWrite(getTimeToLive)
                .Build();