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

Go to download
Show more of this group Show more artifacts with this name
Show all versions of ehcache-107 Show documentation
The JSR-107 compatibility module of Ehcache 3
There is a newer version: 3.10.8
/*
 * 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 java.io.Closeable;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import static java.util.Collections.emptyMap;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import javax.cache.Cache;

import javax.cache.integration.CacheLoader;
import javax.cache.integration.CacheWriter;
import org.ehcache.spi.loaderwriter.BulkCacheWritingException;

import org.ehcache.spi.loaderwriter.CacheLoaderWriter;

/**
 * @author teck
 */
class Eh107CacheLoaderWriter implements CacheLoaderWriter, Closeable {

  private final CacheLoader cacheLoader;
  private final CacheWriter cacheWriter;

  Eh107CacheLoaderWriter(CacheLoader cacheLoader, CacheWriter cacheWriter) {
    this.cacheLoader = cacheLoader;
    this.cacheWriter = cacheWriter;
  }

  @Override
  public V load(K key) throws Exception {
    if (cacheLoader == null) {
      return null;
    } else {
      return cacheLoader.load(key);
    }
  }

  @Override
  public Map loadAll(Iterable keys) throws Exception {
    if (cacheLoader == null) {
      return emptyMap();
    } else {
      return cacheLoader.loadAll(keys);
    }
  }

  @Override
  public void write(K key, V value) throws Exception {
    if (cacheWriter != null) {
      cacheWriter.write(cacheEntryFor(key, value));
    }
  }

  @Override
  public void delete(K key) throws Exception {
    if (cacheWriter != null) {
      cacheWriter.delete(key);
    }
  }

  @Override
  public void deleteAll(Iterable keys) throws Exception {
    if (cacheWriter != null) {
      Set allKeys = new HashSet();
      for (K key : keys) {
        allKeys.add(key);
      }

      try {
        cacheWriter.deleteAll(allKeys);
      } catch (Exception e) {
        // the remaining keys were not written per 107 spec
        Map failures = failures(allKeys, e);
        Set successes = successes(keys, failures.keySet());
        throw new BulkCacheWritingException(failures, successes);
      }
    }
  }

  private Set successes(Iterable keys, Set failures) {
    Set set = new HashSet();
    for (K key : keys) {
      if (!failures.contains(key)) {
        set.add(key);
      }
    }
    return set;
  }

  private Map failures(Set keys, Exception e) {
    Map map = new HashMap(keys.size());
    for (K key : keys) {
      map.put(key, e);
    }
    return map;
  }

  @Override
  public void writeAll(Iterable> entries) throws Exception {
    if (cacheWriter != null) {
      Collection> toWrite = new ArrayList>();
      for (Map.Entry entry : entries) {
        toWrite.add(cacheEntryFor(entry.getKey(), entry.getValue()));
      }

      try {
        cacheWriter.writeAll(toWrite);
      } catch (Exception e) {
        // the remaining entries were not written per 107 spec
        Map failures = new HashMap();
        for (Cache.Entry entry : toWrite) {
          failures.put(entry.getKey(), e);
        }

        Set successes = new HashSet();
        for (Map.Entry entry : entries) {
          K key = entry.getKey();
          if (!failures.containsKey(key)) {
            successes.add(key);
          }
        }

        throw new BulkCacheWritingException(failures, successes);
      }
    }
  }

  @Override
  public void close() throws IOException {
    try {
      if (cacheLoader instanceof Closeable) {
        ((Closeable)cacheLoader).close();
      }
    } finally {
      if (cacheWriter instanceof Closeable) {
        ((Closeable)cacheWriter).close();
      }
    }
  }

  private static  Cache.Entry cacheEntryFor(K key, V value) {
    return new Entry(key, value);
  }

  static class Entry implements Cache.Entry {

    private final K key;
    private final V value;

    Entry(K key, V value) {
      this.key = key;
      this.value = value;
    }

    @Override
    public K getKey() {
      return key;
    }

    @Override
    public V getValue() {
      return value;
    }

    @Override
    public  T unwrap(Class clazz) {
      throw new IllegalArgumentException();
    }

    @Override
    public int hashCode() {
      return (key == null ? 0 : key.hashCode()) ^
          (value == null ? 0 : value.hashCode());
    }

    @Override
    public boolean equals(Object obj) {
      if (obj instanceof Entry) {
        Entry other = (Entry) obj;

        Object key1 = getKey();
        Object key2 = other.getKey();
        if (key1 == key2 || (key1 != null && key1.equals(key2))) {
          Object value1 = getValue();
          Object value2 = other.getValue();
          if (value1 == value2 || (value1 != null && value1.equals(value2)))
            return true;
        }
      }
      return false;
    }
  }
}