net.sf.jaccumulator

Interface AccumulatorReplicator<ACCUMULATOR extends AccumulatorReplicator<ACCUMULATOR>>

Type Parameters:

ACCUMULATOR - the factory product

All Superinterfaces:

PrimitiveReplicator<ACCUMULATOR>, RealReplicator<ACCUMULATOR>, Replicator<ACCUMULATOR>, ScalarReplicator<ACCUMULATOR>

All Known Subinterfaces:

Accumulator<ACCUMULATOR>, SealedAccumulator<ACCUMULATOR>

All Known Implementing Classes:

AbstractAccumulator, AbstractConstantAccumulator, AbstractSimpleAccumulator, AbstractStickyTarget, ConstantAccumulator, SimpleAccumulator

public interface AccumulatorReplicator<ACCUMULATOR extends AccumulatorReplicator<ACCUMULATOR>>
extends PrimitiveReplicator<ACCUMULATOR>

A replicator for Accumulators

Since:

JAccumulator 4.0

Author:

Nicole Tedesco (Nicole@NicoleTedesco.com)

Method Summary

Methods

Modifier and Type	Method and Description
ACCUMULATOR	copy() Minimize implicit loops and produce a shallow copy of this Accumulator.
ACCUMULATOR	copySharing(Accumulator<?> anAccumulator) Using this Accumulator as a factory, and where possible, produce a new Accumulator of the same type but directly sharing the target Primitive and its relationship collection.
ACCUMULATOR	copySharing(net.sf.jupperware.association.AssociativeList<Accumulator<?>,Accumulator<?>> members) Using this Accumulator as a factory, and where possible, produce a new Accumulator of the same type but directly share the specified relationship collection.
ACCUMULATOR	copySharing(Primitive<?> aTarget) Using this Accumulator as a factory, and where possible, produce a new Accumulator of the same type but directly share the specified Primitive target.
ACCUMULATOR	copySharing(Primitive<?> aTarget, net.sf.jupperware.association.AssociativeList<Accumulator<?>,Accumulator<?>> members) Using this Accumulator as a factory, and where possible, produce a new Accumulator of the same type but directly share the specified Primitive target and relationship collection.
ACCUMULATOR	copyUsingAccumulator(SealedAccumulator<?> anAccumulator) Using this Accumulator as a factory, produce a new Accumulator of the same type but initialized with the target Primitive and a shallow copy of the members of the specified Accumulator
ACCUMULATOR	copyUsingPrimitive(SealedPrimitive<?> aValue) Using this Accumulator as a factory, produce a new Accumulator of the same type, and with a shallow copy of its members, but initialize the Primitive target of the new instance with the specified value
Accumulator<?>	toAccumulator() If this object is already Accumulator then simply call its copy() function, otherwise convert it to a new Accumulator instance

Methods inherited from interface net.sf.jaccumulator.primitives.PrimitiveReplicator

copyUsingText, toPrimitive

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

copyUsing, copyUsing, copyUsingReal, toReal

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

copyUsing, copyUsing, copyUsing, copyUsing, copyUsing, copyUsing, copyUsing, copyUsing, copyUsingScalar, toScalar

Method Detail

copy

ACCUMULATOR copy()

Minimize implicit loops and produce a shallow copy of this Accumulator. The new copy will possess its own member collection management system but will share each member instance.

Specified by:

copy in interface Replicator<ACCUMULATOR extends AccumulatorReplicator<ACCUMULATOR>>

Returns:

a shallow copy of this Accumulator

copySharing

ACCUMULATOR copySharing(Accumulator<?> anAccumulator)

Using this Accumulator as a factory, and where possible, produce a new Accumulator of the same type but directly sharing the target Primitive and its relationship collection. Where direct sharing is not possible, shallow copies will be performed instead.

Parameters:

anAccumulator - an Accumulator to share with

Returns:

a copy of this Accumulator that directly shares the target Primitive and and its relationship collection

copySharing

ACCUMULATOR copySharing(net.sf.jupperware.association.AssociativeList<Accumulator<?>,Accumulator<?>> members)

Using this Accumulator as a factory, and where possible, produce a new Accumulator of the same type but directly share the specified relationship collection. Where direct sharing is not possible, shallow copies will be performed instead.

Parameters:

members - the relationship collection to share

Returns:

a copy of this Accumulator that directly shares the specified relationship collection

copySharing

ACCUMULATOR copySharing(Primitive<?> aTarget)

Using this Accumulator as a factory, and where possible, produce a new Accumulator of the same type but directly share the specified Primitive target. Where direct sharing is not possible, shallow copies will be performed instead.

Parameters:

members - the Primitive to share

Returns:

a copy of this Accumulator that directly shares the specified Primitive target

copySharing

ACCUMULATOR copySharing(Primitive<?> aTarget,
                      net.sf.jupperware.association.AssociativeList<Accumulator<?>,Accumulator<?>> members)

Using this Accumulator as a factory, and where possible, produce a new Accumulator of the same type but directly share the specified Primitive target and relationship collection. Where direct sharing is not possible, shallow copies will be performed instead.

Parameters:

aTarget - the Primitive to share

members - the relationship collection to share

Returns:

a copy of this Accumulator that directly shares the specified Primitive target and relationship collection

copyUsingAccumulator

ACCUMULATOR copyUsingAccumulator(SealedAccumulator<?> anAccumulator)

Using this Accumulator as a factory, produce a new Accumulator of the same type but initialized with the target Primitive and a shallow copy of the members of the specified Accumulator

Parameters:

anAccumulator - an Accumulator to copy from

Returns:

a copy of this Accumulator initialized using the target Primitive and a shallow copy of the members of the specified Accumulator

copyUsingPrimitive

ACCUMULATOR copyUsingPrimitive(SealedPrimitive<?> aValue)

Using this Accumulator as a factory, produce a new Accumulator of the same type, and with a shallow copy of its members, but initialize the Primitive target of the new instance with the specified value

Specified by:

copyUsingPrimitive in interface PrimitiveReplicator<ACCUMULATOR extends AccumulatorReplicator<ACCUMULATOR>>

Parameters:

aValue - a new value

Returns:

a new Accumulator of this type, a shallow copy of its current members, but a Primitive target initialized using the specified value

toAccumulator

Accumulator<?> toAccumulator()

If this object is already Accumulator then simply call its copy() function, otherwise convert it to a new Accumulator instance

Returns:

a new Accumulator