com.aerospike.client.exp.BitExp Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of aerospike-client-bc-jdk8 Show documentation
Aerospike Java client interface to Aerospike database server. Uses Bouncy Castle crypto library for RIPEMD-160 hashing.
The newest version!
/*
 * Copyright 2012-2021 Aerospike, Inc.
 *
 * Portions may be licensed to Aerospike, Inc. under one or more contributor
 * license agreements WHICH ARE COMPATIBLE WITH THE APACHE LICENSE, VERSION 2.0.
 *
 * 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 com.aerospike.client.exp;

import com.aerospike.client.operation.BitOverflowAction;
import com.aerospike.client.operation.BitPolicy;
import com.aerospike.client.operation.BitResizeFlags;
import com.aerospike.client.util.Pack;
import com.aerospike.client.util.Packer;

/**
 * Bit expression generator. See {@link com.aerospike.client.exp.Exp}.
 * 
 * The bin expression argument in these methods can be a reference to a bin or the
 * result of another expression. Expressions that modify bin values are only used
 * for temporary expression evaluation and are not permanently applied to the bin.
 * Bit modify expressions return the blob bin's value.
 * 

 * Offset orientation is left-to-right.  Negative offsets are supported.
 * If the offset is negative, the offset starts backwards from end of the bitmap.
 * If an offset is out of bounds, a parameter error will be returned.
 */
public final class BitExp {
	private static final int MODULE = 1;
	private static final int RESIZE = 0;
	private static final int INSERT = 1;
	private static final int REMOVE = 2;
	private static final int SET = 3;
	private static final int OR = 4;
	private static final int XOR = 5;
	private static final int AND = 6;
	private static final int NOT = 7;
	private static final int LSHIFT = 8;
	private static final int RSHIFT = 9;
	private static final int ADD = 10;
	private static final int SUBTRACT = 11;
	private static final int SET_INT = 12;
	private static final int GET = 50;
	private static final int COUNT = 51;
	private static final int LSCAN = 52;
	private static final int RSCAN = 53;
	private static final int GET_INT = 54;

	private static final int INT_FLAGS_SIGNED = 1;

	/**
	 * Create expression that resizes byte[] to byteSize according to resizeFlags (See {@link BitResizeFlags})
	 * and returns byte[].
	 * 

	 * bin = [0b00000001, 0b01000010]
	 * byteSize = 4
	 * resizeFlags = 0
	 * returns [0b00000001, 0b01000010, 0b00000000, 0b00000000]
	 * 
	 * {@code
	 * // Resize bin "a" and compare bit count
	 * Exp.eq(
	 *   BitExp.count(Exp.val(0), Exp.val(3),
	 *     BitExp.resize(BitPolicy.Default, Exp.val(4), 0, Exp.blobBin("a"))),
	 *   Exp.val(2))
	 * }
	 */
	public static Exp resize(BitPolicy policy, Exp byteSize, int resizeFlags, Exp bin) {
		byte[] bytes = Pack.pack(RESIZE, byteSize, policy.flags, resizeFlags);
		return addWrite(bin, bytes);
	}

	/**
	 * Create expression that inserts value bytes into byte[] bin at byteOffset and returns byte[].
	 * 
	 * bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
	 * byteOffset = 1
	 * value = [0b11111111, 0b11000111]
	 * bin result = [0b00000001, 0b11111111, 0b11000111, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
	 * 
	 * {@code
	 * // Insert bytes into bin "a" and compare bit count
	 * Exp.eq(
	 *   BitExp.count(Exp.val(0), Exp.val(3),
	 *     BitExp.insert(BitPolicy.Default, Exp.val(1), Exp.val(bytes), Exp.blobBin("a"))),
	 *   Exp.val(2))
	 * }
	 */
	public static Exp insert(BitPolicy policy, Exp byteOffset, Exp value, Exp bin) {
		byte[] bytes = Pack.pack(INSERT, byteOffset, value, policy.flags);
		return addWrite(bin, bytes);
	}

	/**
	 * Create expression that removes bytes from byte[] bin at byteOffset for byteSize and returns byte[].
	 * 
	 * bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
	 * byteOffset = 2
	 * byteSize = 3
	 * bin result = [0b00000001, 0b01000010]
	 * 
	 * {@code
	 * // Remove bytes from bin "a" and compare bit count
	 * Exp.eq(
	 *   BitExp.count(Exp.val(0), Exp.val(3),
	 *     BitExp.remove(BitPolicy.Default, Exp.val(2), Exp.val(3), Exp.blobBin("a"))),
	 *   Exp.val(2))
	 * }
	 */
	public static Exp remove(BitPolicy policy, Exp byteOffset, Exp byteSize, Exp bin) {
		byte[] bytes = Pack.pack(REMOVE, byteOffset, byteSize, policy.flags);
		return addWrite(bin, bytes);
	}

	/**
	 * Create expression that sets value on byte[] bin at bitOffset for bitSize and returns byte[].
	 * 
	 * bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
	 * bitOffset = 13
	 * bitSize = 3
	 * value = [0b11100000]
	 * bin result = [0b00000001, 0b01000111, 0b00000011, 0b00000100, 0b00000101]
	 * 
	 * {@code
	 * // Set bytes in bin "a" and compare bit count
	 * Exp.eq(
	 *   BitExp.count(Exp.val(0), Exp.val(3),
	 *     BitExp.set(BitPolicy.Default, Exp.val(13), Exp.val(3), Exp.val(bytes), Exp.blobBin("a"))),
	 *   Exp.val(2))
	 * }
	 */
	public static Exp set(BitPolicy policy, Exp bitOffset, Exp bitSize, Exp value, Exp bin) {
		byte[] bytes = Pack.pack(SET, bitOffset, bitSize, value, policy.flags);
		return addWrite(bin, bytes);
	}

	/**
	 * Create expression that performs bitwise "or" on value and byte[] bin at bitOffset for bitSize
	 * and returns byte[].
	 * 
	 * bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
	 * bitOffset = 17
	 * bitSize = 6
	 * value = [0b10101000]
	 * bin result = [0b00000001, 0b01000010, 0b01010111, 0b00000100, 0b00000101]
	 * 
	 */
	public static Exp or(BitPolicy policy, Exp bitOffset, Exp bitSize, Exp value, Exp bin) {
		byte[] bytes = Pack.pack(OR, bitOffset, bitSize, value, policy.flags);
		return addWrite(bin, bytes);
	}

	/**
	 * Create expression that performs bitwise "xor" on value and byte[] bin at bitOffset for bitSize
	 * and returns byte[].
	 * 
	 * bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
	 * bitOffset = 17
	 * bitSize = 6
	 * value = [0b10101100]
	 * bin result = [0b00000001, 0b01000010, 0b01010101, 0b00000100, 0b00000101]
	 * 
	 */
	public static Exp xor(BitPolicy policy, Exp bitOffset, Exp bitSize, Exp value, Exp bin) {
		byte[] bytes = Pack.pack(XOR, bitOffset, bitSize, value, policy.flags);
		return addWrite(bin, bytes);
	}

	/**
	 * Create expression that performs bitwise "and" on value and byte[] bin at bitOffset for bitSize
	 * and returns byte[].
	 * 
	 * bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
	 * bitOffset = 23
	 * bitSize = 9
	 * value = [0b00111100, 0b10000000]
	 * bin result = [0b00000001, 0b01000010, 0b00000010, 0b00000000, 0b00000101]
	 * 
	 */
	public static Exp and(BitPolicy policy, Exp bitOffset, Exp bitSize, Exp value, Exp bin) {
		byte[] bytes = Pack.pack(AND, bitOffset, bitSize, value, policy.flags);
		return addWrite(bin, bytes);
	}

	/**
	 * Create expression that negates byte[] bin starting at bitOffset for bitSize and returns byte[].
	 * 
	 * bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
	 * bitOffset = 25
	 * bitSize = 6
	 * bin result = [0b00000001, 0b01000010, 0b00000011, 0b01111010, 0b00000101]
	 * 
	 */
	public static Exp not(BitPolicy policy, Exp bitOffset, Exp bitSize, Exp bin) {
		byte[] bytes = Pack.pack(NOT, bitOffset, bitSize, policy.flags);
		return addWrite(bin, bytes);
	}

	/**
	 * Create expression that shifts left byte[] bin starting at bitOffset for bitSize and returns byte[].
	 * 
	 * bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
	 * bitOffset = 32
	 * bitSize = 8
	 * shift = 3
	 * bin result = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00101000]
	 * 
	 */
	public static Exp lshift(BitPolicy policy, Exp bitOffset, Exp bitSize, Exp shift, Exp bin) {
		byte[] bytes = Pack.pack(LSHIFT, bitOffset, bitSize, shift, policy.flags);
		return addWrite(bin, bytes);
	}

	/**
	 * Create expression that shifts right byte[] bin starting at bitOffset for bitSize and returns byte[].
	 * 
	 * bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
	 * bitOffset = 0
	 * bitSize = 9
	 * shift = 1
	 * bin result = [0b00000000, 0b11000010, 0b00000011, 0b00000100, 0b00000101]
	 * 
	 */
	public static Exp rshift(BitPolicy policy, Exp bitOffset, Exp bitSize, Exp shift, Exp bin) {
		byte[] bytes = Pack.pack(RSHIFT, bitOffset, bitSize, shift, policy.flags);
		return addWrite(bin, bytes);
	}

	/**
	 * Create expression that adds value to byte[] bin starting at bitOffset for bitSize and returns byte[].
	 * BitSize must be <= 64. Signed indicates if bits should be treated as a signed number.
	 * If add overflows/underflows, {@link BitOverflowAction} is used.
	 * 
	 * bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
	 * bitOffset = 24
	 * bitSize = 16
	 * value = 128
	 * signed = false
	 * bin result = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b10000101]
	 * 
	 */
	public static Exp add(
		BitPolicy policy,
		Exp bitOffset,
		Exp bitSize,
		Exp value,
		boolean signed,
		BitOverflowAction action,
		Exp bin
	) {
		byte[] bytes = packMath(ADD, policy, bitOffset, bitSize, value, signed, action);
		return addWrite(bin, bytes);
	}

	/**
	 * Create expression that subtracts value from byte[] bin starting at bitOffset for bitSize and returns byte[].
	 * BitSize must be <= 64. Signed indicates if bits should be treated as a signed number.
	 * If add overflows/underflows, {@link BitOverflowAction} is used.
	 * 
	 * bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
	 * bitOffset = 24
	 * bitSize = 16
	 * value = 128
	 * signed = false
	 * bin result = [0b00000001, 0b01000010, 0b00000011, 0b0000011, 0b10000101]
	 * 
	 */
	public static Exp subtract(
		BitPolicy policy,
		Exp bitOffset,
		Exp bitSize,
		Exp value,
		boolean signed,
		BitOverflowAction action,
		Exp bin
	) {
		byte[] bytes = packMath(SUBTRACT, policy, bitOffset, bitSize, value, signed, action);
		return addWrite(bin, bytes);
	}

	/**
	 * Create expression that sets value to byte[] bin starting at bitOffset for bitSize and returns byte[].
	 * BitSize must be <= 64.
	 * 
	 * bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
	 * bitOffset = 1
	 * bitSize = 8
	 * value = 127
	 * bin result = [0b00111111, 0b11000010, 0b00000011, 0b0000100, 0b00000101]
	 * 
	 */
	public static Exp setInt(BitPolicy policy, Exp bitOffset, Exp bitSize, Exp value, Exp bin) {
		byte[] bytes = Pack.pack(SET_INT, bitOffset, bitSize, value, policy.flags);
		return addWrite(bin, bytes);
	}

	/**
	 * Create expression that returns bits from byte[] bin starting at bitOffset for bitSize.
	 * 
	 * bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
	 * bitOffset = 9
	 * bitSize = 5
	 * returns [0b10000000]
	 * 
	 * {@code
	 * // Bin "a" bits = [0b10000000]
	 * Exp.eq(
	 *   BitExp.get(Exp.val(9), Exp.val(5), Exp.blobBin("a")),
	 *   Exp.val(new byte[] {(byte)0b10000000}))
	 * }
	 */
	public static Exp get(Exp bitOffset, Exp bitSize, Exp bin) {
		byte[] bytes = Pack.pack(GET, bitOffset, bitSize);
		return addRead(bin, bytes, Exp.Type.BLOB);
	}

	/**
	 * Create expression that returns integer count of set bits from byte[] bin starting at
	 * bitOffset for bitSize.
	 * 
	 * bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
	 * bitOffset = 20
	 * bitSize = 4
	 * returns 2
	 * 
	 * {@code
	 * // Bin "a" bit count <= 2
	 * Exp.le(BitExp.count(Exp.val(0), Exp.val(5), Exp.blobBin("a")), Exp.val(2))
	 * }
	 */
	public static Exp count(Exp bitOffset, Exp bitSize, Exp bin) {
		byte[] bytes = Pack.pack(COUNT, bitOffset, bitSize);
		return addRead(bin, bytes, Exp.Type.INT);
	}

	/**
	 * Create expression that returns integer bit offset of the first specified value bit in byte[] bin
	 * starting at bitOffset for bitSize.
	 * 
	 * bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
	 * bitOffset = 24
	 * bitSize = 8
	 * value = true
	 * returns 5
	 * 
	 * {@code
	 * // lscan(a) == 5
	 * Exp.eq(BitExp.lscan(Exp.val(24), Exp.val(8), Exp.val(true), Exp.blobBin("a")), Exp.val(5))
	 * }
	 *
	 * @param bitOffset		offset int expression
	 * @param bitSize		size int expression
	 * @param value			boolean expression
	 * @param bin			bin or blob value expression
	 */
	public static Exp lscan(Exp bitOffset, Exp bitSize, Exp value, Exp bin) {
		byte[] bytes = Pack.pack(LSCAN, bitOffset, bitSize, value);
		return addRead(bin, bytes, Exp.Type.INT);
	}

	/**
	 * Create expression that returns integer bit offset of the last specified value bit in byte[] bin
	 * starting at bitOffset for bitSize.
	 * Example:
	 * 
	 * bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
	 * bitOffset = 32
	 * bitSize = 8
	 * value = true
	 * returns 7
	 * 
	 * {@code
	 * // rscan(a) == 7
	 * Exp.eq(BitExp.rscan(Exp.val(32), Exp.val(8), Exp.val(true), Exp.blobBin("a")), Exp.val(7))
	 * }
	 *
	 * @param bitOffset		offset int expression
	 * @param bitSize		size int expression
	 * @param value			boolean expression
	 * @param bin			bin or blob value expression
	 */
	public static Exp rscan(Exp bitOffset, Exp bitSize, Exp value, Exp bin) {
		byte[] bytes = Pack.pack(RSCAN, bitOffset, bitSize, value);
		return addRead(bin, bytes, Exp.Type.INT);
	}

	/**
	 * Create expression that returns integer from byte[] bin starting at bitOffset for bitSize.
	 * Signed indicates if bits should be treated as a signed number.
	 * 
	 * bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
	 * bitOffset = 8
	 * bitSize = 16
	 * signed = false
	 * returns 16899
	 * 
	 * {@code
	 * // getInt(a) == 16899
	 * Exp.eq(BitExp.getInt(Exp.val(8), Exp.val(16), false, Exp.blobBin("a")), Exp.val(16899))
	 * }
	 */
	public static Exp getInt(Exp bitOffset, Exp bitSize, boolean signed, Exp bin) {
		byte[] bytes = packGetInt(bitOffset, bitSize, signed);
		return addRead(bin, bytes, Exp.Type.INT);
	}

	private static byte[] packMath(
		int command,
		BitPolicy policy,
		Exp bitOffset,
		Exp bitSize,
		Exp value,
		boolean signed,
		BitOverflowAction action
	) {
		Packer packer = new Packer();
		// Pack.init() only required when CTX is used and server does not support CTX for bit operations.
		// Pack.init(packer, ctx);
		packer.packArrayBegin(6);
		packer.packInt(command);
		bitOffset.pack(packer);
		bitSize.pack(packer);
		value.pack(packer);
		packer.packInt(policy.flags);

		int flags = action.flags;

		if (signed) {
			flags |= INT_FLAGS_SIGNED;
		}
		packer.packInt(flags);
		return packer.toByteArray();
	}

	private static byte[] packGetInt(Exp bitOffset, Exp bitSize, boolean signed) {
		Packer packer = new Packer();
		// Pack.init() only required when CTX is used and server does not support CTX for bit operations.
		// Pack.init(packer, ctx);
		packer.packArrayBegin(signed ? 4 : 3);
		packer.packInt(GET_INT);
		bitOffset.pack(packer);
		bitSize.pack(packer);

		if (signed) {
			packer.packInt(INT_FLAGS_SIGNED);
		}
		return packer.toByteArray();
	}

	private static Exp addWrite(Exp bin, byte[] bytes) {
		return new Exp.Module(bin, bytes, Exp.Type.BLOB.code, MODULE | Exp.MODIFY);
	}

	private static Exp addRead(Exp bin, byte[] bytes, Exp.Type retType) {
		return new Exp.Module(bin, bytes, retType.code, MODULE);
	}
}