AtomixAtomicCounterMapCommands.java

/*
 * Copyright 2017-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 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.copycat.Command;
import io.atomix.copycat.Query;

/**
 * Atomic counter map commands.
 */
public final class AtomixAtomicCounterMapCommands {
    private AtomixAtomicCounterMapCommands() {
    }

    public abstract static class AtomicCounterMapCommand<V> implements Command<V>, CatalystSerializable {
        @Override
        public CompactionMode compaction() {
            return CompactionMode.SNAPSHOT;
        }

        @Override
        public void writeObject(BufferOutput<?> buffer, Serializer serializer) {
        }

        @Override
        public void readObject(BufferInput<?> buffer, Serializer serializer) {
        }
    }

    public abstract static class AtomicCounterMapQuery<V> implements Query<V>, CatalystSerializable {
        @Override
        public void writeObject(BufferOutput<?> buffer, Serializer serializer) {
        }

        @Override
        public void readObject(BufferInput<?> buffer, Serializer serializer) {
        }
    }

    public abstract static class KeyCommand<V> extends AtomicCounterMapCommand<V> {
        private String key;

        public KeyCommand() {
        }

        public KeyCommand(String key) {
            this.key = key;
        }

        public String key() {
            return key;
        }

        @Override
        public void writeObject(BufferOutput<?> buffer, Serializer serializer) {
            buffer.writeString(key);
        }

        @Override
        public void readObject(BufferInput<?> buffer, Serializer serializer) {
            key = buffer.readString();
        }
    }

    public abstract static class KeyQuery<V> extends AtomicCounterMapQuery<V> {
        private String key;

        public KeyQuery() {
        }

        public KeyQuery(String key) {
            this.key = key;
        }

        public String key() {
            return key;
        }

        @Override
        public void writeObject(BufferOutput<?> buffer, Serializer serializer) {
            buffer.writeString(key);
        }

        @Override
        public void readObject(BufferInput<?> buffer, Serializer serializer) {
            key = buffer.readString();
        }
    }

    public static class KeyValueCommand<V> extends KeyCommand<V> {
        private long value;

        public KeyValueCommand() {
        }

        public KeyValueCommand(String key, long value) {
            super(key);
            this.value = value;
        }

        public long value() {
            return value;
        }

        @Override
        public void writeObject(BufferOutput<?> buffer, Serializer serializer) {
            super.writeObject(buffer, serializer);
            buffer.writeLong(value);
        }

        @Override
        public void readObject(BufferInput<?> buffer, Serializer serializer) {
            super.readObject(buffer, serializer);
            value = buffer.readLong();
        }
    }

    public static class Get extends KeyQuery<Long> {
        public Get() {
        }

        public Get(String key) {
            super(key);
        }
    }

    public static class Put extends KeyValueCommand<Long> {
        public Put() {
        }

        public Put(String key, long value) {
            super(key, value);
        }
    }

    public static class PutIfAbsent extends KeyValueCommand<Long> {
        public PutIfAbsent() {
        }

        public PutIfAbsent(String key, long value) {
            super(key, value);
        }
    }

    public static class Replace extends KeyCommand<Boolean> {
        private long replace;
        private long value;

        public Replace() {
        }

        public Replace(String key, long replace, long value) {
            super(key);
            this.replace = replace;
            this.value = value;
        }

        public long replace() {
            return replace;
        }

        public long value() {
            return value;
        }

        @Override
        public void writeObject(BufferOutput<?> buffer, Serializer serializer) {
            super.writeObject(buffer, serializer);
            buffer.writeLong(replace);
            buffer.writeLong(value);
        }

        @Override
        public void readObject(BufferInput<?> buffer, Serializer serializer) {
            super.readObject(buffer, serializer);
            replace = buffer.readLong();
            value = buffer.readLong();
        }
    }

    public static class Remove extends KeyCommand<Long> {
        public Remove() {
        }

        public Remove(String key) {
            super(key);
        }
    }

    public static class RemoveValue extends KeyValueCommand<Boolean> {
        public RemoveValue() {
        }

        public RemoveValue(String key, long value) {
            super(key, value);
        }
    }

    public static class IncrementAndGet extends KeyCommand<Long> {
        public IncrementAndGet() {
        }

        public IncrementAndGet(String key) {
            super(key);
        }
    }

    public static class DecrementAndGet extends KeyCommand<Long> {
        public DecrementAndGet(String key) {
            super(key);
        }

        public DecrementAndGet() {
        }
    }

    public static class GetAndIncrement extends KeyCommand<Long> {
        public GetAndIncrement() {
        }

        public GetAndIncrement(String key) {
            super(key);
        }
    }

    public static class GetAndDecrement extends KeyCommand<Long> {
        public GetAndDecrement() {
        }

        public GetAndDecrement(String key) {
            super(key);
        }
    }

    public abstract static class DeltaCommand extends KeyCommand<Long> {
        private long delta;

        public DeltaCommand() {
        }

        public DeltaCommand(String key, long delta) {
            super(key);
            this.delta = delta;
        }

        public long delta() {
            return delta;
        }

        @Override
        public void writeObject(BufferOutput<?> buffer, Serializer serializer) {
            super.writeObject(buffer, serializer);
            buffer.writeLong(delta);
        }

        @Override
        public void readObject(BufferInput<?> buffer, Serializer serializer) {
            super.readObject(buffer, serializer);
            delta = buffer.readLong();
        }
    }

    public static class AddAndGet extends DeltaCommand {
        public AddAndGet() {
        }

        public AddAndGet(String key, long delta) {
            super(key, delta);
        }
    }

    public static class GetAndAdd extends DeltaCommand {
        public GetAndAdd() {
        }

        public GetAndAdd(String key, long delta) {
            super(key, delta);
        }
    }

    public static class Size extends AtomicCounterMapQuery<Integer> {
    }

    public static class IsEmpty extends AtomicCounterMapQuery<Boolean> {
    }

    public static class Clear extends AtomicCounterMapCommand<Void> {
    }

    /**
     * Counter map command type resolver.
     */
    public static class TypeResolver implements SerializableTypeResolver {
        @Override
        public void resolve(SerializerRegistry registry) {
            registry.register(Get.class, -790);
            registry.register(Put.class, -791);
            registry.register(PutIfAbsent.class, -792);
            registry.register(Replace.class, -793);
            registry.register(Remove.class, -794);
            registry.register(RemoveValue.class, -795);
            registry.register(IncrementAndGet.class, -796);
            registry.register(DecrementAndGet.class, -797);
            registry.register(GetAndIncrement.class, -798);
            registry.register(GetAndDecrement.class, -799);
            registry.register(AddAndGet.class, -800);
            registry.register(GetAndAdd.class, -801);
            registry.register(Size.class, -801);
            registry.register(IsEmpty.class, -801);
            registry.register(Clear.class, -801);
        }
    }
}