org.abora.gold.tumbler
Class SequenceRegion

java.lang.Object
  |
  +--org.abora.gold.java.AboraHeaper
        |
        +--org.abora.gold.xpp.basic.Heaper
              |
              +--org.abora.gold.spaces.basic.XnRegion
                    |
                    +--org.abora.gold.tumbler.SequenceRegion

public class SequenceRegion

extends XnRegion

Represents a Region of Sequences. We can efficiently represent unions of intervals,
delimited either by individual sequences or by a match with all sequences prefixed by some
sequence up to some index.

Field Summary

protected boolean	myStartsInside
protected PtrArray	myTransitions
protected int	myTransitionsCount
protected static SequenceRegion	TheEmptySequenceRegion
protected static SequenceRegion	TheFullSequenceRegion
protected static SequenceManager	TheManager

Fields inherited from class org.abora.gold.spaces.basic.XnRegion

CantMixCoordSpacesSignal, EmptyRegionSignal

Fields inherited from class org.abora.gold.xpp.basic.Heaper

AllBlasts, BecomeMap, GarbageCount, InGC, InitializedClasses, InitializingClasses, LastMemory, NextClientRequestNumber, NotOneElementSignal, PackageTable, PromiseNameTable, StringHashSBoxes

Fields inherited from class org.abora.gold.java.AboraHeaper

ActiveClubs, CurrentAuthor, CurrentBertCanopyCache, CurrentBertCrum, CurrentChunk, CurrentGrandMap, CurrentKeyMaster, CurrentPacker, CurrentSensorCanopyCache, CurrentServer, CurrentSession, CurrentSessions, CurrentTrace, InitialEditClub, InitialOwner, InitialReadClub, InitialSponsor, InsideTransactionFlag

Constructor Summary

SequenceRegion(boolean startsInside, PtrArray transitions)

SequenceRegion(boolean startsInside, PtrArray transitions, int count)

SequenceRegion(Rcvr receiver)

Method Summary

static SequenceRegion	above(Sequence sequence)
int	actualHashForEqual()
Stepper	actualStepper(OrderSpec order) Only called if I've already said I'm enumerable in the originally stated order.
XnRegion	asSimpleRegion() Return a simple region containing all positions contained by myself. If I am simple, then the result must be me.
static SequenceRegion	below(Sequence sequence)
XnRegion	complement() Essential.
CoordinateSpace	coordinateSpace() Essential.
IntegerVar	count() How many positions do I contain? If I am not 'isFinite', then this message will BLAST.
ScruSet	distinctions() Break it up into a set of non-full distinctions.
static SequenceRegion	empty()
static int	EXCLUSIVE()
static SequenceRegion	full()
boolean	hasMember(Position position) Do I contain this position? More than anything else, the behavior of this message is the defining characteristic of an XuRegion.
static int	INCLUSIVE()
static void	info() {Int32 constFn CLIENT INLINE} EXCLUSIVE {Int32 constFn CLIENT INLINE} INCLUSIVE {Int32 constFn CLIENT INLINE} PREFIX {Stepper CLIENT of: SequenceRegion} intervals: order {OrderSpec default: NULL} {BooleanVar CLIENT} isBoundedAbove {BooleanVar CLIENT} isBoundedBelow {BooleanVar CLIENT} isInterval {Sequence CLIENT} lowerEdge {IntegerVar CLIENT} lowerEdgePrefixLimit {Int32 CLIENT} lowerEdgeType {Sequence CLIENT} upperEdge {IntegerVar CLIENT} upperEdgePrefixLimit {Int32 CLIENT} upperEdgeType
static void	initTimeNonInherited()
XnRegion	intersect(XnRegion other) Essential.
Stepper	intervals()
Stepper	intervals(OrderSpec order) Essential.
boolean	isBoundedAbove() Same meaning as IntegerRegion::isBoundedAbove
boolean	isBoundedBelow() Same meaning as IntegerRegion::isBoundedBelow
boolean	isEmpty() Every coordinate space has exactly one empty region.
boolean	isEnumerable(OrderSpec order) See comment in XuRegion::stepper. a->stepper(os) won't BLAST iff a->isEnumerable(os)
boolean	isEqual(Heaper other) Two regions are equal iff they contain exactly the same set of positions
boolean	isFinite() Essential.
boolean	isFull() true if this is the largest possible region in this space -- the region that contains all positions in the space.
boolean	isInterval() Whether this Region is a non-empty interval, i.e.
boolean	isSimple() Am I a simple region.
boolean	isSubsetOf(XnRegion other) I'm a subset of other if I don't have any positions that he doesn't.
static void	linkTimeNonInherited()
Sequence	lowerBound() The largest sequence such that all the positions in the region are >= it.
Sequence	lowerEdge() Essential.
IntegerVar	lowerEdgePrefixLimit() Essential.
int	lowerEdgeType() Essential.
static int	PREFIX()
static SequenceRegion	prefixedBy(Sequence sequence, IntegerVar limit) All sequences matching the given up to and including the number at limit
void	printOn(java.io.PrintWriter oo)
void	receiveSequenceRegion(Rcvr rcvr)
PtrArray	secretTransitions()
int	secretTransitionsCount()
void	sendSelfTo(Xmtr xmtr) do nothing
void	sendSequenceRegion(Xmtr xmtr)
Stepper	simpleRegions(OrderSpec order) Break myself up into a finite set of non-empty simple regions which, when unionWith'ed together will yield me.
XnRegion	simpleUnion(XnRegion other) The result must contain all positions contained by either of the two original regions, and the result must be simple.
boolean	startsInside()
Stepper	stepper(OrderSpec order) Essential.
static SequenceRegion	strictlyAbove(Sequence sequence)
static SequenceRegion	strictlyBelow(Sequence sequence)
XnRegion	unionWith(XnRegion other) The result has as members exactly those positions which are members of either of the original two regions.
Sequence	upperBound() The smallest Sequence such that all the positions in the region are <= it.
Sequence	upperEdge() Essential.
IntegerVar	upperEdgePrefixLimit() Essential.
int	upperEdgeType() Essential.
static SequenceRegion	usingx(boolean startsInside, PtrArray transitions) Make a new region, reusing the given array.
XnRegion	with(Position pos) the region with one more position.
static SequenceRegion	with(Sequence sequence)

Methods inherited from class org.abora.gold.spaces.basic.XnRegion

asArray, chooseMany, chooseMany, chooseOne, chooseOne, delta, disjointSimpleRegions, disjointSimpleRegions, dox, immuSet, intersects, isDistinction, isEnumerable, mapping, minus, simpleRegions, stepper, theOne, without

Methods inherited from class org.abora.gold.xpp.basic.Heaper

abstractDeclarationFor, abstractTypeFor, addMethodAttributeToInOf, addPackage, addPackageCategory, allClientProtocolOn, argumentTypesFor, arrow, blast, blast, BLAST, cachePromiseNameTable, cachePromiseNameTableIn, canYouBecome, cast, cleanPromiseClasses, cleanupGarbage, clientClassesDo, clientFunctionsOn, clientMethodsOn, clientProtocol, clientProtocolDo, clientProtocolOn, clientProtocolOn, collectibleClasses, compare, compileClientSubclasses, compileConstantPromiseMethods, compileCreateFromRcvr, compileEQ, compileGeneratedClassMethod, compileGeneratedMethod, compileHook, compilePromise, compilePromiseDefaultMethods, compilePromiseFluidDeclarations, compilePromiseHandlers, compilePromiseMethods, compileRequestCreateMsgInArguments, compileRequestEvaluateMsgInReturningArguments, compileRPCSpecialistEvaluateMsgForReturningArguments, compileSendSelfTo, compileSendSelfToSendHook, compileStubbleMethods, compileSubclassStubbleMethods, computeMangle, computePreorder, constantTypeValue, convert, convertCopyDeclarations, convertDeferredDeclarations, convertProxyDeclarations, convertSubclassCopyDeclarations, convertSubclassDeferredDeclarations, convertSubclassProxyDeclarations, copyReferencesToType, create, create, create, create, create, create, create, create, create, create, createRequestClassArguments, definesProxyMethods, delete, deref, destroy, destruct, destructor, enum, enumFlags, equals, exportName, fetchAttribute, fetchPackage, fetchSuperCategory, fileOutClientProtocol, findCategory, findSenderAndReceiverMethods, findTailInto, flushPromiseNameTable, foo, freezeClientClasses, freezeClientProtocol, freezeStProtocol, frozenClasses, garbageCollect, garbageCollectFrom, gcOpportunity, gcOpportunity, generatedCategory, generatePromiseNames, getCategory, getOrMakePackage, getSuperCategory, handlerSignaturesFrom, hash, hashForEqual, hasProxyMethods, info_clientClasses, info_clientSideClasses, info_promiseClasses, info_stProtocol, inGC, initializedClasses, initializingClasses, initPackages, initStringHashSBoxes, inspectPieces, instanceSize, IntegerVar, isByProxy, isConstructed, isDestructed, isEqualOrSubclassOf, isGenerated, isIntType, isKindOf, isRawType, isUnlocked, make, makeClassTable, makeFillTable, makeRequestTable, mangle, markChildren, markCount, markInstances, mayBecome, mayBecomeAnySubclassOf, new1, newX, nonCopyVariables, notWorking, pack, packageClasses, packagingCategory, parseExportName, passe, pointerToStaticMember, pointerToStaticMember, pointerToVirtualMember, preorderMax, preorderNumber, PROBLEM, problems, promiseClass, promiseDefaultValue, promiseName, promiseNameTable, promiseToAbstract, registerPackageCategory, removeGeneratedCode, removeStubbleMethods, removeSubclassGeneratedCode, removeSubclassStubbleMethods, requestProcedure, requestProceduresFrom, returnTypeFor, rootName, scheduleTermination, sendProxyTo, serverNameFor, setGC, signal, signals, smalltalkSelector, stClientProtocol, stubbleSelectorTokenReturnsArguments, subclassNonCopyVariables, takeOop, togglePromiseName, togglePromiseOfParse, unimplemented, unmangle, verifyFreeze, wipeStubble

Methods inherited from class org.abora.gold.java.AboraHeaper

asOop, basicInspect, displayString, error, hack, halt, inspect, knownBug, mightNotImplement, REQUIRES, shouldImplement, shouldNotImplement, stubbleForSubclassResponsibility, thingToDo, willNotImplement

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

myStartsInside

protected boolean myStartsInside

myTransitions

protected PtrArray myTransitions

myTransitionsCount

protected int myTransitionsCount

TheEmptySequenceRegion

protected static SequenceRegion TheEmptySequenceRegion

TheFullSequenceRegion

protected static SequenceRegion TheFullSequenceRegion

TheManager

protected static SequenceManager TheManager

Constructor Detail

SequenceRegion

public SequenceRegion(boolean startsInside,
                      PtrArray transitions)

SequenceRegion

public SequenceRegion(boolean startsInside,
                      PtrArray transitions,
                      int count)

SequenceRegion

public SequenceRegion(Rcvr receiver)

Method Detail

asSimpleRegion

public XnRegion asSimpleRegion()

Description copied from class: XnRegion

Return a simple region containing all positions contained by myself.
If I am simple, then the result must be me. Otherwise,
the resulting region will contain more positions than I do, but it
must contain all those that I do. It would be good for the resulting
simple region to not contain many more points than it needs in order
to satisfy these constraints; but this is a preference, not a
specification. Particular spaces may specify stronger guarantees,
but as far as class XuRegion is concerned it is correct (though silly)
for this message to always return the full region for the space.

Overrides:

asSimpleRegion in class XnRegion

coordinateSpace

public CoordinateSpace coordinateSpace()

Description copied from class: XnRegion

Essential. The coordinate space in which this is a region

Overrides:

coordinateSpace in class XnRegion

lowerBound

public Sequence lowerBound()

The largest sequence such that all the positions in the region are >= it. Does not
necessarily lie in the region. For example, the region of all numbers > 2.3 has a
lowerBound of 2.3. Mathematically, this is called the 'greatest lower bound'.

lowerEdge

public Sequence lowerEdge()

Essential. The Sequence associated with the lower edge of the Region. To find out where
the boundary is in relation to this sequence, check lowerEdgeType. BLASTS if unbounded
below.

lowerEdgePrefixLimit

public IntegerVar lowerEdgePrefixLimit()

Essential. If lowerEdgeType is prefix, then it includes an Sequence matching each integer
in the lowerEdge up to and including lowerEdgePrefixLimit.

lowerEdgeType

public int lowerEdgeType()

Essential. The kind of Sequence associated with the lower edge of the Region. If
SequenceRegion::inclusive then it includes the lowerEdge; if exclusive, then it does not;
if prefix, then it includes any Sequence matching each integer in the lowerEdge up to and
including lowerEdgePrefixLimit.

upperBound

public Sequence upperBound()

The smallest Sequence such that all the positions in the region are <= it. Does not
necessarily lie in the region. For example, the region of all numbers < 2.3 has an
upperBound of 2.3. Mathematically, this is called the 'least upper bound'.

upperEdge

public Sequence upperEdge()

Essential. The Sequence associated with the upper edge of the Region. To find out where
the boundary is in relation to this sequence, check upperEdgeType. BLASTS if unbounded
below.

upperEdgePrefixLimit

public IntegerVar upperEdgePrefixLimit()

Essential. If upperEdgeType is prefix, then it includes a Sequence matching each integer
in the upperEdge up to and including upperEdgePrefixLimit.

upperEdgeType

public int upperEdgeType()

Essential. The kind of Sequence associated with the upper edge of the Region. If
SequenceRegion::inclusive then it includes the upperEdge; if exclusive, then it does not;
if prefix, then it includes any Sequence matching each integer in the upperEdge up to and
including upperEdgePrefixLimit.

actualHashForEqual

public int actualHashForEqual()

Overrides:

actualHashForEqual in class XnRegion

hasMember

public boolean hasMember(Position position)

Description copied from class: XnRegion

Do I contain this position? More than anything else, the behavior of this message is the
defining characteristic of an XuRegion. All other messages (except for the simplicity
characterization) should be specifiable in terms of the behavior of this message. What an
XuRegion *is* (mostly) is a finite decision procedure for accepting or rejecting any given
position.

Overrides:

hasMember in class XnRegion

isBoundedAbove

public boolean isBoundedAbove()

Same meaning as IntegerRegion::isBoundedAbove

isBoundedBelow

public boolean isBoundedBelow()

Same meaning as IntegerRegion::isBoundedBelow

isEmpty

public boolean isEmpty()

Description copied from class: XnRegion

Every coordinate space has exactly one empty region. It is the one containing no
positions. It and only it responds 'true' to this message.

Overrides:

isEmpty in class XnRegion

isEnumerable

public boolean isEnumerable(OrderSpec order)

Description copied from class: XnRegion

See comment in XuRegion::stepper.
a->stepper(os) won't BLAST iff a->isEnumerable(os)

Overrides:

isEnumerable in class XnRegion

isEqual

public boolean isEqual(Heaper other)

Description copied from class: XnRegion

Two regions are equal iff they contain exactly the same set of positions

Overrides:

isEqual in class XnRegion

isFinite

public boolean isFinite()

Description copied from class: XnRegion

Essential. Do I contain a finite number of positions? If I do, then the 'count' message
will say how many, and I will gladly provide a stepper which will step over all of them.
I.e., isFinite implies isEnumerable.

Overrides:

isFinite in class XnRegion

isFull

public boolean isFull()

Description copied from class: XnRegion

true if this is the largest possible region in this space -- the region that contains all
positions in the space. Note that in a space which has no positions (which is perfectly
valid), the one XuRegion would be both empty (since it has no positions) and full (since
it has all the positions in the space).

Overrides:

isFull in class XnRegion

isSimple

public boolean isSimple()

Description copied from class: XnRegion

Am I a simple region. See XuRegion class comment for implications of being simple.

Overrides:

isSimple in class XnRegion

isSubsetOf

public boolean isSubsetOf(XnRegion other)

Description copied from class: XnRegion

I'm a subset of other if I don't have any positions that he doesn't. Note that if we are
equal, then I am still a subset of him. If you want to know if I'm a strict subset, you
can ask
a->isSubsetOf(b) && !! a->isEqual(b)

Overrides:

isSubsetOf in class XnRegion

actualStepper

public Stepper actualStepper(OrderSpec order)

Description copied from class: XnRegion

Only called if I've already said I'm enumerable in the originally stated order. Also, if
the originally stated order was NULL, I get a guaranteed non-null order. Subclasses which
override 'stepper' to a method which doesn't send 'actualStepper' may override
'actualStepper' to a stub method which always BLASTs.

Overrides:

actualStepper in class XnRegion

count

public IntegerVar count()

Description copied from class: XnRegion

How many positions do I contain? If I am not 'isFinite', then this message will BLAST.

Overrides:

count in class XnRegion

distinctions

public ScruSet distinctions()

Description copied from class: XnRegion

Break it up into a set of non-full distinctions. It is an error to send
this to a non-simple region. A full region will respond with the null
set. Other distinctions will respond with a singleton set containing
themselves, and simple regions will respond with a set of distinctions
which, when intersected together, yield the original region.

Overrides:

distinctions in class XnRegion

intervals

public Stepper intervals(OrderSpec order)

Essential. Break this up into disjoint intervals

isInterval

public boolean isInterval()

Whether this Region is a non-empty interval, i.e. if A, B in the Region and A <= C <= B
then C is in the Region. This includes inequalities (e.g. {x | x > 5.3}) and the
fullRegion in addition to ordinary two-ended intervals.

simpleRegions

public Stepper simpleRegions(OrderSpec order)

Description copied from class: XnRegion

Break myself up into a finite set of non-empty simple regions which, when
unionWith'ed together will yield me. May be sent to any region. If I
am isEmpty, I will respond with the empty stepper. Otherwise, if I am
simple I will respond with a stepper producing just myself.
Please only use NULL for the 'order' argument for now unless the
documentation for a particular region or coordinate space says that
it will deal with the 'order' argument meaningfully. When no order is
specified then I may return the simple regions in any order. When the
ordering functionality is implemented, then I am constrained to
produce the simple regions in an order consistent with the argument's
ordering of my positions. When the simple regions don't overlap, and
don't surround each other in the ordering, then the meaning is clear.
Otherwise, there are several plausible options for how we should
specify this message.

Overrides:

simpleRegions in class XnRegion

stepper

public Stepper stepper(OrderSpec order)

Description copied from class: XnRegion

Essential. If my positions are enumerable in the order specified, then return a stepper
which will so enumerate them. If 'order' is NULL, then I may treat this as a request to
enumerate according to any order I choose, except that if I am enumerable in ascending
order, then I must be enumerable given NULL. For example, if I choose to regard NULL as
implying ascending order, and I am only enumerable in descending order, then given NULL, I
may blast even though there is an order in which I am enumerable.
In fact, right now the ability to respond to an 'order' argument is in such a
to-be-implemented state that it should only be considered safe to provide a NULL argument,
unless the documentation on a particular space or region says otherwise.
The eventual specification of this message is clear, and is upwards compatible from the
current behavior: If I can enumerate in an order consistent with 'order', do so. If
'order' is NULL, then if I can be enumerated at all (if there is any counting sequence),
then I still do so. For example, I should be able to get an (infinite) stepper for
stepping through all the integers, but not all the reals. As the above example shows,
being enumerable doesn't imply being finite.
Also, being able to produce a stepper that continues to yield more positions in the
specified order is not sufficient to imply being enumerable. To be enumerable, it must be
the case that any given position which is a member of the region will eventually be
reached by the stepper. Not all implementations currently succeed in guaranteeing this
(See UnionCrossRegion::isEnumerable).
See ScruTable::stepper.

Overrides:

stepper in class XnRegion

complement

public XnRegion complement()

Description copied from class: XnRegion

Essential. Return a region of containing exactly those positions not in this region. The
complement of a distinction must be a distinction.

Overrides:

complement in class XnRegion

intersect

public XnRegion intersect(XnRegion other)

Description copied from class: XnRegion

Essential. The intersection of two simple regions must be simple. The intersection of two
distinctions must therefore be a simple region. The result has exactly those members which
both the original regions have.

Overrides:

intersect in class XnRegion

simpleUnion

public XnRegion simpleUnion(XnRegion other)

Description copied from class: XnRegion

The result must contain all positions contained by either of the two
original regions, and the result must be simple. However, the result
may contain additional positions. See the comment on
'XuRegion::asSimpleRegion'. a->simpleUnion(b) satisfies the same specification
as (a->unionWith(b))->asSimpleRegion(). However, the two results do
not have to be the same region.

Overrides:

simpleUnion in class XnRegion

unionWith

public XnRegion unionWith(XnRegion other)

Description copied from class: XnRegion

The result has as members exactly those positions which are members of either of the
original two regions. No matter how simple the two original regions are, the result may be
non-simple.
The only reason this is called 'unionWith' instead of 'union' is that the latter is a C++
keyword.

Overrides:

unionWith in class XnRegion

with

public XnRegion with(Position pos)

Description copied from class: XnRegion

the region with one more position. Actually, if I already contain pos, then the result is
just me.

Overrides:

with in class XnRegion

printOn

public void printOn(java.io.PrintWriter oo)

Overrides:

printOn in class Heaper

secretTransitions

public PtrArray secretTransitions()

secretTransitionsCount

public int secretTransitionsCount()

startsInside

public boolean startsInside()

intervals

public Stepper intervals()

receiveSequenceRegion

public void receiveSequenceRegion(Rcvr rcvr)

sendSequenceRegion

public void sendSequenceRegion(Xmtr xmtr)

sendSelfTo

public void sendSelfTo(Xmtr xmtr)

Description copied from class: Heaper

do nothing

Overrides:

sendSelfTo in class Heaper

with

public static SequenceRegion with(Sequence sequence)

above

public static SequenceRegion above(Sequence sequence)

below

public static SequenceRegion below(Sequence sequence)

empty

public static SequenceRegion empty()

full

public static SequenceRegion full()

prefixedBy

public static SequenceRegion prefixedBy(Sequence sequence,
                                        IntegerVar limit)

All sequences matching the given up to and including the number at limit

strictlyAbove

public static SequenceRegion strictlyAbove(Sequence sequence)

strictlyBelow

public static SequenceRegion strictlyBelow(Sequence sequence)

initTimeNonInherited

public static void initTimeNonInherited()

linkTimeNonInherited

public static void linkTimeNonInherited()

usingx

public static SequenceRegion usingx(boolean startsInside,
                                    PtrArray transitions)

Make a new region, reusing the given array. No one else should ever modify it!!

EXCLUSIVE

public static int EXCLUSIVE()

INCLUSIVE

public static int INCLUSIVE()

PREFIX

public static int PREFIX()

info

public static void info()

{Int32 constFn CLIENT INLINE} EXCLUSIVE
{Int32 constFn CLIENT INLINE} INCLUSIVE
{Int32 constFn CLIENT INLINE} PREFIX
{Stepper CLIENT of: SequenceRegion} intervals: order {OrderSpec default: NULL}
{BooleanVar CLIENT} isBoundedAbove
{BooleanVar CLIENT} isBoundedBelow
{BooleanVar CLIENT} isInterval
{Sequence CLIENT} lowerEdge
{IntegerVar CLIENT} lowerEdgePrefixLimit
{Int32 CLIENT} lowerEdgeType
{Sequence CLIENT} upperEdge
{IntegerVar CLIENT} upperEdgePrefixLimit
{Int32 CLIENT} upperEdgeType