net.sf.jaccumulator.bytes

Class ByteArrayCursor

java.lang.Object

java.lang.Number

net.sf.jaccumulator.scalars.AbstractScalar<REAL>

net.sf.jaccumulator.reals.AbstractReal<PRIMITIVE>

net.sf.jaccumulator.primitives.AbstractPrimitive<PRIMITIVE>

net.sf.jaccumulator.primitives.AbstractNumericPrimitive<PRIMITIVE>

net.sf.jaccumulator.bytes.AbstractBytePrimitive<ByteArrayCursor>

net.sf.jaccumulator.bytes.ByteArrayCursor

All Implemented Interfaces:

Serializable, Appendable, CharSequence, Comparable<SealedPrimitive<?>>, AlgebraicStructure<ByteArrayCursor>, BooleanValue<ByteArrayCursor>, MutableBooleanValue<ByteArrayCursor>, SealedBooleanValue, ByteValue<ByteArrayCursor>, MutableByteValue<ByteArrayCursor>, SealedByteValue, CharacterValue<ByteArrayCursor>, MutableCharacterValue<ByteArrayCursor>, SealedCharacterValue, DoubleValue<ByteArrayCursor>, MutableDoubleValue<ByteArrayCursor>, SealedDoubleValue, FloatValue<ByteArrayCursor>, MutableFloatValue<ByteArrayCursor>, SealedFloatValue, IntegerValue<ByteArrayCursor>, MutableIntegerValue<ByteArrayCursor>, SealedIntegerValue, LongValue<ByteArrayCursor>, MutableLongValue<ByteArrayCursor>, SealedLongValue, Mutable, MutableAlgebraicStructure<ByteArrayCursor>, MutableKernel<ByteArrayCursor>, MutablePrimitive<ByteArrayCursor>, Primitive<ByteArrayCursor>, PrimitiveInductor<ByteArrayCursor>, PrimitiveReplicator<ByteArrayCursor>, SealedPrimitive<ByteArrayCursor>, MutableReal<ByteArrayCursor>, MutableRealDomain<ByteArrayCursor>, Real<ByteArrayCursor>, RealDomain<ByteArrayCursor>, RealInductor<ByteArrayCursor>, RealReplicator<ByteArrayCursor>, SealedReal<ByteArrayCursor>, SealedRealBag, SealedRealDomain, Replicator<ByteArrayCursor>, CharacterProperties, MutableScalar<ByteArrayCursor>, MutableScalarDomain<ByteArrayCursor>, NumericProperties, Scalar<ByteArrayCursor>, ScalarDomain<ByteArrayCursor>, ScalarInductor<ByteArrayCursor>, ScalarReplicator<ByteArrayCursor>, SealedScalar<ByteArrayCursor>, SealedScalarBag, SealedScalarDomain, SealedAlgebraicStructure, SealedKernel, MutableShortValue<ByteArrayCursor>, SealedShortValue, ShortValue<ByteArrayCursor>, StructureProperties, MutableText<ByteArrayCursor>, MutableTextValue<ByteArrayCursor>, SealedText<ByteArrayCursor>, SealedTextValue, Text<ByteArrayCursor>, TextInductor, TextProperties, TextReplicator<ByteArrayCursor>, TextValue<ByteArrayCursor>, MutableUnlimitedDecimalValue<ByteArrayCursor>, MutableUnlimitedIntegerValue<ByteArrayCursor>, SealedUnlimitedDecimalValue, SealedUnlimitedIntegerValue, UnlimitedDecimalValue<ByteArrayCursor>, UnlimitedIntegerValue<ByteArrayCursor>

public final class ByteArrayCursor
extends AbstractBytePrimitive<ByteArrayCursor>

A byte fixed array cursor

Since:

JAccumulator 4.0

Author:

Nicole Tedesco (Nicole@NicoleTedesco.com)

See Also:

Serialized Form

Field Summary

Fields inherited from class net.sf.jaccumulator.scalars.AbstractScalar

NaN, ONEI, ZERO_DOUBLE_LONG_BITS, ZERO_FLOAT_INT_BITS, ZEROI

Constructor Summary

Constructors

Constructor and Description
ByteArrayCursor()
ByteArrayCursor(byte[] aSuperstructure)
ByteArrayCursor(byte[] aSuperstructure, int aKey)

Method Summary

Methods

Modifier and Type	Method and Description
ByteArrayCursor	and(byte aValue) Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector
byte	bytePostDecrement() Decrement the scalar value of this object then return the original value prior to decrementing
byte	bytePostIncrement() Increment the scalar value of this object then return the original value prior to incrementing
byte	byteValue()
ByteArrayCursor	copy() Produce a replica of this object
ByteArrayCursor	copyUsing(BigDecimal aKey) Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified
ByteArrayCursor	copyUsing(BigInteger aKey) Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified
ByteArrayCursor	copyUsing(boolean aKey) Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified
ByteArrayCursor	copyUsing(byte aKey) Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified
ByteArrayCursor	copyUsing(char aKey) Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified
ByteArrayCursor	copyUsing(double aKey) Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified
ByteArrayCursor	copyUsing(float aKey) Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified
ByteArrayCursor	copyUsing(int aKey) Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified
ByteArrayCursor	copyUsing(long aKey) Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified
ByteArrayCursor	copyUsing(short aKey) Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified
ByteArrayCursor	copyUsingPrimitive(SealedPrimitive<?> aKey) Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified
ByteArrayCursor	copyUsingReal(SealedReal<?> aKey) Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified
ByteArrayCursor	copyUsingScalar(SealedScalar<?> aKey) Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified
ByteArrayCursor	copyUsingText(CharSequence aKey) Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified
ByteArrayCursor	decrement() Replace the current value with the current value minus unity (one)
ByteArrayCursor	difference(byte aValue) Set the value of this scalar to the mathematical difference between its current value and the specified value
ConcurrencyStrategy	getConcurrency()
ByteArrayCursor	increment() Replace the current value with the current value plus unity (one)
ByteArrayCursor	mod(byte aValue) Set the value of this scalar to its current value modulo of the specified value
ByteArrayCursor	not() Replace the current integral binary vector with its one's complement.
ByteArrayCursor	or(byte aValue) Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector
ByteArrayCursor	product(byte aValue) Set the value of this scalar to the mathematical product of its current value and the specified value
ByteArrayCursor	quotient(byte aValue) Set the value of this scalar to the mathematical quotient of its current value and the specified value
ByteArrayCursor	setScalar(byte aValue) Set this property to the specified byte value and answer this object (facilitates chaining)
ByteArrayCursor	shiftLeft(int count) Attempt to shift the elements of this tuple to the "left" the specified number of ordinal positions.
ByteArrayCursor	shiftRight(int count) Attempt to shift the elements of this tuple to the "right" the specified number of ordinal positions.
ByteArrayCursor	shiftRightExtendZero(int count) Attempt to shift the elements of this tuple to the "right" the specified number of ordinal positions without sign extension.
ByteArrayCursor	sum(byte aValue) Set the value of this scalar to the mathematical sum of its current value and the specified value
ByteArrayCursor	xor(byte aValue) Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector

Methods inherited from class net.sf.jaccumulator.bytes.AbstractBytePrimitive

absoluteValue, and, booleanPostDecrement, booleanPostIncrement, booleanValue, charPostDecrement, charPostIncrement, charValue, cube, difference, doublePostDecrement, doublePostIncrement, doubleValue, floatPostDecrement, floatPostIncrement, floatValue, getStructureStrategy, hashCode, inducePostDecrement, inducePostIncrement, induceRealMaximum, induceRealMinimum, induceRealValue, induceScalarMaximum, induceScalarMinimum, induceScalarValue, intPostDecrement, intPostIncrement, intValue, inverse, isDigit, isFinite, isIdentifierIgnorable, isInfinity, isInvalid, isISOControl, isJavaIdentifierPart, isJavaIdentifierStart, isLetter, isLetterOrDigit, isLowerCase, isMaximum, isMinimum, isMirrored, isModulo, isNegative, isNegativeFinite, isNegativeInfinity, isPositive, isPositiveFinite, isPositiveInfinity, isReal, isTitleCase, isUnicode, isUnicodeIdentifierPart, isUnicodeIdentifierStart, isUnity, isUpperCase, isWhitespace, isZero, longPostDecrement, longPostIncrement, longValue, lowerCase, negate, or, product, quotient, round, setMaximum, setMinimum, setNumber, setPrimitive, setReal, setReal, setReal, setScalar, setScalar, setScalar, setScalar, setScalar, setScalar, setScalar, setScalar, setUnity, setZero, shortPostDecrement, shortPostIncrement, shortValue, square, sum, swapPrimitives, titleCase, toNumber, toString, toUnlimitedDecimal, toUnlimitedInteger, unlimitedDecimalPostDecrement, unlimitedDecimalPostIncrement, unlimitedIntegerPostDecrement, unlimitedIntegerPostIncrement, upperCase, xor

Methods inherited from class net.sf.jaccumulator.primitives.AbstractNumericPrimitive

append, append, append, append, append, append, append, append, append, append, append, append, append, append, appendCodePoint, charAt, clear, clearContents, clearText, codePointAt, codePointBefore, codePointCount, compareTo, compareToPrimitive, delete, deleteCharAt, equals, indexOfText, indexOfText, inducePostDecrement, inducePostDecrement, inducePostIncrement, inducePostIncrement, inducePrimitiveValue, induceTextValue, insert, insert, insert, insert, insert, insert, insert, insert, insert, insert, insert, insert, isEmpty, isEqualToPrimitive, isEqualToText, isGreaterOrEqualToPrimitive, isGreaterOrEqualToText, isGreaterThanPrimitive, isGreaterThanText, isLessOrEqualToPrimitive, isLessOrEqualToText, isLessThanPrimitive, isLessThanText, isNotEqualToPrimitive, isNotEqualToText, isText, length, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, prepend, replace, replace, replaceAll, replaceCharacter, replaceFirst, reverse, setBoolean, setCharacter, setCharAt, setLength, setText, subSequence, substring, substring, textPostDecrement, textPostIncrement, toPrimitive, toPrimitive, trim

Methods inherited from class net.sf.jaccumulator.primitives.AbstractPrimitive

andOfPrimitive, angleWithPrimitive, compareToText, differenceOfPrimitive, hypotenuseWithPrimitive, inducePrimitiveMaximum, inducePrimitiveMinimum, induceTextSize, modOfPrimitive, orOfPrimitive, powerOfPrimitive, productOfPrimitive, quotientOfPrimitive, sumOfPrimitive, toPrimitive, xorOfPrimitive

Methods inherited from class net.sf.jaccumulator.reals.AbstractReal

and, andOfNumber, andOfReal, angleWithReal, compareToNumber, compareToReal, compareToReal, compareToReal, difference, difference, differenceOfNumber, differenceOfReal, gcd, gcdOfNumber, gcdOfReal, hypotenuseWithReal, induceRealSize, isEqual, isEqual, isEqualToNumber, isEqualToReal, isGreater, isGreater, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqualToNumber, isGreaterOrEqualToReal, isGreaterThanNumber, isGreaterThanReal, isLess, isLess, isLessOrEqual, isLessOrEqual, isLessOrEqualToNumber, isLessOrEqualToReal, isLessThanNumber, isLessThanReal, isNotEqual, isNotEqual, isNotEqualToNumber, isNotEqualToReal, mod, mod, modOfNumber, modOfReal, or, orOfNumber, orOfReal, powerOfReal, product, product, productOfNumber, productOfReal, quotient, quotient, quotientOfNumber, quotientOfReal, sum, sum, sumOfNumber, sumOfReal, toReal, unlimitedIntegerModularInverse, xor, xorOfNumber, xorOfReal

Methods inherited from class net.sf.jaccumulator.scalars.AbstractScalar

and, and, and, and, andOfScalar, angleWith, angleWithNumber, angleWithScalar, arcCosine, arcSine, arcTangent, assertDomain, assertPrecision, base10Log, boundsCheck, byteMaskAt, byteNotMaskAt, byteValue, ceiling, charMaskAt, charNotMaskAt, charValue, clearByteBitAt, clearCharBitAt, clearDoubleBitAt, clearFloatBitAt, clearIntBitAt, clearLongBitAt, clearShortBitAt, clearUnlimitedDecimalBitAt, clearUnlimitedIntegerBitAt, compareTo, compareTo, compareTo, compareTo, compareTo, compareTo, compareTo, compareTo, compareTo, compareTo, compareTo, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToZero, cosine, cubeRoot, degrees, difference, difference, difference, difference, difference, difference, differenceOfScalar, divideByZero, down, exponential, exponentialLessOne, floor, gcd, gcd, gcd, gcd, gcd, gcdOfScalar, getBooleanBitAt, getByteBitAt, getCharBitAt, getDomain, getDoubleBitAt, getFloatBitAt, getIntBitAt, getLongBitAt, getPrecision, getShortBitAt, getUnlimitedDecimalBitAt, getUnlimitedIntegerBitAt, halfDown, halfEven, halfUp, hashCode, hashCode, hashCode, hashCode, hashCode, hashCode, hashCode, hashCode, hyperbolicCosine, hyperbolicSine, hyperbolicTangent, hypotenuseWith, hypotenuseWithNumber, hypotenuseWithScalar, indexOutOfBoundsAt, induceScalarSize, intGCD, intMaskAt, intModularInverse, intModularQuotient, intNotMaskAt, intValue, invalidate, isAlphabetic, isBmpCodePoint, isConfigurable, isCountable, isElastic, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqualToScalar, isExpandable, isFalse, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqualToScalar, isGreaterThanScalar, isHighSurrogate, isIdeographic, isImaginary, isLess, isLess, isLess, isLess, isLess, isLess, isLess, isLess, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqualToScalar, isLessThanScalar, isLowSurrogate, isMutable, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqualToScalar, isOrdered, isReducible, isSupplementaryCodePoint, isSurrogate, isTrue, isUnique, isValid, isValidCodePoint, longGCD, longMaskAt, longModularInverse, longModularQuotient, longNotMaskAt, longSize, longValue, milliseconds, mod, mod, mod, mod, mod, mod, mod, modOfScalar, nanoseconds, naturalLog, naturalLogPlusOne, or, or, or, or, orOfScalar, power, power, powerOfNumber, powerOfScalar, product, product, product, product, product, product, productOfScalar, promoteTo, quotient, quotient, quotient, quotient, quotient, quotient, quotientOfScalar, radians, random, setByteBitAt, setCharBitAt, setDoubleBitAt, setE, setEnumeration, setFalse, setFloatBitAt, setIntBitAt, setLongBitAt, setNegativeInfinity, setPi, setPositiveInfinity, setShortBitAt, setTrue, setUnlimitedDecimalBitAt, setUnlimitedIntegerBitAt, shortMaskAt, shortNotMaskAt, shortValue, signum, sine, size, squareRoot, sum, sum, sum, sum, sum, sum, sumOfScalar, tangent, toBoolean, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toBooleanArray, toByteArray, toCharacter, toCodePoint, toEnumeration, toScalar, toUnlimitedInteger, unlimitedIntegerMaskAt, unlimitedIntegerNotMaskAt, up, xor, xor, xor, xor, xorOfScalar

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface net.sf.jaccumulator.reals.SealedReal

compareToReal, compareToReal, compareToReal, isEqual, isEqual, isEqualToReal, isGreater, isGreater, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqualToReal, isGreaterThanReal, isLess, isLess, isLessOrEqual, isLessOrEqual, isLessOrEqualToReal, isLessThanReal, isNotEqual, isNotEqual, isNotEqualToReal

Methods inherited from interface net.sf.jaccumulator.scalars.SealedScalar

compareToNumber, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToScalar, compareToZero, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqual, isEqualToNumber, isEqualToScalar, isFalse, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreater, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqual, isGreaterOrEqualToNumber, isGreaterOrEqualToScalar, isGreaterThanNumber, isGreaterThanScalar, isLess, isLess, isLess, isLess, isLess, isLess, isLess, isLess, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqual, isLessOrEqualToNumber, isLessOrEqualToScalar, isLessThanNumber, isLessThanScalar, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqual, isNotEqualToNumber, isNotEqualToScalar, isTrue, toBoolean, toCharacter, toCodePoint, toEnumeration

Methods inherited from interface net.sf.jaccumulator.scalars.NumericProperties

isImaginary, isValid, signum

Methods inherited from interface net.sf.jaccumulator.scalars.CharacterProperties

isAlphabetic, isBmpCodePoint, isHighSurrogate, isIdeographic, isLowSurrogate, isSupplementaryCodePoint, isSurrogate, isValidCodePoint

Methods inherited from interface net.sf.jaccumulator.scalars.SealedScalarDomain

getPrecision

Methods inherited from interface net.sf.jaccumulator.reals.SealedRealBag

induceRealSize

Methods inherited from interface net.sf.jaccumulator.scalars.SealedScalarBag

induceScalarSize

Methods inherited from interface net.sf.jaccumulator.SealedAlgebraicStructure

getDomain, longSize, size

Methods inherited from interface net.sf.jaccumulator.StructureProperties

isConfigurable, isCountable, isElastic, isExpandable, isOrdered, isReducible, isUnique

Methods inherited from interface net.sf.jaccumulator.reals.RealReplicator

toReal

Methods inherited from interface net.sf.jaccumulator.scalars.ScalarReplicator

toScalar

Methods inherited from interface net.sf.jaccumulator.reals.MutableReal

and, andOfReal, angleWithReal, difference, difference, differenceOfReal, gcd, gcdOfReal, hypotenuseWithReal, mod, mod, modOfReal, or, orOfReal, powerOfReal, product, product, productOfReal, quotient, quotient, quotientOfReal, sum, sum, sumOfReal, xor, xorOfReal

Methods inherited from interface net.sf.jaccumulator.scalars.MutableScalar

and, and, and, and, andOfNumber, andOfScalar, angleWith, angleWithNumber, angleWithScalar, arcCosine, arcSine, arcTangent, base10Log, ceiling, cosine, cubeRoot, degrees, difference, difference, difference, difference, difference, difference, differenceOfNumber, differenceOfScalar, down, exponential, exponentialLessOne, floor, gcd, gcd, gcd, gcd, gcd, gcdOfNumber, gcdOfScalar, halfDown, halfEven, halfUp, hyperbolicCosine, hyperbolicSine, hyperbolicTangent, hypotenuseWith, hypotenuseWithNumber, hypotenuseWithScalar, invalidate, milliseconds, mod, mod, mod, mod, mod, mod, mod, modOfNumber, modOfScalar, nanoseconds, naturalLog, naturalLogPlusOne, or, or, or, or, orOfNumber, orOfScalar, power, power, powerOfNumber, powerOfScalar, product, product, product, product, product, product, productOfNumber, productOfScalar, quotient, quotient, quotient, quotient, quotient, quotient, quotientOfNumber, quotientOfScalar, radians, random, setE, setEnumeration, setNegativeInfinity, setPi, setPositiveInfinity, sine, squareRoot, sum, sum, sum, sum, sum, sum, sumOfNumber, sumOfScalar, tangent, up, xor, xor, xor, xor, xorOfNumber, xorOfScalar

Methods inherited from interface net.sf.jaccumulator.booleans.MutableBooleanValue

setFalse, setTrue

Methods inherited from interface net.sf.jaccumulator.scalars.MutableScalarDomain

assertPrecision, promoteTo

Methods inherited from interface net.sf.jaccumulator.MutableAlgebraicStructure

assertDomain

Methods inherited from interface net.sf.jaccumulator.Mutable

isMutable

Constructor Detail

ByteArrayCursor

public ByteArrayCursor()

ByteArrayCursor

public ByteArrayCursor(byte[] aSuperstructure)

ByteArrayCursor

public ByteArrayCursor(byte[] aSuperstructure,
               int aKey)

Method Detail

and

public final ByteArrayCursor and(byte aValue)
                          throws UnsupportedOperationException,
                                 IllegalArgumentException,
                                 ArithmeticException

Description copied from interface: MutableScalar

Set this value to the bit and of the integral boolean vector equivalent of this value and the specified integral boolean vector

Specified by:

and in interface MutableScalar<ByteArrayCursor>

Overrides:

and in class AbstractScalar<ByteArrayCursor>

Parameters:

aValue - an integral boolean vector

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

IllegalArgumentException - if the new value was incommensurate with this object's specification

ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object

bytePostDecrement

public final byte bytePostDecrement()
                             throws UnsupportedOperationException,
                                    ArithmeticException,
                                    IllegalArgumentException

Description copied from interface: MutableByteValue

Decrement the scalar value of this object then return the original value prior to decrementing

Returns:

the original value of this scalar

Throws:

UnsupportedOperationException - if this object's value cannot be changed

ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object

IllegalArgumentException - if the new value was incommensurate with this object's specification

bytePostIncrement

public final byte bytePostIncrement()
                             throws UnsupportedOperationException,
                                    ArithmeticException,
                                    IllegalArgumentException

Description copied from interface: MutableByteValue

Increment the scalar value of this object then return the original value prior to incrementing

Returns:

the original value of this scalar

Throws:

UnsupportedOperationException - if this object's value cannot be changed

ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object

IllegalArgumentException - if the new value was incommensurate with this object's specification

byteValue

public final byte byteValue()

Specified by:

byteValue in interface SealedByteValue

Overrides:

byteValue in class Number

Returns:

the property value as a system byte

copy

public final ByteArrayCursor copy()

Description copied from interface: Replicator

Produce a replica of this object

Returns:

a replica of this object

copyUsing

public final ByteArrayCursor copyUsing(BigDecimal aKey)

Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified

Specified by:

copyUsing in interface RealReplicator<ByteArrayCursor>

Overrides:

copyUsing in class AbstractBytePrimitive<ByteArrayCursor>

Parameters:

aKey - a new cursor

Returns:

a copy (clone) of this cursor initialized using same source domain and the specified key

copyUsing

public final ByteArrayCursor copyUsing(BigInteger aKey)

Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified

Specified by:

copyUsing in interface RealReplicator<ByteArrayCursor>

Overrides:

copyUsing in class AbstractBytePrimitive<ByteArrayCursor>

Parameters:

aKey - a new cursor

Returns:

a copy (clone) of this cursor initialized using same source domain and the specified key

copyUsing

public final ByteArrayCursor copyUsing(boolean aKey)

Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified

Specified by:

copyUsing in interface ScalarReplicator<ByteArrayCursor>

Overrides:

copyUsing in class AbstractBytePrimitive<ByteArrayCursor>

Parameters:

aKey - a new cursor

Returns:

a copy (clone) of this cursor initialized using same source domain and the specified key

copyUsing

public final ByteArrayCursor copyUsing(byte aKey)

Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified

Parameters:

aKey - a new cursor

Returns:

a copy (clone) of this cursor initialized using same source domain and the specified key

copyUsing

public final ByteArrayCursor copyUsing(char aKey)

Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified

Specified by:

copyUsing in interface ScalarReplicator<ByteArrayCursor>

Overrides:

copyUsing in class AbstractBytePrimitive<ByteArrayCursor>

Parameters:

aKey - a new cursor

Returns:

a copy (clone) of this cursor initialized using same source domain and the specified key

copyUsing

public final ByteArrayCursor copyUsing(double aKey)

Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified

Specified by:

copyUsing in interface ScalarReplicator<ByteArrayCursor>

Overrides:

copyUsing in class AbstractBytePrimitive<ByteArrayCursor>

Parameters:

aKey - a new cursor

Returns:

a copy (clone) of this cursor initialized using same source domain and the specified key

copyUsing

public final ByteArrayCursor copyUsing(float aKey)

Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified

Specified by:

copyUsing in interface ScalarReplicator<ByteArrayCursor>

Overrides:

copyUsing in class AbstractBytePrimitive<ByteArrayCursor>

Parameters:

aKey - a new cursor

Returns:

a copy (clone) of this cursor initialized using same source domain and the specified key

copyUsing

public final ByteArrayCursor copyUsing(int aKey)

Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified

Specified by:

copyUsing in interface ScalarReplicator<ByteArrayCursor>

Overrides:

copyUsing in class AbstractBytePrimitive<ByteArrayCursor>

Parameters:

aKey - a new cursor

Returns:

a copy (clone) of this cursor initialized using same source domain and the specified key

copyUsing

public final ByteArrayCursor copyUsing(long aKey)

Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified

Specified by:

copyUsing in interface ScalarReplicator<ByteArrayCursor>

Overrides:

copyUsing in class AbstractBytePrimitive<ByteArrayCursor>

Parameters:

aKey - a new cursor

Returns:

a copy (clone) of this cursor initialized using same source domain and the specified key

copyUsing

public final ByteArrayCursor copyUsing(short aKey)

Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified

Specified by:

copyUsing in interface ScalarReplicator<ByteArrayCursor>

Overrides:

copyUsing in class AbstractBytePrimitive<ByteArrayCursor>

Parameters:

aKey - a new cursor

Returns:

a copy (clone) of this cursor initialized using same source domain and the specified key

copyUsingPrimitive

public final ByteArrayCursor copyUsingPrimitive(SealedPrimitive<?> aKey)

Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified

Specified by:

copyUsingPrimitive in interface PrimitiveReplicator<ByteArrayCursor>

Overrides:

copyUsingPrimitive in class AbstractBytePrimitive<ByteArrayCursor>

Parameters:

aKey - a new cursor

Returns:

a copy (clone) of this cursor initialized using same source domain and the specified key

copyUsingReal

public final ByteArrayCursor copyUsingReal(SealedReal<?> aKey)

Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified

Specified by:

copyUsingReal in interface RealReplicator<ByteArrayCursor>

Overrides:

copyUsingReal in class AbstractBytePrimitive<ByteArrayCursor>

Parameters:

aKey - a new cursor

Returns:

a copy (clone) of this cursor initialized using same source domain and the specified key

copyUsingScalar

public final ByteArrayCursor copyUsingScalar(SealedScalar<?> aKey)

Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified

Specified by:

copyUsingScalar in interface ScalarReplicator<ByteArrayCursor>

Overrides:

copyUsingScalar in class AbstractBytePrimitive<ByteArrayCursor>

Parameters:

aKey - a new cursor

Returns:

a copy (clone) of this cursor initialized using same source domain and the specified key

copyUsingText

public final ByteArrayCursor copyUsingText(CharSequence aKey)

Using this Cursor as a factory, produce a new Cursor of the same type, using the same source domain, but keyed using the value specified

Specified by:

copyUsingText in interface PrimitiveReplicator<ByteArrayCursor>

Specified by:

copyUsingText in interface TextReplicator<ByteArrayCursor>

Overrides:

copyUsingText in class AbstractNumericPrimitive<ByteArrayCursor>

Parameters:

aKey - a new cursor

Returns:

a copy (clone) of this cursor initialized using same source domain and the specified key

decrement

public final ByteArrayCursor decrement()
                                throws UnsupportedOperationException,
                                       ArithmeticException,
                                       IllegalArgumentException

Description copied from interface: MutableScalar

Replace the current value with the current value minus unity (one)

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object

IllegalArgumentException - if the new value was incommensurate with this object's specification

difference

public final ByteArrayCursor difference(byte aValue)
                                 throws UnsupportedOperationException,
                                        IllegalArgumentException,
                                        ArithmeticException

Description copied from interface: MutableScalar

Set the value of this scalar to the mathematical difference between its current value and the specified value

Specified by:

difference in interface MutableScalar<ByteArrayCursor>

Overrides:

difference in class AbstractScalar<ByteArrayCursor>

Parameters:

aValue - a subtrahend

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

IllegalArgumentException - if the new value was incommensurate with this object's specification

ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object

getConcurrency

public final ConcurrencyStrategy getConcurrency()

Returns:

the supported threading strategy

increment

public final ByteArrayCursor increment()
                                throws UnsupportedOperationException,
                                       ArithmeticException,
                                       IllegalArgumentException

Description copied from interface: MutableScalar

Replace the current value with the current value plus unity (one)

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object

IllegalArgumentException - if the new value was incommensurate with this object's specification

mod

public final ByteArrayCursor mod(byte aValue)
                          throws UnsupportedOperationException,
                                 IllegalArgumentException,
                                 ArithmeticException

Description copied from interface: MutableScalar

Set the value of this scalar to its current value modulo of the specified value

Specified by:

mod in interface MutableScalar<ByteArrayCursor>

Overrides:

mod in class AbstractScalar<ByteArrayCursor>

Parameters:

aValue - a modulus

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

IllegalArgumentException - if the new value was incommensurate with this object's specification

ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object

not

public final ByteArrayCursor not()
                          throws UnsupportedOperationException,
                                 IllegalArgumentException,
                                 ArithmeticException

Description copied from interface: MutableScalar

Replace the current integral binary vector with its one's complement. Decimal values, such as double, will be first converted to unlimited integers before their bits are reversed.

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

IllegalArgumentException - if the new value was incommensurate with this object's specification

ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object

or

public final ByteArrayCursor or(byte aValue)
                         throws UnsupportedOperationException,
                                IllegalArgumentException,
                                ArithmeticException

Description copied from interface: MutableScalar

Set this value to the bit or of the integral boolean vector equivalent of this value and the specified integral boolean vector

Specified by:

or in interface MutableScalar<ByteArrayCursor>

Overrides:

or in class AbstractScalar<ByteArrayCursor>

Parameters:

aValue - an integral boolean vector

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

IllegalArgumentException - if the new value was incommensurate with this object's specification

ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object

product

public final ByteArrayCursor product(byte aValue)
                              throws UnsupportedOperationException,
                                     IllegalArgumentException,
                                     ArithmeticException

Description copied from interface: MutableScalar

Set the value of this scalar to the mathematical product of its current value and the specified value

Specified by:

product in interface MutableScalar<ByteArrayCursor>

Overrides:

product in class AbstractScalar<ByteArrayCursor>

Parameters:

aValue - a multiplicand

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

IllegalArgumentException - if the new value was incommensurate with this object's specification

ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object

quotient

public final ByteArrayCursor quotient(byte aValue)
                               throws UnsupportedOperationException,
                                      IllegalArgumentException,
                                      ArithmeticException

Description copied from interface: MutableScalar

Set the value of this scalar to the mathematical quotient of its current value and the specified value

Specified by:

quotient in interface MutableScalar<ByteArrayCursor>

Overrides:

quotient in class AbstractScalar<ByteArrayCursor>

Parameters:

aValue - a divisor

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

IllegalArgumentException - if the new value was incommensurate with this object's specification

ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object

setScalar

public final ByteArrayCursor setScalar(byte aValue)
                                throws UnsupportedOperationException,
                                       IllegalArgumentException,
                                       ArithmeticException

Description copied from interface: MutableByteValue

Set this property to the specified byte value and answer this object (facilitates chaining)

Parameters:

aValue - a byte value

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

IllegalArgumentException - if the specified value was incommensurate with this object's specification

ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this object

shiftLeft

public final ByteArrayCursor shiftLeft(int count)
                                throws UnsupportedOperationException,
                                       IllegalArgumentException,
                                       ArithmeticException

Description copied from interface: MutableScalar

Attempt to shift the elements of this tuple to the "left" the specified number of ordinal positions. In a bit sequence this functions resorts to the familiar "left shift" process (e.g., Java <<). In other sequences, the specified number of default values will be prepended to the beginning of the sequence, increasing the ordinal position of all existing elements by the specified count.

Parameters:

count - the number of default values to be prepended to this sequence

Returns:

this structure (facilitates chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed or if this structure is not an algebraic tuple

IllegalArgumentException - if the specified value was incommensurate with this structure's specification

ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this structure

shiftRight

public final ByteArrayCursor shiftRight(int count)
                                 throws UnsupportedOperationException,
                                        IllegalArgumentException,
                                        ArithmeticException

Description copied from interface: MutableScalar

Attempt to shift the elements of this tuple to the "right" the specified number of ordinal positions. In a bit sequence this functions resorts to the familiar "right shift" process, with sign extension (e.g., the Java >> operator). In other sequences, the specified number of values will be removed from the beginning of the sequence, decreasing the ordinal position of all remaining elements by the specified count.

Parameters:

count - the number of values to be removed from the beginning of this sequence

Returns:

this structure (facilitates chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed or if this structure is not an algebraic tuple

IllegalArgumentException - if the specified value was incommensurate with this structure's specification

ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this structure

shiftRightExtendZero

public final ByteArrayCursor shiftRightExtendZero(int count)
                                           throws UnsupportedOperationException,
                                                  IllegalArgumentException,
                                                  ArithmeticException

Description copied from interface: MutableScalar

Attempt to shift the elements of this tuple to the "right" the specified number of ordinal positions without sign extension. In a bit sequence this functions resorts to the familiar "right shift" process, with zero extension (e.g., the Java >>> operator). In other sequences, the specified number of values will be removed from the beginning of the sequence, decreasing the ordinal position of all remaining elements by the specified count.

Specified by:

shiftRightExtendZero in interface MutableScalar<ByteArrayCursor>

Overrides:

shiftRightExtendZero in class AbstractScalar<ByteArrayCursor>

Parameters:

count - the number of values to be removed from the beginning of this sequence

Returns:

this structure (facilitates chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed or if this structure is not an algebraic tuple

IllegalArgumentException - if the specified value was incommensurate with this structure's specification

ArithmeticException - the numeric value provided was incompatible with with algebraic interpretation of this structure

sum

public final ByteArrayCursor sum(byte aValue)
                          throws UnsupportedOperationException,
                                 IllegalArgumentException,
                                 ArithmeticException

Description copied from interface: MutableScalar

Set the value of this scalar to the mathematical sum of its current value and the specified value

Specified by:

sum in interface MutableScalar<ByteArrayCursor>

Overrides:

sum in class AbstractScalar<ByteArrayCursor>

Parameters:

aValue - an addend

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

IllegalArgumentException - if the new value was incommensurate with this object's specification

ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object

xor

public final ByteArrayCursor xor(byte aValue)
                          throws UnsupportedOperationException,
                                 IllegalArgumentException,
                                 ArithmeticException

Description copied from interface: MutableScalar

Set this value to the bit exclusive-or of the integral boolean vector equivalent of this value and the specified integral boolean vector

Specified by:

xor in interface MutableScalar<ByteArrayCursor>

Overrides:

xor in class AbstractScalar<ByteArrayCursor>

Parameters:

aValue - an integral boolean vector

Returns:

this object (facilitates operation chaining)

Throws:

UnsupportedOperationException - if this object's value cannot be changed

IllegalArgumentException - if the new value was incommensurate with this object's specification

ArithmeticException - the new numeric value was incompatible with with algebraic interpretation of this object