com.sportradar.unifiedodds.sdk.di.InternalCachesProviderImpl Maven / Gradle / Ivy

package com.sportradar.unifiedodds.sdk.di;

import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import com.sportradar.unifiedodds.sdk.caching.*;
import com.sportradar.unifiedodds.sdk.caching.ci.markets.MarketDescriptionCI;
import com.sportradar.unifiedodds.sdk.caching.ci.markets.VariantDescriptionCI;
import com.sportradar.utils.URN;

import java.util.Date;
import java.util.concurrent.TimeUnit;

/**
 * Created on 2019-03-29
 *
 * @author e.roznik
 */
class InternalCachesProviderImpl implements InternalCachesProvider {
    private final Cache sportDataCache;
    private final Cache categoryDataCache;
    private final Cache sportEventCache;
    private final Cache playerProfileCache;
    private final Cache competitorCache;
    private final Cache simpleTeamCompetitorCache;
    private final Cache sportEventStatusCache;
    private final Cache invariantMarketCache;
    private final Cache variantMarketCache;
    private final Cache dispatchedFixtureChanges;
    private final Cache variantDescriptionCache;
    private final Cache fixtureTimestampCache;

    InternalCachesProviderImpl() {
        sportDataCache = CacheBuilder.newBuilder().build();
        categoryDataCache = CacheBuilder.newBuilder().build();

        sportEventCache = CacheBuilder.newBuilder()
                .expireAfterWrite(12, TimeUnit.HOURS)
                .removalListener(new SDKCacheRemovalListener<>("SportEventCache"))
                .build();

        playerProfileCache = CacheBuilder.newBuilder()
                .expireAfterWrite(24, TimeUnit.HOURS)
                .removalListener(new SDKCacheRemovalListener<>("PlayerProfileCache"))
                .build();
        competitorCache = CacheBuilder.newBuilder()
                .expireAfterWrite(24, TimeUnit.HOURS)
                .removalListener(new SDKCacheRemovalListener<>("CompetitorProfileCache"))
                .build();
        simpleTeamCompetitorCache = CacheBuilder.newBuilder()
                .expireAfterWrite(24, TimeUnit.HOURS)
                .removalListener(new SDKCacheRemovalListener<>("SimpleTeamCompetitorCache"))
                .build();

        sportEventStatusCache = CacheBuilder.newBuilder()
                .expireAfterWrite(5, TimeUnit.MINUTES)
                .removalListener(new SDKCacheRemovalListener<>("SportEventStatusCache", true))
                .build();

        invariantMarketCache = CacheBuilder.newBuilder().build(); // timer cleanup & refresh
        variantDescriptionCache = CacheBuilder.newBuilder().build(); // timer cleanup & refresh
        variantMarketCache = CacheBuilder.newBuilder().expireAfterAccess(3, TimeUnit.HOURS).build();
        fixtureTimestampCache = CacheBuilder.newBuilder().expireAfterWrite(2, TimeUnit.MINUTES).build();

        dispatchedFixtureChanges = CacheBuilder.newBuilder().expireAfterWrite(1, TimeUnit.HOURS).build();
    }

    @Override
    public Cache getSportDataCache() {
        return sportDataCache;
    }

    @Override
    public Cache getCategoryDataCache() {
        return categoryDataCache;
    }

    @Override
    public Cache getSportEventCache() {
        return sportEventCache;
    }

    @Override
    public Cache getPlayerProfileCache() {
        return playerProfileCache;
    }

    @Override
    public Cache getCompetitorCache() {
        return competitorCache;
    }

    @Override
    public Cache getSimpleTeamCompetitorCache() {
        return simpleTeamCompetitorCache;
    }

    @Override
    public Cache getSportEventStatusCache() {
        return sportEventStatusCache;
    }

    @Override
    public Cache getInvariantMarketCache() {
        return invariantMarketCache;
    }

    @Override
    public Cache getVariantMarketCache() {
        return variantMarketCache;
    }

    @Override
    public Cache getDispatchedFixtureChanges() {
        return dispatchedFixtureChanges;
    }

    @Override
    public Cache getVariantDescriptionCache() {
        return variantDescriptionCache;
    }

    @Override
    public Cache getFixtureTimestampCache() {
        return fixtureTimestampCache;
    }
}