io.engineblock.activityapi.cyclelog.buffers.Buffer Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of eb-api Show documentation

The driver API for engineblock; Provides the interfaces needed to build drivers that can be loaded by engineblock core

There is a newer version: 2.12.65

/*
 *
 *    Copyright 2016 jshook
 *    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 io.engineblock.activityapi.cyclelog.buffers;

import java.lang.reflect.Array;
import java.nio.BufferOverflowException;
import java.nio.BufferUnderflowException;

/**
 * This is a lightweight buffer implementation that allows for buffer
 * flipping and callbacks when the buffer is full.
 * @param  The type held in this buffer
 */
public abstract class Buffer implements Comparable> {

    private int position;
    private int limit;
    private T[] data;

    public Buffer(Class clazz,int size) {
        data = clazz.cast(Array.newInstance(clazz.getComponentType(), size));
        limit=data.length;
        position=0;
    }

    protected void onFull() {
    }

    protected abstract int compare(T one, T other);

    public int position() {
        return position;
    }

    public Buffer position(int position) {
        this.position=position;
        return this;
    }

    public int remaining() {
        return limit-position;
    }

    public Buffer put(T element) {
        if (position>=limit) {
            throw new BufferOverflowException();
        }
        data[position++]=element;
        if (position==limit) {
            onFull();
        }
        return this;
    }

    public T get() {
        if (position >=limit) {
            throw new BufferUnderflowException();
        }
        T got = data[position++];
        return got;
    }


    public Buffer flip() {
        this.limit=position;
        this.position=0;
        return this;
    }

    @Override
    public int compareTo(Buffer other) {
        int lengthDiff = Integer.compare(data.length, other.data.length);
        if (lengthDiff!=0) {
            return lengthDiff;
        }
        int compareTo = Math.min(position, other.position);

        for (int pos = 0; pos