Package com.aerospike.client.operation

Class BitOperation

java.lang.Object
com.aerospike.client.operation.BitOperation
public final class BitOperation extends Object
Bit operations. Create bit operations used by client operate command. 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.

Bit operations on bitmap items nested in lists/maps are not currently supported by the server.

  • Constructor Details

    • BitOperation

      public BitOperation()

  • Method Details

    • resize

      public static Operation resize(BitPolicy policy, String binName, int byteSize, int resizeFlags)
      Create byte "resize" operation. Server resizes byte[] to byteSize according to resizeFlags (See BitResizeFlags). Server does not return a value. Example:
      • bin = [0b00000001, 0b01000010]
      • byteSize = 4
      • resizeFlags = 0
      • bin result = [0b00000001, 0b01000010, 0b00000000, 0b00000000]

    • insert

      public static Operation insert(BitPolicy policy, String binName, int byteOffset, byte[] value)
      Create byte "insert" operation. Server inserts value bytes into byte[] bin at byteOffset. Server does not return a value. Example:
      • bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
      • byteOffset = 1
      • value = [0b11111111, 0b11000111]
      • bin result = [0b00000001, 0b11111111, 0b11000111, 0b01000010, 0b00000011, 0b00000100, 0b00000101]

    • remove

      public static Operation remove(BitPolicy policy, String binName, int byteOffset, int byteSize)
      Create byte "remove" operation. Server removes bytes from byte[] bin at byteOffset for byteSize. Server does not return a value. Example:
      • bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
      • byteOffset = 2
      • byteSize = 3
      • bin result = [0b00000001, 0b01000010]

    • set

      public static Operation set(BitPolicy policy, String binName, int bitOffset, int bitSize, byte[] value)
      Create bit "set" operation. Server sets value on byte[] bin at bitOffset for bitSize. Server does not return a value. Example:
      • bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
      • bitOffset = 13
      • bitSize = 3
      • value = [0b11100000]
      • bin result = [0b00000001, 0b01000111, 0b00000011, 0b00000100, 0b00000101]

    • or

      public static Operation or(BitPolicy policy, String binName, int bitOffset, int bitSize, byte[] value)
      Create bit "or" operation. Server performs bitwise "or" on value and byte[] bin at bitOffset for bitSize. Server does not return a value. Example:
      • bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
      • bitOffset = 17
      • bitSize = 6
      • value = [0b10101000]
      • bin result = [0b00000001, 0b01000010, 0b01010111, 0b00000100, 0b00000101]

    • xor

      public static Operation xor(BitPolicy policy, String binName, int bitOffset, int bitSize, byte[] value)
      Create bit "exclusive or" operation. Server performs bitwise "xor" on value and byte[] bin at bitOffset for bitSize. Server does not return a value. Example:
      • bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
      • bitOffset = 17
      • bitSize = 6
      • value = [0b10101100]
      • bin result = [0b00000001, 0b01000010, 0b01010101, 0b00000100, 0b00000101]

    • and

      public static Operation and(BitPolicy policy, String binName, int bitOffset, int bitSize, byte[] value)
      Create bit "and" operation. Server performs bitwise "and" on value and byte[] bin at bitOffset for bitSize. Server does not return a value. Example:
      • bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
      • bitOffset = 23
      • bitSize = 9
      • value = [0b00111100, 0b10000000]
      • bin result = [0b00000001, 0b01000010, 0b00000010, 0b00000000, 0b00000101]

    • not

      public static Operation not(BitPolicy policy, String binName, int bitOffset, int bitSize)
      Create bit "not" operation. Server negates byte[] bin starting at bitOffset for bitSize. Server does not return a value. Example:
      • bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
      • bitOffset = 25
      • bitSize = 6
      • bin result = [0b00000001, 0b01000010, 0b00000011, 0b01111010, 0b00000101]

    • lshift

      public static Operation lshift(BitPolicy policy, String binName, int bitOffset, int bitSize, int shift)
      Create bit "left shift" operation. Server shifts left byte[] bin starting at bitOffset for bitSize. Server does not return a value. Example:
      • bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
      • bitOffset = 32
      • bitSize = 8
      • shift = 3
      • bin result = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00101000]

    • rshift

      public static Operation rshift(BitPolicy policy, String binName, int bitOffset, int bitSize, int shift)
      Create bit "right shift" operation. Server shifts right byte[] bin starting at bitOffset for bitSize. Server does not return a value. Example:
      • bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
      • bitOffset = 0
      • bitSize = 9
      • shift = 1
      • bin result = [0b00000000, 0b11000010, 0b00000011, 0b00000100, 0b00000101]

    • add

      public static Operation add(BitPolicy policy, String binName, int bitOffset, int bitSize, long value, boolean signed, BitOverflowAction action)
      Create bit "add" operation. Server adds value to byte[] bin starting at bitOffset for bitSize. BitSize must be <= 64. Signed indicates if bits should be treated as a signed number. If add overflows/underflows, BitOverflowAction is used. Server does not return a value. Example:
      • bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
      • bitOffset = 24
      • bitSize = 16
      • value = 128
      • signed = false
      • bin result = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b10000101]

    • subtract

      public static Operation subtract(BitPolicy policy, String binName, int bitOffset, int bitSize, long value, boolean signed, BitOverflowAction action)
      Create bit "subtract" operation. Server subtracts value from byte[] bin starting at bitOffset for bitSize. BitSize must be <= 64. Signed indicates if bits should be treated as a signed number. If add overflows/underflows, BitOverflowAction is used. Server does not return a value. Example:
      • bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
      • bitOffset = 24
      • bitSize = 16
      • value = 128
      • signed = false
      • bin result = [0b00000001, 0b01000010, 0b00000011, 0b0000011, 0b10000101]

    • setInt

      public static Operation setInt(BitPolicy policy, String binName, int bitOffset, int bitSize, long value)
      Create bit "setInt" operation. Server sets value to byte[] bin starting at bitOffset for bitSize. Size must be <= 64. Server does not return a value. Example:
      • bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
      • bitOffset = 1
      • bitSize = 8
      • value = 127
      • bin result = [0b00111111, 0b11000010, 0b00000011, 0b0000100, 0b00000101]

    • get

      public static Operation get(String binName, int bitOffset, int bitSize)
      Create bit "get" operation. Server returns bits from byte[] bin starting at bitOffset for bitSize. Example:
      • bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
      • bitOffset = 9
      • bitSize = 5
      • returns [0b10000000]

    • count

      public static Operation count(String binName, int bitOffset, int bitSize)
      Create bit "count" operation. Server returns integer count of set bits from byte[] bin starting at bitOffset for bitSize. Example:
      • bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
      • bitOffset = 20
      • bitSize = 4
      • returns 2

    • lscan

      public static Operation lscan(String binName, int bitOffset, int bitSize, boolean value)
      Create bit "left scan" operation. Server returns integer bit offset of the first specified value bit in byte[] bin starting at bitOffset for bitSize. Example:
      • bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
      • bitOffset = 24
      • bitSize = 8
      • value = true
      • returns 5

    • rscan

      public static Operation rscan(String binName, int bitOffset, int bitSize, boolean value)
      Create bit "right scan" operation. Server 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

    • getInt

      public static Operation getInt(String binName, int bitOffset, int bitSize, boolean signed)
      Create bit "get integer" operation. Server returns integer from byte[] bin starting at bitOffset for bitSize. Signed indicates if bits should be treated as a signed number. Example:
      • bin = [0b00000001, 0b01000010, 0b00000011, 0b00000100, 0b00000101]
      • bitOffset = 8
      • bitSize = 16
      • signed = false
      • returns 16899