org.abora.gold.edge
Class EdgeManager

java.lang.Object
  |
  +--org.abora.gold.java.AboraHeaper
        |
        +--org.abora.gold.xpp.basic.Heaper
              |
              +--org.abora.gold.edge.EdgeManager

Direct Known Subclasses:

RealManager, SequenceManager

public class EdgeManager

extends Heaper

Manages the common code for regions which are represented as a sequence of
EdgeTransitions. Each coordinate space should define a subclass which implements the
appropriate methods, and then use it to do the various region operations. Clients of the
region do not need to see any of these classes.

Field Summary

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

EdgeManager()

Method Summary

int	actualHashForEqual()
XnRegion	asSimpleRegion(XnRegion region)
XnRegion	complement(XnRegion region)
IntegerVar	count(XnRegion region) Because Edge Regions should only be used on infinitely divisible spaces (like rationals), if it's finite then it is bounded on both sides, and all the internal intervals are singletons
ScruSet	distinctions(XnRegion region)
EdgeAccumulator	edgeAccumulator(boolean startsInside) Create an accumulator which takes edges and creates a region
Position	edgePosition(TransitionEdge edge) The position associated with the given edge.
EdgeStepper	edgeStepper(XnRegion region) Create a stepper for iterating through the edges of the region
Position	greatestLowerBound(XnRegion region) The largest position such that no other positions in the region are any less than it.
boolean	hasMember(XnRegion region, Position pos)
XnRegion	intersect(XnRegion meRegion, XnRegion otherRegion)
boolean	isBoundedLeft(XnRegion region) Same meaning as IntegerRegion::isBoundedLeft
boolean	isBoundedRight(XnRegion region) Same meaning as IntegerRegion::isBoundedRight
boolean	isEmpty(XnRegion region)
boolean	isEqual(java.lang.Object other)
boolean	isFinite(XnRegion region) Here is one place where the *infinite* of the infinite divisibility assumed by OrderedRegion about the full ordering comes in (see class comment). An interval whose left edge is not the same as the right edge is assumed to contain an infinite number of positions
boolean	isFull(XnRegion region)
boolean	isSimple(XnRegion region)
boolean	isSubsetOf(XnRegion me, XnRegion other)
Position	leastUpperBound(XnRegion region) The smallest position such that no other positions in the region are any greater than it.
TransitionEdge	lowerEdge(XnRegion region)
XnRegion	makeNew(boolean startsInside, PtrArray transitions) Make a new region of the right type
XnRegion	makeNew(boolean startsInside, PtrArray transitions, int count) Make a new region of the right type
PtrArray	posTransitions(Position pos)
void	printRegionOn(XnRegion region, java.io.PrintWriter oo)
Stepper	simpleRegions(XnRegion region, OrderSpec order)
XnRegion	simpleUnion(XnRegion me, XnRegion other)
EdgeStepper	singleEdgeStepper(Position pos) Create a stepper for iterating through the edges of the region
boolean	startsInside(XnRegion region)
PtrArray	transitions(XnRegion region)
int	transitionsCount(XnRegion region)
XnRegion	unionWith(XnRegion meRegion, XnRegion otherRegion)
TransitionEdge	upperEdge(XnRegion region)
XnRegion	with(XnRegion meRegion, Position newPos)

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, isEqual, isEqualOrSubclassOf, isGenerated, isIntType, isKindOf, isRawType, isUnlocked, linkTimeNonInherited, make, makeClassTable, makeFillTable, makeRequestTable, mangle, markChildren, markCount, markInstances, mayBecome, mayBecomeAnySubclassOf, new1, newX, nonCopyVariables, notWorking, pack, packageClasses, packagingCategory, parseExportName, passe, pointerToStaticMember, pointerToStaticMember, pointerToVirtualMember, preorderMax, preorderNumber, printOn, PROBLEM, problems, promiseClass, promiseDefaultValue, promiseName, promiseNameTable, promiseToAbstract, registerPackageCategory, removeGeneratedCode, removeStubbleMethods, removeSubclassGeneratedCode, removeSubclassStubbleMethods, requestProcedure, requestProceduresFrom, returnTypeFor, rootName, scheduleTermination, sendProxyTo, sendSelfTo, 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

Constructor Detail

EdgeManager

public EdgeManager()

Method Detail

edgeAccumulator

public EdgeAccumulator edgeAccumulator(boolean startsInside)

Create an accumulator which takes edges and creates a region

edgeStepper

public EdgeStepper edgeStepper(XnRegion region)

Create a stepper for iterating through the edges of the region

lowerEdge

public TransitionEdge lowerEdge(XnRegion region)

singleEdgeStepper

public EdgeStepper singleEdgeStepper(Position pos)

Create a stepper for iterating through the edges of the region

upperEdge

public TransitionEdge upperEdge(XnRegion region)

hasMember

public boolean hasMember(XnRegion region,
                         Position pos)

isBoundedLeft

public boolean isBoundedLeft(XnRegion region)

Same meaning as IntegerRegion::isBoundedLeft

isBoundedRight

public boolean isBoundedRight(XnRegion region)

Same meaning as IntegerRegion::isBoundedRight

isEmpty

public boolean isEmpty(XnRegion region)

isFinite

public boolean isFinite(XnRegion region)

Here is one place where the *infinite* of the infinite divisibility assumed by
OrderedRegion about the full ordering comes in (see class comment).
An interval whose left edge is not the same as the right edge is assumed to contain an
infinite number of positions

isFull

public boolean isFull(XnRegion region)

isSimple

public boolean isSimple(XnRegion region)

isSubsetOf

public boolean isSubsetOf(XnRegion me,
                          XnRegion other)

count

public IntegerVar count(XnRegion region)

Because Edge Regions should only be used on infinitely divisible spaces (like rationals),
if it's finite then it is bounded on both sides, and all the internal intervals are
singletons

asSimpleRegion

public XnRegion asSimpleRegion(XnRegion region)

greatestLowerBound

public Position greatestLowerBound(XnRegion region)

The largest position such that no other positions in the region are any less than it. In
other words, this is the lower bounding element. We choose to avoid the terms 'lowerBound'
and 'upperBound' as their meanings in IntegerRegion are significantly different. Here,
both 'all numbers >= 3' and 'all numbers > 3' have a 'greatestLowerBound' of 3 even though
the latter doesn't include 3. To tell whether a bound is included, good old 'hasMember'
should do a fine job.

leastUpperBound

public Position leastUpperBound(XnRegion region)

The smallest position such that no other positions in the region are
any greater than it. In other words, this is the upper bounding element.
We choose to avoid the terms 'lowerBound' and 'upperBound' as
their meanings in IntegerRegion are significantly different. Here, both
'all numbers <= 3' and 'all numbers < 3' have a 'leastUpperBound'
of 3 even though the latter doesn't include 3. To tell whether a
bound is included, good old 'hasMember' should do a fine job.

simpleUnion

public XnRegion simpleUnion(XnRegion me,
                            XnRegion other)

printRegionOn

public void printRegionOn(XnRegion region,
                          java.io.PrintWriter oo)

complement

public XnRegion complement(XnRegion region)

distinctions

public ScruSet distinctions(XnRegion region)

intersect

public XnRegion intersect(XnRegion meRegion,
                          XnRegion otherRegion)

simpleRegions

public Stepper simpleRegions(XnRegion region,
                             OrderSpec order)

unionWith

public XnRegion unionWith(XnRegion meRegion,
                          XnRegion otherRegion)

with

public XnRegion with(XnRegion meRegion,
                     Position newPos)

edgePosition

public Position edgePosition(TransitionEdge edge)

The position associated with the given edge. Blast if there is none

makeNew

public XnRegion makeNew(boolean startsInside,
                        PtrArray transitions)

Make a new region of the right type

makeNew

public XnRegion makeNew(boolean startsInside,
                        PtrArray transitions,
                        int count)

Make a new region of the right type

posTransitions

public PtrArray posTransitions(Position pos)

startsInside

public boolean startsInside(XnRegion region)

transitions

public PtrArray transitions(XnRegion region)

transitionsCount

public int transitionsCount(XnRegion region)

actualHashForEqual

public int actualHashForEqual()

Overrides:

actualHashForEqual in class Heaper

isEqual

public boolean isEqual(java.lang.Object other)