/*
* Copyright 2009 Geir Magnusson Jr.
*
* 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 voldemort.store.noop;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import voldemort.VoldemortException;
import voldemort.store.AbstractStorageEngine;
import voldemort.store.NoSuchCapabilityException;
import voldemort.store.StoreCapabilityType;
import voldemort.store.StoreUtils;
import voldemort.utils.ByteArray;
import voldemort.utils.ClosableIterator;
import voldemort.utils.Pair;
import voldemort.versioning.Version;
import voldemort.versioning.Versioned;
/**
* Implementation of a store that does the least amount possible. It will
* 'reflect' values sent to it so that it can be tested with real values. It's
* being done this way to avoid coupling the engine or it's configuration with
* knowledge of the serializer being used
*
*/
public class NoopStorageEngine extends AbstractStorageEngine<ByteArray, byte[], byte[]> {
protected boolean dataReflect;
protected ByteArray key;
protected Versioned<byte[]> value;
protected List<Versioned<byte[]>> dataList = new MyList();
protected Map<ByteArray, List<Versioned<byte[]>>> dataMap = new MyMap();
public NoopStorageEngine(String name, boolean reflect) {
super(name);
this.dataReflect = reflect;
}
@Override
public ClosableIterator<Pair<ByteArray, Versioned<byte[]>>> entries(int partition) {
throw new UnsupportedOperationException("Partition based entries scan not supported for this storage type");
}
@Override
public ClosableIterator<ByteArray> keys(int partition) {
throw new UnsupportedOperationException("Partition based key scan not supported for this storage type");
}
@Override
public List<Versioned<byte[]>> get(ByteArray key, byte[] transforms) throws VoldemortException {
return dataList;
}
@Override
public Map<ByteArray, List<Versioned<byte[]>>> getAll(Iterable<ByteArray> keys,
Map<ByteArray, byte[]> transforms)
throws VoldemortException {
return dataMap;
}
@Override
public List<Version> getVersions(ByteArray key) {
return StoreUtils.getVersions(get(key, null));
}
@Override
public void put(ByteArray key, Versioned<byte[]> value, byte[] transforms)
throws VoldemortException {
if(dataReflect) {
this.key = key;
this.value = value;
}
}
@Override
public boolean delete(ByteArray key, Version version) throws VoldemortException {
return true;
}
@Override
public Object getCapability(StoreCapabilityType capability) {
throw new NoSuchCapabilityException(capability, getName());
}
class MyMap extends HashMap<ByteArray, List<Versioned<byte[]>>> {
public static final long serialVersionUID = 1;
@Override
public List<Versioned<byte[]>> get(Object key) {
return dataList;
}
}
class MyList extends ArrayList<Versioned<byte[]>> {
public static final long serialVersionUID = 1;
@Override
public Versioned<byte[]> get(int index) {
return value;
}
@Override
public int size() {
return value == null ? 0 : 1;
}
}
}