org.ehcache.jsr107.Eh107CompleteConfiguration Maven / Gradle / Ivy

Go to download
/*
 * Copyright Terracotta, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.ehcache.jsr107;

import org.ehcache.config.CacheConfiguration;
import org.ehcache.impl.config.copy.DefaultCopierConfiguration;
import org.ehcache.impl.copy.IdentityCopier;
import org.ehcache.spi.service.ServiceConfiguration;

import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

import javax.cache.configuration.CacheEntryListenerConfiguration;
import javax.cache.configuration.CompleteConfiguration;
import javax.cache.configuration.Configuration;
import javax.cache.configuration.Factory;
import javax.cache.expiry.EternalExpiryPolicy;
import javax.cache.expiry.ExpiryPolicy;
import javax.cache.integration.CacheLoader;
import javax.cache.integration.CacheWriter;

/**
 * @author teck
 */
class Eh107CompleteConfiguration extends Eh107Configuration implements CompleteConfiguration {

  private static final long serialVersionUID = -142083640934760400L;

  private final Class keyType;
  private final Class valueType;
  private final boolean isStoreByValue;
  private final boolean isReadThrough;
  private final boolean isWriteThrough;
  private volatile boolean isStatisticsEnabled;
  private volatile boolean isManagementEnabled;
  private final List> cacheEntryListenerConfigs = new CopyOnWriteArrayList<>();
  private final Factory> cacheLoaderFactory;
  private final Factory> cacheWriterFactory;
  private final Factory expiryPolicyFactory;

  private final transient CacheConfiguration ehcacheConfig;


  Eh107CompleteConfiguration(Configuration config) {
    this(config, null);
  }

  Eh107CompleteConfiguration(Configuration config, org.ehcache.config.CacheConfiguration ehcacheConfig) {
    this(config, ehcacheConfig, false, false);
  }

  public Eh107CompleteConfiguration(Configuration config, final CacheConfiguration ehcacheConfig, boolean useEhcacheExpiry, boolean useEhcacheLoaderWriter) {
    this.ehcacheConfig = ehcacheConfig;
    this.keyType = config.getKeyType();
    this.valueType = config.getValueType();
    this.isStoreByValue = isStoreByValue(config, ehcacheConfig);

    Factory tempExpiryPolicyFactory = EternalExpiryPolicy.factoryOf();

    if (config instanceof CompleteConfiguration) {
      CompleteConfiguration completeConfig = (CompleteConfiguration) config;
      this.isReadThrough = completeConfig.isReadThrough();
      this.isWriteThrough = completeConfig.isWriteThrough();
      this.isStatisticsEnabled = completeConfig.isStatisticsEnabled();
      this.isManagementEnabled = completeConfig.isManagementEnabled();

      if (useEhcacheLoaderWriter) {
        this.cacheLoaderFactory = createThrowingFactory();
        this.cacheWriterFactory = createThrowingFactory();
      } else {
        this.cacheLoaderFactory = completeConfig.getCacheLoaderFactory();
        this.cacheWriterFactory = completeConfig.getCacheWriterFactory();
      }

      tempExpiryPolicyFactory = completeConfig.getExpiryPolicyFactory();
      for (CacheEntryListenerConfiguration listenerConfig : completeConfig.getCacheEntryListenerConfigurations()) {
        cacheEntryListenerConfigs.add(listenerConfig);
      }
    } else {
      this.isReadThrough = false;
      this.isWriteThrough = false;
      this.isStatisticsEnabled = false;
      this.isManagementEnabled = false;
      this.cacheLoaderFactory = null;
      this.cacheWriterFactory = null;
    }

    if (useEhcacheExpiry) {
      tempExpiryPolicyFactory = createThrowingFactory();
    }

    this.expiryPolicyFactory = tempExpiryPolicyFactory;
  }

  private static  boolean isStoreByValue(Configuration config, CacheConfiguration ehcacheConfig) {
    if(ehcacheConfig != null) {
      Collection> serviceConfigurations = ehcacheConfig.getServiceConfigurations();
      for (ServiceConfiguration serviceConfiguration : serviceConfigurations) {
        if (serviceConfiguration instanceof DefaultCopierConfiguration) {
          DefaultCopierConfiguration copierConfig = (DefaultCopierConfiguration)serviceConfiguration;
          if(copierConfig.getType().equals(DefaultCopierConfiguration.Type.VALUE)) {
            if(copierConfig.getClazz().isAssignableFrom(IdentityCopier.class)) {
              return false;
            } else {
              return true;
            }
          }
        }
      }
    }
    return config.isStoreByValue();
  }

  @Override
  public Class getKeyType() {
    return this.keyType;
  }

  @Override
  public Class getValueType() {
    return this.valueType;
  }

  @Override
  public boolean isStoreByValue() {
    return this.isStoreByValue;
  }

  @Override
  public boolean isReadThrough() {
    return this.isReadThrough;
  }

  @Override
  public boolean isWriteThrough() {
    return this.isWriteThrough;
  }

  @Override
  public boolean isStatisticsEnabled() {
    return this.isStatisticsEnabled;
  }

  @Override
  public boolean isManagementEnabled() {
    return this.isManagementEnabled;
  }

  @Override
  public Iterable> getCacheEntryListenerConfigurations() {
    return Collections.unmodifiableList(this.cacheEntryListenerConfigs);
  }

  @Override
  public Factory> getCacheLoaderFactory() {
    return this.cacheLoaderFactory;
  }

  @Override
  public Factory> getCacheWriterFactory() {
    return this.cacheWriterFactory;
  }

  @Override
  public Factory getExpiryPolicyFactory() {
    return this.expiryPolicyFactory;
  }

  @Override
  void setManagementEnabled(boolean isManagementEnabled) {
    this.isManagementEnabled = isManagementEnabled;
  }

  @Override
  void setStatisticsEnabled(boolean isStatisticsEnabled) {
    this.isStatisticsEnabled = isStatisticsEnabled;
  }

  @Override
  void addCacheEntryListenerConfiguration(CacheEntryListenerConfiguration listenerConfig) {
    this.cacheEntryListenerConfigs.add(listenerConfig);
  }

  @Override
  void removeCacheEntryListenerConfiguration(CacheEntryListenerConfiguration listenerConfig) {
    this.cacheEntryListenerConfigs.remove(listenerConfig);
  }

  @Override
  public  T unwrap(Class clazz) {
      return Unwrap.unwrap(clazz, this, ehcacheConfig);
  }

  private Object writeReplace() {
    throw new UnsupportedOperationException("Serialization of Ehcache provider configuration classes is not supported");
  }

  private  Factory createThrowingFactory() {
    return (Factory) () -> {
      throw new UnsupportedOperationException("Cannot convert from Ehcache type to JSR-107 factory");
    };
  }
}