Eh107CompleteConfiguration.java

/*
 * 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.io.ObjectStreamException;
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<K, V> extends Eh107Configuration<K, V> implements CompleteConfiguration<K, V> {

  private static final long serialVersionUID = -142083640934760400L;

  private final Class<K> keyType;
  private final Class<V> valueType;
  private final boolean isStoreByValue;
  private final boolean isReadThrough;
  private final boolean isWriteThrough;
  private volatile boolean isStatisticsEnabled;
  private volatile boolean isManagementEnabled;
  private final List<CacheEntryListenerConfiguration<K, V>> cacheEntryListenerConfigs = new CopyOnWriteArrayList<CacheEntryListenerConfiguration<K, V>>();
  private final Factory<CacheLoader<K, V>> cacheLoaderFactory;
  private final Factory<CacheWriter<? super K, ? super V>> cacheWriterFactory;
  private final Factory<ExpiryPolicy> expiryPolicyFactory;

  private final transient CacheConfiguration<K, V> ehcacheConfig;


  Eh107CompleteConfiguration(Configuration<K, V> config) {
    this(config, null);
  }

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

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

    Factory<ExpiryPolicy> tempExpiryPolicyFactory = EternalExpiryPolicy.factoryOf();

    if (config instanceof CompleteConfiguration) {
      CompleteConfiguration<K, V> completeConfig = (CompleteConfiguration<K, V>) 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<K, V> 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 <K, V> boolean isStoreByValue(Configuration<K, V> config, CacheConfiguration<K, V> ehcacheConfig) {
    if(ehcacheConfig != null) {
      Collection<ServiceConfiguration<?>> 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<K> getKeyType() {
    return this.keyType;
  }

  @Override
  public Class<V> 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<CacheEntryListenerConfiguration<K, V>> getCacheEntryListenerConfigurations() {
    return Collections.unmodifiableList(this.cacheEntryListenerConfigs);
  }

  @Override
  public Factory<CacheLoader<K, V>> getCacheLoaderFactory() {
    return this.cacheLoaderFactory;
  }

  @Override
  public Factory<CacheWriter<? super K, ? super V>> getCacheWriterFactory() {
    return this.cacheWriterFactory;
  }

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

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

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

  @Override
  void addCacheEntryListenerConfiguration(CacheEntryListenerConfiguration<K, V> listenerConfig) {
    this.cacheEntryListenerConfigs.add(listenerConfig);
  }

  @Override
  void removeCacheEntryListenerConfiguration(CacheEntryListenerConfiguration<K, V> listenerConfig) {
    this.cacheEntryListenerConfigs.remove(listenerConfig);
  }

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

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

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