Class AbstractArrAPI

Lib/src/main/java/me/egg82/arr/common/AbstractArrAPI.java:35–443

import java.util.concurrent.TimeUnit;

public abstract class AbstractArrAPI implements ArrAPI {
    protected final Logger logger = LoggerFactory.getLogger(getClass());

    private final ConcurrentMap<Class<? extends FetchableAPIObject>, @Nullable Constructor<?>> constructors = new ConcurrentHashMap<>();
    private final ConcurrentMap<Class<? extends APIObject>, @Nullable Constructor<?>> genericConstructors = new ConcurrentHashMap<>();
    private final ConcurrentMap<Class<? extends FetchableAPIObject>, @Nullable Object> unknowns = new ConcurrentHashMap<>();

    private final ExpiringMap<Pair<Class<? extends FetchableAPIObject>, String>, @Nullable Object> cache = ExpiringMap.builder().expirationPolicy(ExpirationPolicy.CREATED).variableExpiration().build();
    private final ExpiringMap<Pair<ObjectIntPair<Class<? extends FetchableAPIObject>>, String>, @Nullable Object> idCache = ExpiringMap.builder().expirationPolicy(ExpirationPolicy.CREATED).variableExpiration().build();

    protected final String baseUrl;
    protected final String apiKey;
    protected final int id;

    public AbstractArrAPI(@NotNull String baseUrl, @NotNull String apiKey, int id) {
        this.baseUrl = baseUrl;
        this.apiKey = apiKey;
        this.id = id;
    }

    @Override
    public @NotNull String baseUrl() {
        return this.baseUrl;
    }

    @Override
    public @NotNull String apiKey() {
        return this.apiKey;
    }

    @Override
    public <T extends FetchableAPIObject> @Nullable T fetch(@NotNull Class<T> type, @Nullable Map<String, @NotNull Object> params) {
        Tristate memoryCache = CacheConfigVars.getTristate(CacheConfigVars.USE_MEMORY_CACHE);
        Tristate fileCache = CacheConfigVars.getTristate(CacheConfigVars.USE_FILE_CACHE);
        if ((memoryCache == Tristate.AUTO && fileCache == Tristate.AUTO && !isCacheWritable()) || (memoryCache == Tristate.AUTO && fileCache == Tristate.FALSE) || memoryCache == Tristate.TRUE) {
            Pair<Class<? extends FetchableAPIObject>, String> key = Pair.of(type, encode(params));
            T r = type.cast(cache.computeIfAbsent(key, k -> fetchInternal(type, params)));
            if (r != null) {
                Duration expires = r.expiresIn();
                cache.setExpiration(key, expires.toMillis(), TimeUnit.MILLISECONDS);
            }
            return r;
        }
        return fetchInternal(type, params);
    }

    private <T extends FetchableAPIObject> @Nullable T fetchInternal(@NotNull Class<T> type, @Nullable Map<String, @NotNull Object> params) {
        T cache = getCache(type, params);
        if (cache != null) {
            if (params == null || params.isEmpty()) {
                logger.debug("Loaded {} from cache ({}_{})", type.getSimpleName(), this.type(), this.id);
            } else {
                logger.debug("Loaded {} ({}) from cache ({}_{})", type.getSimpleName(), encode(params), this.type(), this.id);
            }
            return cache;
        }

        T unknown = buildUnknown(type);