Adding commands for the AsyncConsistentTreeMap, commands relating to transactions are temporarily removed.
Change-Id: Iec5b972fb9de2dbfdfbe315b330778139ba92c90
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AsyncConsistentTreeMapCommands.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AsyncConsistentTreeMapCommands.java
new file mode 100644
index 0000000..3915b86
--- /dev/null
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AsyncConsistentTreeMapCommands.java
@@ -0,0 +1,651 @@
+/*
+ * Copyright 2016-present Open Networking Laboratory
+ *
+ * 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.onosproject.store.primitives.resources.impl;
+
+import com.google.common.base.MoreObjects;
+import io.atomix.catalyst.buffer.BufferInput;
+import io.atomix.catalyst.buffer.BufferOutput;
+import io.atomix.catalyst.serializer.CatalystSerializable;
+import io.atomix.catalyst.serializer.SerializableTypeResolver;
+import io.atomix.catalyst.serializer.Serializer;
+import io.atomix.catalyst.serializer.SerializerRegistry;
+import io.atomix.catalyst.util.Assert;
+import io.atomix.copycat.Command;
+import io.atomix.copycat.Query;
+import org.onlab.util.Match;
+import org.onosproject.store.service.Versioned;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.NavigableMap;
+import java.util.NavigableSet;
+import java.util.Set;
+
+/**
+ * {@link org.onosproject.store.service.AsyncConsistentTreeMap} Resource
+ * state machine operations.
+ */
+public final class AsyncConsistentTreeMapCommands {
+
+ private AsyncConsistentTreeMapCommands() {
+ }
+
+ /**
+ * Abstract treeMap command.
+ */
+ @SuppressWarnings("serial")
+ public abstract static class TreeCommand<V>
+ implements Command<V>, CatalystSerializable {
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .toString();
+ }
+
+ @Override
+ public void writeObject(BufferOutput<?> buffer,
+ Serializer serializer) {
+ }
+
+ @Override
+ public void readObject(BufferInput<?> buffer, Serializer serializer) {
+ }
+ }
+
+ /**
+ * Abstract treeMap query.
+ */
+ @SuppressWarnings("serial")
+ public abstract static class TreeQuery<V>
+ implements Query<V>, CatalystSerializable {
+ @Override
+ public ConsistencyLevel consistency() {
+ return ConsistencyLevel.LINEARIZABLE_LEASE;
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .toString();
+ }
+
+ @Override
+ public void writeObject(BufferOutput<?> bufferOutput,
+ Serializer serializer) {
+
+ }
+
+ @Override
+ public void readObject(BufferInput<?> bufferInput,
+ Serializer serializer) {
+
+ }
+ }
+ /**
+ * Abstract key-based query.
+ */
+ @SuppressWarnings("serial")
+ public abstract static class KeyQuery<K> extends TreeQuery<K> {
+ protected String key;
+
+ public KeyQuery(String key) {
+ this.key = Assert.notNull(key, "key");
+ }
+
+ public KeyQuery() {
+ }
+
+ public String key() {
+ return key;
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .add("key", key)
+ .toString();
+ }
+
+ @Override
+ public void writeObject(BufferOutput<?> bufferOutput,
+ Serializer serializer) {
+ super.writeObject(bufferOutput, serializer);
+ serializer.writeObject(key, bufferOutput);
+ }
+
+ @Override
+ public void readObject(BufferInput<?> bufferInput,
+ Serializer serializer) {
+ super.readObject(bufferInput, serializer);
+ key = serializer.readObject(bufferInput);
+ }
+ }
+
+ /**
+ * Abstract value-based query.
+ */
+ @SuppressWarnings("serial")
+ public abstract static class ValueQuery<V> extends TreeQuery<V> {
+ protected byte[] value;
+
+ public ValueQuery() {}
+
+ public ValueQuery(byte[] value) {
+ this.value = Assert.notNull(value, "value");
+ }
+
+ public byte[] value() {
+ return value;
+ }
+
+ @Override
+ public void writeObject(BufferOutput<?> bufferOutput,
+ Serializer serializer) {
+ super.writeObject(bufferOutput, serializer);
+ serializer.writeObject(value, bufferOutput);
+ }
+
+ @Override
+ public void readObject(BufferInput<?> bufferInput,
+ Serializer serializer) {
+ super.readObject(bufferInput, serializer);
+ value = serializer.readObject(bufferInput);
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .add("value", value)
+ .toString();
+ }
+ }
+
+ /**
+ * Contains key command.
+ */
+ @SuppressWarnings("serial")
+ public static class ContainsKey extends KeyQuery<Boolean> {
+
+ public ContainsKey(String key) {
+ super(key);
+ }
+
+ public ContainsKey() {
+ }
+ }
+ /**
+ * Contains value command.
+ */
+ @SuppressWarnings("serial")
+ public static class ContainsValue extends ValueQuery<Boolean> {
+ public ContainsValue() {
+ }
+
+ public ContainsValue(byte[] value) {
+ super(value);
+ }
+
+ }
+
+ /**
+ * AsyncConsistentTreeMap update command.
+ */
+ @SuppressWarnings("serial")
+ public static class UpdateAndGet
+ extends TreeCommand<MapEntryUpdateResult<String, byte[]>> {
+ private String key;
+ private byte[] value;
+ private Match<byte[]> valueMatch;
+ private Match<Long> versionMatch;
+ public UpdateAndGet() {
+ }
+
+ public UpdateAndGet(String key,
+ byte[] value,
+ Match<byte[]> valueMatch,
+ Match<Long> versionMatch) {
+ this.key = key;
+ this.value = value;
+ this.valueMatch = valueMatch;
+ this.versionMatch = versionMatch;
+ }
+
+ public String key() {
+ return this.key;
+ }
+
+ public byte[] value() {
+ return this.value;
+ }
+
+ public Match<byte[]> valueMatch() {
+ return this.valueMatch;
+ }
+
+ public Match<Long> versionMatch() {
+ return this.versionMatch;
+ }
+
+ @Override
+ public CompactionMode compaction() {
+ return value == null ? CompactionMode.FULL : CompactionMode.QUORUM;
+ }
+
+ @Override
+ public void writeObject(BufferOutput<?> buffer,
+ Serializer serializer) {
+ super.writeObject(buffer, serializer);
+ serializer.writeObject(key, buffer);
+ serializer.writeObject(value, buffer);
+ serializer.writeObject(valueMatch, buffer);
+ serializer.writeObject(versionMatch, buffer);
+ }
+
+ @Override
+ public void readObject(BufferInput<?> buffer, Serializer serializer) {
+ super.readObject(buffer, serializer);
+ key = serializer.readObject(buffer);
+ value = serializer.readObject(buffer);
+ valueMatch = serializer.readObject(buffer);
+ versionMatch = serializer.readObject(buffer);
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .add("key", key)
+ .add("value", value)
+ .add("valueMatch", valueMatch)
+ .add("versionMatch", versionMatch)
+ .toString();
+ }
+ }
+
+ /**
+ * Get query command.
+ */
+ @SuppressWarnings("serial")
+ public static class Get extends KeyQuery<Versioned<byte[]>> {
+ public Get() {
+ }
+
+ public Get(String key) {
+ super(key);
+ }
+ }
+
+ /**
+ * Is empty query.
+ */
+ @SuppressWarnings("serial")
+ public static class IsEmpty extends TreeQuery<Boolean> {
+
+ }
+
+ /**
+ * Key set query.
+ */
+ @SuppressWarnings("serial")
+ public static class KeySet extends TreeQuery<Set<String>> {
+ }
+
+ /**
+ * Value set query.
+ */
+ @SuppressWarnings("serial")
+ public static class Values
+ extends TreeQuery<Collection<Versioned<byte[]>>> {
+ }
+
+ /**
+ * Entry set query.
+ */
+ @SuppressWarnings("serial")
+ public static class EntrySet
+ extends TreeQuery<Set<Map.Entry<String, Versioned<byte[]>>>> {
+ }
+
+ /**
+ * Size query.
+ */
+ @SuppressWarnings("serial")
+ public static class Size extends TreeQuery<Integer> {
+ }
+
+ /**
+ * Clear command.
+ */
+ @SuppressWarnings("serial")
+ public static class Clear
+ extends TreeCommand<MapEntryUpdateResult.Status> {
+ @Override
+ public CompactionMode compaction() {
+ return CompactionMode.FULL;
+ }
+ }
+
+ /**
+ * Change listen.
+ */
+ @SuppressWarnings("serial")
+ public static class Listen implements Command<Void>, CatalystSerializable {
+ @Override
+ public void writeObject(BufferOutput<?> buffer,
+ Serializer serializer) {
+ }
+
+ @Override
+ public void readObject(BufferInput<?> buffer, Serializer serializer) {
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .toString();
+ }
+ }
+
+ /**
+ * Change unlisten.
+ */
+ @SuppressWarnings("serial")
+ public static class Unlisten implements Command<Void>,
+ CatalystSerializable {
+ @Override
+ public void writeObject(BufferOutput<?> buffer,
+ Serializer serializer) {
+ }
+
+ @Override
+ public void readObject(BufferInput<?> buffer, Serializer serializer) {
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .toString();
+ }
+ }
+
+ /* Tree map specific commands below */
+
+ /**
+ * First key query.
+ */
+ @SuppressWarnings("serial")
+ public static class FirstKey<K> extends TreeQuery<K> {
+ }
+
+ /**
+ * Last key query.
+ */
+ @SuppressWarnings("serial")
+ public static class LastKey<K> extends TreeQuery<K> {
+ }
+
+ /**
+ * First entry query.
+ */
+ @SuppressWarnings("serial")
+ public static class FirstEntry<K, V> extends TreeQuery<Map.Entry<K, V>> {
+ }
+
+ /**
+ * Last entry query.
+ */
+ @SuppressWarnings("serial")
+ public static class LastEntry<K, V> extends TreeQuery<Map.Entry<K, V>> {
+ }
+
+ /**
+ * First entry query, if none exists returns null.
+ */
+ @SuppressWarnings("serial")
+ public static class PollFirstEntry<K, V>
+ extends TreeQuery<Map.Entry<K, V>> {
+ }
+
+ /**
+ * Last entry query, if none exists returns null.
+ */
+ @SuppressWarnings("serial")
+ public static class PollLastEntry<K, V>
+ extends TreeQuery<Map.Entry<K, V>> {
+ }
+
+ /**
+ * Query returns the entry associated with the largest key less than the
+ * passed in key.
+ */
+ @SuppressWarnings("serial")
+ public static class LowerEntry<K, V> extends KeyQuery<K> {
+ public LowerEntry() {
+ }
+
+ public LowerEntry(String key) {
+ super(key);
+ }
+ }
+
+ /**
+ * Query returns the largest key less than the specified key.
+ */
+ @SuppressWarnings("serial")
+ public static class LowerKey<K> extends KeyQuery<K> {
+ public LowerKey() {
+ }
+
+ public LowerKey(String key) {
+ super(key);
+ }
+ }
+
+ /**
+ * Query returns the entry associated with the largest key smaller than or
+ * equal to the specified key.
+ */
+ @SuppressWarnings("serial")
+ public static class FloorEntry<K, V> extends KeyQuery<Map.Entry<K, V>> {
+ public FloorEntry() {
+ }
+
+ public FloorEntry(String key) {
+ super(key);
+ }
+ }
+
+ /**
+ * Query returns the largest key smaller than or equal to the passed in
+ * key.
+ */
+ @SuppressWarnings("serial")
+ public static class FloorKey<K> extends KeyQuery<K> {
+ public FloorKey() {
+ }
+
+ public FloorKey(String key) {
+ super(key);
+ }
+ }
+
+ /**
+ * Returns the entry associated with the smallest key larger than or equal
+ * to the specified key.
+ */
+ @SuppressWarnings("serial")
+ public static class CeilingEntry<K, V> extends KeyQuery<Map.Entry<K, V>> {
+ public CeilingEntry() {
+ }
+
+ public CeilingEntry(String key) {
+ super(key);
+ }
+ }
+
+ /**
+ * Returns the smallest key larger than or equal to the specified key.
+ * @param <K>
+ */
+ @SuppressWarnings("serial")
+ public static class CeilingKey<K> extends KeyQuery<K> {
+ public CeilingKey() {
+ }
+
+ public CeilingKey(String key) {
+ super(key);
+ }
+ }
+
+ /**
+ * Returns the entry associated with the smallest key larger than the
+ * specified key.
+ */
+ @SuppressWarnings("serial")
+ public static class HigherEntry<K, V> extends KeyQuery<Map.Entry<K, V>> {
+ public HigherEntry() {
+ }
+
+ public HigherEntry(String key) {
+ super(key);
+ }
+ }
+
+ /**
+ * Returns the smallest key larger than the specified key.
+ */
+ @SuppressWarnings("serial")
+ public static class HigherKey<K> extends KeyQuery<K> {
+ public HigherKey() {
+ }
+
+ public HigherKey(String key) {
+ super(key);
+ }
+ }
+
+ @SuppressWarnings("serial")
+ public static class NavigableKeySet<K, V>
+ extends TreeQuery<NavigableSet<K>> {
+ }
+
+ @SuppressWarnings("serial")
+ public static class SubMap<K, V> extends TreeQuery<NavigableMap<K, V>> {
+ private K fromKey;
+ private K toKey;
+ private boolean inclusiveFrom;
+ private boolean inclusiveTo;
+
+ public SubMap() {
+ }
+
+ public SubMap(K fromKey, K toKey, boolean inclusiveFrom,
+ boolean inclusiveTo) {
+ this.fromKey = fromKey;
+ this.toKey = toKey;
+ this.inclusiveFrom = inclusiveFrom;
+ this.inclusiveTo = inclusiveTo;
+ }
+
+ @Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .add("getFromKey", fromKey)
+ .add("getToKey", toKey)
+ .add("inclusiveFrotBound", inclusiveFrom)
+ .add("inclusiveToBound", inclusiveTo)
+ .toString();
+ }
+
+ @Override
+ public void writeObject(BufferOutput<?> bufferOutput,
+ Serializer serializer) {
+ super.writeObject(bufferOutput, serializer);
+ serializer.writeObject(fromKey, bufferOutput);
+ serializer.writeObject(toKey, bufferOutput);
+ serializer.writeObject(inclusiveFrom, bufferOutput);
+ serializer.writeObject(inclusiveTo, bufferOutput);
+ }
+
+ @Override
+ public void readObject(BufferInput<?> bufferInput,
+ Serializer serializer) {
+ super.readObject(bufferInput, serializer);
+ fromKey = serializer.readObject(bufferInput);
+ toKey = serializer.readObject(bufferInput);
+ inclusiveFrom = serializer.readObject(bufferInput);
+ inclusiveTo = serializer.readObject(bufferInput);
+ }
+
+ public K fromKey() {
+ return fromKey;
+ }
+
+ public K toKey() {
+ return toKey;
+ }
+
+ public boolean isInclusiveFrom() {
+ return inclusiveFrom;
+ }
+
+ public boolean isInclusiveTo() {
+ return inclusiveTo;
+ }
+ }
+
+ /**
+ * Tree map command type resolver.
+ */
+ public static class TypeResolver implements SerializableTypeResolver {
+ @Override
+ public void resolve(SerializerRegistry registry) {
+ //NOTE the registration values must be unique throughout the
+ // project.
+ registry.register(ContainsKey.class, -1161);
+ registry.register(ContainsValue.class, -1162);
+ registry.register(Get.class, -1163);
+ registry.register(EntrySet.class, -1164);
+ registry.register(Values.class, -1165);
+ registry.register(KeySet.class, -1166);
+ registry.register(Clear.class, -1167);
+ registry.register(IsEmpty.class, -1168);
+ registry.register(Size.class, -1169);
+ registry.register(Listen.class, -1170);
+ registry.register(Unlisten.class, -1171);
+ //Transaction related commands will be added here with numbers
+ // -1172 to -1174
+ registry.register(UpdateAndGet.class, -1175);
+ registry.register(FirstKey.class, -1176);
+ registry.register(LastKey.class, -1177);
+ registry.register(FirstEntry.class, -1178);
+ registry.register(LastEntry.class, -1179);
+ registry.register(PollFirstEntry.class, -1180);
+ registry.register(PollLastEntry.class, -1181);
+ registry.register(LowerEntry.class, -1182);
+ registry.register(LowerKey.class, -1183);
+ registry.register(FloorEntry.class, -1184);
+ registry.register(FloorKey.class, -1185);
+ registry.register(CeilingEntry.class, -1186);
+ registry.register(CeilingKey.class, -1187);
+ registry.register(HigherEntry.class, -1188);
+ registry.register(HigherKey.class, -1189);
+ registry.register(SubMap.class, -1190);
+ registry.register(NavigableKeySet.class, -1191);
+ }
+ }
+}
diff --git a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentMapCommands.java b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentMapCommands.java
index 7e7b979..b83aa52 100644
--- a/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentMapCommands.java
+++ b/core/store/primitives/src/main/java/org/onosproject/store/primitives/resources/impl/AtomixConsistentMapCommands.java
@@ -156,6 +156,13 @@
}
@Override
+ public String toString() {
+ return MoreObjects.toStringHelper(getClass())
+ .add("value", value)
+ .toString();
+ }
+
+ @Override
public void writeObject(BufferOutput<?> buffer, Serializer serializer) {
super.writeObject(buffer, serializer);
serializer.writeObject(value, buffer);
@@ -192,13 +199,6 @@
public ContainsValue(byte[] value) {
super(value);
}
-
- @Override
- public String toString() {
- return MoreObjects.toStringHelper(getClass())
- .add("value", value)
- .toString();
- }
}
/**
@@ -453,14 +453,14 @@
}
/**
- * KeySet query.
+ * ValueSet query.
*/
@SuppressWarnings("serial")
public static class Values extends MapQuery<Collection<Versioned<byte[]>>> {
}
/**
- * KeySet query.
+ * EntrySet query.
*/
@SuppressWarnings("serial")
public static class EntrySet extends MapQuery<Set<Map.Entry<String, Versioned<byte[]>>>> {