Modifier and Type | Interface and Description |
---|---|
interface |
Accumulator<ACCUMULATOR extends Accumulator<ACCUMULATOR>>
An Accumulator is a three-way association between a
Primitive
target, a Javascript-like associative list of
member relationships, and a function defined by the subclass of
Accumulator. |
interface |
SealedAccumulator<ACCUMULATOR extends SealedAccumulator<ACCUMULATOR>>
A read-only
Accumulator |
Modifier and Type | Class and Description |
---|---|
class |
AbstractAccumulator<ACCUMULATOR extends Accumulator<ACCUMULATOR>>
Common
Accumulator behavior |
class |
AbstractConstantAccumulator<ACCUMULATOR extends AbstractConstantAccumulator<ACCUMULATOR>>
Common behavior for Accumulators with read-only
Primitive
targets and read-only relationship
collections |
class |
AbstractSimpleAccumulator<ACCUMULATOR extends Accumulator<ACCUMULATOR>>
Common behavior for a simple Accumulator with an independent, replaceable
target Primitive |
class |
AbstractStickyTarget<ACCUMULATOR extends Accumulator<ACCUMULATOR>>
Common behavior for a simple Accumulator with an independent,
non-replaceable
target Primitive |
class |
ConstantAccumulator
|
class |
SimpleAccumulator
A simple Accumulator with an independent, replaceable
target Primitive |
Modifier and Type | Method and Description |
---|---|
ACCUMULATOR |
AccumulatorReplicator.copyUsingPrimitive(SealedPrimitive<?> aValue)
|
ACCUMULATOR |
AbstractConstantAccumulator.copyUsingPrimitive(SealedPrimitive<?> aValue) |
ACCUMULATOR |
AbstractAccumulator.copyUsingPrimitive(SealedPrimitive<?> aValue) |
Modifier and Type | Class and Description |
---|---|
class |
AbstractBooleanPrimitive<PRIMITIVE extends AbstractBooleanPrimitive<PRIMITIVE>>
Abstract
boolean precision primitive implementation |
class |
BooleanArrayCursor
A
boolean fixed array cursor |
class |
BooleanPrimitive
|
Modifier and Type | Method and Description |
---|---|
BooleanArrayCursor |
BooleanArrayCursor.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 |
PRIMITIVE |
AbstractBooleanPrimitive.copyUsingPrimitive(SealedPrimitive<?> aValue) |
PRIMITIVE |
AbstractBooleanPrimitive.setPrimitive(SealedPrimitive<?> aValue) |
Modifier and Type | Class and Description |
---|---|
class |
AbstractBytePrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
Abstract
byte precision primitive implementation |
class |
ByteArrayCursor
A
byte fixed array cursor |
class |
BytePrimitive
A
byte precision primitive implementation |
Modifier and Type | Method and Description |
---|---|
ByteArrayCursor |
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 |
PRIMITIVE |
AbstractBytePrimitive.copyUsingPrimitive(SealedPrimitive<?> aValue) |
PRIMITIVE |
AbstractBytePrimitive.setPrimitive(SealedPrimitive<?> aValue) |
Modifier and Type | Class and Description |
---|---|
class |
AbstractCharacterPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
Abstract
char precision primitive implementation |
class |
CharacterArrayCursor
A
char fixed array Cursor |
class |
CharacterPrimitive
A
char precision primitive implementation |
Modifier and Type | Method and Description |
---|---|
CharacterArrayCursor |
CharacterArrayCursor.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 |
PRIMITIVE |
AbstractCharacterPrimitive.copyUsingPrimitive(SealedPrimitive<?> aValue) |
PRIMITIVE |
AbstractCharacterPrimitive.setPrimitive(SealedPrimitive<?> aValue) |
Modifier and Type | Class and Description |
---|---|
class |
AbstractDoublePrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
Abstract
double precision primitive implementation |
class |
DoublePrimitive
A
double precision primitive implementation |
Modifier and Type | Method and Description |
---|---|
PRIMITIVE |
AbstractDoublePrimitive.copyUsingPrimitive(SealedPrimitive<?> aValue) |
PRIMITIVE |
AbstractDoublePrimitive.setPrimitive(SealedPrimitive<?> aValue) |
Modifier and Type | Class and Description |
---|---|
class |
AbstractFloatPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
Abstract
float precision primitive implementation |
class |
FloatPrimitive
A
float precision primitive implementation |
Modifier and Type | Method and Description |
---|---|
PRIMITIVE |
AbstractFloatPrimitive.copyUsingPrimitive(SealedPrimitive<?> aValue) |
PRIMITIVE |
AbstractFloatPrimitive.setPrimitive(SealedPrimitive<?> aValue) |
Modifier and Type | Class and Description |
---|---|
class |
GaussianRandomPrimitive
A
RandomPrimitive that returns values that conform to a
Gaussian distribution |
class |
Milliseconds
|
class |
Nanoseconds
|
class |
RandomPrimitive
Wraps a
Random number generator, producing next numbers in sequence
upon demand. |
Modifier and Type | Method and Description |
---|---|
RandomPrimitive |
RandomPrimitive.copyUsingPrimitive(SealedPrimitive<?> aValue) |
Modifier and Type | Class and Description |
---|---|
class |
AbstractIntegerPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
Abstract
int precision primitive implementation |
class |
AbstractModuloIntegerPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
Common behavior for all
integer primitives that
obey modular arithmetic |
class |
EnumerationPrimitive
A
int precision primitive implementation |
class |
IntegerPrimitive
A
int precision primitive implementation |
class |
ModuloIntegerPrimitive
A
int precision primitive implementation |
Modifier and Type | Method and Description |
---|---|
PRIMITIVE |
AbstractIntegerPrimitive.copyUsingPrimitive(SealedPrimitive<?> aValue) |
EnumerationPrimitive |
EnumerationPrimitive.setPrimitive(SealedPrimitive<?> aValue) |
PRIMITIVE |
AbstractIntegerPrimitive.setPrimitive(SealedPrimitive<?> aValue) |
Modifier and Type | Method and Description |
---|---|
boolean |
True.acceptPrimitive(SealedPrimitive<?> aSignal,
MODEL aModel) |
boolean |
PrimitiveProduction.acceptPrimitive(SealedPrimitive<?> aSignal,
MODEL aModel) |
boolean |
PrimitiveGuard.acceptPrimitive(SealedPrimitive<?> aSignal,
MODEL aModel) |
boolean |
False.acceptPrimitive(SealedPrimitive<?> aSignal,
MODEL aModel) |
ControlIntention |
PrimitiveProduction.reactToPrimitive(SealedPrimitive<?> aSignal,
MODEL aModel) |
ControlIntention |
PrimitiveAction.reactToPrimitive(SealedPrimitive<?> aSignal,
MODEL aModel) |
ControlIntention |
To.reactToPrimitive(SealedPrimitive<?> aSignal,
Primitive<?> aModel) |
ControlIntention |
To.ToPrimitive.reactToPrimitive(SealedPrimitive<?> aSignal,
Primitive<?> aModel) |
ControlIntention |
To.ToReal.reactToPrimitive(SealedPrimitive<?> aSignal,
Primitive<?> aModel) |
ControlIntention |
To.ToScalar.reactToPrimitive(SealedPrimitive<?> aSignal,
Primitive<?> aModel) |
Modifier and Type | Class and Description |
---|---|
class |
AbstractLongPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
Abstract
long precision primitive implementation |
class |
LongPrimitive
A
long precision primitive implementation |
Modifier and Type | Method and Description |
---|---|
PRIMITIVE |
AbstractLongPrimitive.copyUsingPrimitive(SealedPrimitive<?> aValue) |
PRIMITIVE |
AbstractLongPrimitive.setPrimitive(SealedPrimitive<?> aValue) |
Modifier and Type | Interface and Description |
---|---|
interface |
SealedPrimitive<PRIMITIVE extends SealedPrimitive<PRIMITIVE>>
Read operations for system supported primitives.
|
Modifier and Type | Interface and Description |
---|---|
interface |
Primitive<PRIMITIVE extends Primitive<PRIMITIVE>>
Read and write operations for system supported primitives.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractConstant<PRIMITIVE extends Primitive<PRIMITIVE>>
A sealed
primitive whose modification functions are shunted
and which will produce UnsupportedOperationExceptions upon access |
class |
AbstractNumericPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
|
class |
AbstractPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
Common read and write behavior for primitive representations
|
class |
AbstractPrimitiveWrapper<PRIMITIVE extends Primitive<PRIMITIVE>>
An abstract
primitive wrapper, ready to be overridden and
missing only the protected AbstractPrimitiveWrapper.getTarget() and the explicit
copy functions |
class |
Constant
Read-only
primitive |
class |
Variant
|
Modifier and Type | Method and Description |
---|---|
PRIMITIVE |
MutablePrimitive.andOfPrimitive(SealedPrimitive<?> aValue)
Set this value to the bit and of the integral boolean
vector equivalent of this value and the specified integral boolean vector
|
PRIMITIVE |
AbstractPrimitive.andOfPrimitive(SealedPrimitive<?> aValue) |
PRIMITIVE |
MutablePrimitive.angleWithPrimitive(SealedPrimitive<?> y)
Set this value to the angle formed by the rectangular coordinates given
by the current value, x, and the specified value, y.
|
PRIMITIVE |
AbstractPrimitive.angleWithPrimitive(SealedPrimitive<?> aValue) |
int |
AbstractPrimitiveWrapper.compareTo(SealedPrimitive<?> o) |
int |
AbstractNumericPrimitive.compareTo(SealedPrimitive<?> aComparable) |
int |
SealedPrimitive.compareToPrimitive(SealedPrimitive<?> aPrimitive)
Compares this object with the specified object for order
|
int |
AbstractPrimitiveWrapper.compareToPrimitive(SealedPrimitive<?> aPrimitive) |
int |
AbstractNumericPrimitive.compareToPrimitive(SealedPrimitive<?> aComparable) |
Variant |
Variant.copyUsingPrimitive(SealedPrimitive<?> aValue) |
PRIMITIVE |
PrimitiveReplicator.copyUsingPrimitive(SealedPrimitive<?> aValue)
Using this primitive as a factory, produce a new primitive of the same
type but initialized with the value specified
|
Constant |
Constant.copyUsingPrimitive(SealedPrimitive<?> aValue) |
PRIMITIVE |
MutablePrimitive.differenceOfPrimitive(SealedPrimitive<?> aValue)
Set the value of this scalar to the mathematical difference
between its current value and the specified value.
|
PRIMITIVE |
AbstractPrimitive.differenceOfPrimitive(SealedPrimitive<?> aValue) |
PRIMITIVE |
MutablePrimitive.hypotenuseWithPrimitive(SealedPrimitive<?> y)
Set this value to the hypotenuse formed by the square root of the sum of
the square of the current value, x, and the square of the
specified value, y, without intermediate overflow or underflow
|
PRIMITIVE |
AbstractPrimitive.hypotenuseWithPrimitive(SealedPrimitive<?> aValue) |
boolean |
SealedPrimitive.isEqualToPrimitive(SealedPrimitive<?> aPrimitive) |
boolean |
AbstractPrimitiveWrapper.isEqualToPrimitive(SealedPrimitive<?> aPrimitive) |
boolean |
AbstractNumericPrimitive.isEqualToPrimitive(SealedPrimitive<?> aValue) |
boolean |
SealedPrimitive.isGreaterOrEqualToPrimitive(SealedPrimitive<?> aPrimitive) |
boolean |
AbstractPrimitiveWrapper.isGreaterOrEqualToPrimitive(SealedPrimitive<?> aPrimitive) |
boolean |
AbstractNumericPrimitive.isGreaterOrEqualToPrimitive(SealedPrimitive<?> aValue) |
boolean |
SealedPrimitive.isGreaterThanPrimitive(SealedPrimitive<?> aPrimitive) |
boolean |
AbstractPrimitiveWrapper.isGreaterThanPrimitive(SealedPrimitive<?> aPrimitive) |
boolean |
AbstractNumericPrimitive.isGreaterThanPrimitive(SealedPrimitive<?> aValue) |
boolean |
SealedPrimitive.isLessOrEqualToPrimitive(SealedPrimitive<?> aPrimitive) |
boolean |
AbstractPrimitiveWrapper.isLessOrEqualToPrimitive(SealedPrimitive<?> aPrimitive) |
boolean |
AbstractNumericPrimitive.isLessOrEqualToPrimitive(SealedPrimitive<?> aValue) |
boolean |
SealedPrimitive.isLessThanPrimitive(SealedPrimitive<?> aPrimitive) |
boolean |
AbstractPrimitiveWrapper.isLessThanPrimitive(SealedPrimitive<?> aPrimitive) |
boolean |
AbstractNumericPrimitive.isLessThanPrimitive(SealedPrimitive<?> aValue) |
boolean |
SealedPrimitive.isNotEqualToPrimitive(SealedPrimitive<?> aPrimitive) |
boolean |
AbstractPrimitiveWrapper.isNotEqualToPrimitive(SealedPrimitive<?> aPrimitive) |
boolean |
AbstractNumericPrimitive.isNotEqualToPrimitive(SealedPrimitive<?> aValue) |
PRIMITIVE |
MutablePrimitive.modOfPrimitive(SealedPrimitive<?> aValue)
Set the value of this scalar to its current value modulo of the
specified value
|
PRIMITIVE |
AbstractPrimitive.modOfPrimitive(SealedPrimitive<?> aValue) |
PRIMITIVE |
MutablePrimitive.orOfPrimitive(SealedPrimitive<?> aValue)
Set this value to the bit or of the integral boolean vector
equivalent of this value and the specified integral boolean vector
|
PRIMITIVE |
AbstractPrimitive.orOfPrimitive(SealedPrimitive<?> aValue) |
PRIMITIVE |
MutablePrimitive.powerOfPrimitive(SealedPrimitive<?> aValue)
Set this value to the current value, x, raised to the specified
exponent, n, or xn
|
PRIMITIVE |
AbstractPrimitive.powerOfPrimitive(SealedPrimitive<?> aValue) |
PRIMITIVE |
MutablePrimitive.productOfPrimitive(SealedPrimitive<?> aValue)
Set the value of this scalar to the mathematical product of its
current value and the specified value.
|
PRIMITIVE |
AbstractPrimitive.productOfPrimitive(SealedPrimitive<?> aValue) |
PRIMITIVE |
MutablePrimitive.quotientOfPrimitive(SealedPrimitive<?> aValue)
Set the value of this scalar to the mathematical quotient between
its current value and the specified value.
|
PRIMITIVE |
AbstractPrimitive.quotientOfPrimitive(SealedPrimitive<?> aValue) |
PRIMITIVE |
MutablePrimitive.setPrimitive(SealedPrimitive<?> aValue)
Set this property to the specified primitive
|
PRIMITIVE |
AbstractPrimitiveWrapper.setPrimitive(SealedPrimitive<?> aValue) |
PRIMITIVE |
AbstractNumericPrimitive.setPrimitive(SealedPrimitive<?> aValue) |
PRIMITIVE |
MutablePrimitive.sumOfPrimitive(SealedPrimitive<?> aValue)
Set the value of this scalar to the mathematical sum of its
current value and the specified value.
|
PRIMITIVE |
AbstractPrimitive.sumOfPrimitive(SealedPrimitive<?> aValue) |
static Variant |
Variant.valueOfPrimitive(SealedPrimitive<?> aValue) |
static Constant |
Constant.valueOfPrimitive(SealedPrimitive<?> aPrimitive) |
PRIMITIVE |
MutablePrimitive.xorOfPrimitive(SealedPrimitive<?> aValue)
Set this value to the bit exclusive-or of the integral
boolean vector equivalent of this value and the specified integral
boolean vector
|
PRIMITIVE |
AbstractPrimitive.xorOfPrimitive(SealedPrimitive<?> aValue) |
Modifier and Type | Class and Description |
---|---|
class |
AbstractShortPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
Abstract
short precision primitive implementation |
class |
ShortPrimitive
A
short precision primitive implementation |
Modifier and Type | Method and Description |
---|---|
PRIMITIVE |
AbstractShortPrimitive.copyUsingPrimitive(SealedPrimitive<?> aValue) |
PRIMITIVE |
AbstractShortPrimitive.setPrimitive(SealedPrimitive<?> aValue) |
Modifier and Type | Class and Description |
---|---|
class |
AbstractTextPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
|
class |
TextPrimitive
|
Modifier and Type | Method and Description |
---|---|
int |
AbstractTextPrimitive.compareTo(SealedPrimitive<?> aPrimitive) |
int |
AbstractTextPrimitive.compareToPrimitive(SealedPrimitive<?> aPrimitive) |
PRIMITIVE |
AbstractTextPrimitive.copyUsingPrimitive(SealedPrimitive<?> aValue) |
boolean |
AbstractTextPrimitive.isEqualToPrimitive(SealedPrimitive<?> aPrimitive) |
boolean |
AbstractTextPrimitive.isGreaterOrEqualToPrimitive(SealedPrimitive<?> aPrimitive) |
boolean |
AbstractTextPrimitive.isGreaterThanPrimitive(SealedPrimitive<?> aPrimitive) |
boolean |
AbstractTextPrimitive.isLessOrEqualToPrimitive(SealedPrimitive<?> aPrimitive) |
boolean |
AbstractTextPrimitive.isLessThanPrimitive(SealedPrimitive<?> aPrimitive) |
boolean |
AbstractTextPrimitive.isNotEqualToPrimitive(SealedPrimitive<?> aPrimitive) |
PRIMITIVE |
AbstractTextPrimitive.setPrimitive(SealedPrimitive<?> aValue) |
Modifier and Type | Class and Description |
---|---|
class |
AbstractUnlimitedDecimalPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
|
class |
AbstractUnlimitedIntegerPrimitive<PRIMITIVE extends Primitive<PRIMITIVE>>
|
class |
UnlimitedDecimalPrimitive
|
class |
UnlimitedIntegerPrimitive
|
Modifier and Type | Method and Description |
---|---|
UnlimitedIntegerPrimitive |
UnlimitedIntegerPrimitive.copyUsingPrimitive(SealedPrimitive<?> aValue) |
UnlimitedDecimalPrimitive |
UnlimitedDecimalPrimitive.copyUsingPrimitive(SealedPrimitive<?> aValue) |
PRIMITIVE |
AbstractUnlimitedIntegerPrimitive.setPrimitive(SealedPrimitive<?> aValue) |
PRIMITIVE |
AbstractUnlimitedDecimalPrimitive.setPrimitive(SealedPrimitive<?> aValue) |
Constructor and Description |
---|
AbstractUnlimitedIntegerPrimitive(SealedPrimitive<?> aValue) |
UnlimitedIntegerPrimitive(SealedPrimitive<?> aValue) |
Copyright © 2006-2012 Ware-Squared Software Development. All Rights Reserved.