org.abora.gold.nkernel
Class FeEdition

java.lang.Object
  |
  +--org.abora.gold.java.AboraHeaper
        |
        +--org.abora.gold.xpp.basic.Heaper
              |
              +--org.abora.gold.nkernel.FeRangeElement
                    |
                    +--org.abora.gold.nkernel.FeEdition

public class FeEdition

extends FeRangeElement

The kind of FeRangeElement that consists of an immutable organization of RangeElements,
indexed by Positions in some CoordinateSpace.
R1 prohibits cyclic containment.
Set notation is used in the comments documenting some of the methods of this class. In
each case the cleartext explanation stands alone, and the set notation is a separate, more
formal, expression of the actions of the method, in terms of key(position)/label/value
triples ("").

Field Summary

protected BeEdition	myBeEdition
protected FeLabel	myLabel

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

FeEdition(BeEdition beEdition, FeLabel label)

Method Summary

void	addCompletionDetector(FeCompletionDetector detector)
void	addFillInDetector(FeFillInDetector detector)
void	addFillRangeDetector(FeFillRangeDetector detector) Essential.
FeRangeElement	again() These don't change as long as someone has a handle on them.
FeEdition	allBecome(FeEdition newIdentities, XnRegion positions)
PrimArray	asArray(XnRegion positions, OrderSpec ordering)
BeEdition	beEdition()
boolean	canMakeIdentical(FeRangeElement newIdentity) Essential.
XnRegion	canMakeRangeIdentical(FeEdition newIdentities)
XnRegion	canMakeRangeIdentical(FeEdition newIdentities, XnRegion positions) Essential.
BeCarrier	carrier() Return an object that wraps up any run-time state that might be needed inside the Be system.
FeEdition	combine(FeEdition other) Essential.
CoordinateSpace	coordinateSpace() Return the space in which the positions of this Edition are positions.
FeEdition	copy(XnRegion positions) Return a new FeEdition which is the subset of this Edition with the domain restricted to the given set of positions The new edition has the same label as this edition. { | k in positions and in self }
IntegerVar	cost(int method) Essential.
IntegerVar	count() Return the number of positions in this Edition.
void	destruct() Classes should implement this message rather than a destructor.
static int	DIRECT() For transcluders and works queries - only return objects which directly contain the sources of the query (i.e.
XnRegion	domain() Essential.
static FeEdition	empty(CoordinateSpace keySpace) An empty Edition, with the given CoordinateSpace but no contents.
void	endorse(CrossRegion additionalEndorsements) Essential.
CrossRegion	endorsements() Essential.
FeRangeElement	fetch(Position position) The value at the position, or NULL if there is none
BeRangeElement	fetchBe() If this has a reified Be object, then return it, else NULL
FeFillRangeDetector	fillRangeDetector() Essential.
static int	FROM_OTHER() For sharedWith/sharedRegion/notSharedWith - look for RangeElements contained transitively within the other Edition
static int	FROM() For transcluders, and works queries - consider RangeElements contained transitively inside the Edition, as well as just its immediate RangeElements
static FeEdition	fromAll(XnRegion keys, FeRangeElement value) Essential.
static FeEdition	fromArray(PrimArray values) Essential.
static FeEdition	fromArray(PrimArray values, XnRegion keys) Essential.
static FeEdition	fromArray(PrimArray values, XnRegion keys, OrderSpec ordering) Essential.
static FeEdition	fromOne(Position key, FeRangeElement value) A singleton Edition mapping from a single key to a single value.
FeRangeElement	get(Position position) Return the value at the given position, or blast if there is no such position (i.e.
BeRangeElement	getOrMakeBe() An individual BeRangeElement for this identity.
boolean	hasPosition(Position position) Return whether the given position is in the Edition.
static int	IGNORE_ARRAY_ORDERING() Used for retrieve.
static int	IGNORE_TOTAL_ORDERING() Used for retrieve.
boolean	includesKey(Position position) Whether the given position is in the Edition.
static void	info() {Int32 constFn INLINE CLIENT} DIRECT.U.CONTAINERS.U.ONLY {Int32 constFn INLINE CLIENT} FROM.U.OTHER.U.TRANSITIVE.U.CONTENTS {Int32 constFn INLINE CLIENT} FROM.U.TRANSITIVE.U.CONTENTS {Int32 constFn INLINE CLIENT} IGNORE.U.ARRAY.U.ORDERING {Int32 constFn INLINE CLIENT} IGNORE.U.TOTAL.U.ORDERING {Int32 constFn INLINE CLIENT} LOCAL.U.PRESENT.U.ONLY {Int32 constFn INLINE CLIENT} OMIT.U.SHARED {Int32 constFn INLINE CLIENT} PRORATE.U.SHARED {Int32 constFn INLINE CLIENT} SEPARATE.U.OWNERS {Int32 constFn INLINE CLIENT} TO.U.TRANSITIVE.U.CONTENTS {Int32 constFn INLINE CLIENT} TOTAL.U.SHARED {void CLIENT} addFillRangeDetector: detector {PrFillRangeDetector} {XuRegion CLIENT} canMakeRangeIdentical: newIdentities {FeEdition} with: positions {XuRegion default: NULL} {FeEdition CLIENT} combine: other {FeEdition} {CoordinateSpace CLIENT} coordinateSpace {FeEdition CLIENT} copy: positions {XuRegion} {IntegerVar CLIENT} cost: method {Int32} {IntegerVar CLIENT} count {XuRegion CLIENT} domain {void CLIENT} endorse: endorsements {CrossRegion} {CrossRegion CLIENT} endorsements {FeRangeElement CLIENT} get: position {Position} {BooleanVar CLIENT} hasPosition: position {Position} {BooleanVar CLIENT} isEmpty {BooleanVar CLIENT} isFinite {BooleanVar CLIENT} isRangeIdentical: other {FeEdition} {BooleanVar CLIENT} isRangeIdentical: other {FeEdition} with: region {XuRegion default: NULL} {FeEdition CLIENT} makeRangeIdentical: newIdentities {FeEdition} with: positions {XuRegion default: NULL} {Mapping CLIENT} mapSharedOnto: other {FeEdition} {Mapping CLIENT} mapSharedTo: other {FeEdition} {FeEdition CLIENT} notSharedWith: other {FeEdition} with: flags {Int32 default: Int32Zero} {XuRegion CLIENT} positionsLabelled: label {FeLabel} {XuRegion CLIENT} positionsOf: value {FeRangeElement} {IDRegion CLIENT} rangeOwners: positions {XuRegion default: NULL} {FeEdition CLIENT} rangeTranscluders: positions {XuRegion default: NULL} with: directFilter {Filter default: NULL} with: indirectFilter {Filter default: NULL} with: flags {Int32 default: Int32Zero} with: otherTrail {FeEdition default: NULL} {FeEdition CLIENT} rangeWorks: positions {XuRegion default: NULL} with: filter {Filter default: NULL} with: flags {Int32 default: Int32Zero} with: otherTrail {FeEdition default: NULL} {FeEdition CLIENT} rebind: position {Position} with: edition {FeEdition} {void CLIENT} removeFillRangeDetector: detector {PrFillRangeDetector} {FeEdition CLIENT} replace: other {FeEdition} {void CLIENT} retract: endorsements {CrossRegion} {(Stepper of: Bundle) CLIENT} retrieve: positions {XuRegion default: NULL} with: order {OrderSpec default: NULL} with: flags {Int32 default: Int32Zero} {FeEdition CLIENT} setRangeOwners: newOwner {ID} with: positions {XuRegion default: NULL} {XuRegion CLIENT} sharedRegion: other {FeEdition} with: flags {Int32 default: Int32Zero} {FeEdition CLIENT} sharedWith: other {FeEdition} with: flags {Int32 default: Int32Zero} {TableStepper CLIENT of: FeRangeElement} stepper: region {XuRegion default: NULL} with: order {OrderSpec default: NULL} {FeRangeElement CLIENT} theOne {FeEdition CLIENT} transformedBy: mapping {Mapping} {CrossRegion CLIENT} visibleEndorsements {FeEdition CLIENT} with: position {Position} with: value {FeRangeElement} {FeEdition CLIENT} withAll: positions {XuRegion} with: value {FeRangeElement} {FeEdition CLIENT} without: position {Position} {FeEdition CLIENT} withoutAll: positions {XuRegion}
boolean	isEmpty() Return whether there are any positions in this Edition.
boolean	isFinite() Return whether there are a finite number of positions in this Edition.
boolean	isRangeIdentical(FeEdition other)
boolean	isRangeIdentical(FeEdition other, XnRegion region) Whether the two Editions have the same domains, and each RangeElement isIdentical to the corresponding RangeElement in the other Edition.
XnRegion	keysLabelled(FeLabel label)
XnRegion	keysOf(FeRangeElement value) All of the keys in this Edition at which the given RangeElement can be found.
FeLabel	label() Essential.
static int	LOCAL() For transcluders and works queries - only guarantee to return items which are currently known to this server
void	makeIdentical(FeRangeElement newIdentity) Essential.
FeEdition	makeRangeIdentical(FeEdition newIdentities)
FeEdition	makeRangeIdentical(FeEdition newIdentities, XnRegion positions) Essential.
Mapping	mapSharedOnto(FeEdition other) Return a mapping such that for each range element that appears in both editions, the mapping maps each of its appearances in the argument edition to some appearance in this one.
Mapping	mapSharedTo(FeEdition other) Essential.
FeEdition	notSharedWith(FeEdition other)
FeEdition	notSharedWith(FeEdition other, int flags) Return a new FeEdition containing exactly the subset of this Edition whose RangeElements are not in the other Edition. Equivalent to: this->copy (this->sharedRegion (other)->complement ()). { | in self and in other and v1 is same as v2 } Note that this is useful for optimization of FeBe communication and Frontend display updating.
static int	OMIT() For cost - omit the cost of shared material
static FeEdition	on(BeEdition be)
static FeEdition	on(BeEdition be, FeLabel label)
static int	otherTransitiveContents() For sharedWith/sharedRegion/notSharedWith
FeEdition	parcelAt(Position position) Some subset of this Edition, containing the given position, all with the same owner { | in self and in self and v.owner == v2.owner }
FeEdition	parcels() Divides this Edition into pieces each of whose RangeElements are all owned by a single Club. { } > | in self and k1 == v2's owner }
static FeEdition	placeHolders(XnRegion keys) Essential.
XnRegion	positionsLabelled(FeLabel label) Return a region consisting of exactly the positions in this Edition which are associated with the given label. { k | in self }
XnRegion	positionsOf(FeRangeElement value) Return the region consisting of all the positions in this Edition at which the given RangeElement can be found. Equivalent to: this->sharedRegion (theServer ()->makeEditionWith (some position, value)). { k | in self and v is same as value }
void	printOn(java.io.PrintWriter oo)
static int	PRORATE() For cost - prorate the cost of shared material among Editions sharing it
IDRegion	rangeOwners(XnRegion positions) The owners of all the RangeElements in the given Region, or in the entire Edition if no Region is specified.
FeEdition	rangeTranscluders()
FeEdition	rangeTranscluders(XnRegion positions)
FeEdition	rangeTranscluders(XnRegion positions, Filter filter)
FeEdition	rangeTranscluders(XnRegion positions, Filter filter, Filter transitiveFilter)
FeEdition	rangeTranscluders(XnRegion positions, Filter filter, Filter transitiveFilter, int flags)
FeEdition	rangeTranscluders(XnRegion positions, Filter directFilter, Filter indirectFilter, int flags, FeEdition otherTranscluders) Essential.
FeEdition	rangeWorks()
FeEdition	rangeWorks(XnRegion region)
FeEdition	rangeWorks(XnRegion region, Filter filter)
FeEdition	rangeWorks(XnRegion region, Filter filter, int flags)
FeEdition	rangeWorks(XnRegion positions, Filter filter, int flags, FeEdition otherTranscluders) Essential.
FeEdition	rebind(Position position, FeEdition edition) Return a new FeEdition which is a copy of this Edition with the contained Edition at the given position replaced by the given Edition, but with the Label at that position unchanged.
FeRangeElement	relabelled(FeLabel label) Essential.
void	removeCompletionDetector(FeCompletionDetector detector)
void	removeFillInDetector(FeFillInDetector detector)
void	removeFillRangeDetector(FeFillRangeDetector detector) Essential.
FeEdition	reorganize(XnRegion oldRegion, OrderSpec oldOrder, XnRegion newRegion, OrderSpec newOrder) Rearrange the positions of this Edition to lie in the given region, with the given ordering.
FeEdition	replace(FeEdition other) Return a new FeEdition with the label of the current Edition and the contents of both Editions; where they share positions, use the contents and labels of the other Edition. Equivalent to this->copy (other->domain ()->complement ())->combine (other). { | in other or ( in self and not in other }
void	retract(CrossRegion endorsements) Essential.
Stepper	retrieve()
Stepper	retrieve(XnRegion positions)
Stepper	retrieve(XnRegion positions, OrderSpec order)
Stepper	retrieve(XnRegion region, OrderSpec order, int flags) Essential.
static int	SEPARATE() For retrieve - ensure that each Bundle in a retrieve has a single owner
FeEdition	setAllOwners(ID newOwner, XnRegion region)
FeEdition	setRangeOwners(ID newOwner)
FeEdition	setRangeOwners(ID newOwner, XnRegion region) Changes the owner of all RangeElements in the Edition (but not the Edition itself!!); requires the authority of the current owner of each range element.
XnRegion	sharedRegion(FeEdition other)
XnRegion	sharedRegion(FeEdition other, int flags) Return the subset of the positions of this Edition which have RangeElements that are in the other Edition. If nestThis flag is set, then returns not only positions of RangeElements which are in the other, but also positions of Editions which have RangeElements which are in the other, or which have other such Editions, recursively.
FeEdition	sharedWith(FeEdition other)
FeEdition	sharedWith(FeEdition other, int flags) Essential.
TableStepper	stepper()
TableStepper	stepper(XnRegion region)
TableStepper	stepper(XnRegion region, OrderSpec ordering) Return a stepper for iterating over the positions and RangeElements of this Edition.
FeRangeElement	theOne() If this Edition has a single position, then return the RangeElement at that position; if not, blasts.
static int	thisTransitiveContents() Used for version comparison.
static int	TO() For sharedRegion, sharedWith, notSharedWith queries - look down towards transitively contained material
static int	TOTAL() For cost - count the entire cost of shared material
FeEdition	transclusions(XnRegion positions, Filter directFilter, Filter indirectFilter, int flags, FeEdition otherTransclusions)
FeEdition	transformedBy(Mapping mapping) Essential.
void	unendorse(CrossRegion endorsements)
CrossRegion	visibleEndorsements() Essential.
FeEdition	with(Position position, FeRangeElement value) Return a new FeEditionwith the same contents and label as this Edition, except for the addition or substitution of a RangeElement at a specified position. (The difference between with() and rebind() is exactly that rebind() preserves the old label at position, while with() installs the label attached to the value argument.) Equivalent to: this->replace (FeServer::current ()->makeEditionWith (position, value))
FeEdition	withAll(XnRegion positions, FeRangeElement value) Return a new FeEdition with the same contents and label as this Edition, except at a specified set of positions, where the old values and labels, if there are any, are superceded by the value argument. Equivalent to: this->replace (FeServer::current ()->makeEditionWithAll (positions, value))
FeEdition	without(Position position) Return a new FeEdition with the same contents and label as this Edition, except at a specified position, where the old value and label, if there is one, is removed. Equivalent to: this->copy (position->asRegion ()->complement ())
FeEdition	withoutAll(XnRegion positions) Return a new FeEdition with the same contents and label as this Edition, except at a specified set of positions, where the old values and labels, if there are any, are removed. Equivalent to this->copy (positions->complement ())
Pair	zoneAt(Position position) Essential.
FeEdition	zoneOf(PrimSpec values)
TwoStepper	zones(OrderSpec ordering) Divides this Edition up into pieces all of whose RangeElements have the same PrimSpec.

Methods inherited from class org.abora.gold.nkernel.FeRangeElement

actualHashForEqual, addFillDetector, becomeOther, fillDetector, inspect, isEqual, isIdentical, isSameAs, owner, placeHolder, removeFillDetector, setOwner, transcluders, transcluders, transcluders, transcluders, transcluders, validateEndorsement, validateSignature, works, works, works, works

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, 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, 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, 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

myBeEdition

protected BeEdition myBeEdition

myLabel

protected FeLabel myLabel

Constructor Detail

FeEdition

public FeEdition(BeEdition beEdition,
                 FeLabel label)

Method Detail

combine

public FeEdition combine(FeEdition other)

Essential. Return a new FeEdition containing the contents of boththe receiver and the
argument Editions, and with the label of the receiving edition; where they share
positions, they must have the same RangeElement. Currently the two may not share
positions. It is unclear whether to elevate this from an implementation restriction to a
specification. The advantage of so specifying is that 'combine' becomes timing
independent, i.e. a failing combine could otherwise succeed after the differing range
elements were unified (by FeRangeElement::makeIdentical()). See FeEdition::mapSharedOnto
and FeEdition::transformedBy.
{ | in self or in other }
requires:
currently: { k | in self and in other } is empty
eventually maybe: { k | v1 not same as v2
and in self and in other } is empty

copy

public FeEdition copy(XnRegion positions)

Return a new FeEdition which is the subset of this Edition with the domain restricted to
the given set of positions The new edition has the same label as this edition.
{ | k in positions and in self }

replace

public FeEdition replace(FeEdition other)

Return a new FeEdition with the label of the current Edition and the contents of both
Editions; where they share positions, use the contents and labels of the other Edition.
Equivalent to
this->copy (other->domain ()->complement ())->combine (other).
{ | in other or ( in self and not in other }

transformedBy

public FeEdition transformedBy(Mapping mapping)

Essential. Return a new FeEdition containing the contents and label of the current
Edition with the positions transformed according to the given Mapping. Where the Mapping
takes several positions in the domain to a single position in the range, this Edition must
have the same RangeElement and label at all the domain positions. Currently the mapping
must be 'onto', i.e., no more that one domain position may map onto any given range
position. It is unclear whether to elevate this from an implementation restriction to a
specification. See FeEdition::mapSharedOnto and FeEdition::combine.
{ | in self and in mapping }
requires:
Currently: not exists k1a, k1b : k1a !!= k1b and in mapping and in
mapping.
Maybe eventually: for all v1, v2 : in result and in result, v1 is same
as v2

with

public FeEdition with(Position position,
                      FeRangeElement value)

Return a new FeEditionwith the same contents and label as this Edition, except for the
addition or substitution of a RangeElement at a specified position.
(The difference between with() and rebind() is exactly that rebind() preserves the old
label at position, while with() installs the label attached to the value argument.)
Equivalent to:
this->replace (FeServer::current ()->makeEditionWith (position, value))

withAll

public FeEdition withAll(XnRegion positions,
                         FeRangeElement value)

Return a new FeEdition with the same contents and label as this Edition, except at a
specified set of positions, where the old values and labels, if there are any, are
superceded by the value argument.
Equivalent to:
this->replace (FeServer::current ()->makeEditionWithAll (positions, value))

without

public FeEdition without(Position position)

Return a new FeEdition with the same contents and label as this Edition, except at a
specified position, where the old value and label, if there is one, is removed.
Equivalent to:
this->copy (position->asRegion ()->complement ())

withoutAll

public FeEdition withoutAll(XnRegion positions)

Return a new FeEdition with the same contents and label as this Edition, except at a
specified set of positions, where the old values and labels, if there are any, are
removed.
Equivalent to
this->copy (positions->complement ())

coordinateSpace

public CoordinateSpace coordinateSpace()

Return the space in which the positions of this Edition are positions. Equivalent to
this->domain ()->coordinateSpace ()

cost

public IntegerVar cost(int method)

Essential. Retiurn how much space this Edition is taking up on the disk, in bytes (but the
precision may exceed the accuracy; it's simply a well-known unit). The method determines
how material shared with other Editions is treated: if omitShared, it is not counted at
all; if prorateShared, then it is divided evenly among the Editions sharing it; if
totalShared, its entire cost is counted. This figure is only approximate, and may vary
with time.
(No permissions are required to obtain this informiation, even though it exposes sharing
by Editions you can't read to traffic analysis.)

count

public IntegerVar count()

Return the number of positions in this Edition. Blasts if infinite. Equivalent to
this->domain ()->count ()

domain

public XnRegion domain()

Essential. Return the region consisting of all the positions in this Edition. May be
infinite, or empty.
{ k | in self }

get

public FeRangeElement get(Position position)

Return the value at the given position, or blast if there is no such position (i.e. if !!
this->domain ()->hasMember (position)).
v : in self
requires: in self

hasPosition

public boolean hasPosition(Position position)

Return whether the given position is in the Edition. Equivalent to
this->domain ()->hasMember (position)

isEmpty

public boolean isEmpty()

Return whether there are any positions in this Edition. Equivalent to
this->domain ()->isEmpty ()

isFinite

public boolean isFinite()

Return whether there are a finite number of positions in this Edition. Equivalent to
this->domain ()->isFinite ()

retrieve

public Stepper retrieve(XnRegion region,
                        OrderSpec order,
                        int flags)

Essential. This is the fundamental retrieval operation. Return a stepper of bundles.
Each bundle is an association between a region in the domain and the range elements
associated with that region. Where the region is associated with data, for instance, the
bundle contains a PrimArray of the data elements.
If a region is given, only that subset of the Edition's contents will be returned. If it
is not given, the entire content of the Edition will be returned.
if the ignoreTotalOrdering flag is set, then the operation can group non-contiguous
regions, and can supply the bundles in any order.
if the ignoreArrayOrdering flag is set, then ArrayBundles returned by the operation can be
ordered differently from the supplied order.
If an OrderSpec is not supplied, then the ordering will be the default order for the
coordinate space, if one exists, and if none exists the returned data will be completely
unordered and the Ordering flags will be ignored.

stepper

public TableStepper stepper(XnRegion region,
                            OrderSpec ordering)

Return a stepper for iterating over the positions and RangeElements of this Edition. If a
region is specified, then it only iterates over the domain positions which are in the
given region. If no ordering is specified, then the default ascending full ordering of the
CoordinateSpace is used, or a random order chosen if there is no default.

theOne

public FeRangeElement theOne()

If this Edition has a single position, then return the RangeElement at that position; if
not, blasts. Equivalent to
this->get (this->domain ()->theOne ())

isRangeIdentical

public boolean isRangeIdentical(FeEdition other,
                                XnRegion region)

Whether the two Editions have the same domains, and each RangeElement isIdentical to the
corresponding RangeElement in the other Edition.

mapSharedOnto

public Mapping mapSharedOnto(FeEdition other)

Return a mapping such that for each range element that appears in both editions, the
mapping maps each of its appearances in the argument edition to some appearance in this
one. (Some of the appearances in this edition may be unmapped or mapped to multiple
appearances in the argument edition.) Like 'mapSharedTo' except that the resulting
mapping is 'onto'. This means that each range position of the resulting mapping inverse
maps to at most one domain position. Such a mapping is suitable as an argument to
'transformedBy', and represents the minimal transformation needed to make the shared part
of 'other' from self. Note that there is no unique answer.
result = { | in self and in other and v1 is same as v2
and not exists k11 : k11 !!= k1 and in result }
Note that this is useful for optimization of FeBe communication and Frontend display
updating.

mapSharedTo

public Mapping mapSharedTo(FeEdition other)

Essential. Return a Mapping from each of the positions in this Edition to all of the
positions in the other Edition which have the same RangeElement.
{ | in self and in other and v1 is same as v2 }

notSharedWith

public FeEdition notSharedWith(FeEdition other,
                               int flags)

Return a new FeEdition containing exactly the subset of this Edition whose RangeElements
are not in the other Edition.
Equivalent to:
this->copy (this->sharedRegion (other)->complement ()).
{ | in self and in other and v1 is same as v2 }
Note that this is useful for optimization of FeBe communication and Frontend display
updating.

positionsOf

public XnRegion positionsOf(FeRangeElement value)

Return the region consisting of all the positions in this Edition at which the given
RangeElement can be found.
Equivalent to:
this->sharedRegion (theServer ()->makeEditionWith (some position, value)).
{ k | in self and v is same as value }

rangeTranscluders

public FeEdition rangeTranscluders(XnRegion positions,
                                   Filter directFilter,
                                   Filter indirectFilter,
                                   int flags,
                                   FeEdition otherTranscluders)

Essential. Return a new FeEdition containing all Editions which can be read with the
authority of the CurrentKeyMaster, and which transclude RangeElements in this Edition.
Immediately returns with an Edition full of PlaceHolders, which will be filled in as
results appear; the lookup proceeds asynchronously.
The Server will attempt to avoid placing duplicate copies in the result, but it may still
happen.
If a Region is given, then the request only considers the subset at those positions (i.e.
equivalent to this->copy (positions)->rangeTransclusions (...))
If a directFilter is given, then the endorsements on the resulting Editions, unioned with
the endorsements on any Works directly on those Editions to which the CurrentKeyMaster has
read permission, must pass the filter.
If an indirectFilter is given, then the resulting Editions must be contained, directly or
indirectly, by an Edition whose endorsements (unioned with its readable Works
endorsements) pass the filter. (Giving a non-NULL indirectFilter will probably not be
supported in version 1.0.)
If the directContainersOnly flag is set, then the result only includes Editions which have
the material as RangeElements; otherwise, the result includes Editions which indirectly
contain the material through other Editions. (Setting this flag will probably not be
supported in version 1.0.)
If the fromTransitiveContents flag is set, then the result includes transclusions of
RangeElements of sub-Editions of this one, in addition to the RangeElements in this
Edition. (Setting ths flag will probably not be supported in version 1.0.)
If localPresentOnly flag is clear, a persistent request will be created, and the new
FeEdition will continue to be filled in in the future. If it is set, only those Editions
which are currently known to transclude by this Backend are sure to be recorded into the
Trail. (Some, but not all, Editions which come to transclude while this request is being
processed may be recorded. If the request is followed by a
FeServer::waitForConsequences(), no Editions which come to transclude after the wait
completes will be recorded.)
If otherTranscluders is given, then the results will be recorded into it. (This may
increase the chance of the same Edition being recorded twice.)
(For convenience, you can attach a TransclusionDetector to the result Edition. See
FeEdition::addFillRangeDetector() See also FeServer::waitForConsequences().)

rangeWorks

public FeEdition rangeWorks(XnRegion positions,
                            Filter filter,
                            int flags,
                            FeEdition otherTranscluders)

Essential. Return a new FeEdition containing all Works which contain RangeElements of
this Edition and can be read by the CurrentKeyMaster. Returns an IDSpace Edition full of
PlaceHolders, which will be filled with Works as results come in.
If a filter is given, then only Works whose endorsements pass the Filter are returned.
If the localPresentOnly flag is clear, a persistent request will be created, and as new
Works come to be known to the Server, they will be filled into the resulting Edition. If
it is set, only Works currently known to this Server are sure to be recorded into the
Trail. (Some, but not all, Works which become known while this request is being processed
may be recorded. If the request is followed by a FeServer::waitForConsequences(), no
Works which become known after the wait completes will be recorded.)
If the fromTransitiveContents flag is set, then the result includes Works which contain
RangeElements transitively contained in this Edition. (This may not be supported in 1.0)
If directContainersOnly is set, then only Works which are directly on Editions which are
RangeElements of this Edition are returned (and not Works which are on Editions which have
them as sub-Editions).
If otherTranscluders is given, this records works into that trail.
(For convenience, you can attach a TransclusionDetector to the result Edition. See
FeEdition::addFillRangeDetector() See also FeServer::waitForConsequences().)
{ | w's contains self, w passes filter}

sharedRegion

public XnRegion sharedRegion(FeEdition other,
                             int flags)

Return the subset of the positions of this Edition which have RangeElements that are in
the other Edition.
If nestThis flag is set, then returns not only positions of RangeElements which are in the
other, but also positions of Editions which have RangeElements which are in the other, or
which have other such Editions, recursively. (This searches down to, but not across, work
boundaries.)
If nestOther flag is set, then looks not only for RangeElements which are values of the
other Edition, but also those which are values of sub-Editions of the other Edition. (This
option will probably not be supported in version 1.0).
If both flags are false, then equivalent to:
this->mapSharedTo (other)->domain ()
{ k1 | in self and in other and v1 is same as v2 }

sharedWith

public FeEdition sharedWith(FeEdition other,
                            int flags)

Essential. Return a new FeEdition consisting of the subset of this Edition whose
RangeElements are in the other Edition. If the same RangeElement is in this Edition at
several different positions, all positions will be in the result (provided the
RangeElement is also in the other Edition).
Equivalent to:
this->copy (this->sharedRegion (other, flags)).
{ | in self and in other and v1 is same as v2 }

endorse

public void endorse(CrossRegion additionalEndorsements)

Essential. Adds to the endorsements on this Edition. The region of
additionalEndorsements must consist of a finite number of (club ID, token ID) pairs.
CurrentKeyMaster must hold the signature authority of all the Clubs used to endorse; the
request will blast and do nothing if any of the required authority is lacking. (Redoing
an endorse() undoes a retract())

endorsements

public CrossRegion endorsements()

Essential. Return all of the endorsements which have been placed on this Edition and not
retracted.

retract

public void retract(CrossRegion endorsements)

Essential. Removes endorsements from this Edition. This requires that the
CurrentKeyMaster hold signature authority for all of the Clubs whose endorsements are in
the list; will blast and do nothing if any of the required authority is lacking, even if
the endorsements weren't there to be retracted. Ignores all endorsements which you could
have removed, but which don't happen to be there right now.
In the current release removed endorsements aren't preserved, so they vanish forever.
Beginning in some future release removed endorsements will become inactive, but it will be
possible to detect that they once had been present. The intent is for a removed
endorsement to be analogous to a signature that has been struck out. You can express that
you changed your mind, but you can't undo the past.

visibleEndorsements

public CrossRegion visibleEndorsements()

Essential. Return all the unretracted endorsements on this Edition along with those on
any Works directly on it which the CurrentKeyMaster has permission to read.

addFillRangeDetector

public void addFillRangeDetector(FeFillRangeDetector detector)

Essential. Connect a FillRangeDetector to the underlying BeEdition so that when any of
the PlaceHolders in that Edition become any other kind of RangeElement, then the Detector
will be triggered with an Edition containing the new RangeElements (but not necessarily at
the same positions, or even in the same CoordinateSpace). If there already are
non-PlaceHolders, then the Detector is triggered immediately with those RangeElements.
See FillRangeDetector::allFilled (Edition * newIdentities).

canMakeRangeIdentical

public XnRegion canMakeRangeIdentical(FeEdition newIdentities,
                                      XnRegion positions)

Essential. Return the region consisting of all locations at which my RangeElements can
NOT be made identical to the corresponding RangeElements in the other Edition. (This seems
like the opposite of what you want, but in fact it makes it easy to check for success.)
Does not check whether you have permissions to do so, just whether it could be done by
someone with the appropriate permissions. See rangeOwners.

fillRangeDetector

public FeFillRangeDetector fillRangeDetector()

Essential. Return a FillRangeDetector so that when any of the PlaceHolders in this
Edition become any other kind of RangeElement, then the Detector will be triggered with an
Edition containing the new RangeElements (but not necessarily at the same positions, or
even in the same CoordinateSpace). If there already are non-PlaceHolders, then the
Detector is triggered immediately with those RangeElements.
See FillRangeDetector::allFilled (Edition * newIdentities).

makeRangeIdentical

public FeEdition makeRangeIdentical(FeEdition newIdentities,
                                    XnRegion positions)

Essential. Try to change the identity of each RangeElements of this Edition which are in
the Region (or all if no Region supplied) to that of the RangeElement at the same position
in the other Edition. Returns the subset of this Edition which did not end up with the new
identities, because of
- lack of ownership authority
- different contents
- contents of other edition unreadable
- incompatible types
- no corresponding new identity
Note that the labels on the RangeElements need not match and will NOT be changed.

rangeOwners

public IDRegion rangeOwners(XnRegion positions)

The owners of all the RangeElements in the given Region, or in the entire
Edition if no Region is specified.

removeFillRangeDetector

public void removeFillRangeDetector(FeFillRangeDetector detector)

Essential. Remove a Detector which had been added to this Edition. You should remove
every Detector you add, although they will go away automatically when a client session
terminates.

setRangeOwners

public FeEdition setRangeOwners(ID newOwner,
                                XnRegion region)

Changes the owner of all RangeElements in the Edition (but not the Edition itself!!);
requires the authority of the current owner of each range element. If a Region is
supplied, then only sets those in the region.
Returns the subset of this Edition which is in the Region whose owners did not end up
being the new Owner because of lack of authority.

label

public FeLabel label()

Description copied from class: FeRangeElement

Essential. Return the label attached to this FeRangeElement. (An FeRangeElement holds a
BeRangeElement and a label.) All FeRangeElements have a label attached to them when they
are created (in the various Server::newRangeElement operations). Derived Editions have
the same the label as the Edition they were derived from (e.g. the receiver of copy,
combine, replace, transformedBy, etc.) Labels may be available only on Editions in 1.0.
(While this is in force, label() will blast if sent to other kinds of FeEditions.)

Overrides:

label in class FeRangeElement

positionsLabelled

public XnRegion positionsLabelled(FeLabel label)

Return a region consisting of exactly the positions in this Edition which are associated
with the given label.
{ k | in self }

rebind

public FeEdition rebind(Position position,
                        FeEdition edition)

Return a new FeEdition which is a copy of this Edition with the contained Edition at the
given position replaced by the given Edition, but with the Label at that position
unchanged. Equivalent to
this->with (position, edition->relabelled (this->get (position)->label ())).
Note that rebind() is useless (and blasts) when a non-edition RangeElement is at the given
position.
{ | ((k isEqual: position) and (v is same as edition))
or ( in self and k !!= position) }

relabelled

public FeRangeElement relabelled(FeLabel label)

Description copied from class: FeRangeElement

Essential. Return a new FeRangeElement with the same identity and contents (i.e. holding
the same BeRangeElement), but with a different label. (Get new labels from
FeServer::newLabel())

Overrides:

relabelled in class FeRangeElement

beEdition

public BeEdition beEdition()

carrier

public BeCarrier carrier()

Return an object that wraps up any run-time state that might be needed inside the Be
system. Right now that means labels.

Overrides:

carrier in class FeRangeElement

fetch

public FeRangeElement fetch(Position position)

The value at the position, or NULL if there is none

fetchBe

public BeRangeElement fetchBe()

Description copied from class: FeRangeElement

If this has a reified Be object, then return it, else NULL

Overrides:

fetchBe in class FeRangeElement

getOrMakeBe

public BeRangeElement getOrMakeBe()

Description copied from class: FeRangeElement

An individual BeRangeElement for this identity. If the object is virtualized, then
de-virtualizes it.

Overrides:

getOrMakeBe in class FeRangeElement

again

public FeRangeElement again()

These don't change as long as someone has a handle on them.

Overrides:

again in class FeRangeElement

canMakeIdentical

public boolean canMakeIdentical(FeRangeElement newIdentity)

Description copied from class: FeRangeElement

Essential. Whether the identity of this object could be changed to the other.
Does not check whether the CurrentKeyMaster has authority to do it.
The restrictions on this operation depend on which subclass this is, but in general
(except for PlaceHolders) an object can only become another of the same type with the same
content.

Overrides:

canMakeIdentical in class FeRangeElement

makeIdentical

public void makeIdentical(FeRangeElement newIdentity)

Description copied from class: FeRangeElement

Essential. Change the identity of this object to the other. BLAST if unsuccessful.
Requires authority of the current owner; if the operation is successful, the owner will
appear to change to that of the other object.
Also requires enough permission on newIdentity to determine, by comparing content, whether
the operation would succeed.
The restrictions on this operation depend on which subclass this is, but in general
(except for PlaceHolders) an object can only become another of the same type with the same
content.

Overrides:

makeIdentical in class FeRangeElement

printOn

public void printOn(java.io.PrintWriter oo)

Overrides:

printOn in class Heaper

canMakeRangeIdentical

public XnRegion canMakeRangeIdentical(FeEdition newIdentities)

isRangeIdentical

public boolean isRangeIdentical(FeEdition other)

makeRangeIdentical

public FeEdition makeRangeIdentical(FeEdition newIdentities)

notSharedWith

public FeEdition notSharedWith(FeEdition other)

rangeTranscluders

public FeEdition rangeTranscluders()

rangeTranscluders

public FeEdition rangeTranscluders(XnRegion positions)

rangeTranscluders

public FeEdition rangeTranscluders(XnRegion positions,
                                   Filter filter)

rangeTranscluders

public FeEdition rangeTranscluders(XnRegion positions,
                                   Filter filter,
                                   Filter transitiveFilter)

rangeTranscluders

public FeEdition rangeTranscluders(XnRegion positions,
                                   Filter filter,
                                   Filter transitiveFilter,
                                   int flags)

rangeWorks

public FeEdition rangeWorks()

rangeWorks

public FeEdition rangeWorks(XnRegion region)

rangeWorks

public FeEdition rangeWorks(XnRegion region,
                            Filter filter)

rangeWorks

public FeEdition rangeWorks(XnRegion region,
                            Filter filter,
                            int flags)

retrieve

public Stepper retrieve()

retrieve

public Stepper retrieve(XnRegion positions)

retrieve

public Stepper retrieve(XnRegion positions,
                        OrderSpec order)

setRangeOwners

public FeEdition setRangeOwners(ID newOwner)

sharedRegion

public XnRegion sharedRegion(FeEdition other)

sharedWith

public FeEdition sharedWith(FeEdition other)

stepper

public TableStepper stepper()

stepper

public TableStepper stepper(XnRegion region)

addCompletionDetector

public void addCompletionDetector(FeCompletionDetector detector)

addFillInDetector

public void addFillInDetector(FeFillInDetector detector)

allBecome

public FeEdition allBecome(FeEdition newIdentities,
                           XnRegion positions)

asArray

public PrimArray asArray(XnRegion positions,
                         OrderSpec ordering)

keysLabelled

public XnRegion keysLabelled(FeLabel label)

parcelAt

public FeEdition parcelAt(Position position)

Some subset of this Edition, containing the given position, all with the same owner
{ | in self and in self and v.owner == v2.owner }

parcels

public FeEdition parcels()

Divides this Edition into pieces each of whose RangeElements are all owned by a single
Club.
{ } > | in self and k1 == v2's owner }

removeCompletionDetector

public void removeCompletionDetector(FeCompletionDetector detector)

removeFillInDetector

public void removeFillInDetector(FeFillInDetector detector)

reorganize

public FeEdition reorganize(XnRegion oldRegion,
                            OrderSpec oldOrder,
                            XnRegion newRegion,
                            OrderSpec newOrder)

Rearrange the positions of this Edition to lie in the given region, with the given
ordering. Equivalent to server->makeEdition (this->asArray (oldRegion, oldOrder),
newRegion, newOrder, NULL), except that it doesn't require everything to be in the same
zone (and is of course more efficient).
This message is tentative and may be removed from the protocol.

setAllOwners

public FeEdition setAllOwners(ID newOwner,
                              XnRegion region)

transclusions

public FeEdition transclusions(XnRegion positions,
                               Filter directFilter,
                               Filter indirectFilter,
                               int flags,
                               FeEdition otherTransclusions)

unendorse

public void unendorse(CrossRegion endorsements)

zoneAt

public Pair zoneAt(Position position)

Essential. A zone containing the given position, all with the same kind of RangeElements.

zoneOf

public FeEdition zoneOf(PrimSpec values)

zones

public TwoStepper zones(OrderSpec ordering)

Divides this Edition up into pieces all of whose RangeElements have the same PrimSpec. If
no ordering is given, then uses the default full ordering for this CoordinateSpace.

includesKey

public boolean includesKey(Position position)

Whether the given position is in the Edition. Equivalent to
this->domain ()->hasMember (position)

keysOf

public XnRegion keysOf(FeRangeElement value)

All of the keys in this Edition at which the given RangeElement can be found. Equivalent
to
this->sharedRegion (theServer ()->makeEditionWith (some position, value)).
{ k | in self and v is same as value }

destruct

public void destruct()

Description copied from class: Heaper

Classes should implement this message rather than a destructor. We use this so
the destruction behavior implemented in abstract superclasses can access the
vtable of the concrete run-time type in C++. Using a message makes C++
parallel the Smalltalk semantics for delete. Destroy will actually call the destructor.

Overrides:

destruct in class Heaper

fromArray

public static FeEdition fromArray(PrimArray values)

Essential. Creates an Edition mapping from a Region of keys to the values in an array.
The ordering specifies the correspondance between the keys and the indices in the array.
If a Region is given, then it must have the same count as the array. If no Region is
given, then it is taken to be the IntegerRegion from 0 to the size of the array. If no
OrderSpec is given, then it is the default ascending full ordering for that
CoordinateSpace.

fromArray

public static FeEdition fromArray(PrimArray values,
                                  XnRegion keys)

Essential. Creates an Edition mapping from a Region of keys to the values in an array.
The ordering specifies the correspondance between the keys and the indices in the array.
If a Region is given, then it must have the same count as the array. If no Region is
given, then it is taken to be the IntegerRegion from 0 to the size of the array. If no
OrderSpec is given, then it is the default ascending full ordering for that
CoordinateSpace.

empty

public static FeEdition empty(CoordinateSpace keySpace)

An empty Edition, with the given CoordinateSpace but no contents.

fromAll

public static FeEdition fromAll(XnRegion keys,
                                FeRangeElement value)

Essential. A singleton Edition mapping from a Region of keys (potentially infinite) to a
single value.

fromArray

public static FeEdition fromArray(PrimArray values,
                                  XnRegion keys,
                                  OrderSpec ordering)

Essential. Creates an Edition mapping from a Region of keys to the values in an array.
The ordering specifies the correspondance between the keys and the indices in the array.
If a Region is given, then it must have the same count as the array. If no Region is
given, then it is taken to be the IntegerRegion from 0 to the size of the array. If no
OrderSpec is given, then it is the default ascending full ordering for that
CoordinateSpace.

fromOne

public static FeEdition fromOne(Position key,
                                FeRangeElement value)

A singleton Edition mapping from a single key to a single value.

on

public static FeEdition on(BeEdition be)

on

public static FeEdition on(BeEdition be,
                           FeLabel label)

placeHolders

public static FeEdition placeHolders(XnRegion keys)

Essential. Create a new Edition mapping from each key in the Region to a new, unique
PlaceHolder. The owner will have the capability to make them become something else.

DIRECT

public static int DIRECT()

For transcluders and works queries - only return objects which directly contain the
sources of the query (i.e. excludes those which only contain it transitively through
intermediate Editions)

FROM_OTHER

public static int FROM_OTHER()

For sharedWith/sharedRegion/notSharedWith - look for RangeElements contained transitively
within the other Edition

FROM

public static int FROM()

For transcluders, and works queries - consider RangeElements contained transitively inside
the Edition, as well as just its immediate RangeElements

IGNORE_ARRAY_ORDERING

public static int IGNORE_ARRAY_ORDERING()

Used for retrieve. Allow the ArrayBundles in retrieve to be organized according to a
different ordering.

IGNORE_TOTAL_ORDERING

public static int IGNORE_TOTAL_ORDERING()

Used for retrieve. Allow non-contiguous chunks to be grouped together on retrieve, and
allow the bundles to be presented in any order.

LOCAL

public static int LOCAL()

For transcluders and works queries - only guarantee to return items which are currently
known to this server

OMIT

public static int OMIT()

For cost - omit the cost of shared material

otherTransitiveContents

public static int otherTransitiveContents()

For sharedWith/sharedRegion/notSharedWith

PRORATE

public static int PRORATE()

For cost - prorate the cost of shared material among Editions sharing it

SEPARATE

public static int SEPARATE()

For retrieve - ensure that each Bundle in a retrieve has a single owner

thisTransitiveContents

public static int thisTransitiveContents()

Used for version comparison.

TO

public static int TO()

For sharedRegion, sharedWith, notSharedWith queries - look down towards transitively
contained material

TOTAL

public static int TOTAL()

For cost - count the entire cost of shared material

info

public static void info()

{Int32 constFn INLINE CLIENT} DIRECT.U.CONTAINERS.U.ONLY
{Int32 constFn INLINE CLIENT} FROM.U.OTHER.U.TRANSITIVE.U.CONTENTS
{Int32 constFn INLINE CLIENT} FROM.U.TRANSITIVE.U.CONTENTS
{Int32 constFn INLINE CLIENT} IGNORE.U.ARRAY.U.ORDERING
{Int32 constFn INLINE CLIENT} IGNORE.U.TOTAL.U.ORDERING
{Int32 constFn INLINE CLIENT} LOCAL.U.PRESENT.U.ONLY
{Int32 constFn INLINE CLIENT} OMIT.U.SHARED
{Int32 constFn INLINE CLIENT} PRORATE.U.SHARED
{Int32 constFn INLINE CLIENT} SEPARATE.U.OWNERS
{Int32 constFn INLINE CLIENT} TO.U.TRANSITIVE.U.CONTENTS
{Int32 constFn INLINE CLIENT} TOTAL.U.SHARED
{void CLIENT} addFillRangeDetector: detector {PrFillRangeDetector}
{XuRegion CLIENT} canMakeRangeIdentical: newIdentities {FeEdition} with: positions
{XuRegion default: NULL}
{FeEdition CLIENT} combine: other {FeEdition}
{CoordinateSpace CLIENT} coordinateSpace
{FeEdition CLIENT} copy: positions {XuRegion}
{IntegerVar CLIENT} cost: method {Int32}
{IntegerVar CLIENT} count
{XuRegion CLIENT} domain
{void CLIENT} endorse: endorsements {CrossRegion}
{CrossRegion CLIENT} endorsements
{FeRangeElement CLIENT} get: position {Position}
{BooleanVar CLIENT} hasPosition: position {Position}
{BooleanVar CLIENT} isEmpty
{BooleanVar CLIENT} isFinite
{BooleanVar CLIENT} isRangeIdentical: other {FeEdition}
{BooleanVar CLIENT} isRangeIdentical: other {FeEdition} with: region {XuRegion default:
NULL}
{FeEdition CLIENT} makeRangeIdentical: newIdentities {FeEdition} with: positions {XuRegion
default: NULL}
{Mapping CLIENT} mapSharedOnto: other {FeEdition}
{Mapping CLIENT} mapSharedTo: other {FeEdition}
{FeEdition CLIENT} notSharedWith: other {FeEdition} with: flags {Int32 default: Int32Zero}
{XuRegion CLIENT} positionsLabelled: label {FeLabel}
{XuRegion CLIENT} positionsOf: value {FeRangeElement}
{IDRegion CLIENT} rangeOwners: positions {XuRegion default: NULL}
{FeEdition CLIENT} rangeTranscluders: positions {XuRegion default: NULL} with:
directFilter {Filter default: NULL} with: indirectFilter {Filter default: NULL} with:
flags {Int32 default: Int32Zero} with: otherTrail {FeEdition default: NULL}
{FeEdition CLIENT} rangeWorks: positions {XuRegion default: NULL} with: filter {Filter
default: NULL} with: flags {Int32 default: Int32Zero} with: otherTrail {FeEdition default:
NULL}
{FeEdition CLIENT} rebind: position {Position} with: edition {FeEdition}
{void CLIENT} removeFillRangeDetector: detector {PrFillRangeDetector}
{FeEdition CLIENT} replace: other {FeEdition}
{void CLIENT} retract: endorsements {CrossRegion}
{(Stepper of: Bundle) CLIENT} retrieve: positions {XuRegion default: NULL} with: order
{OrderSpec default: NULL} with: flags {Int32 default: Int32Zero}
{FeEdition CLIENT} setRangeOwners: newOwner {ID} with: positions {XuRegion default: NULL}
{XuRegion CLIENT} sharedRegion: other {FeEdition} with: flags {Int32 default: Int32Zero}
{FeEdition CLIENT} sharedWith: other {FeEdition} with: flags {Int32 default: Int32Zero}
{TableStepper CLIENT of: FeRangeElement} stepper: region {XuRegion default: NULL} with:
order {OrderSpec default: NULL}
{FeRangeElement CLIENT} theOne
{FeEdition CLIENT} transformedBy: mapping {Mapping}
{CrossRegion CLIENT} visibleEndorsements
{FeEdition CLIENT} with: position {Position} with: value {FeRangeElement}
{FeEdition CLIENT} withAll: positions {XuRegion} with: value {FeRangeElement}
{FeEdition CLIENT} without: position {Position}
{FeEdition CLIENT} withoutAll: positions {XuRegion}