org.terracotta.quartz.collections.SerializedToolkitStore Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of quartz Show documentation
Enterprise Job Scheduler
There is a newer version: 2.5.0-rc1
/*
 * All content copyright Terracotta, Inc., unless otherwise indicated. All rights reserved. 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.terracotta.quartz.collections;

import org.terracotta.toolkit.store.ToolkitStore;
import org.terracotta.toolkit.concurrent.locks.ToolkitReadWriteLock;
import org.terracotta.toolkit.config.Configuration;
import org.terracotta.toolkit.search.QueryBuilder;
import org.terracotta.toolkit.search.attribute.ToolkitAttributeExtractor;

import java.io.IOException;
import java.io.Serializable;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class SerializedToolkitStore implements ToolkitStore {
  private final ToolkitStore toolkitStore;

  public SerializedToolkitStore(ToolkitStore toolkitMap) {
    this.toolkitStore = toolkitMap;
  }

  @Override
  public int size() {
    return this.toolkitStore.size();
  }

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

  private static String serializeToString(Object key) {
    try {
      return SerializationHelper.serializeToString(key);
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }

  private static Object deserializeFromString(String key) {
    try {
      return SerializationHelper.deserializeFromString(key);
    } catch (IOException e) {
      throw new RuntimeException(e);
    } catch (ClassNotFoundException e) {
      throw new RuntimeException(e);
    }
  }

  @Override
  public boolean containsKey(Object key) {
    return this.toolkitStore.containsKey(serializeToString(key));
  }

  @Override
  public V get(Object key) {
    return this.toolkitStore.get(serializeToString(key));
  }

  @Override
  public V put(K key, V value) {
    return this.toolkitStore.put(serializeToString(key), value);
  }

  @Override
  public V remove(Object key) {
    return this.toolkitStore.remove(serializeToString(key));
  }

  @Override
  public void putAll(Map m) {
    Map tempMap = new HashMap();
    for (Entry entry : m.entrySet()) {
      tempMap.put(serializeToString(entry.getKey()), entry.getValue());
    }

    toolkitStore.putAll(tempMap);
  }

  @Override
  public void clear() {
    toolkitStore.clear();
  }

  @Override
  public Set keySet() {
    return new ToolkitKeySet(toolkitStore.keySet());
  }

  @Override
  public boolean isDestroyed() {
    return toolkitStore.isDestroyed();
  }

  @Override
  public void destroy() {
    toolkitStore.destroy();
  }

  @Override
  public String getName() {
    return toolkitStore.getName();
  }

  @Override
  public ToolkitReadWriteLock createLockForKey(K key) {
    return toolkitStore.createLockForKey(serializeToString(key));
  }

  @Override
  public void removeNoReturn(Object key) {
    toolkitStore.removeNoReturn(serializeToString(key));
  }

  @Override
  public void putNoReturn(K key, V value) {
    toolkitStore.putNoReturn(serializeToString(key), value);
  }

  @Override
  public Map getAll(Collection keys) {
    HashSet tempSet = new HashSet();
    for (K key : keys) {
      tempSet.add(serializeToString(key));
    }

    Map m = toolkitStore.getAll(tempSet);
    Map tempMap = m.isEmpty() ? Collections.EMPTY_MAP : new HashMap();

    for (Entry entry : m.entrySet()) {
      tempMap.put((K) deserializeFromString(entry.getKey()), entry.getValue());
    }

    return tempMap;
  }

  @Override
  public Configuration getConfiguration() {
    return toolkitStore.getConfiguration();
  }

  @Override
  public void setConfigField(String name, Serializable value) {
    toolkitStore.setConfigField(name, value);
  }

  @Override
  public boolean containsValue(Object value) {
    return toolkitStore.containsValue(value);
  }

  @Override
  public V putIfAbsent(K key, V value) {
    return toolkitStore.putIfAbsent(serializeToString(key), value);
  }

  @Override
  public Set> entrySet() {
    return new ToolkitEntrySet(this.toolkitStore.entrySet());
  }

  @Override
  public Collection values() {
    return this.toolkitStore.values();
  }

  @Override
  public boolean remove(Object key, Object value) {
    return this.toolkitStore.remove(serializeToString(key), value);
  }

  @Override
  public boolean replace(K key, V oldValue, V newValue) {
    return this.toolkitStore.replace(serializeToString(key), oldValue, newValue);
  }

  @Override
  public V replace(K key, V value) {
    return this.toolkitStore.replace(serializeToString(key), value);
  }

  private static class ToolkitEntrySet implements Set> {
    private final Set> set;

    public ToolkitEntrySet(Set> set) {
      this.set = set;
    }

    @Override
    public int size() {
      return set.size();
    }

    @Override
    public boolean isEmpty() {
      return set.isEmpty();
    }

    @Override
    public boolean contains(Object o) {
      if (!(o instanceof Map.Entry)) { return false; }

      Map.Entry entry = (java.util.Map.Entry) o;
      ToolkitMapEntry toolkitEntry = null;
      toolkitEntry = new ToolkitMapEntry(serializeToString(entry.getKey()), entry.getValue());
      return this.set.contains(toolkitEntry);
    }

    @Override
    public Iterator> iterator() {
      return new ToolkitEntryIterator(set.iterator());
    }

    @Override
    public Object[] toArray() {
      throw new UnsupportedOperationException();
    }

    @Override
    public  T[] toArray(T[] a) {
      throw new UnsupportedOperationException();
    }

    @Override
    public boolean add(java.util.Map.Entry e) {
      throw new UnsupportedOperationException();
    }

    @Override
    public boolean remove(Object o) {
      throw new UnsupportedOperationException();
    }

    @Override
    public boolean containsAll(Collection c) {
      throw new UnsupportedOperationException();
    }

    @Override
    public boolean addAll(Collection> c) {
      throw new UnsupportedOperationException();
    }

    @Override
    public boolean retainAll(Collection c) {
      throw new UnsupportedOperationException();
    }

    @Override
    public boolean removeAll(Collection c) {
      throw new UnsupportedOperationException();
    }

    @Override
    public void clear() {
      throw new UnsupportedOperationException();
    }
  }

  private static class ToolkitEntryIterator implements Iterator> {

    private final Iterator> iter;

    public ToolkitEntryIterator(Iterator> iter) {
      this.iter = iter;
    }

    @Override
    public boolean hasNext() {
      return iter.hasNext();
    }

    @Override
    public java.util.Map.Entry next() {
      Map.Entry entry = iter.next();
      if (entry == null) { return null; }
      return new ToolkitMapEntry(deserializeFromString(entry.getKey()), entry.getValue());
    }

    @Override
    public void remove() {
      iter.remove();
    }

  }

  private static class ToolkitMapEntry implements Map.Entry {
    private final K k;
    private final V v;

    public ToolkitMapEntry(K k, V v) {
      this.k = k;
      this.v = v;
    }

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

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

    @Override
    public V setValue(V value) {
      throw new UnsupportedOperationException();
    }

  }

  private static class ToolkitKeySet implements Set {

    private final Set set;

    public ToolkitKeySet(Set set) {
      this.set = set;
    }

    @Override
    public int size() {
      return set.size();
    }

    @Override
    public boolean isEmpty() {
      return set.isEmpty();
    }

    @Override
    public boolean contains(Object o) {
      return set.contains(serializeToString(o));
    }

    @Override
    public Iterator iterator() {
      return new ToolkitKeyIterator(set.iterator());
    }

    @Override
    public Object[] toArray() {
      throw new UnsupportedOperationException();
    }

    @Override
    public  T[] toArray(T[] a) {
      throw new UnsupportedOperationException();
    }

    @Override
    public boolean add(K e) {
      throw new UnsupportedOperationException();
    }

    @Override
    public boolean remove(Object o) {
      throw new UnsupportedOperationException();
    }

    @Override
    public boolean containsAll(Collection c) {
      throw new UnsupportedOperationException();
    }

    @Override
    public boolean addAll(Collection c) {
      throw new UnsupportedOperationException();
    }

    @Override
    public boolean retainAll(Collection c) {
      throw new UnsupportedOperationException();
    }

    @Override
    public boolean removeAll(Collection c) {
      throw new UnsupportedOperationException();
    }

    @Override
    public void clear() {
      throw new UnsupportedOperationException();
    }
  }

  private static class ToolkitKeyIterator implements Iterator {

    private final Iterator iter;

    public ToolkitKeyIterator(Iterator iter) {
      this.iter = iter;
    }

    @Override
    public boolean hasNext() {
      return iter.hasNext();
    }

    @Override
    public K next() {
      String k = iter.next();
      if (k == null) { return null; }
      return (K) deserializeFromString(k);
    }

    @Override
    public void remove() {
      iter.remove();
    }

  }

  @Override
  public void setAttributeExtractor(ToolkitAttributeExtractor attrExtractor) {
     this.toolkitStore.setAttributeExtractor(attrExtractor);
  }

  @Override
  public QueryBuilder createQueryBuilder() {
    throw new UnsupportedOperationException();
  }

}