branchx.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
branchx.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
branchx.cxx:RPTR(BranchDescription) BranchDescription::make (APTR(DagWood) xfulltrace, APTR(TracePosition) parent){
branchx.cxx:	RETURN_CONSTRUCT(TreeBranch,(xfulltrace, parent));
branchx.cxx:		APTR(TracePosition) parent1, 
branchx.cxx:		APTR(TracePosition) parent2)
branchx.cxx:	RETURN_CONSTRUCT(DagBranch,(xfulltrace, parent1, parent2));
branchx.cxx:/* Instances of subclasses describe the different kinds of paths in a 
branchx.cxx:three kinds are root (no parent), tree (one parent) and dag (two 
branchx.cxx:parent) branches.  
branchx.cxx:At the moment, these never go away!!! */
branchx.cxx:UInt32 BranchDescription::contentsHash (){
branchx.cxx:	return this->Abraham::contentsHash() ^ myLeft->hashForEqual() ^ myRight->hashForEqual() ^ fulltrace->hashForEqual();
branchx.cxx:	parent1->cacheIn(navCache);
branchx.cxx:	parent2->cacheIn(navCache);
branchx.cxx:	parent1 = p1;
branchx.cxx:	parent2 = p2;
branchx.cxx:UInt32 DagBranch::contentsHash (){
branchx.cxx:	return this->BranchDescription::contentsHash() ^ parent1->hashForEqual() ^ parent2->hashForEqual();
branchx.cxx:	parent->cacheIn(navCache);
branchx.cxx:	parent = p;
branchx.cxx:UInt32 TreeBranch::contentsHash (){
branchx.cxx:	return this->BranchDescription::contentsHash() ^ parent->hashForEqual();
branchx.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
branchx.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
branchx.hxx:	/* Instances of subclasses describe the different kinds of 
branchx.hxx:	three kinds are root (no parent), tree (one parent) and dag 
branchx.hxx:	(two parent) branches.  
branchx.hxx:	At the moment, these never go away!!! */
branchx.hxx:	static RPTR(BranchDescription) make (APTR(DagWood) ARG(xfulltrace), APTR(TracePosition) ARG(parent));
branchx.hxx:			APTR(TracePosition) ARG(parent1), 
branchx.hxx:			APTR(TracePosition) ARG(parent2))
branchx.hxx:	virtual UInt32 contentsHash ();
branchx.hxx:	/* NO CLASS COMMENT */
branchx.hxx:	virtual UInt32 contentsHash ();
branchx.hxx:	CHKPTR(TracePosition) parent1;
branchx.hxx:	CHKPTR(TracePosition) parent2;
branchx.hxx:	/* NO CLASS COMMENT */
branchx.hxx:	/* NO CLASS COMMENT */
branchx.hxx:	virtual UInt32 contentsHash ();
branchx.hxx:	CHKPTR(TracePosition) parent;
branchx.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
branchx.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
branchx.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
branchx.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
brange1p.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
brange1p.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
brange1p.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
brange1p.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
brange1p.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
brange1p.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
brange1x.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
brange1x.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
brange1x.cxx:RPTR(BeCarrier) BeCarrier::label (APTR(BeRangeElement) element){
brange1x.cxx:	RETURN_CONSTRUCT(BeCarrier,(CurrentGrandMap.fluidGet()->newLabel(), element));
brange1x.cxx:RPTR(BeCarrier) BeCarrier::make (APTR(BeRangeElement) element){
brange1x.cxx:	RETURN_CONSTRUCT(BeCarrier,(NULL, element));
brange1x.cxx:RPTR(BeCarrier) BeCarrier::make (APTR(BeLabel) OR(NULL) label, APTR(BeRangeElement) element){
brange1x.cxx:	RETURN_CONSTRUCT(BeCarrier,(label, element));
brange1x.cxx:/* These are used to carry a combination of a rangeElement and a 
brange1x.cxx:label.  Using FeRangeElements would be a hack that drags in 
brange1x.cxx:RPTR(FeRangeElement) BeCarrier::makeFe (){
brange1x.cxx:		WPTR(FeRangeElement) 	returnValue;
brange1x.cxx:		returnValue = myRangeElement->makeFe(myLabel);
brange1x.cxx:		WPTR(FeRangeElement) 	returnValue;
brange1x.cxx:		returnValue = myRangeElement->makeFe(myLabel);
brange1x.cxx:RPTR(BeRangeElement) BeCarrier::rangeElement (){
brange1x.cxx:	return (BeRangeElement*) myRangeElement;
brange1x.cxx:BeCarrier::BeCarrier (APTR(BeLabel) OR(NULL) label, APTR(BeRangeElement) element) {
brange1x.cxx:	myRangeElement = element;
brange1x.cxx:	if (!(myLabel != NULL == myRangeElement->isKindOf(cat_BeEdition))) {
brange1x.cxx: *                    Class BeRangeElement 
brange1x.cxx:/* This is the actual representation on disk; the Fe versions of 
brange1x.cxx:these classes hide the actual representation. */
brange1x.cxx:void BeRangeElement::addFeRangeElement (APTR(FeRangeElement) element){
brange1x.cxx:	if (myFeRangeElements == NULL) {
brange1x.cxx:		myFeRangeElements = PrimSet::weak();
brange1x.cxx:	myFeRangeElements->introduce(element);
brange1x.cxx:BooleanVar BeRangeElement::isPurgeable (){
brange1x.cxx:		/* myFeRangeElements == NULL || myFeRangeElements->isEmpty() */
brange1x.cxx:		crutch_Flag = myFeRangeElements == NULL;
brange1x.cxx:			crutch_Flag = myFeRangeElements->isEmpty();
brange1x.cxx:BooleanVar BeRangeElement::makeIdentical (APTR(BeRangeElement) /* other */){
brange1x.cxx:	/* Change the identity of this object to that of the other.
brange1x.cxx:		 Only placeHolders implement it at the moment, so the 
brange1x.cxx:RPTR(ID) BeRangeElement::owner (){
brange1x.cxx:void BeRangeElement::removeFeRangeElement (APTR(FeRangeElement) element){
brange1x.cxx:		/* myFeRangeElements == NULL || !myFeRangeElements->hasMember(element) */
brange1x.cxx:		crutch_Flag = myFeRangeElements == NULL;
brange1x.cxx:			crutch_Flag = !myFeRangeElements->hasMember(element);
brange1x.cxx:			BLAST(NeverAddedFeRangeElement);
brange1x.cxx:	myFeRangeElements->wipe(element);
brange1x.cxx:	if (myFeRangeElements->isEmpty()) {
brange1x.cxx:		{myFeRangeElements->destroy();  myFeRangeElements = NULL /* don't want stale (S/CHK)PTRs */;}
brange1x.cxx:		myFeRangeElements = NULL;
brange1x.cxx:void BeRangeElement::setOwner (APTR(ID) club){
brange1x.cxx:	BEGIN_CONSISTENT(1) {
brange1x.cxx:	} END_CONSISTENT;
brange1x.cxx:void BeRangeElement::addOParent (APTR(Loaf) oparent){
brange1x.cxx:	/* add oparent to the set of upward pointers.  Editions may
brange1x.cxx:	BEGIN_INSISTENT(5) {
brange1x.cxx:		myHCrum->addOParent(oparent);
brange1x.cxx:	} END_INSISTENT;
brange1x.cxx:BooleanVar BeRangeElement::anyPasses (APTR(PropFinder) finder){
brange1x.cxx:RPTR(BertCrum) BeRangeElement::bertCrum (){
brange1x.cxx:void BeRangeElement::checkRecorders (APTR(PropFinder) finder, APTR(SensorCrum) OR(NULL) scrum){
brange1x.cxx:UInt32 BeRangeElement::contentsHash (){
brange1x.cxx:	return this->Abraham::contentsHash() ^ myHCrum->hashForEqual() ^ mySensorCrum->hashForEqual() ^ myOwner->hashForEqual();
brange1x.cxx:void BeRangeElement::delayedStoreBackfollow (
brange1x.cxx:RPTR(PrimSet) OF1(FeRangeElement) BeRangeElement::feRangeElements (){
brange1x.cxx:	if (myFeRangeElements == NULL) {
brange1x.cxx:		WPTR(PrimSet) OF1(FeRangeElement) 	returnValue;
brange1x.cxx:		return (PrimSet*) myFeRangeElements;
brange1x.cxx:RPTR(HistoryCrum) BeRangeElement::hCrum (){
brange1x.cxx:BooleanVar BeRangeElement::inTrace (APTR(TracePosition) trace){
brange1x.cxx:RPTR(Mapping) BeRangeElement::mappingTo (APTR(TracePosition) trace, APTR(Mapping) mapping){
brange1x.cxx:void BeRangeElement::removeOParent (APTR(OPart) oparent){
brange1x.cxx:	/* remove oparent from the set of upward pointers. */
brange1x.cxx:	myHCrum->removeOParent(oparent);
brange1x.cxx:RPTR(SensorCrum) BeRangeElement::sensorCrum (){
brange1x.cxx:BooleanVar BeRangeElement::updateBCrumTo (APTR(BertCrum) newBCrum){
brange1x.cxx:BeRangeElement::BeRangeElement () {
brange1x.cxx:	myFeRangeElements = NULL;
brange1x.cxx:BeRangeElement::BeRangeElement (APTR(SensorCrum) sensorCrum, TCSJ) {
brange1x.cxx:	myFeRangeElements = NULL;
brange1x.cxx:void BeRangeElement::dismantle (){
brange1x.cxx:	BEGIN_CONSISTENT(2) {
brange1x.cxx:	} END_CONSISTENT;
brange1x.cxx:void BeRangeElement::restartRE (APTR(Rcvr) /* rcvr */){
brange1x.cxx:	myFeRangeElements = NULL;
brange1x.cxx:RPTR(BeEdition) BeRangeElement::works (
brange1x.cxx:		APTR(Filter) endorsementsFilter, 
brange1x.cxx:	/* See comment in FeRangeElement */
brange1x.cxx:	BLAST(NOT_YET_IMPLEMENTED);
brange1x.cxx:RPTR(FeRangeElement) BeDataHolder::makeFe (APTR(BeLabel) OR(NULL) label){
brange1x.cxx:	WPTR(FeRangeElement) 	returnValue;
brange1x.cxx:RPTR(FeRangeElement) BeIDHolder::makeFe (APTR(BeLabel) OR(NULL) label){
brange1x.cxx:	WPTR(FeRangeElement) 	returnValue;
brange1x.cxx:	BLAST(NOT_YET_IMPLEMENTED);
brange1x.cxx:RPTR(FeRangeElement) BeLabel::makeFe (APTR(BeLabel) OR(NULL) label){
brange1x.cxx:	WPTR(FeRangeElement) 	returnValue;
brange1x.cxx:		instead of range elements, so just remember them. */
brange1x.cxx:		/* this->BeRangeElement::isPurgeable() && myDetectors == NULL */
brange1x.cxx:		crutch_Flag = this->BeRangeElement::isPurgeable();
brange1x.cxx:RPTR(FeRangeElement) BePlaceHolder::makeFe (APTR(BeLabel) OR(NULL) label){
brange1x.cxx:	WPTR(FeRangeElement) 	returnValue;
brange1x.cxx:BooleanVar BePlaceHolder::makeIdentical (APTR(BeRangeElement) other){
brange1x.cxx:	/* Change the identity of this object to that of the other. */
brange1x.cxx:	/* Make all my persistent oParents point at the other guy.
brange1x.cxx:		make all the session level FeRangeElements point at the other guy. */
brange1x.cxx:	SPTR(ScruSet) OF1(OPart) oParents;
brange1x.cxx:	oParents = this->hCrum()->oParents();
brange1x.cxx:	/* if there are several oParents then a given Detector may be 
brange1x.cxx:	BEGIN_CONSISTENT(-1) {
brange1x.cxx:		BEGIN_FOR_EACH(Loaf,loaf,(oParents->stepper())) {
brange1x.cxx:	} END_CONSISTENT;
brange1x.cxx:	BEGIN_FOR_EACH(FePlaceHolder,elem,(this->feRangeElements()->stepper())) {
brange1x.cxx:		SPTR(FeRangeElement) fe;
brange1x.cxx:				fe = ed->makeFe(CurrentGrandMap.fluidGet()->newLabel());
brange1x.cxx:	: BeRangeElement(SensorCrum::partial(), tcsj) {
brange1x.cxx:	: BeRangeElement(SensorCrum::partial(), tcsj) {
brange1x.cxx:	BEGIN_CONSISTENT(3) {
brange1x.cxx:	} END_CONSISTENT;
brange1x.cxx:	BEGIN_CONSISTENT(2) {
brange1x.cxx:	} END_CONSISTENT;
brange1x.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
brange1x.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
brange1x.hxx:	/* These are used to carry a combination of a rangeElement 
brange1x.hxx:	and a label.  Using FeRangeElements would be a hack that 
brange1x.hxx:	static RPTR(BeCarrier) label (APTR(BeRangeElement) ARG(element));
brange1x.hxx:	static RPTR(BeCarrier) make (APTR(BeRangeElement) ARG(element));
brange1x.hxx:	static RPTR(BeCarrier) make (APTR(BeLabel) OR(NULL) ARG(label), APTR(BeRangeElement) ARG(element));
brange1x.hxx:	virtual RPTR(FeRangeElement) makeFe ();
brange1x.hxx:	virtual RPTR(BeRangeElement) rangeElement ();
brange1x.hxx:	BeCarrier (APTR(BeLabel) OR(NULL) ARG(label), APTR(BeRangeElement) ARG(element));
brange1x.hxx:	CHKPTR(BeRangeElement) myRangeElement;
brange1x.hxx: *                    Class BeRangeElement 
brange1x.hxx:	/* This is the actual representation on disk; the Fe versions 
brange1x.hxx:	of these classes hide the actual representation. */
brange1x.hxx:class BeRangeElement : public Abraham {
brange1x.hxx:/* Attributes for class BeRangeElement */
brange1x.hxx:	DEFERRED(BeRangeElement)
brange1x.hxx:	SHEPHERD_ANCESTOR(BeRangeElement,Abraham)
brange1x.hxx:	COPY(BeRangeElement,DiskCuisine)
brange1x.hxx:	DEFERRED_LOCKED(BeRangeElement)
brange1x.hxx:	AUTO_GC(BeRangeElement)
brange1x.hxx:	virtual void addFeRangeElement (APTR(FeRangeElement) ARG(element));
brange1x.hxx:	virtual RPTR(FeRangeElement) makeFe (APTR(BeLabel) OR(NULL) ARG(label)) DEFERRED_FUNC;
brange1x.hxx:	/* Change the identity of this object to that of the other.
brange1x.hxx:		 Only placeHolders implement it at the moment, so the 
brange1x.hxx:	virtual NOLOCK BooleanVar makeIdentical (APTR(BeRangeElement) ARG(other));
brange1x.hxx:	virtual void removeFeRangeElement (APTR(FeRangeElement) ARG(element));
brange1x.hxx:	/* add oparent to the set of upward pointers.  Editions may
brange1x.hxx:	virtual void addOParent (APTR(Loaf) ARG(oparent));
brange1x.hxx:	virtual UInt32 contentsHash ();
brange1x.hxx:	virtual RPTR(PrimSet) OF1(FeRangeElement) feRangeElements ();
brange1x.hxx:	/* remove oparent from the set of upward pointers. */
brange1x.hxx:	virtual void removeOParent (APTR(OPart) ARG(oparent));
brange1x.hxx:	BeRangeElement ();
brange1x.hxx:	BeRangeElement (APTR(SensorCrum) ARG(sensorCrum), TCSJ);
brange1x.hxx:	/* See comment in FeRangeElement */
brange1x.hxx:			APTR(Filter) ARG(endorsementsFilter), 
brange1x.hxx:	NOCOPY CHKPTR(PrimSet) OF1(FeRangeElement) OR(NULL) myFeRangeElements;
brange1x.hxx:};  /* end class BeRangeElement */
brange1x.hxx:	/* NO CLASS COMMENT */
brange1x.hxx:class BeDataHolder : public BeRangeElement {
brange1x.hxx:	SHEPHERD_PATRIARCH(BeDataHolder,BeRangeElement)
brange1x.hxx:	virtual RPTR(FeRangeElement) makeFe (APTR(BeLabel) OR(NULL) ARG(label));
brange1x.hxx:	/* NO CLASS COMMENT */
brange1x.hxx:class BeIDHolder : public BeRangeElement {
brange1x.hxx:	SHEPHERD_PATRIARCH(BeIDHolder,BeRangeElement)
brange1x.hxx:	virtual RPTR(FeRangeElement) makeFe (APTR(BeLabel) OR(NULL) ARG(label));
brange1x.hxx:	/* NO CLASS COMMENT */
brange1x.hxx:class BeLabel : public BeRangeElement {
brange1x.hxx:	SHEPHERD_PATRIARCH(BeLabel,BeRangeElement)
brange1x.hxx:	virtual RPTR(FeRangeElement) makeFe (APTR(BeLabel) OR(NULL) ARG(label));
brange1x.hxx:	/* NO CLASS COMMENT */
brange1x.hxx:class BePlaceHolder : public BeRangeElement {
brange1x.hxx:	SHEPHERD_PATRIARCH(BePlaceHolder,BeRangeElement)
brange1x.hxx:	virtual RPTR(FeRangeElement) makeFe (APTR(BeLabel) OR(NULL) ARG(label));
brange1x.hxx:	/* Change the identity of this object to that of the other. */
brange1x.hxx:	/* Make all my persistent oParents point at the other guy.
brange1x.hxx:		make all the session level FeRangeElements point at the other guy. */
brange1x.hxx:	virtual BooleanVar makeIdentical (APTR(BeRangeElement) ARG(other));
brange1x.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
brange1x.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
brange1x.ixx: *                    Class BeRangeElement 
brange1x.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
brange1x.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
brange1x.oxx:OPAQUE_TYPE_3(BeRangeElement,Abraham,Heaper);
brange1x.oxx:OPAQUE_TYPE_4(BeDataHolder,BeRangeElement,Abraham,Heaper);
brange1x.oxx:OPAQUE_TYPE_4(BeIDHolder,BeRangeElement,Abraham,Heaper);
brange1x.oxx:OPAQUE_TYPE_4(BeLabel,BeRangeElement,Abraham,Heaper);
brange1x.oxx:OPAQUE_TYPE_4(BePlaceHolder,BeRangeElement,Abraham,Heaper);
brange2p.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
brange2p.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
brange2p.hxx:	/* NO CLASS COMMENT */
brange2p.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
brange2p.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
brange2p.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
brange2p.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
brange2x.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
brange2x.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
brange2x.cxx:	BEGIN_CONSISTENT(-1) {
brange2x.cxx:	} END_CONSISTENT;
brange2x.cxx:/* This is the actual representation on disk; the Fe versions of 
brange2x.cxx:these classes hide the actual representation. */
brange2x.cxx:	ckm = CurrentKeyMaster.fluidGet();
brange2x.cxx:/* contents */
brange2x.cxx:	/* The current Edition.
brange2x.cxx:	/* Change the current edition and notify anyone who cares 
brange2x.cxx:	gm = CurrentGrandMap.fluidGet();
brange2x.cxx:										(CurrentAuthor fluidGet with: 
brange2x.cxx:	/* Change the current edition and notify anyone who cares 
brange2x.cxx:	BEGIN_CONSISTENT(-1) {
brange2x.cxx:			myReviser = CurrentAuthor.fluidGet();
brange2x.cxx:	} END_CONSISTENT;
brange2x.cxx:		BEGIN_CONSISTENT(-1) {
brange2x.cxx:			myHistory = CurrentGrandMap.fluidGet()->newEmptyEdition(IntegerSpace::make ());
brange2x.cxx:		} END_CONSISTENT;
brange2x.cxx:	BEGIN_CONSISTENT(1) {
brange2x.cxx:	} END_CONSISTENT;
brange2x.cxx:	BEGIN_CONSISTENT(-1) {
brange2x.cxx:	} END_CONSISTENT;
brange2x.cxx:	BEGIN_CONSISTENT(-1) {
brange2x.cxx:	} END_CONSISTENT;
brange2x.cxx:void BeWork::endorse (APTR(CrossRegion) endorsements){
brange2x.cxx:	/* Adds to the endorsements on this Work. The set of 
brange2x.cxx:	endorsements must be a finite number of (club ID, token ID) 
brange2x.cxx:	if (endorsements->isEmpty()) {
brange2x.cxx:	BEGIN_CONSISTENT(8) {
brange2x.cxx:		this->propChange(PropChange::endorsementsChange(), BertProp::endorsementsProp(endorsements->unionWith(myOwnProp->endorsements())));
brange2x.cxx:	} END_CONSISTENT;
brange2x.cxx:RPTR(CrossRegion) BeWork::endorsements (){
brange2x.cxx:	/* All endorsements which have been placed on this Work. The 
brange2x.cxx:	current Edition of this Work by filtering for these 
brange2x.cxx:	endorsements; they are also used to filter various other 
brange2x.cxx:	return CAST(CrossRegion,myOwnProp->endorsements());
brange2x.cxx:void BeWork::retract (APTR(CrossRegion) endorsements){
brange2x.cxx:	/* Removes endorsements from this Work. This requires the 
brange2x.cxx:	authority of all of the Clubs whose endorsements are in the 
brange2x.cxx:	list. Ignores all endorsements which you could have removed, 
brange2x.cxx:	if (endorsements->isEmpty()) {
brange2x.cxx:	BEGIN_CONSISTENT(5) {
brange2x.cxx:		this->propChange(PropChange::endorsementsChange(), BertProp::endorsementsProp(myOwnProp->endorsements()->minus(endorsements)));
brange2x.cxx:	} END_CONSISTENT;
brange2x.cxx:		/* this->BeRangeElement::isPurgeable() && this->fetchLockingWork() == NULL && myRevisionWatchers == NULL */
brange2x.cxx:		crutch_Flag = this->BeRangeElement::isPurgeable();
brange2x.cxx:RPTR(FeRangeElement) BeWork::makeFe (APTR(BeLabel) OR(NULL) label){
brange2x.cxx:	WPTR(FeRangeElement) 	returnValue;
brange2x.cxx:		BEGIN_CONSISTENT(newClubs->count() + 1) {
brange2x.cxx:				CurrentGrandMap.fluidGet()->getClub(clubID)->addSponsored(this);
brange2x.cxx:		} END_CONSISTENT;
brange2x.cxx:		BEGIN_CONSISTENT(lostClubs->count() + 1) {
brange2x.cxx:				CurrentGrandMap.fluidGet()->getClub(clubID)->removeSponsored(this);
brange2x.cxx:		} END_CONSISTENT;
brange2x.cxx:	BEGIN_FOR_EACH(FeWork,work,(this->feRangeElements()->stepper())) {
brange2x.cxx:BeWork::BeWork (APTR(FeEdition) contents, BooleanVar isClub) {
brange2x.cxx:	myEdition = contents->beEdition();
brange2x.cxx:	myEditionLabel = CAST(BeLabel,contents->label()->getOrMakeBe());
brange2x.cxx:		permissions = CurrentGrandMap.fluidGet()->globalIDSpace()->emptyRegion();
brange2x.cxx:	myReviser = CurrentAuthor.fluidGet();
brange2x.cxx:	if (InitialSponsor.fluidGet() == CurrentGrandMap.fluidGet()->emptyClubID()) {
brange2x.cxx:		CurrentGrandMap.fluidGet()->getClub(iD)->addSponsored(this);
brange2x.cxx:	oo << this->getCategory()->name() << "(" << CurrentGrandMap.fluidGet()->iDsOf(this) << ")";
brange2x.cxx:BUILD_FLUID(BeClub,CurrentOwner, NULL, ServerChunk::emulsion());	/* in BeClub */
brange2x.cxx:RPTR(BeClub) BeClub::make (APTR(FeEdition) contents){
brange2x.cxx:	BEGIN_CONSISTENT(-1) {
brange2x.cxx:		RETURN_CONSTRUCT(BeClub,(contents, tcsj));
brange2x.cxx:	} END_CONSISTENT;
brange2x.cxx:/* dependents */
brange2x.cxx:	/* Add a sponsored Work (sent from the Work) */
brange2x.cxx:	BEGIN_INSISTENT(1) {
brange2x.cxx:	} END_INSISTENT;
brange2x.cxx:RPTR(FeRangeElement) BeClub::makeFe (APTR(BeLabel) OR(NULL) label){
brange2x.cxx:	WPTR(FeRangeElement) 	returnValue;
brange2x.cxx:	/* Add a sponsored Work (sent from the Work) */
brange2x.cxx:	BEGIN_INSISTENT(1) {
brange2x.cxx:	} END_INSISTENT;
brange2x.cxx:/* contents */
brange2x.cxx:void BeClub::revise (APTR(FeEdition) contents){
brange2x.cxx:	if (!FeClubDescription::check(contents)) {
brange2x.cxx:	BEGIN_CONSISTENT(-1) {
brange2x.cxx:		this->BeWork::revise(contents);
brange2x.cxx:		newMembership = CAST(FeEdition,contents->fetch(Sequence::string("ClubDescription:Membership")));
brange2x.cxx:				memberTest = newMembership != NULL && newMembership->isIdentical(oldMembership);
brange2x.cxx:			/* Update self and all parents with new 
brange2x.cxx:	} END_CONSISTENT;
brange2x.cxx:void BeClub::addImmediateSuperClub (APTR(BeClub) parent){
brange2x.cxx:	myImmediateSuperClubs->store(parent);
brange2x.cxx:void BeClub::removeImmediateSuperClub (APTR(BeClub) parent){
brange2x.cxx:	myImmediateSuperClubs->remove(parent);
brange2x.cxx:	result = result->with(CurrentGrandMap.fluidGet()->iDOf(this));
brange2x.cxx:		BEGIN_INSISTENT(4) {
brange2x.cxx:		} END_INSISTENT;
brange2x.cxx:	result = result->with(CurrentGrandMap.fluidGet()->iDOf(this));
brange2x.cxx:		BEGIN_INSISTENT(4) {
brange2x.cxx:				UpdateTransitiveSuperClubIDs::make (myMembers->copy()->asMuSet(), CurrentGrandMap.fluidGet())->schedule();
brange2x.cxx:		} END_INSISTENT;
brange2x.cxx:BeClub::BeClub (APTR(FeEdition) contents, TCSJ) 
brange2x.cxx:	: BeWork(contents, TRUE) {
brange2x.cxx:	membership = CAST(FeEdition,contents->fetch(Sequence::string("ClubDescription:Membership")));
brange2x.cxx:		BEGIN_CONSISTENT(5) {
brange2x.cxx:		} END_CONSISTENT;
brange2x.cxx:		BEGIN_CONSISTENT(2) {
brange2x.cxx:			{	FLUID_BIND(CurrentGrandMap,myGrandMap) {
brange2x.cxx:		} END_CONSISTENT;
brange2x.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
brange2x.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
brange2x.hxx:	/* This is the actual representation on disk; the Fe versions 
brange2x.hxx:	of these classes hide the actual representation. */
brange2x.hxx:class BeWork : public BeRangeElement {
brange2x.hxx:	SHEPHERD_PATRIARCH(BeWork,BeRangeElement)
brange2x.hxx:  public: /* contents */
brange2x.hxx:	/* The current Edition.
brange2x.hxx:	/* Change the current edition and notify anyone who cares 
brange2x.hxx:	/* Change the current edition and notify anyone who cares 
brange2x.hxx:	/* Adds to the endorsements on this Work. The set of 
brange2x.hxx:	endorsements must be a finite number of (club ID, token ID) 
brange2x.hxx:	virtual void endorse (APTR(CrossRegion) ARG(endorsements));
brange2x.hxx:	/* All endorsements which have been placed on this Work. The 
brange2x.hxx:	current Edition of this Work by filtering for these 
brange2x.hxx:	endorsements; they are also used to filter various other 
brange2x.hxx:	virtual RPTR(CrossRegion) endorsements ();
brange2x.hxx:	/* Removes endorsements from this Work. This requires the 
brange2x.hxx:	authority of all of the Clubs whose endorsements are in the 
brange2x.hxx:	list. Ignores all endorsements which you could have removed, 
brange2x.hxx:	virtual void retract (APTR(CrossRegion) ARG(endorsements));
brange2x.hxx:	virtual RPTR(FeRangeElement) makeFe (APTR(BeLabel) OR(NULL) ARG(label));
brange2x.hxx:	BeWork (APTR(FeEdition) ARG(contents), BooleanVar ARG(isClub));
brange2x.hxx:DESIGN_FLUID(BeClub,CurrentOwner);	/* in BeClub */
brange2x.hxx:	/* NO CLASS COMMENT */
brange2x.hxx:	static RPTR(BeClub) make (APTR(FeEdition) ARG(contents));
brange2x.hxx:  public: /* dependents */
brange2x.hxx:	/* Add a sponsored Work (sent from the Work) */
brange2x.hxx:	virtual RPTR(FeRangeElement) makeFe (APTR(BeLabel) OR(NULL) ARG(label));
brange2x.hxx:	/* Add a sponsored Work (sent from the Work) */
brange2x.hxx:  public: /* contents */
brange2x.hxx:	virtual void revise (APTR(FeEdition) ARG(contents));
brange2x.hxx:	virtual void addImmediateSuperClub (APTR(BeClub) ARG(parent));
brange2x.hxx:	virtual void removeImmediateSuperClub (APTR(BeClub) ARG(parent));
brange2x.hxx:	BeClub (APTR(FeEdition) ARG(contents), TCSJ);
brange2x.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
brange2x.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
brange2x.ixx:#include "entx.hxx"  // for various fluids.
brange2x.ixx:/* contents */
brange2x.ixx:/* dependents */
brange2x.ixx:/* contents */
brange2x.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
brange2x.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
brange2x.oxx:OPAQUE_TYPE_4(BeWork,BeRangeElement,Abraham,Heaper);
brange2x.oxx:OPAQUE_TYPE_5(BeClub,BeWork,BeRangeElement,Abraham,Heaper);
brange3p.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
brange3p.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
brange3p.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
brange3p.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
brange3p.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
brange3p.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
brange3x.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
brange3x.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
brange3x.cxx:#ifndef ENTX_HXX
brange3x.cxx:#include "entx.hxx"
brange3x.cxx:#endif /* ENTX_HXX */
brange3x.cxx:	BEGIN_CONSISTENT(5) {
brange3x.cxx:	} END_CONSISTENT;
brange3x.cxx:	/* An Edition with the contents of both Editions; where they 
brange3x.cxx:	share keys, they must have the same RangeElement. */
brange3x.cxx:	/* Eventually trace coordinates should be delayed. */
brange3x.cxx:	{	FLUID_BIND(CurrentTrace,this->hCrum()->hCut()->newSuccessorAfter(other->hCrum()->hCut())) {
brange3x.cxx:			{	FLUID_BIND(CurrentBertCrum,BertCrum::make ()) {
brange3x.cxx:	{	FLUID_BIND(CurrentTrace,this->hCrum()->hCut()->newSuccessor()) {
brange3x.cxx:			{	FLUID_BIND(CurrentBertCrum,BertCrum::make ()) {
brange3x.cxx:	/* An Edition with the contents of both Editions; where they 
brange3x.cxx:	share keys, use the contents of the other Edition. Equivalent to
brange3x.cxx:			this->copy (other->domain ()->complement ())->combine (other) */
brange3x.cxx:	/* This should be implemented directly. */
brange3x.cxx:	returnValue = this->copy(other->domain()->complement())->combine(other);
brange3x.cxx:	the same RangeElement at all the domain keys. */
brange3x.cxx:			if (dsp->isIdentity()) {
brange3x.cxx:			{	FLUID_BIND(CurrentTrace,this->hCrum()->hCut()->newSuccessor()) {
brange3x.cxx:					{	FLUID_BIND(CurrentBertCrum,BertCrum::make ()) {
brange3x.cxx:	{	FLUID_BIND(CurrentTrace,this->hCrum()->hCut()->newSuccessor()) {
brange3x.cxx:			{	FLUID_BIND(CurrentBertCrum,BertCrum::make ()) {
brange3x.cxx:								BLAST(NOT_YET_IMPLEMENTED);
brange3x.cxx:	/* A new Edition with a RangeElement at a specified key. The 
brange3x.cxx:	old value, if there is one, is superceded. Equivalent to
brange3x.cxx:	returnValue = this->replace(CurrentGrandMap.fluidGet()->newEditionWith(key, value));
brange3x.cxx:	/* A new Edition with a RangeElement at a specified set of 
brange3x.cxx:	keys. The old values, if there are any, are superceded. Equivalent to
brange3x.cxx:	returnValue = this->replace(CurrentGrandMap.fluidGet()->newEditionWithAll(keys, value));
brange3x.cxx:	/* A new Edition without any RangeElement at a specified key. 
brange3x.cxx:	The old value, if there is one, is removed. Equivalent to
brange3x.cxx:			this->copy (key->asRegion ()->complement ()) */
brange3x.cxx:	returnValue = this->copy(key->asRegion()->complement());
brange3x.cxx:	/* A new Edition without any RangeElements at the specified 
brange3x.cxx:	keys. The old values, if there are any, are removed. Equivalent to
brange3x.cxx:			this->copy (keys->complement ()) */
brange3x.cxx:	returnValue = this->copy(keys->complement());
brange3x.cxx:	Equivalent to
brange3x.cxx:	Equivalent to
brange3x.cxx:RPTR(FeRangeElement) OR(NULL) BeEdition::fetch (APTR(Position) key){
brange3x.cxx:	/* Create a front end representation for what is at the given key. */
brange3x.cxx:	WPTR(FeRangeElement) OR(NULL) 	returnValue;
brange3x.cxx:RPTR(FeRangeElement) BeEdition::get (APTR(Position) key){
brange3x.cxx:	SPTR(FeRangeElement) OR(NULL) result;
brange3x.cxx:	WPTR(FeRangeElement) 	returnValue;
brange3x.cxx:	/* Whether the given key is in the Edition. Equivalent to
brange3x.cxx:	/* Whether there are any keys in this Edition. Equivalent to
brange3x.cxx:	Equivalent to
brange3x.cxx:		/* this->BeRangeElement::isPurgeable() && myDetectors == NULL */
brange3x.cxx:		crutch_Flag = this->BeRangeElement::isPurgeable();
brange3x.cxx:RPTR(FeRangeElement) BeEdition::makeFe (APTR(BeLabel) OR(NULL) label){
brange3x.cxx:	WPTR(FeRangeElement) 	returnValue;
brange3x.cxx:	/* The owners of all the RangeElements in the given Region, 
brange3x.cxx:	or in the entire 
brange3x.cxx:	/* Essential.  This is the fundamental retrieval operation.  
brange3x.cxx:	between a region in the domain and the range elements 
brange3x.cxx:	the data elements.
brange3x.cxx:	/* The above comment is horribly insufficient. */
brange3x.cxx:		data structures changing as the client steps */
brange3x.cxx:RPTR(FeRangeElement) BeEdition::theOne (){
brange3x.cxx:	key; if not, blasts. Equivalent to
brange3x.cxx:	WPTR(FeRangeElement) 	returnValue;
brange3x.cxx:RPTR(CrossRegion) BeEdition::visibleEndorsements (){
brange3x.cxx:	/* All of the endorsements on this Edition and all Works 
brange3x.cxx:	which the CurrentKeyMaster can read. */
brange3x.cxx:	result = myOwnProp->endorsements();
brange3x.cxx:		if (work->canBeReadBy(CurrentKeyMaster.fluidGet())) {
brange3x.cxx:			result = result->unionWith(work->endorsements());
brange3x.cxx:void BeEdition::endorse (APTR(CrossRegion) endorsements){
brange3x.cxx:	/* Adds to the endorsements on this Edition. The set of 
brange3x.cxx:	endorsements must be a finite number of (club ID, token ID) pairs. */
brange3x.cxx:	if (endorsements->isEmpty()) {
brange3x.cxx:	BEGIN_CONSISTENT(8) {
brange3x.cxx:		this->propChange(PropChange::endorsementsChange(), BertProp::endorsementsProp(endorsements->unionWith(myProp->endorsements())));
brange3x.cxx:	} END_CONSISTENT;
brange3x.cxx:RPTR(CrossRegion) BeEdition::endorsements (){
brange3x.cxx:	/* All of the endorsements on this Edition. */
brange3x.cxx:	return CAST(CrossRegion,myOwnProp->endorsements());
brange3x.cxx:		BEGIN_CONSISTENT(6) {
brange3x.cxx:		} END_CONSISTENT;
brange3x.cxx:	/* Attempt to apply the change directly to the current set of 
brange3x.cxx:	else.  (BIG and not currently log.)
brange3x.cxx:		 If the new properties are different than the old ones we 
brange3x.cxx:		 		remember the current props
brange3x.cxx:		 		In a consistent block
brange3x.cxx:		BEGIN_CONSISTENT(9) {
brange3x.cxx:						SouthRecorderChecker::make (myOrglRoot, finder, CAST(SensorCrum,myOrglRoot->sensorCrum()->fetchParent()));
brange3x.cxx:		} END_CONSISTENT;
brange3x.cxx:void BeEdition::retract (APTR(CrossRegion) endorsements){
brange3x.cxx:	/* Removes endorsements from this Edition. Ignores all 
brange3x.cxx:	endorsements which you could have removed, but which don't 
brange3x.cxx:	if (endorsements->isEmpty()) {
brange3x.cxx:	BEGIN_CONSISTENT(4) {
brange3x.cxx:		this->propChange(PropChange::endorsementsChange(), BertProp::endorsementsProp(myOwnProp->endorsements()->minus(endorsements)));
brange3x.cxx:	} END_CONSISTENT;
brange3x.cxx:RPTR(CrossRegion) BeEdition::totalEndorsements (){
brange3x.cxx:	/* All of the endorsements on this Edition and all Works 
brange3x.cxx:	result = myOwnProp->endorsements();
brange3x.cxx:		result = result->unionWith(work->endorsements());
brange3x.cxx:void BeEdition::ringDetectors (APTR(FeEdition) newIdentities){
brange3x.cxx:	/* Ring all my detectors with the given Edition as an argument */
brange3x.cxx:			det->rangeFilled(newIdentities);
brange3x.cxx:	/* Changes the owner of all RangeElements; requires the 
brange3x.cxx:	authority of the current owner.
brange3x.cxx:	{	FLUID_BIND(CurrentTrace,this->hCrum()->hCut()->newSuccessor()) {
brange3x.cxx:			{	FLUID_BIND(CurrentBertCrum,BertCrum::make ()) {
brange3x.cxx:RPTR(Pair) OF1(BeEdition) BeEdition::tryAllBecome (APTR(BeEdition) newIdentities){
brange3x.cxx:	/* Change the identities of the RangeElements of this Edition 
brange3x.cxx:			- different contents
brange3x.cxx:			- no corresponding new identity
brange3x.cxx:	BLAST(NOT_YET_IMPLEMENTED);
brange3x.cxx:	the same. Equivalent to
brange3x.cxx:	BLAST(NOT_YET_IMPLEMENTED);
brange3x.cxx:void BeEdition::addOParent (APTR(Loaf) oparent){
brange3x.cxx:	/* add oparent to the set of upward pointers.  Editions may
brange3x.cxx:	this->BeRangeElement::addOParent(oparent);
brange3x.cxx:		/* next->isFull() || this->BeRangeElement::anyPasses(next) */
brange3x.cxx:			crutch_Flag = this->BeRangeElement::anyPasses(next);
brange3x.cxx:	/* replace endorsements with those in the prop */
brange3x.cxx:			as an argument */
brange3x.cxx:		/* using scrum's parent records things twice */
brange3x.cxx:		SouthRecorderChecker::make (myOrglRoot, newFinder, CAST(SensorCrum,scrum->fetchParent()))->schedule();
brange3x.cxx:RPTR(ImmuSet) OF1(BeWork) BeEdition::currentWorks (){
brange3x.cxx:	/* The Works currently on this Edition */
brange3x.cxx:RPTR(BeRangeElement) BeEdition::getOrMakeBe (APTR(Position) key){
brange3x.cxx:	/* An actual, non-virtual FE range element at that key. Used 
brange3x.cxx:	BeRangeElement::become () */
brange3x.cxx:	WPTR(BeRangeElement) 	returnValue;
brange3x.cxx:	BEGIN_CONSISTENT(-1) {
brange3x.cxx:	} END_CONSISTENT;
brange3x.cxx:			BEGIN_CONSISTENT(1) {
brange3x.cxx:			} END_CONSISTENT;
brange3x.cxx:	BEGIN_CONSISTENT(-1) {
brange3x.cxx:	} END_CONSISTENT;
brange3x.cxx:	if (this->BeRangeElement::updateBCrumTo(newBCrum)) {
brange3x.cxx:RPTR(XnRegion) BeEdition::keysOf (APTR(FeRangeElement) value){
brange3x.cxx:	RangeElement can be found. Equivalent to
brange3x.cxx:	returnValue = this->sharedRegion(CurrentGrandMap.fluidGet()->newEditionWith(IntegerPos::zero(), value->carrier()));
brange3x.cxx:	the keys in the other Edition which have the same RangeElement. */
brange3x.cxx:	/* The subset of this Edition whose RangeElements are not in 
brange3x.cxx:	the other Edition. Equivalent to
brange3x.cxx:			this->copy (this->sharedRegion (other, flags)->complement ()) */
brange3x.cxx:	returnValue = this->copy(this->sharedRegion(other, flags)->complement());
brange3x.cxx:	RangeElements that are in the other Edition. If both flags 
brange3x.cxx:	are false, then equivalent to
brange3x.cxx:		If nestThis, then returns not only keys of RangeElements 
brange3x.cxx:	to RangeElements which are in the other.
brange3x.cxx:		If nestOther, then looks not only for RangeElements which 
brange3x.cxx:		BLAST(NOT_YET_IMPLEMENTED);
brange3x.cxx:	/* The subset of this Edition whose RangeElements are in the 
brange3x.cxx:	other Edition. If the same RangeElement is in this Edition at 
brange3x.cxx:	several different keys, all keys will be in the result 
brange3x.cxx:	(provided the RangeElement is also in the other Edition). Equivalent to
brange3x.cxx:		APTR(Filter) endorsementsFilter, 
brange3x.cxx:	if (!(flags == (FeEdition::LOCAL_PRESENT_ONLY() | FeEdition::DIRECT_CONTAINERS_ONLY()))) {
brange3x.cxx:		returnValue = this->BeRangeElement::works(permissions, endorsementsFilter, flags);
brange3x.cxx:		if (endorsementsFilter->match(work->endorsements())) {
brange3x.cxx:	iDSpace = CurrentGrandMap.fluidGet()->newIDSpace();
brange3x.cxx:	returnValue = CurrentGrandMap.fluidGet()->newPlaceHolders(region->complement())->combine(
brange3x.cxx:			CurrentGrandMap.fluidGet()->newValueEdition(CAST(PtrArray,result->value()), region, iDSpace->ascending()));
brange3x.cxx:	: BeRangeElement(root->sensorCrum(), tcsj) {
brange3x.cxx:	BEGIN_CONSISTENT(5) {
brange3x.cxx:	} END_CONSISTENT;
brange3x.cxx:	BEGIN_CONSISTENT(-1) {
brange3x.cxx:		this->BeRangeElement::dismantle();
brange3x.cxx:	} END_CONSISTENT;
brange3x.cxx:				[DiskManager consistent: 2 with:
brange3x.cxx:	/* Reject all the unimplemented cases.
brange3x.cxx:			snapshotting the current login authority
brange3x.cxx:			filtered by the endorsementsFilter
brange3x.cxx:	if ((flags & ~(FeEdition::DIRECT_CONTAINERS_ONLY() | FeEdition::LOCAL_PRESENT_ONLY())) != Int32Zero) {
brange3x.cxx:		BLAST(NOT_YET_IMPLEMENTED);
brange3x.cxx:		result = CurrentGrandMap.fluidGet()->newPlaceHolders(CurrentGrandMap.fluidGet()->newIDSpace()->fullRegion());
brange3x.cxx:			RecorderFossil::transcluders((flags & FeEdition::DIRECT_CONTAINERS_ONLY()) != Int32Zero, CurrentKeyMaster.fluidFetch()->loginAuthority(), directFilter, indirectFilter, result->getOrMakeTrailBlazer());
brange3x.cxx:	if ((flags & FeEdition::LOCAL_PRESENT_ONLY()) != Int32Zero) {
brange3x.cxx:			BLAST(NOT_YET_IMPLEMENTED);
brange3x.cxx:	/* Reject all the unimplemented cases.
brange3x.cxx:			snapshotting the current login authority
brange3x.cxx:			filtered by the endorsementsFilter
brange3x.cxx:	if ((flags & ~(FeEdition::DIRECT_CONTAINERS_ONLY() | FeEdition::LOCAL_PRESENT_ONLY())) != Int32Zero) {
brange3x.cxx:		BLAST(NOT_YET_IMPLEMENTED);
brange3x.cxx:		result = CurrentGrandMap.fluidGet()->newPlaceHolders(CurrentGrandMap.fluidGet()->newIDSpace()->fullRegion());
brange3x.cxx:			RecorderFossil::works((flags & FeEdition::DIRECT_CONTAINERS_ONLY()) != Int32Zero, CurrentKeyMaster.fluidGet()->loginAuthority(), filter, result->getOrMakeTrailBlazer());
brange3x.cxx:	if ((flags & FeEdition::LOCAL_PRESENT_ONLY()) != Int32Zero) {
brange3x.cxx:			BLAST(NOT_YET_IMPLEMENTED);
brange3x.cxx:	/* Walk down orgl's O-tree (onto range elements of interest) 
brange3x.cxx:	endorsement and permission filtering info rootward in the 
brange3x.cxx:			- Second: Find and record any currently matching stamps.
brange3x.cxx:	of recorder information is completed before the present part 
brange3x.cxx:	SPTR(Agenda) rAgents;
brange3x.cxx:	rAgents = Agenda::make ();
brange3x.cxx:		{	FLUID_BIND(CurrentTrace,this->hCrum()->hCut()->newSuccessor()) {
brange3x.cxx:				{	FLUID_BIND(CurrentBertCrum,BertCrum::make ()) {
brange3x.cxx:	oroot->storeRecordingAgents(fossil, rAgents);
brange3x.cxx:	Sequencer::make (rAgents, matcher)->schedule();
brange3x.cxx:	/* Find and record any currently matching Editions. */
brange3x.cxx:		{	FLUID_BIND(CurrentTrace,this->hCrum()->hCut()->newSuccessor()) {
brange3x.cxx:				{	FLUID_BIND(CurrentBertCrum,BertCrum::make ()) {
brange3x.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
brange3x.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
brange3x.hxx:	/* NO CLASS COMMENT */
brange3x.hxx:class BeEdition : public BeRangeElement {
brange3x.hxx:	SHEPHERD_PATRIARCH(BeEdition,BeRangeElement)
brange3x.hxx:	/* An Edition with the contents of both Editions; where they 
brange3x.hxx:	share keys, they must have the same RangeElement. */
brange3x.hxx:	/* An Edition with the contents of both Editions; where they 
brange3x.hxx:	share keys, use the contents of the other Edition. Equivalent to
brange3x.hxx:			this->copy (other->domain ()->complement ())->combine (other) */
brange3x.hxx:	the same RangeElement at all the domain keys. */
brange3x.hxx:	/* A new Edition with a RangeElement at a specified key. The 
brange3x.hxx:	old value, if there is one, is superceded. Equivalent to
brange3x.hxx:	/* A new Edition with a RangeElement at a specified set of 
brange3x.hxx:	keys. The old values, if there are any, are superceded. Equivalent to
brange3x.hxx:	/* A new Edition without any RangeElement at a specified key. 
brange3x.hxx:	The old value, if there is one, is removed. Equivalent to
brange3x.hxx:			this->copy (key->asRegion ()->complement ()) */
brange3x.hxx:	/* A new Edition without any RangeElements at the specified 
brange3x.hxx:	keys. The old values, if there are any, are removed. Equivalent to
brange3x.hxx:			this->copy (keys->complement ()) */
brange3x.hxx:	Equivalent to
brange3x.hxx:	Equivalent to
brange3x.hxx:	/* Create a front end representation for what is at the given key. */
brange3x.hxx:	virtual RPTR(FeRangeElement) OR(NULL) fetch (APTR(Position) ARG(key));
brange3x.hxx:	virtual RPTR(FeRangeElement) get (APTR(Position) ARG(key));
brange3x.hxx:	/* Whether the given key is in the Edition. Equivalent to
brange3x.hxx:	/* Whether there are any keys in this Edition. Equivalent to
brange3x.hxx:	Equivalent to
brange3x.hxx:	virtual RPTR(FeRangeElement) makeFe (APTR(BeLabel) OR(NULL) ARG(label));
brange3x.hxx:	/* The owners of all the RangeElements in the given Region, 
brange3x.hxx:	or in the entire 
brange3x.hxx:	/* Essential.  This is the fundamental retrieval operation.  
brange3x.hxx:	between a region in the domain and the range elements 
brange3x.hxx:	the data elements.
brange3x.hxx:	virtual CLIENT RPTR(Stepper) OF1(Bundle) retrieve (
brange3x.hxx:	key; if not, blasts. Equivalent to
brange3x.hxx:	virtual RPTR(FeRangeElement) theOne ();
brange3x.hxx:	/* All of the endorsements on this Edition and all Works 
brange3x.hxx:	which the CurrentKeyMaster can read. */
brange3x.hxx:	virtual RPTR(CrossRegion) visibleEndorsements ();
brange3x.hxx:	/* Adds to the endorsements on this Edition. The set of 
brange3x.hxx:	endorsements must be a finite number of (club ID, token ID) pairs. */
brange3x.hxx:	virtual void endorse (APTR(CrossRegion) ARG(endorsements));
brange3x.hxx:	/* All of the endorsements on this Edition. */
brange3x.hxx:	virtual RPTR(CrossRegion) endorsements ();
brange3x.hxx:	/* Removes endorsements from this Edition. Ignores all 
brange3x.hxx:	endorsements which you could have removed, but which don't 
brange3x.hxx:	virtual void retract (APTR(CrossRegion) ARG(endorsements));
brange3x.hxx:	/* All of the endorsements on this Edition and all Works 
brange3x.hxx:	virtual RPTR(CrossRegion) totalEndorsements ();
brange3x.hxx:	/* Ring all my detectors with the given Edition as an argument */
brange3x.hxx:	virtual void ringDetectors (APTR(FeEdition) ARG(newIdentities));
brange3x.hxx:	/* Changes the owner of all RangeElements; requires the 
brange3x.hxx:	authority of the current owner.
brange3x.hxx:	/* Change the identities of the RangeElements of this Edition 
brange3x.hxx:			- different contents
brange3x.hxx:			- no corresponding new identity
brange3x.hxx:	virtual RPTR(Pair) OF1(BeEdition) tryAllBecome (APTR(BeEdition) ARG(newIdentities));
brange3x.hxx:	the same. Equivalent to
brange3x.hxx:	/* add oparent to the set of upward pointers.  Editions may
brange3x.hxx:	virtual void addOParent (APTR(Loaf) ARG(oparent));
brange3x.hxx:	/* The Works currently on this Edition */
brange3x.hxx:	virtual RPTR(ImmuSet) OF1(BeWork) currentWorks ();
brange3x.hxx:	/* An actual, non-virtual FE range element at that key. Used 
brange3x.hxx:	BeRangeElement::become () */
brange3x.hxx:	virtual RPTR(BeRangeElement) getOrMakeBe (APTR(Position) ARG(key));
brange3x.hxx:	RangeElement can be found. Equivalent to
brange3x.hxx:	virtual RPTR(XnRegion) keysOf (APTR(FeRangeElement) ARG(value));
brange3x.hxx:	the keys in the other Edition which have the same RangeElement. */
brange3x.hxx:	/* The subset of this Edition whose RangeElements are not in 
brange3x.hxx:	the other Edition. Equivalent to
brange3x.hxx:			this->copy (this->sharedRegion (other, flags)->complement ()) */
brange3x.hxx:	RangeElements that are in the other Edition. If both flags 
brange3x.hxx:	are false, then equivalent to
brange3x.hxx:		If nestThis, then returns not only keys of RangeElements 
brange3x.hxx:	to RangeElements which are in the other.
brange3x.hxx:		If nestOther, then looks not only for RangeElements which 
brange3x.hxx:	/* The subset of this Edition whose RangeElements are in the 
brange3x.hxx:	other Edition. If the same RangeElement is in this Edition at 
brange3x.hxx:	several different keys, all keys will be in the result 
brange3x.hxx:	(provided the RangeElement is also in the other Edition). Equivalent to
brange3x.hxx:			APTR(Filter) ARG(endorsementsFilter), 
brange3x.hxx:	/* Walk down orgl's O-tree (onto range elements of interest) 
brange3x.hxx:	endorsement and permission filtering info rootward in the 
brange3x.hxx:			- Second: Find and record any currently matching stamps.
brange3x.hxx:	of recorder information is completed before the present part 
brange3x.hxx:	/* Find and record any currently matching Editions. */
brange3x.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
brange3x.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
brange3x.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
brange3x.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
brange3x.oxx:OPAQUE_TYPE_4(BeEdition,BeRangeElement,Abraham,Heaper);
canopyp.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
canopyp.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
canopyp.hxx:	/* NO CLASS COMMENT */
canopyp.hxx:		to contain childCrum's new parent: parentCrum. 
canopyp.hxx:	virtual void updateCacheForParent (APTR(CanopyCrum) ARG(childCrum), APTR(CanopyCrum) ARG(parentCrum));
canopyp.hxx:		because canopyCrum has new parents. For now, just 
canopyp.hxx:	canopy.  Each step propagates it one step parentwards, until 
canopyp.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
canopyp.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
canopyp.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
canopyp.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
canopyr.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
canopyr.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
canopyr.hxx:	canopy.  Each step propagates it one step parentwards, until 
canopyr.hxx:	/* propagate some prop(erty) change one step parentwards, 
canopyr.hxx:	canopy.  Each step propagates it one step parentwards, until 
canopyr.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
canopyr.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
canopyr.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
canopyr.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
canopyx.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
canopyx.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
canopyx.cxx:GPTR(PtrArray) OF1(Position OR(XnRegion)) CanopyCrum::FlagEndorsements = NULL;
canopyx.cxx:GPTR(CrossRegion) CanopyCrum::OtherEndorsements = NULL;
canopyx.cxx:UInt32 CanopyCrum::endorsementsFlags (APTR(CrossRegion) endorsements){
canopyx.cxx:	/* Flag bits corresponding to endorsements */
canopyx.cxx:	result = CanopyCrum::TheEFlagsCache->fetch(endorsements);
canopyx.cxx:		/* result != UInt32Zero || endorsements->isEmpty() */
canopyx.cxx:			crutch_Flag = endorsements->isEmpty();
canopyx.cxx:	f = CanopyCrum::firstEndorsementsFlag();
canopyx.cxx:	if ( ! (CanopyCrum::FlagEndorsements != NULL) ) {
canopyx.cxx:		UInt32 LoopFinal = CanopyCrum::FlagEndorsements->count();
canopyx.cxx:				BEGIN_CHOOSE(CanopyCrum::FlagEndorsements->get(i)) {
canopyx.cxx:						if (endorsements->hasMember(p)) {
canopyx.cxx:						if (endorsements->intersects(r)) {
canopyx.cxx:	if (endorsements->intersects(CanopyCrum::OtherEndorsements)) {
canopyx.cxx:		result |= CanopyCrum::otherEndorsementsFlag();
canopyx.cxx:	CanopyCrum::TheEFlagsCache->cache(endorsements, result);
canopyx.cxx:	if (permissions->hasMember(CurrentGrandMap.fluidGet()->publicClubID())) {
canopyx.cxx:		CanopyCrum::OtherClubs = CAST(IDRegion,CurrentGrandMap.fluidGet()->publicClubID()->asRegion()->complement());
canopyx.cxx:Int32 CanopyCrum::endorsementFlagLimit (){
canopyx.cxx:	/* Max number of special endorsement flags */
canopyx.cxx:	/* 28 bits - 2 for permissions - 1 for all other endorsements 
canopyx.cxx:UInt32 CanopyCrum::firstEndorsementsFlag (){
canopyx.cxx:	/* Rightmost flag for interesting endorsements */
canopyx.cxx:UInt32 CanopyCrum::otherEndorsementsFlag (){
canopyx.cxx:	/* Flag for all uninteresting endorsements */
canopyx.cxx:void CanopyCrum::useEndorsementFlags (APTR(PtrArray) OF1(Position OR(XnRegion)) endorsements){
canopyx.cxx:	/* Use a special flag to look for any of the these endorsements */
canopyx.cxx:		/* CanopyCrum::FlagEndorsements == NULL || CanopyCrum::FlagEndorsements->contentsEqual(endorsements) */
canopyx.cxx:		crutch_Flag = CanopyCrum::FlagEndorsements == NULL;
canopyx.cxx:			crutch_Flag = CanopyCrum::FlagEndorsements->contentsEqual(endorsements);
canopyx.cxx:	if (endorsements->count() > CanopyCrum::endorsementFlagLimit()) {
canopyx.cxx:	CanopyCrum::FlagEndorsements = CAST(PtrArray,endorsements->copy());
canopyx.cxx:	CanopyCrum::OtherEndorsements = CAST(CrossRegion,CurrentGrandMap.fluidGet()->endorsementSpace()->fullRegion());
canopyx.cxx:		Int32 LoopFinal = CanopyCrum::FlagEndorsements->count();
canopyx.cxx:				BEGIN_CHOOSE(CanopyCrum::FlagEndorsements->get(i)) {
canopyx.cxx:						CanopyCrum::OtherEndorsements = CAST(CrossRegion,CanopyCrum::OtherEndorsements->without(p));
canopyx.cxx:						CanopyCrum::OtherEndorsements = CAST(CrossRegion,CanopyCrum::OtherEndorsements->minus(r));
canopyx.cxx:Essentially, when the join of two trees is asked for, if the two 
canopyx.cxx:by flag words in the CanopyCrum. Any interesting Club or endorsement 
canopyx.cxx:endorsement". Any criteria not given a bit of their own require an 
canopyx.cxx:		 in object-oriented systems. */
canopyx.cxx:	BEGIN_CONSISTENT(3) {
canopyx.cxx:		(child1 = this->makeNew())->setParent(this);
canopyx.cxx:		(child2 = this->makeNew())->setParent(this);
canopyx.cxx:		this->canopyCache()->updateCacheForParent(child1, this);
canopyx.cxx:		this->canopyCache()->updateCacheForParent(child2, this);
canopyx.cxx:	} END_CONSISTENT;
canopyx.cxx:	/* Propagate the children's props into their new parent */
canopyx.cxx:		height is currently handle by changeCanopy and will 
canopyx.cxx:		be moved out to HeightChanger momentarily. */
canopyx.cxx:			BEGIN_CONSISTENT(-1) {
canopyx.cxx:					(child2 = this->makeNewParent(child2, otherCanopy))->setParent(this);
canopyx.cxx:					(child1 = this->makeNewParent(child1, otherCanopy))->setParent(this);
canopyx.cxx:			} END_CONSISTENT;
canopyx.cxx:		 or an anscestor (through the parent links). 
canopyx.cxx:	space management.  (Maybe backpointers later.) */
canopyx.cxx:RPTR(CanopyCrum) CanopyCrum::fetchParent (){
canopyx.cxx:	return (CanopyCrum*) parent;
canopyx.cxx:	space management.  (Maybe backpointers later.)
canopyx.cxx:		/* (myRefCount == IntegerVar0 and: [parent == NULL])
canopyx.cxx:void CanopyCrum::setParent (APTR(CanopyCrum) OR(NULL) p){
canopyx.cxx:		/* parent == NULL && p != NULL */
canopyx.cxx:		crutch_Flag = parent == NULL;
canopyx.cxx:	parent = p;
canopyx.cxx:		/* myRefCount == IntegerVar0 && parent == NULL */
canopyx.cxx:			crutch_Flag = parent == NULL;
canopyx.cxx:	if ( ! (parent == NULL) ) {
canopyx.cxx:	BEGIN_CONSISTENT(3) {
canopyx.cxx:			child1->setParent(NULL);
canopyx.cxx:			child2->setParent(NULL);
canopyx.cxx:	} END_CONSISTENT;
canopyx.cxx:	child1 = child2 = parent = NULL;
canopyx.cxx:	child1->setParent(this);
canopyx.cxx:	child2->setParent(this);
canopyx.cxx:	parent = NULL;
canopyx.cxx:	myPropJoint and move to parent. */
canopyx.cxx:	BEGIN_INSISTENT(3) {
canopyx.cxx:	} END_INSISTENT;
canopyx.cxx:UInt32 CanopyCrum::contentsHash (){
canopyx.cxx:	persistent state whether or not
canopyx.cxx:	return this->Abraham::contentsHash() ^ child1->hashForEqual() ^ child2->hashForEqual() ^ parent->hashForEqual() ^ IntegerPos::integerHash(minH) ^ IntegerPos::integerHash(maxH) ^ myFlags ^ myOwnFlags ^ IntegerPos::integerHash(myRefCount);
canopyx.cxx:			save current flags
canopyx.cxx:	/* Propagate the children's props into their new parent */
canopyx.cxx:		height is currently handle by changeCanopy and will 
canopyx.cxx:		be moved out to HeightChanger momentarily. */
canopyx.cxx:		cur = cur->fetchParent();
canopyx.cxx:		cur = this->makeNewParent(prev, otherCanopy);
canopyx.cxx:		this->canopyCache()->updateCacheForParent(prev, cur);
canopyx.cxx:		this->canopyCache()->updateCacheForParent(otherCanopy, cur);
canopyx.cxx:	/* Cur now contains the closest parent shared between self 
canopyx.cxx:BUILD_FLUID(CanopyCache,CurrentBertCanopyCache, CanopyCache::make (), DiskManager::emulsion());	/* in BertCrum */
canopyx.cxx:	BEGIN_CONSISTENT(1) {
canopyx.cxx:	} END_CONSISTENT;
canopyx.cxx:		APTR(CrossRegion) OR(NULL) endorsements, 
canopyx.cxx:	if (endorsements != NULL) {
canopyx.cxx:		result |= CanopyCrum::endorsementsFlags(endorsements);
canopyx.cxx:/* This implementation tracks the endorsement information with 
canopyx.cxx:upon insertion of new elements in such a way that the ocrums 
canopyx.cxx:doing so currently in case we change algorithms.
canopyx.cxx:	/* should have one per Ent */
canopyx.cxx:	returnValue = CurrentBertCanopyCache.fluidGet();
canopyx.cxx:RPTR(CanopyCrum) BertCrum::makeNewParent (APTR(CanopyCrum) first, APTR(CanopyCrum) second){
canopyx.cxx:	BEGIN_CONSISTENT(3) {
canopyx.cxx:	} END_CONSISTENT;
canopyx.cxx:	/* Create a new parent for two BertCrums.
canopyx.cxx:		My client must bring my properties up to date.  This 
canopyx.cxx:	constructor just makes a new parent whose properties are empty */
canopyx.cxx:	this->canopyCache()->updateCacheForParent(this->fetchChild1(), this);
canopyx.cxx:	this->canopyCache()->updateCacheForParent(this->fetchChild2(), this);
canopyx.cxx:BUILD_FLUID(CanopyCache,CurrentSensorCanopyCache, CanopyCache::make (), DiskManager::emulsion());	/* in SensorCrum */
canopyx.cxx:	BEGIN_CONSISTENT(2) {
canopyx.cxx:	} END_CONSISTENT;
canopyx.cxx:	BEGIN_CONSISTENT(1) {
canopyx.cxx:	} END_CONSISTENT;
canopyx.cxx:		APTR(CrossRegion) OR(NULL) endorsements, 
canopyx.cxx:	if (endorsements != NULL) {
canopyx.cxx:		result |= CanopyCrum::endorsementsFlags(endorsements);
canopyx.cxx:/* This implementation is the same as BertCrums.  This will require 
canopyx.cxx:pointers into the ent to implement delete (for archiving).  Canopy 
canopyx.cxx:	/* should have one per Ent */
canopyx.cxx:	returnValue = CurrentSensorCanopyCache.fluidGet();
canopyx.cxx:		If sCrum is null or not me, return my parent so caller can 
canopyx.cxx:		Return a pointer to our parent (so caller can iterate this 
canopyx.cxx:	return CAST(SensorCrum,this->fetchParent());
canopyx.cxx:RPTR(AgendaItem) SensorCrum::recordingAgent (APTR(RecorderFossil) recorder){
canopyx.cxx:	/* If the recorder we're adding isn't already present here
canopyx.cxx:			pack up the fossil for shipment to the hoister
canopyx.cxx:		BEGIN_CONSISTENT(2) {
canopyx.cxx:		} END_CONSISTENT;
canopyx.cxx:RPTR(CanopyCrum) SensorCrum::makeNewParent (APTR(CanopyCrum) first, APTR(CanopyCrum) second){
canopyx.cxx:	BEGIN_CONSISTENT(3) {
canopyx.cxx:	} END_CONSISTENT;
canopyx.cxx:	/* Create a new parent for two SensorCrums.
canopyx.cxx:		This constructor just makes a new parent whose properties 
canopyx.cxx:	are empty. My client must bring my properties up to date. */
canopyx.cxx:	this->canopyCache()->updateCacheForParent(this->fetchChild1(), this);
canopyx.cxx:	this->canopyCache()->updateCacheForParent(this->fetchChild2(), this);
canopyx.cxx:	BEGIN_CONSISTENT(3) {
canopyx.cxx:	} END_CONSISTENT;
canopyx.cxx:	BEGIN_CONSISTENT(2) {
canopyx.cxx:	} END_CONSISTENT;
canopyx.cxx: Each step propagates it one step parentwards, until it gets to a 
canopyx.cxx:	BEGIN_CONSISTENT(3) {
canopyx.cxx:	} END_CONSISTENT;
canopyx.cxx:	BEGIN_CONSISTENT(2) {
canopyx.cxx:	} END_CONSISTENT;
canopyx.cxx: Each step propagates it one step parentwards, until it gets to a 
canopyx.cxx:	BEGIN_CONSISTENT(3) {
canopyx.cxx:			this->setCrum(this->fetchCrum()->fetchParent());
canopyx.cxx:	} END_CONSISTENT;
canopyx.cxx:			cur = cur->fetchParent();
canopyx.cxx:void CanopyCache::updateCacheForParent (APTR(CanopyCrum) childCrum, APTR(CanopyCrum) parentCrum){
canopyx.cxx:		to contain childCrum's new parent: parentCrum. 
canopyx.cxx:		myCachedPath->store(parentCrum);
canopyx.cxx:			myCachedRoot = parentCrum;
canopyx.cxx:		because canopyCrum has new parents. For now, just 
canopyx.cxx:	BEGIN_CONSISTENT(3) {
canopyx.cxx:	} END_CONSISTENT;
canopyx.cxx: Each step propagates it one step parentwards, until it gets to a 
canopyx.cxx:	BEGIN_CONSISTENT(3) {
canopyx.cxx:			this->setCrum(this->fetchCrum()->fetchParent());
canopyx.cxx:	} END_CONSISTENT;
canopyx.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
canopyx.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
canopyx.hxx:	Essentially, when the join of two trees is asked for, if the 
canopyx.hxx:	Club or endorsement gets a bit, and there is a bit for "any 
canopyx.hxx:	other Club" and "any other endorsement". Any criteria not 
canopyx.hxx:	/* Flag bits corresponding to endorsements */
canopyx.hxx:	static UInt32 endorsementsFlags (APTR(CrossRegion) ARG(endorsements));
canopyx.hxx:	/* Max number of special endorsement flags */
canopyx.hxx:	static Int32 endorsementFlagLimit ();
canopyx.hxx:	/* Rightmost flag for interesting endorsements */
canopyx.hxx:	static UInt32 firstEndorsementsFlag ();
canopyx.hxx:	/* Flag for all uninteresting endorsements */
canopyx.hxx:	static UInt32 otherEndorsementsFlag ();
canopyx.hxx:	/* Use a special flag to look for any of the these endorsements */
canopyx.hxx:	static void useEndorsementFlags (APTR(PtrArray) OF1(Position OR(XnRegion)) ARG(endorsements));
canopyx.hxx:		 in object-oriented systems. */
canopyx.hxx:		 or an anscestor (through the parent links). 
canopyx.hxx:	space management.  (Maybe backpointers later.) */
canopyx.hxx:	virtual NOLOCK RPTR(CanopyCrum) fetchParent ();
canopyx.hxx:	space management.  (Maybe backpointers later.)
canopyx.hxx:	virtual void setParent (APTR(CanopyCrum) OR(NULL) ARG(p));
canopyx.hxx:	persistent state whether or not
canopyx.hxx:	virtual UInt32 contentsHash ();
canopyx.hxx:		This method just makes a new parent whose properties are 
canopyx.hxx:	empty. My client must bring my properties up to date */
canopyx.hxx:	virtual RPTR(CanopyCrum) makeNewParent (APTR(CanopyCrum) ARG(first), APTR(CanopyCrum) ARG(second)) DEFERRED_FUNC;
canopyx.hxx:	CHKPTR(CanopyCrum) OR(NULL) parent;
canopyx.hxx:	static GPTR(PtrArray) OF1(Position OR(XnRegion)) FlagEndorsements;
canopyx.hxx:	static GPTR(CrossRegion) OtherEndorsements;
canopyx.hxx:DESIGN_FLUID(CanopyCache,CurrentBertCanopyCache);	/* in BertCrum */
canopyx.hxx:	/* This implementation tracks the endorsement information with 
canopyx.hxx:	upon insertion of new elements in such a way that the ocrums 
canopyx.hxx:	doing so currently in case we change algorithms.
canopyx.hxx:			APTR(CrossRegion) OR(NULL) ARG(endorsements), 
canopyx.hxx:	/* should have one per Ent */
canopyx.hxx:	virtual RPTR(CanopyCrum) makeNewParent (APTR(CanopyCrum) ARG(first), APTR(CanopyCrum) ARG(second));
canopyx.hxx:	/* Create a new parent for two BertCrums.
canopyx.hxx:		My client must bring my properties up to date.  This 
canopyx.hxx:	constructor just makes a new parent whose properties are empty */
canopyx.hxx:DESIGN_FLUID(CanopyCache,CurrentSensorCanopyCache);	/* in SensorCrum */
canopyx.hxx:	/* This implementation is the same as BertCrums.  This will require 
canopyx.hxx:	pointers into the ent to implement delete (for archiving).  Canopy 
canopyx.hxx:			APTR(CrossRegion) OR(NULL) ARG(endorsements), 
canopyx.hxx:	/* should have one per Ent */
canopyx.hxx:		If sCrum is null or not me, return my parent so caller can 
canopyx.hxx:	virtual RPTR(AgendaItem) recordingAgent (APTR(RecorderFossil) ARG(recorder));
canopyx.hxx:	virtual RPTR(CanopyCrum) makeNewParent (APTR(CanopyCrum) ARG(first), APTR(CanopyCrum) ARG(second));
canopyx.hxx:	/* Create a new parent for two SensorCrums.
canopyx.hxx:		This constructor just makes a new parent whose properties 
canopyx.hxx:	are empty. My client must bring my properties up to date. */
canopyx.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
canopyx.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
canopyx.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
canopyx.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
counterp.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
counterp.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
counterp.hxx:	preallocations to disk.  It then increments purely in memory 
counterp.hxx:	virtual IntegerVar decrement ();
counterp.hxx:	virtual IntegerVar decrementBy (IntegerVar ARG(count));
counterp.hxx:	virtual IntegerVar increment ();
counterp.hxx:	virtual IntegerVar incrementBy (IntegerVar ARG(count));
counterp.hxx:	/* re-initialize the non-persistent part */
counterp.hxx:	virtual UInt32 contentsHash ();
counterp.hxx:	IntegerVar myPersistentCount;
counterp.hxx:	GrandHashTables don't ned to flush their entirety to disk.  
counterp.hxx:	virtual IntegerVar decrement ();
counterp.hxx:	virtual IntegerVar decrementBy (IntegerVar ARG(count));
counterp.hxx:	virtual IntegerVar increment ();
counterp.hxx:	virtual IntegerVar incrementBy (IntegerVar ARG(count));
counterp.hxx:	/* re-initialize the non-persistent part */
counterp.hxx:	virtual UInt32 contentsHash ();
counterp.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
counterp.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
counterp.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
counterp.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
counterx.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
counterx.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
counterx.cxx:preallocations to disk.  It then increments purely in memory until 
counterx.cxx:IntegerVar BatchCounter::decrement (){
counterx.cxx:		BEGIN_CONSISTENT(1) {
counterx.cxx:		} END_CONSISTENT;
counterx.cxx:IntegerVar BatchCounter::decrementBy (IntegerVar count){
counterx.cxx:		BEGIN_CONSISTENT(1) {
counterx.cxx:		} END_CONSISTENT;
counterx.cxx:IntegerVar BatchCounter::increment (){
counterx.cxx:		if (myCount > myPersistentCount) {
counterx.cxx:			BEGIN_CONSISTENT(1) {
counterx.cxx:				myPersistentCount = myCount + myBatchCount;
counterx.cxx:			} END_CONSISTENT;
counterx.cxx:IntegerVar BatchCounter::incrementBy (IntegerVar count){
counterx.cxx:		if (myCount > myPersistentCount) {
counterx.cxx:			BEGIN_CONSISTENT(1) {
counterx.cxx:				myPersistentCount = myCount + myBatchCount;
counterx.cxx:			} END_CONSISTENT;
counterx.cxx:		BEGIN_CONSISTENT(1) {
counterx.cxx:		} END_CONSISTENT;
counterx.cxx:	/* re-initialize the non-persistent part */
counterx.cxx:	myCount = myPersistentCount;
counterx.cxx:	BEGIN_CONSISTENT(1) {
counterx.cxx:		myPersistentCount = myCount = count;
counterx.cxx:	} END_CONSISTENT;
counterx.cxx:	myPersistentCount = myCount = count;
counterx.cxx:UInt32 BatchCounter::contentsHash (){
counterx.cxx:	return this->Counter::contentsHash() ^ IntegerPos::integerHash(myPersistentCount);
counterx.cxx:ned to flush their entirety to disk.  It localizes the state change 
counterx.cxx:IntegerVar SingleCounter::decrement (){
counterx.cxx:		BEGIN_CONSISTENT(1) {
counterx.cxx:		} END_CONSISTENT;
counterx.cxx:IntegerVar SingleCounter::decrementBy (IntegerVar count){
counterx.cxx:		BEGIN_CONSISTENT(1) {
counterx.cxx:		} END_CONSISTENT;
counterx.cxx:IntegerVar SingleCounter::increment (){
counterx.cxx:		BEGIN_CONSISTENT(1) {
counterx.cxx:		} END_CONSISTENT;
counterx.cxx:IntegerVar SingleCounter::incrementBy (IntegerVar count){
counterx.cxx:		BEGIN_CONSISTENT(1) {
counterx.cxx:		} END_CONSISTENT;
counterx.cxx:		BEGIN_CONSISTENT(1) {
counterx.cxx:		} END_CONSISTENT;
counterx.cxx:	/* re-initialize the non-persistent part */
counterx.cxx:UInt32 SingleCounter::contentsHash (){
counterx.cxx:	return this->Counter::contentsHash() ^ IntegerPos::integerHash(myCount);
counterx.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
counterx.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
counterx.hxx:	/* NO CLASS COMMENT */
counterx.hxx:	virtual IntegerVar decrement () DEFERRED_FUNC;
counterx.hxx:	virtual IntegerVar decrementBy (IntegerVar ARG(count)) DEFERRED_FUNC;
counterx.hxx:	virtual IntegerVar increment () DEFERRED_FUNC;
counterx.hxx:	virtual IntegerVar incrementBy (IntegerVar ARG(count)) DEFERRED_FUNC;
counterx.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
counterx.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
counterx.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
counterx.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
cryptop.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
cryptop.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
cryptop.hxx:	/* automatic 0-argument constructor */
cryptop.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
cryptop.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
cryptop.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
cryptop.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
cryptox.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
cryptox.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
cryptox.cxx:		APTR(Sequence) identifier, 
cryptox.cxx:		returnValue = CAST(EncrypterMaker,Encrypter::AllEncrypterMakers->get(identifier))->makeEncrypter(publicKey, privateKey);
cryptox.cxx:void Encrypter::remember (APTR(Sequence) identifier, EncrypterConstructor constructor){
cryptox.cxx:	Encrypter::AllEncrypterMakers->introduce(identifier, maker);
cryptox.cxx:implements a particular algorithm, such as Rivest-Shamir-Adelman, in 
cryptox.cxx:** obsolete documentation **
cryptox.cxx:The algorithm is identified by a Sequence naming it. Each concrete 
cryptox.cxx:create an instance. DEFINE_ENCRYPTER("identifier",AClassName) creates 
cryptox.cxx:identifying the algorithm, and looks for a corresponding 
cryptox.cxx:void Scrambler::remember (APTR(Sequence) identifier, APTR(Scrambler) scrambler){
cryptox.cxx:	The identifier must be unique. */
cryptox.cxx:	Scrambler::AllScramblers->introduce(identifier, scrambler);
cryptox.cxx:RPTR(Scrambler) Scrambler::make (APTR(UInt8Array) identifier){
cryptox.cxx:		return CAST(Scrambler,Scrambler::AllScramblers->get(Sequence::numbers(identifier)));
cryptox.cxx:/* A Scrambler implements a one-way hash function. It should be 
cryptox.cxx:be a hash, in that two similar inputs should produce very different 
cryptox.cxx:outputs. It is furthermore desirable but not essential that the 
cryptox.cxx:one-to-one (two different inputs never produce the same output). Each 
cryptox.cxx:subclass implements some particular algorithm such as Snefru, in 
cryptox.cxx:should use the DEFINE_SCRAMBLER("identifier",(scramblerExpression)) 
cryptox.cxx:identifier. DEFINE_SCRAMBLER must be invoked inside an Initializer 
cryptox.cxx:	/* automatic 0-argument constructor */
cryptox.cxx:	/* automatic 0-argument constructor */
cryptox.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
cryptox.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
cryptox.hxx:#define DEFINE_ENCRYPTER(identifier,encryptorClass) {		\
cryptox.hxx:	Encrypter::remember(Sequence::string(identifier), encryptorClass::make);			\
cryptox.hxx:#define DEFINE_SCRAMBLER(identifier,scrambler) {	\
cryptox.hxx:	Scrambler::remember(Sequence::string(identifier), scrambler);				\
cryptox.hxx:	keys. Each subclass implements a particular algorithm, such 
cryptox.hxx:	** obsolete documentation **
cryptox.hxx:	The algorithm is identified by a Sequence naming it. Each 
cryptox.hxx:	DEFINE_ENCRYPTER("identifier",AClassName) creates an 
cryptox.hxx:	PackOBits identifying the algorithm, and looks for a 
cryptox.hxx:			APTR(Sequence) ARG(identifier), 
cryptox.hxx:	static void remember (APTR(Sequence) ARG(identifier), EncrypterConstructor ARG(constructor));
cryptox.hxx:	/* Decrypt data with the current private key. */
cryptox.hxx:	/* Encrypt the given data with the current public key. */
cryptox.hxx:	/* A Scrambler implements a one-way hash function. It should 
cryptox.hxx:	produce very different outputs. It is furthermore desirable 
cryptox.hxx:	but not essential that the algorithm be cryptographically 
cryptox.hxx:	different inputs never produce the same output). Each 
cryptox.hxx:	subclass implements some particular algorithm such as Snefru, 
cryptox.hxx:	concrete subclass should use the DEFINE_SCRAMBLER("identifier"
cryptox.hxx:	table at some appropriate identifier. DEFINE_SCRAMBLER must 
cryptox.hxx:	The identifier must be unique. */
cryptox.hxx:	static void remember (APTR(Sequence) ARG(identifier), APTR(Scrambler) ARG(scrambler));
cryptox.hxx:	static RPTR(Scrambler) make (APTR(UInt8Array) ARG(identifier));
cryptox.hxx:	/* automatic 0-argument constructor */
cryptox.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
cryptox.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
cryptox.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
cryptox.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
dagwoodx.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
dagwoodx.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
dagwoodx.cxx:Several implementation variables use longs because they represent the 
dagwoodx.cxx:'myRoot' is just for debugging for the moment. */
dagwoodx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
dagwoodx.cxx:	/* Ensure that no elements get allocated on the root branch. */
dagwoodx.cxx:	/* re-initialize the non-persistent part */
dagwoodx.cxx:UInt32 DagWood::contentsHash (){
dagwoodx.cxx:	return this->Abraham::contentsHash() ^ myRoot->hashForEqual();
dagwoodx.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
dagwoodx.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
dagwoodx.hxx:	 Several implementation variables use longs because they 
dagwoodx.hxx:	represent the size of an in-core array (which can't get that 
dagwoodx.hxx:	large).  The variable 'myRoot' is just for debugging for the moment. */
dagwoodx.hxx:	/* re-initialize the non-persistent part */
dagwoodx.hxx:	virtual UInt32 contentsHash ();
dagwoodx.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
dagwoodx.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
dagwoodx.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
dagwoodx.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
detectx.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
detectx.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
detectx.cxx:	/* automatic 0-argument constructor */
detectx.cxx:/* Client defines subclasses and passes in an instance in order to be 
detectx.cxx:RangeElement::transcluders (). If passed to Edition::addFillRangeDetec
detectx.cxx:	/* automatic 0-argument constructor */
detectx.cxx:/* Client defines a subclass and passes it in to Edition::addFillRange
detectx.cxx:of RangeElement. */
detectx.cxx:	/* automatic 0-argument constructor */
detectx.cxx:/* Client defines subclasses and passes in an instance in order to be 
detectx.cxx:	/* automatic 0-argument constructor */
detectx.cxx:	/* automatic 0-argument constructor */
detectx.cxx:/* Will get sent a single message, once, with no parameters, when 
detectx.cxx:	/* automatic 0-argument constructor */
detectx.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
detectx.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
detectx.hxx:	/* automatic 0-argument constructor */
detectx.hxx:	/* Client defines subclasses and passes in an instance in 
detectx.hxx:	uders () or RangeElement::transcluders (). If passed to 
detectx.hxx:	ON_CLIENT(FeFillDetector)
detectx.hxx:	kind of RangeElement */
detectx.hxx:	virtual CLIENT void filled (APTR(FeRangeElement) ARG(newIdentity)) DEFERRED_SUBR;
detectx.hxx:	/* automatic 0-argument constructor */
detectx.hxx:	/* Client defines a subclass and passes it in to 
detectx.hxx:	PlaceHolders become any other kind of RangeElement. */
detectx.hxx:	ON_CLIENT(FeFillRangeDetector)
detectx.hxx:	/* Essential.  Some of the PlaceHolders in the Edition on 
detectx.hxx:	has their new identies as its RangeElements, though the keys 
detectx.hxx:	virtual CLIENT void rangeFilled (APTR(FeEdition) ARG(newIdentities)) DEFERRED_SUBR;
detectx.hxx:	/* automatic 0-argument constructor */
detectx.hxx:	/* Client defines subclasses and passes in an instance in 
detectx.hxx:	ON_CLIENT(FeRevisionDetector)
detectx.hxx:	/* Essential. The Work has been revised. Gives the Work, the 
detectx.hxx:	current Edition, the author ID who had it grabbed, the 
detectx.hxx:	virtual CLIENT void revised (
detectx.hxx:			APTR(FeEdition) ARG(contents), 
detectx.hxx:	/* automatic 0-argument constructor */
detectx.hxx:	ON_CLIENT(FeStatusDetector)
detectx.hxx:	static INLINE CLIENT Int32 EDIT_PERMISSION_CHANGED ();
detectx.hxx:	static INLINE CLIENT Int32 KEYMASTER_CHANGED ();
detectx.hxx:	authority of the CurrentAuthor */
detectx.hxx:	static INLINE CLIENT Int32 SIGNATURE_AUTHORITY ();
detectx.hxx:	/* Essential. The Work has been grabbed, or regrabbed. */
detectx.hxx:	virtual CLIENT void grabbed (
detectx.hxx:	/* Essential. The revise capability of the Work has been lost. */
detectx.hxx:	virtual CLIENT void released (APTR(FeWork) ARG(work), IntegerVar ARG(reason)) DEFERRED_SUBR;
detectx.hxx:	/* automatic 0-argument constructor */
detectx.hxx:	/* Will get sent a single message, once, with no parameters, 
detectx.hxx:	ON_CLIENT(FeWaitDetector)
detectx.hxx:	/* Essential.  Whatever I was waiting for has happened */
detectx.hxx:	virtual CLIENT void done () DEFERRED_SUBR;
detectx.hxx:	/* automatic 0-argument constructor */
detectx.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
detectx.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
detectx.ixx:	authority of the CurrentAuthor */
detectx.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
detectx.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
entx.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
entx.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
entx.cxx:#ifndef ENTX_CXX
entx.cxx:#define ENTX_CXX
entx.cxx:#ifndef ENTX_HXX
entx.cxx:#include "entx.hxx"
entx.cxx:#endif /* ENTX_HXX */
entx.cxx:#ifndef ENTX_IXX
entx.cxx:#include "entx.ixx"
entx.cxx:#endif /* ENTX_IXX */
entx.cxx: *                    Class Ent 
entx.cxx:/* Initializers for Ent */
entx.cxx:BUILD_FLUID(TracePosition,CurrentTrace, NULL, DiskManager::emulsion());	/* in Ent */
entx.cxx:BUILD_FLUID(BertCrum,CurrentBertCrum, NULL, DiskManager::emulsion());	/* in Ent */
entx.cxx:/* Initializers for Ent */
entx.cxx:RPTR(Ent) Ent::make (){
entx.cxx:	RETURN_CONSTRUCT(Ent,());
entx.cxx:RPTR(TracePosition) Ent::newTrace (){
entx.cxx:Ent::Ent () {
entx.cxx:UInt32 Ent::contentsHash (){
entx.cxx:	return this->Abraham::contentsHash() ^ fulltrace->hashForEqual();
entx.cxx:#ifndef ENTX_SXX
entx.cxx:#include "entx.sxx"
entx.cxx:#endif /* ENTX_SXX */
entx.cxx:#endif /* ENTX_CXX */
entx.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
entx.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
entx.hxx:#ifndef ENTX_HXX
entx.hxx:#define ENTX_HXX
entx.hxx:#ifndef ENTX_OXX
entx.hxx:#include "entx.oxx"
entx.hxx:#endif /* ENTX_OXX */
entx.hxx: *                    Class Ent 
entx.hxx:/* Initializers for Ent */
entx.hxx:DESIGN_FLUID(TracePosition,CurrentTrace);	/* in Ent */
entx.hxx:DESIGN_FLUID(BertCrum,CurrentBertCrum);	/* in Ent */
entx.hxx:	/* NO CLASS COMMENT */
entx.hxx:class Ent : public Abraham {
entx.hxx:/* Attributes for class Ent */
entx.hxx:	CONCRETE(Ent)
entx.hxx:	SHEPHERD_PATRIARCH(Ent,Abraham)
entx.hxx:	LOCKED(Ent)
entx.hxx:	COPY(Ent,DiskCuisine)
entx.hxx:	AUTO_GC(Ent)
entx.hxx:/* Initializers for Ent */
entx.hxx:	static RPTR(Ent) make ();
entx.hxx:	static INLINE IntegerVar tableSegmentMaxSize ();
entx.hxx:	Ent ();
entx.hxx:	virtual UInt32 contentsHash ();
entx.hxx:};  /* end class Ent */
entx.hxx:#ifndef ENTX_IXX
entx.hxx:#include "entx.ixx"
entx.hxx:#endif /* ENTX_IXX */
entx.hxx:#endif /* ENTX_HXX */
entx.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
entx.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
entx.ixx:#ifndef ENTX_IXX
entx.ixx:#define ENTX_IXX
entx.ixx: *                    Class Ent 
entx.ixx:INLINE IntegerVar Ent::tableSegmentMaxSize (){
entx.ixx:#endif /* ENTX_IXX */
entx.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
entx.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
entx.oxx:#ifndef ENTX_OXX
entx.oxx:#define ENTX_OXX
entx.oxx:OPAQUE_TYPE_3(Ent,Abraham,Heaper);
entx.oxx:#endif /* ENTX_OXX */
granmapp.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
granmapp.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
granmapp.hxx:	/* NO CLASS COMMENT */
granmapp.hxx:	/* automatic 0-argument constructor */
granmapp.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
granmapp.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
granmapp.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
granmapp.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
granmapx.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
granmapx.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
granmapx.cxx:BUILD_FLUID(BeGrandMap,CurrentGrandMap, NULL, DiskManager::emulsion());	/* in BeGrandMap */
granmapx.cxx:- we had decided to have myRangeElementIDs be a GrandSetTable, but 
granmapx.cxx:implemented right now */
granmapx.cxx:	SPTR(MuTable) OF2(Sequence,CrossRegion) endorsements;
granmapx.cxx:	/* figure out the IDs of the Wrapper endorsement Works */
granmapx.cxx:	endorsements = MuTable::make (SequenceSpace::make ());
granmapx.cxx:		endorsements->introduce(name, myEndorsementSpace->crossOfRegions(CAST(PtrArray,PrimSpec::pointer()->arrayWithTwo(myArchiveClubID->asRegion(), iD->asRegion()))));
granmapx.cxx:	myWrapperEndorsements = endorsements->asImmuTable();
granmapx.cxx:	myEndorsementFlags = PtrArray::nulls(5 + 10);
granmapx.cxx:	myEndorsementFlags->store(UInt32Zero, CAST(XnRegion,endorsements->get(Sequence::string("Text")))->theOne());
granmapx.cxx:	myEndorsementFlags->store(1, CAST(XnRegion,endorsements->get(Sequence::string("HyperLink")))->theOne());
granmapx.cxx:	myEndorsementFlags->store(2, CAST(XnRegion,endorsements->get(Sequence::string("HyperRef")))->theOne());
granmapx.cxx:	myEndorsementFlags->store(3, CAST(XnRegion,endorsements->get(Sequence::string("SingleRef")))->theOne());
granmapx.cxx:	myEndorsementFlags->store(4, CAST(XnRegion,endorsements->get(Sequence::string("MultiRef")))->theOne());
granmapx.cxx:	/* generate some IDs to use as endorsement tokens */
granmapx.cxx:		Int32 LoopFinal = myEndorsementFlags->count();
granmapx.cxx:				myEndorsementFlags->store(i, myEndorsementSpace->crossOfRegions(CAST(PtrArray,PrimSpec::pointer()->arrayWithTwo(myGlobalIDSpace->fullRegion(), myGlobalIDSpace->newID()->asRegion()))));
granmapx.cxx:	CanopyCrum::useEndorsementFlags(myEndorsementFlags);
granmapx.cxx:	CurrentAuthor.fluidSet(myEmptyClubID);
granmapx.cxx:	CurrentKeyMaster.fluidSet(FeKeyMaster::make (this->publicClubID()));
granmapx.cxx:	BEGIN_FOR_POSITIONS(Sequence,name,CrossRegion,end,(endorsements->stepper())) {
granmapx.cxx:	/* actually create the endorsement token Works */
granmapx.cxx:		Int32 LoopFinal = myEndorsementFlags->count();
granmapx.cxx:				/* contents don't matter */
granmapx.cxx:				this->tryIntroduce(CAST(ID,CAST(IDRegion,CAST(CrossRegion,myEndorsementFlags->get(i))->projection(1))->theOne()), work);
granmapx.cxx:					edition->endorse(myEndorsementSpace->crossOfRegions(CAST(PtrArray,PrimSpec::pointer()->arrayWithTwo(myEmptyClubID->asRegion(), myEmptyClubID->asRegion()))));
granmapx.cxx:	CurrentAuthor.fluidSet((ID * ) NULL);
granmapx.cxx:	CurrentKeyMaster.fluidSet((FeKeyMaster * ) NULL);
granmapx.cxx:BeGrandMap::BeGrandMap (APTR(Sequence) identifier, TCSJ) {
granmapx.cxx:	BEGIN_CONSISTENT(-1) {
granmapx.cxx:		myEnt = Ent::make ();
granmapx.cxx:		myIdentifier = identifier;
granmapx.cxx:		myEndorsementSpace = CrossSpace::make (CAST(PtrArray,PrimSpec::pointer()->arrayWithTwo(myGlobalIDSpace, myGlobalIDSpace)));
granmapx.cxx:		myEndorsementFilterSpace = FilterSpace::make (CAST(CoordinateSpace,myEndorsementSpace));
granmapx.cxx:		myRangeElements = GrandHashTable::make (myGlobalIDSpace);
granmapx.cxx:		myRangeElementIDs = GrandHashTable::make (HeaperSpace::make ());
granmapx.cxx:		{	FLUID_BIND(CurrentGrandMap,this) {
granmapx.cxx:	} END_CONSISTENT;
granmapx.cxx:	{	FLUID_BIND(CurrentGrandMap,this) {
granmapx.cxx:	CanopyCrum::useEndorsementFlags(myEndorsementFlags);
granmapx.cxx:UInt32 BeGrandMap::contentsHash (){
granmapx.cxx:	return this->Abraham::contentsHash() ^ myIdentifier->hashForEqual() ^ myLocalIDSpaceCounter->hashForEqual() ^ myEnt->hashForEqual() ^ myEmptyClubID->hashForEqual() ^ myPublicClubID->hashForEqual() ^ myAdminClubID->hashForEqual();
granmapx.cxx:RPTR(ID) BeGrandMap::assignID (APTR(BeRangeElement) value){
granmapx.cxx:BooleanVar BeGrandMap::tryIntroduce (APTR(ID) iD, APTR(BeRangeElement) value){
granmapx.cxx:	if (myRangeElements->includesKey(iD)) {
granmapx.cxx:	BEGIN_CONSISTENT(6) {
granmapx.cxx:		already = CAST(IDRegion,myRangeElementIDs->fetch(hap));
granmapx.cxx:			myRangeElementIDs->introduce(hap, iD->asRegion());
granmapx.cxx:			myRangeElementIDs->replace(hap, already->with(iD));
granmapx.cxx:		myRangeElements->introduce(iD, value);
granmapx.cxx:	} END_CONSISTENT;
granmapx.cxx:RPTR(FilterSpace) BeGrandMap::endorsementFilterSpace (){
granmapx.cxx:	return (FilterSpace*) myEndorsementFilterSpace;
granmapx.cxx:RPTR(CrossSpace) BeGrandMap::endorsementSpace (){
granmapx.cxx:	return (CrossSpace*) myEndorsementSpace;
granmapx.cxx:RPTR(BeRangeElement) OR(NULL) BeGrandMap::fetch (APTR(ID) iD){
granmapx.cxx:	/* The actual BeRangeElement at that ID, or NULL if there is none */
granmapx.cxx:	return CAST(BeRangeElement,myRangeElements->fetch(iD));
granmapx.cxx:RPTR(BeRangeElement) BeGrandMap::get (APTR(ID) iD){
granmapx.cxx:	/* The actual BeRangeElement at that ID, or blast if there is none */
granmapx.cxx:	return CAST(BeRangeElement,myRangeElements->get(iD));
granmapx.cxx:RPTR(FeRangeElement) BeGrandMap::getFe (APTR(ID) iD){
granmapx.cxx:	WPTR(FeRangeElement) 	returnValue;
granmapx.cxx:			theBackend = this->identifier();
granmapx.cxx:		BEGIN_CONSISTENT(666) {
granmapx.cxx:		} END_CONSISTENT;
granmapx.cxx:	BEGIN_CONSISTENT(1) {
granmapx.cxx:	} END_CONSISTENT;
granmapx.cxx:RPTR(Sequence) BeGrandMap::identifier (){
granmapx.cxx:	return (Sequence*) myIdentifier;
granmapx.cxx:RPTR(ID) BeGrandMap::iDOf (APTR(BeRangeElement) value){
granmapx.cxx:	/* Find the ID of a BeRangeElement. Blast if there is no ID 
granmapx.cxx:	result = CAST(IDRegion,myRangeElementIDs->fetch(HeaperAsPosition::make (value)));
granmapx.cxx:RPTR(IDRegion) BeGrandMap::iDsOf (APTR(BeRangeElement) value){
granmapx.cxx:	/* Find the IDs of a BeRangeElement, whether there are none, 
granmapx.cxx:	result = CAST(IDRegion,myRangeElementIDs->fetch(HeaperAsPosition::make (value)));
granmapx.cxx:	returnValue = IDSpace::make (this->identifier(), myLocalIDSpaceCounter->increment());
granmapx.cxx:	SPTR(BeRangeElement) value;
granmapx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
granmapx.cxx:RPTR(ScruTable) OF2(Sequence,CrossRegion) BeGrandMap::wrapperEndorsements (){
granmapx.cxx:	/* A mapping from wrapper names to endorsements */
granmapx.cxx:	return (ImmuTable*) myWrapperEndorsements;
granmapx.cxx:	{	FLUID_BIND(CurrentTrace,myEnt->newTrace()) {
granmapx.cxx:			{	FLUID_BIND(CurrentBertCrum,BertCrum::make ()) {
granmapx.cxx:					if (values->count() <= Ent::tableSegmentMaxSize().asLong()) {
granmapx.cxx:						count = min(Ent::tableSegmentMaxSize().asLong(), values->count() - offset.asLong());
granmapx.cxx:	{	FLUID_BIND(CurrentTrace,value->rangeElement()->hCrum()->hCut()->newSuccessor()) {
granmapx.cxx:			{	FLUID_BIND(CurrentBertCrum,value->rangeElement()->bertCrum()) {
granmapx.cxx:	{	FLUID_BIND(CurrentTrace,value->rangeElement()->hCrum()->hCut()->newSuccessor()) {
granmapx.cxx:			{	FLUID_BIND(CurrentBertCrum,value->rangeElement()->bertCrum()) {
granmapx.cxx:	{	FLUID_BIND(CurrentTrace,myEnt->newTrace()) {
granmapx.cxx:			{	FLUID_BIND(CurrentBertCrum,BertCrum::make ()) {
granmapx.cxx:					BEGIN_CONSISTENT(4) {
granmapx.cxx:					} END_CONSISTENT;
granmapx.cxx:	{	FLUID_BIND(CurrentTrace,myEnt->newTrace()) {
granmapx.cxx:			{	FLUID_BIND(CurrentBertCrum,BertCrum::make ()) {
granmapx.cxx:		APTR(PtrArray) OF1(FeRangeElement) values, 
granmapx.cxx:	SPTR(BeRangeElement) rangeElement;
granmapx.cxx:		BEGIN_KIND(FeRangeElement,fe){
granmapx.cxx:			rangeElement = fe->getOrMakeBe();
granmapx.cxx:				BLAST(MustNotHaveNullElements);
granmapx.cxx:	trace = rangeElement->hCrum()->hCut();
granmapx.cxx:	crum = rangeElement->bertCrum();
granmapx.cxx:					BEGIN_KIND(FeRangeElement,fe){
granmapx.cxx:						rangeElement = fe->getOrMakeBe();
granmapx.cxx:							BLAST(MustNotHaveNullElements);
granmapx.cxx:					consistent block. */
granmapx.cxx:				trace = trace->newSuccessorAfter(rangeElement->hCrum()->hCut());
granmapx.cxx:				crum = crum->computeJoin(rangeElement->bertCrum());
granmapx.cxx:	{	FLUID_BIND(CurrentTrace,trace) {
granmapx.cxx:			{	FLUID_BIND(CurrentBertCrum,CAST(BertCrum,crum)) {
granmapx.cxx:RPTR(BeCarrier) BeGrandMap::carrier (APTR(BeRangeElement) element){
granmapx.cxx:	/* Return a carrier that has the rangeElement with a new 
granmapx.cxx:	if (element->isKindOf(cat_BeEdition)) {
granmapx.cxx:		returnValue = BeCarrier::make (this->newLabel(), element);
granmapx.cxx:		returnValue = BeCarrier::make (element);
granmapx.cxx:	{	FLUID_BIND(CurrentTrace,myEnt->newTrace()) {
granmapx.cxx:			{	FLUID_BIND(CurrentBertCrum,BertCrum::make ()) {
granmapx.cxx:	BEGIN_CONSISTENT(-1) {
granmapx.cxx:	} END_CONSISTENT;
granmapx.cxx:	/* Make a new DataHolder with the given contents. */
granmapx.cxx:	{	FLUID_BIND(CurrentTrace,myEnt->newTrace()) {
granmapx.cxx:			{	FLUID_BIND(CurrentBertCrum,BertCrum::make ()) {
granmapx.cxx:					BEGIN_CONSISTENT(1) {
granmapx.cxx:					} END_CONSISTENT;
granmapx.cxx:		BEGIN_CONSISTENT(-1) {
granmapx.cxx:			{	FLUID_BIND(CurrentTrace,myEnt->newTrace()) {
granmapx.cxx:					{	FLUID_BIND(CurrentBertCrum,BertCrum::make ()) {
granmapx.cxx:		} END_CONSISTENT;
granmapx.cxx:	{	FLUID_BIND(CurrentTrace,myEnt->newTrace()) {
granmapx.cxx:			{	FLUID_BIND(CurrentBertCrum,BertCrum::make ()) {
granmapx.cxx:					BEGIN_CONSISTENT(1) {
granmapx.cxx:					} END_CONSISTENT;
granmapx.cxx:	{	FLUID_BIND(CurrentTrace,myEnt->newTrace()) {
granmapx.cxx:			{	FLUID_BIND(CurrentBertCrum,BertCrum::make ()) {
granmapx.cxx:					BEGIN_CONSISTENT(3) {
granmapx.cxx:					} END_CONSISTENT;
granmapx.cxx:RPTR(BeWork) BeGrandMap::newWork (APTR(FeEdition) contents){
granmapx.cxx:	/* Make a new Work (without an ID) with the given contents.  
granmapx.cxx:		 else comes from the fluid environment. */
granmapx.cxx:	{	FLUID_BIND(CurrentTrace,myEnt->newTrace()) {
granmapx.cxx:			{	FLUID_BIND(CurrentBertCrum,BertCrum::make ()) {
granmapx.cxx:					returnValue = BeWork::make (contents);
granmapx.cxx:	/* automatic 0-argument constructor */
granmapx.cxx:	/* in future implementations this might also get back an ArrayBundle */
granmapx.cxx:	returnValue = CurrentGrandMap.fluidGet()->iDOf(CAST(FeElementBundle,myBundles->get())->element()->getOrMakeBe());
granmapx.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
granmapx.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
granmapx.hxx:#ifndef ENTX_OXX
granmapx.hxx:#include "entx.oxx"
granmapx.hxx:#endif /* ENTX_OXX */
granmapx.hxx:DESIGN_FLUID(BeGrandMap,CurrentGrandMap);	/* in BeGrandMap */
granmapx.hxx:	- we had decided to have myRangeElementIDs be a 
granmapx.hxx:	since that is what we have implemented right now */
granmapx.hxx:	BeGrandMap (APTR(Sequence) ARG(identifier), TCSJ);
granmapx.hxx:	virtual UInt32 contentsHash ();
granmapx.hxx:	virtual RPTR(ID) assignID (APTR(BeRangeElement) ARG(value));
granmapx.hxx:	virtual BooleanVar tryIntroduce (APTR(ID) ARG(iD), APTR(BeRangeElement) ARG(value));
granmapx.hxx:	virtual NOLOCK RPTR(FilterSpace) endorsementFilterSpace ();
granmapx.hxx:	virtual NOLOCK RPTR(CrossSpace) endorsementSpace ();
granmapx.hxx:	/* The actual BeRangeElement at that ID, or NULL if there is none */
granmapx.hxx:	virtual RPTR(BeRangeElement) OR(NULL) fetch (APTR(ID) ARG(iD));
granmapx.hxx:	/* The actual BeRangeElement at that ID, or blast if there is none */
granmapx.hxx:	virtual RPTR(BeRangeElement) get (APTR(ID) ARG(iD));
granmapx.hxx:	virtual RPTR(FeRangeElement) getFe (APTR(ID) ARG(iD));
granmapx.hxx:	virtual NOLOCK RPTR(Sequence) identifier ();
granmapx.hxx:	/* Find the ID of a BeRangeElement. Blast if there is no ID 
granmapx.hxx:	virtual RPTR(ID) iDOf (APTR(BeRangeElement) ARG(value));
granmapx.hxx:	/* Find the IDs of a BeRangeElement, whether there are none, 
granmapx.hxx:	virtual RPTR(IDRegion) iDsOf (APTR(BeRangeElement) ARG(value));
granmapx.hxx:	/* A mapping from wrapper names to endorsements */
granmapx.hxx:	virtual RPTR(ScruTable) OF2(Sequence,CrossRegion) wrapperEndorsements ();
granmapx.hxx:			APTR(PtrArray) OF1(FeRangeElement) ARG(values), 
granmapx.hxx:	/* Return a carrier that has the rangeElement with a new 
granmapx.hxx:	virtual RPTR(BeCarrier) carrier (APTR(BeRangeElement) ARG(element));
granmapx.hxx:	/* Make a new DataHolder with the given contents. */
granmapx.hxx:	/* Make a new Work (without an ID) with the given contents.  
granmapx.hxx:		 else comes from the fluid environment. */
granmapx.hxx:	virtual RPTR(BeWork) newWork (APTR(FeEdition) ARG(contents));
granmapx.hxx:	CHKPTR(Sequence) myIdentifier;
granmapx.hxx:	CHKPTR(CrossSpace) myEndorsementSpace;
granmapx.hxx:	CHKPTR(FilterSpace) OF1(CrossSpace) myEndorsementFilterSpace;
granmapx.hxx:	CHKPTR(MuTable) OF2(ID,BeRangeElement) myRangeElements;
granmapx.hxx:	CHKPTR(MuTable) OF2(HeaperAsPosition OF1(BeRangeElement),IDRegion OR(ID)) myRangeElementIDs;
granmapx.hxx:	CHKPTR(Ent) myEnt;
granmapx.hxx:	CHKPTR(ImmuTable) OF2(Sequence,CrossRegion) myWrapperEndorsements;
granmapx.hxx:	CHKPTR(PtrArray) OF1(Tuple OR(CrossRegion)) myEndorsementFlags;
granmapx.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
granmapx.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
granmapx.ixx:#ifndef ENTX_HXX
granmapx.ixx:#include "entx.hxx"
granmapx.ixx:#endif /* ENTX_HXX */
granmapx.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
granmapx.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
grantabp.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
grantabp.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
grantabp.hxx:/* Presently the values called 'shift' in this module are used with
grantabp.hxx: *                    Class ExponentialHashMap 
grantabp.hxx:/* Initializers for ExponentialHashMap */
grantabp.hxx:	/* NO CLASS COMMENT */
grantabp.hxx:class ExponentialHashMap : public Heaper {
grantabp.hxx:/* Attributes for class ExponentialHashMap */
grantabp.hxx:	CONCRETE(ExponentialHashMap)
grantabp.hxx:	AUTO_GC(ExponentialHashMap)
grantabp.hxx:/* Initializers for ExponentialHashMap */
grantabp.hxx:friend class INIT_TIME_NAME(ExponentialHashMap,initTimeNonInherited);
grantabp.hxx:	static INLINE UInt32 exponentialMap (UInt32 ARG(aHash));
grantabp.hxx:	ExponentialHashMap (Int32 ARG(numPieces), UInt32 ARG(range));
grantabp.hxx:	static GPTR(ExponentialHashMap) TheExponentialMap;
grantabp.hxx:};  /* end class ExponentialHashMap */
grantabp.hxx:	The shift argument to the various methods is the number of pages in the
grantabp.hxx:	parent node to indicate how many low bits of the hash are ignored. */
grantabp.hxx:			Int32 ARG(nEntries), 
grantabp.hxx:	virtual void store (APTR(GrandEntry) ARG(newEntry), Int32 ARG(shift));
grantabp.hxx:			Int32 ARG(nEntries), 
grantabp.hxx:	/* This repacks the entry table after a wipe to keep the 
grantabp.hxx:	table consistent with */
grantabp.hxx:	/* Create a new page with all entries of current page that have a */
grantabp.hxx:	/* Retain all '0' entries in this page. */
grantabp.hxx:	virtual UInt32 contentsHash ();
grantabp.hxx:	virtual RPTR(GrandEntry) entryAt (IntegerVar ARG(idx));
grantabp.hxx:	virtual NOLOCK IntegerVar entryCount ();
grantabp.hxx:	Int32 numEntries;
grantabp.hxx:	CHKPTR(PtrArray) OF1(GrandEntry) entries;
grantabp.hxx:	/* NO CLASS COMMENT */
grantabp.hxx:	virtual RPTR(GrandEntry) entry ();
grantabp.hxx:	virtual void verifyEntry ();
grantabp.hxx:	IntegerVar entryIndex;
grantabp.hxx: *                    Class GrandEntry 
grantabp.hxx:	/* GrandEntries probably want to not be remembered right when 
grantabp.hxx:class GrandEntry : public Abraham {
grantabp.hxx:/* Attributes for class GrandEntry */
grantabp.hxx:	DEFERRED(GrandEntry)
grantabp.hxx:	SHEPHERD_PATRIARCH(GrandEntry,Abraham)
grantabp.hxx:	COPY(GrandEntry,DiskCuisine)
grantabp.hxx:	DEFERRED_LOCKED(GrandEntry)
grantabp.hxx:	AUTO_GC(GrandEntry)
grantabp.hxx:	GrandEntry (APTR(Heaper) ARG(value), UInt32 ARG(hash));
grantabp.hxx:	virtual BooleanVar matches (APTR(GrandEntry) ARG(anEntry)) DEFERRED_FUNC;
grantabp.hxx:	virtual UInt32 contentsHash ();
grantabp.hxx:};  /* end class GrandEntry */
grantabp.hxx: *                    Class   GrandSetEntry 
grantabp.hxx:	/* NO CLASS COMMENT */
grantabp.hxx:class GrandSetEntry : public GrandEntry {
grantabp.hxx:/* Attributes for class GrandSetEntry */
grantabp.hxx:	CONCRETE(GrandSetEntry)
grantabp.hxx:	SHEPHERD_ANCESTOR(GrandSetEntry,GrandEntry)
grantabp.hxx:	COPY(GrandSetEntry,DiskCuisine)
grantabp.hxx:	LOCKED(GrandSetEntry)
grantabp.hxx:	NOT_A_TYPE(GrandSetEntry)
grantabp.hxx:	NO_GC(GrandSetEntry)
grantabp.hxx:	static RPTR(GrandEntry) make (APTR(Heaper) ARG(value), UInt32 ARG(hash));
grantabp.hxx:	virtual BooleanVar matches (APTR(GrandEntry) ARG(anEntry));
grantabp.hxx:	GrandSetEntry (APTR(Heaper) ARG(value), UInt32 ARG(hash));
grantabp.hxx:};  /* end class GrandSetEntry */
grantabp.hxx: *                    Class   GrandTableEntry 
grantabp.hxx:	/* NO CLASS COMMENT */
grantabp.hxx:class GrandTableEntry : public GrandEntry {
grantabp.hxx:/* Attributes for class GrandTableEntry */
grantabp.hxx:	CONCRETE(GrandTableEntry)
grantabp.hxx:	SHEPHERD_ANCESTOR(GrandTableEntry,GrandEntry)
grantabp.hxx:	COPY(GrandTableEntry,DiskCuisine)
grantabp.hxx:	LOCKED(GrandTableEntry)
grantabp.hxx:	NOT_A_TYPE(GrandTableEntry)
grantabp.hxx:	AUTO_GC(GrandTableEntry)
grantabp.hxx:	static RPTR(GrandEntry) make (
grantabp.hxx:	virtual UInt32 contentsHash ();
grantabp.hxx:	virtual BooleanVar matches (APTR(GrandEntry) ARG(anEntry));
grantabp.hxx:	GrandTableEntry (
grantabp.hxx:};  /* end class GrandTableEntry */
grantabp.hxx:	/* NO CLASS COMMENT */
grantabp.hxx:	virtual void verifyEntry ();
grantabp.hxx:	/* NO CLASS COMMENT */
grantabp.hxx:	virtual void verifyEntry ();
grantabp.hxx:	virtual void store (APTR(GrandEntry) ARG(newEntry));
grantabp.hxx:	virtual UInt32 contentsHash ();
grantabp.hxx:	/* GrandNodeReinserter moves the contents of the 
grantabp.hxx:	/* NO CLASS COMMENT */
grantabp.hxx:	virtual void verifyEntry ();
grantabp.hxx:	virtual RPTR(GrandEntry) entry ();
grantabp.hxx:	/* This class has a comment
grantabp.hxx:	virtual RPTR(GrandOverflow) store (APTR(GrandEntry) ARG(newEntry));
grantabp.hxx:	GrandOverflow (Int32 ARG(maxEntries), UInt32 ARG(someDepth));
grantabp.hxx:	/* This repacks the entry table after a wipe to keep the 
grantabp.hxx:	table consistent with */
grantabp.hxx:	/* Recursively insert all overflowed entries into a newly 
grantabp.hxx:	virtual void reinsertEntries (APTR(GrandNode) ARG(node));
grantabp.hxx:	virtual IntegerVar reinsertEntriesConsistency ();
grantabp.hxx:	virtual RPTR(GrandEntry) entryAt (IntegerVar ARG(idx));
grantabp.hxx:	virtual NOLOCK IntegerVar entryCount ();
grantabp.hxx:	virtual UInt32 contentsHash ();
grantabp.hxx:	Int32 numEntries;
grantabp.hxx:	CHKPTR(PtrArray) OF1(GrandEntry) entries;
grantabp.hxx:	/* NO CLASS COMMENT */
grantabp.hxx:	virtual void verifyEntry ();
grantabp.hxx:	virtual RPTR(GrandEntry) entry ();
grantabp.hxx:			IntegerVar ARG(entryIdx), 
grantabp.hxx:	IntegerVar entryIndex;
grantabp.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
grantabp.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
grantabp.ixx: *                    Class ExponentialHashMap 
grantabp.ixx:INLINE UInt32 ExponentialHashMap::exponentialMap (UInt32 aHash){
grantabp.ixx:	return ExponentialHashMap::TheExponentialMap->of(::fastHash(aHash) & ExponentialHashMap::HashBits) & ExponentialHashMap::HashBits;
grantabp.ixx:INLINE UInt32 ExponentialHashMap::hashBits (){
grantabp.ixx:	return ExponentialHashMap::HashBits;
grantabp.ixx: *                    Class GrandEntry 
grantabp.ixx: *                    Class   GrandSetEntry 
grantabp.ixx: *                    Class   GrandTableEntry 
grantabp.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
grantabp.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
grantabp.oxx:OPAQUE_TYPE_2(ExponentialHashMap,Heaper);
grantabp.oxx:OPAQUE_TYPE_3(GrandEntry,Abraham,Heaper);
grantabp.oxx:class GrandSetEntry;
grantabp.oxx:extern Category * cat_GrandSetEntry;
grantabp.oxx:class GrandTableEntry;
grantabp.oxx:extern Category * cat_GrandTableEntry;
grantabt.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
grantabt.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
grantabt.cxx:	/* automatic 0-argument constructor */
grantabt.cxx:	/* Not currently appropriate to GrandHashTable */
grantabt.cxx:	/* automatic 0-argument constructor */
grantabt.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
grantabt.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
grantabt.hxx:/* Presently the values called 'shift' in this module are used with
grantabt.hxx:	/* NO CLASS COMMENT */
grantabt.hxx:	/* automatic 0-argument constructor */
grantabt.hxx:	/* NO CLASS COMMENT */
grantabt.hxx:	/* Not currently appropriate to GrandHashTable */
grantabt.hxx:	/* automatic 0-argument constructor */
grantabt.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
grantabt.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
grantabt.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
grantabt.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
grantabx.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
grantabx.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
grantabx.cxx:	REQUIRES (ExponentialHashMap);
grantabx.cxx:	hash = ExponentialHashMap::exponentialMap(aHeaper->hashForEqual());
grantabx.cxx:		SPTR(GrandEntry) newEntry;
grantabx.cxx:		BEGIN_CONSISTENT(6) {
grantabx.cxx:			newEntry = GrandSetEntry::make (aHeaper, hash);
grantabx.cxx:			node->store(newEntry);
grantabx.cxx:		} END_CONSISTENT;
grantabx.cxx:	myTally->increment();
grantabx.cxx:	SPTR(GrandEntry) newEntry;
grantabx.cxx:	hash = ExponentialHashMap::exponentialMap(aHeaper->hashForEqual());
grantabx.cxx:	BEGIN_CONSISTENT(6) {
grantabx.cxx:		newEntry = GrandSetEntry::make (aHeaper, hash);
grantabx.cxx:		node->store(newEntry);
grantabx.cxx:	} END_CONSISTENT;
grantabx.cxx:		myTally->increment();
grantabx.cxx:	hash = ExponentialHashMap::exponentialMap(aHeaper->hashForEqual());
grantabx.cxx:		myTally->decrement();
grantabx.cxx:	hash = ExponentialHashMap::exponentialMap(aHeaper->hashForEqual());
grantabx.cxx:	BLAST(WILL_NOT_IMPLEMENT);
grantabx.cxx:	BLAST(WILL_NOT_IMPLEMENT);
grantabx.cxx:	aStream << "GrandHashSet(" << this->count() << " entries over " << numNodes << " nodes)";
grantabx.cxx:	nodeIndexShift = ExponentialHashMap::hashBits() / numNodes;
grantabx.cxx:	BEGIN_CONSISTENT(2 * numNodes + 3) {
grantabx.cxx:	} END_CONSISTENT;
grantabx.cxx:	BEGIN_CONSISTENT(numNodes) {
grantabx.cxx:	} END_CONSISTENT;
grantabx.cxx:	/*  reset it to zero.  This allows elements to be wiped from 
grantabx.cxx:		dfi = myDoublingFrontIndex->increment().asLong();
grantabx.cxx:		myDoublingPasses->increment();
grantabx.cxx:	/* re-initialize the non-persistent part */
grantabx.cxx:	REQUIRES (ExponentialHashMap);
grantabx.cxx:	SPTR(GrandEntry) newEntry;
grantabx.cxx:	hash = ExponentialHashMap::exponentialMap(aKey->hashForEqual());
grantabx.cxx:	BEGIN_CONSISTENT(1) {
grantabx.cxx:		newEntry = 
grantabx.cxx:				GrandTableEntry::make (aHeaper, aKey, hash);
grantabx.cxx:	} END_CONSISTENT;
grantabx.cxx:	node->store(newEntry);
grantabx.cxx:		myTally->increment();
grantabx.cxx:	hash = ExponentialHashMap::exponentialMap(aKey->hashForEqual());
grantabx.cxx:		myTally->decrement();
grantabx.cxx:	hash = ExponentialHashMap::exponentialMap(key->hashForEqual());
grantabx.cxx:	SPTR(TableStepper) elements;
grantabx.cxx:	elements = this->stepper();
grantabx.cxx:	BEGIN_FOR_EACH(Heaper,elemValue,(elements)) {
grantabx.cxx:		if (region->hasMember(elements->position())) {
grantabx.cxx:			newTable->store(elements->position(), elemValue);
grantabx.cxx:	aStream << "GrandHashTable(" << this->count() << " entries over " << numNodes << " nodes)";
grantabx.cxx:	nodeIndexShift = ExponentialHashMap::hashBits() / numNodes;
grantabx.cxx:	BEGIN_CONSISTENT(2 * numNodes + 3) {
grantabx.cxx:	} END_CONSISTENT;
grantabx.cxx:	BEGIN_CONSISTENT(numNodes) {
grantabx.cxx:	} END_CONSISTENT;
grantabx.cxx:	/*  reset it to zero.  This allows elements to be wiped from 
grantabx.cxx:		dfi = myDoublingFrontIndex->increment().asLong();
grantabx.cxx:		myDoublingPasses->increment();
grantabx.cxx:	/* re-initialize the non-persistent part */
grantabx.cxx:	BLAST(WILL_NOT_IMPLEMENT);
grantabx.cxx:	BLAST(WILL_NOT_IMPLEMENT);
grantabx.cxx: *                    Class ExponentialHashMap 
grantabx.cxx:/* Initializers for ExponentialHashMap */
grantabx.cxx:UInt32 ExponentialHashMap::HashBits = (1 << 30) - 1;
grantabx.cxx:GPTR(ExponentialHashMap) ExponentialHashMap::TheExponentialMap = NULL;
grantabx.cxx:BEGIN_INIT_TIME(ExponentialHashMap,initTimeNonInherited) {
grantabx.cxx:	CONSTRUCT(ExponentialHashMap::TheExponentialMap,ExponentialHashMap,(256, ExponentialHashMap::HashBits + 1));
grantabx.cxx:} END_INIT_TIME(ExponentialHashMap,initTimeNonInherited);
grantabx.cxx:/* Initializers for ExponentialHashMap */
grantabx.cxx:UInt32 ExponentialHashMap::of (UInt32 aHash){
grantabx.cxx:ExponentialHashMap::ExponentialHashMap (Int32 numPieces, UInt32 range) {
grantabx.cxx:UInt32 ExponentialHashMap::expFuncWithin (UInt32 domElem, UInt32 range){
grantabx.cxx:UInt32 ExponentialHashMap::actualHashForEqual (){
grantabx.cxx:		Int32 nEntries, 
grantabx.cxx:	RETURN_CONSTRUCT(GrandDataPage,(nEntries, node, lowHashBits));
grantabx.cxx:The shift argument to the various methods is the number of pages in the
grantabx.cxx:parent node to indicate how many low bits of the hash are ignored. */
grantabx.cxx:	SPTR(GrandEntry) entry;
grantabx.cxx:	localIndex = originalIndex = aHash / shift % numEntries;
grantabx.cxx:	entry = CAST(GrandEntry,entries->fetch(localIndex));
grantabx.cxx:	while (entry != NULL) {
grantabx.cxx:		if (aHash == entry->hashForEqual()) {
grantabx.cxx:			if (entry->compare(toMatch)) {
grantabx.cxx:				returnValue = entry->value();
grantabx.cxx:		localIndex = (localIndex + 1) % numEntries;
grantabx.cxx:		entry = CAST(GrandEntry,entries->fetch(localIndex));
grantabx.cxx:			entry = NULL;
grantabx.cxx:void GrandDataPage::store (APTR(GrandEntry) newEntry, Int32 shift){
grantabx.cxx:	WPTR(GrandEntry) entry;
grantabx.cxx:	localIndex = originalIndex = newEntry->hashForEqual() / shift % numEntries;
grantabx.cxx:	entry = CAST(GrandEntry,entries->fetch(localIndex));
grantabx.cxx:	while (entry != NULL) {
grantabx.cxx:		if (newEntry->hashForEqual() == entry->hashForEqual()) {
grantabx.cxx:			/* Note that this does not delete the contents */
grantabx.cxx:			if (newEntry->matches(entry)) {
grantabx.cxx:				BEGIN_CONSISTENT(1) {
grantabx.cxx:					{entry->destroy();  entry = NULL /* don't want stale (S/CHK)PTRs */;}
grantabx.cxx:					entries->store(localIndex, newEntry);
grantabx.cxx:				} END_CONSISTENT;
grantabx.cxx:		localIndex = (localIndex + 1) % numEntries;
grantabx.cxx:				BEGIN_CONSISTENT(4) {
grantabx.cxx:					overflow = myGroup->getOverflow()->store(newEntry);
grantabx.cxx:				} END_CONSISTENT;
grantabx.cxx:				overflow->store(newEntry);
grantabx.cxx:		entry = CAST(GrandEntry,entries->fetch(localIndex));
grantabx.cxx:	BEGIN_CONSISTENT(1) {
grantabx.cxx:		entries->store(localIndex, newEntry);
grantabx.cxx:	} END_CONSISTENT;
grantabx.cxx:	WPTR(GrandEntry) entry;
grantabx.cxx:	localIndex = originalIndex = aHash / shift % numEntries;
grantabx.cxx:	entry = CAST(GrandEntry,entries->fetch(localIndex));
grantabx.cxx:	while (entry != NULL) {
grantabx.cxx:		if (aHash == entry->hashForEqual()) {
grantabx.cxx:			if (entry->compare(toMatch)) {
grantabx.cxx:				BEGIN_CONSISTENT(2) {
grantabx.cxx:					{entry->destroy();  entry = NULL /* don't want stale (S/CHK)PTRs */;}
grantabx.cxx:						delete the contents */
grantabx.cxx:					entries->store(localIndex, NULL);
grantabx.cxx:				} END_CONSISTENT;
grantabx.cxx:		localIndex = (localIndex + 1) % numEntries;
grantabx.cxx:		entry = CAST(GrandEntry,entries->fetch(localIndex));
grantabx.cxx:			entry = NULL;
grantabx.cxx:		Int32 nEntries, 
grantabx.cxx:	numEntries = nEntries;
grantabx.cxx:	entries = PtrArray::nulls(numEntries);
grantabx.cxx:	/* This repacks the entry table after a wipe to keep the 
grantabx.cxx:	table consistent with */
grantabx.cxx:	SPTR(PtrArray) OF1(GrandEntry) newEntries;
grantabx.cxx:	SPTR(GrandEntry) entry;
grantabx.cxx:	newEntries = PtrArray::nulls(numEntries);
grantabx.cxx:		Int32 LoopFinal = numEntries;
grantabx.cxx:				if ((entry = CAST(GrandEntry,entries->fetch(i))) != NULL) {
grantabx.cxx:					preferedIndex = entry->hashForEqual() / shift % numEntries;
grantabx.cxx:					if (newEntries->fetch(preferedIndex) != NULL) {
grantabx.cxx:						while (newEntries->fetch(preferedIndex) != NULL) {
grantabx.cxx:							preferedIndex = (preferedIndex + 1) % numEntries;
grantabx.cxx:					newEntries->store(preferedIndex, entry);
grantabx.cxx:	{entries->destroy();  entries = NULL /* don't want stale (S/CHK)PTRs */;}
grantabx.cxx:	entries = newEntries;
grantabx.cxx:	/* Create a new page with all entries of current page that have a */
grantabx.cxx:	/* Retain all '0' entries in this page. */
grantabx.cxx:	WPTR(GrandEntry) oldEntry;
grantabx.cxx:	BEGIN_CONSISTENT(2) {
grantabx.cxx:				GrandDataPage::make (numEntries, myGroup, myLowHashBits + oldNumPages);
grantabx.cxx:		/* Reset overflow structure. Old one is held by parent node. */
grantabx.cxx:			Int32 LoopFinal = numEntries;
grantabx.cxx:					oldEntry = CAST(GrandEntry,entries->fetch(i));
grantabx.cxx:					if (oldEntry != NULL) {
grantabx.cxx:						if ((oldEntry->hashForEqual() / oldNumPages & 1) == 1) {
grantabx.cxx:							newPage->store(oldEntry, newNumPages);
grantabx.cxx:							entries->store(i, NULL);
grantabx.cxx:	} END_CONSISTENT;
grantabx.cxx:		Int32 LoopFinal = numEntries;
grantabx.cxx:				if (entries->fetch(i) != NULL) {
grantabx.cxx:	return (IEEE32) loadCount / (IEEE32) numEntries;
grantabx.cxx:	aStream << "GrandDataPage(" << numEntries << " slots, ";
grantabx.cxx:		Int32 LoopFinal = numEntries;
grantabx.cxx:				if (entries->fetch(i) != NULL) {
grantabx.cxx:	BEGIN_CONSISTENT(1 + numEntries) {
grantabx.cxx:		SPTR(Heaper) entry;
grantabx.cxx:		if (entries != NULL) {
grantabx.cxx:				Int32 LoopFinal = numEntries;
grantabx.cxx:						entry = entries->fetch(i);
grantabx.cxx:						if (entry != NULL) {
grantabx.cxx:							{entry->destroy();  entry = NULL /* don't want stale (S/CHK)PTRs */;}
grantabx.cxx:							entries->store(i, NULL);
grantabx.cxx:			{entries->destroy();  entries = NULL /* don't want stale (S/CHK)PTRs */;}
grantabx.cxx:			entries = NULL;
grantabx.cxx:	} END_CONSISTENT;
grantabx.cxx:UInt32 GrandDataPage::contentsHash (){
grantabx.cxx:	return this->Abraham::contentsHash() ^ IntegerPos::integerHash(myLowHashBits) ^ IntegerPos::integerHash(numEntries) ^ entries->contentsHash() ^ overflow->hashForEqual() ^ myGroup->hashForEqual();
grantabx.cxx:		UInt32 LoopFinal = numEntries;
grantabx.cxx:				if (entries->fetch(i) != NULL) {
grantabx.cxx:RPTR(GrandEntry) GrandDataPage::entryAt (IntegerVar idx){
grantabx.cxx:	return CAST(GrandEntry,entries->fetch(idx.asLong()));
grantabx.cxx:IntegerVar GrandDataPage::entryCount (){
grantabx.cxx:	return numEntries;
grantabx.cxx:RPTR(GrandEntry) GrandDataPageStepper::entry (){
grantabx.cxx:	return (GrandEntry * ) page->entryAt(entryIndex);
grantabx.cxx:	BLAST(SHOULD_NOT_IMPLEMENT);
grantabx.cxx:	return entryIndex < page->entryCount();
grantabx.cxx:	entryIndex += 1;
grantabx.cxx:	this->verifyEntry();
grantabx.cxx:	entryIndex = index;
grantabx.cxx:	this->verifyEntry();
grantabx.cxx:void GrandDataPageStepper::verifyEntry (){
grantabx.cxx:		/* entryIndex < page->entryCount() && page->entryAt(entryIndex) == NULL */
grantabx.cxx:		crutch_Flag = entryIndex < page->entryCount();
grantabx.cxx:			crutch_Flag = page->entryAt(entryIndex) == NULL;
grantabx.cxx:			entryIndex += 1;
grantabx.cxx:	RETURN_CONSTRUCT(GrandDataPageStepper,(page, entryIndex));
grantabx.cxx:	entryIndex = IntegerVar0;
grantabx.cxx:	this->verifyEntry();
grantabx.cxx: *                    Class GrandEntry 
grantabx.cxx:/* GrandEntries probably want to not be remembered right when they are created,
grantabx.cxx:RPTR(Heaper) GrandEntry::value (){
grantabx.cxx:GrandEntry::GrandEntry (APTR(Heaper) value, UInt32 hash) 
grantabx.cxx:UInt32 GrandEntry::contentsHash (){
grantabx.cxx:	return this->Abraham::contentsHash() ^ IntegerPos::integerHash(this->hashForEqual()) ^ objectInternal->hashForEqual();
grantabx.cxx: *                    Class   GrandSetEntry 
grantabx.cxx:RPTR(GrandEntry) GrandSetEntry::make (APTR(Heaper) value, UInt32 hash){
grantabx.cxx:	RETURN_CONSTRUCT(GrandSetEntry,(value, hash));
grantabx.cxx:BooleanVar GrandSetEntry::compare (APTR(Heaper) OR(Position) anObj){
grantabx.cxx:BooleanVar GrandSetEntry::matches (APTR(GrandEntry) anEntry){
grantabx.cxx:	return this->value()->isEqual(anEntry->value());
grantabx.cxx:GrandSetEntry::GrandSetEntry (APTR(Heaper) value, UInt32 hash) 
grantabx.cxx:	: GrandEntry(value, hash) {
grantabx.cxx:void GrandSetEntry::printOn (ostream& aStream){
grantabx.cxx:	aStream << "GrandSetEntry(hash=" << this->hashForEqual() << ", value=" << this->value() << ")";
grantabx.cxx: *                    Class   GrandTableEntry 
grantabx.cxx:RPTR(GrandEntry) GrandTableEntry::make (
grantabx.cxx:	RETURN_CONSTRUCT(GrandTableEntry,(value, key, hash));
grantabx.cxx:void GrandTableEntry::printOn (ostream& aStream){
grantabx.cxx:	aStream << "GrandTableEntry(hash=" << this->hashForEqual() << ", key=" << keyInternal << ", value=" << this->value() << ")";
grantabx.cxx:RPTR(Position) GrandTableEntry::key (){
grantabx.cxx:RPTR(Position) GrandTableEntry::position (){
grantabx.cxx:BooleanVar GrandTableEntry::compare (APTR(Heaper) OR(Position) anObj){
grantabx.cxx:UInt32 GrandTableEntry::contentsHash (){
grantabx.cxx:	return this->GrandEntry::contentsHash() ^ keyInternal->hashForEqual();
grantabx.cxx:BooleanVar GrandTableEntry::matches (APTR(GrandEntry) anEntry){
grantabx.cxx:	return keyInternal->isEqual(CAST(GrandTableEntry,anEntry)->position());
grantabx.cxx:GrandTableEntry::GrandTableEntry (
grantabx.cxx:	: GrandEntry(value, hash) {
grantabx.cxx:void GrandHashSetStepper::verifyEntry (){
grantabx.cxx:			returnValue = nodeStepper->entry()->value();
grantabx.cxx:		this->verifyEntry();
grantabx.cxx:	this->verifyEntry();
grantabx.cxx:void GrandHashTableStepper::verifyEntry (){
grantabx.cxx:			returnValue = nodeStepper->entry()->value();
grantabx.cxx:		this->verifyEntry();
grantabx.cxx:	returnValue = CAST(GrandTableEntry,nodeStepper->entry())->position();
grantabx.cxx:	this->verifyEntry();
grantabx.cxx:void GrandNode::store (APTR(GrandEntry) newEntry){
grantabx.cxx:	CAST(GrandDataPage,primaryPages->fetch(newEntry->hashForEqual() % numPrimaries))->store(newEntry, numPrimaries);
grantabx.cxx:	BEGIN_CONSISTENT(2 + numPrimaries) {
grantabx.cxx:	} END_CONSISTENT;
grantabx.cxx:	BEGIN_CONSISTENT(1) {
grantabx.cxx:	} END_CONSISTENT;
grantabx.cxx:	BEGIN_CONSISTENT(this->doubleNodeConsistency()) {
grantabx.cxx:		/* At this point, the structure is consistent, but 
grantabx.cxx:	} END_CONSISTENT;
grantabx.cxx:	BEGIN_CONSISTENT(1) {
grantabx.cxx:	} END_CONSISTENT;
grantabx.cxx:UInt32 GrandNode::contentsHash (){
grantabx.cxx:	result = this->Abraham::contentsHash() ^ primaryPages->contentsHash() ^ IntegerPos::integerHash(numPrimaries);
grantabx.cxx:		BEGIN_CONSISTENT(2) {
grantabx.cxx:		} END_CONSISTENT;
grantabx.cxx:	BEGIN_CONSISTENT(1) {
grantabx.cxx:	} END_CONSISTENT;
grantabx.cxx:		BEGIN_CONSISTENT(myNode->doubleNodeConsistency() + 2) {
grantabx.cxx:		} END_CONSISTENT;
grantabx.cxx:	BEGIN_CONSISTENT(2) {
grantabx.cxx:	} END_CONSISTENT;
grantabx.cxx:/* GrandNodeReinserter moves the contents of the GrandOverflow 
grantabx.cxx:		BEGIN_CONSISTENT(myOverflow->reinsertEntriesConsistency() + 2) {
grantabx.cxx:			myOverflow->reinsertEntries(myNode);
grantabx.cxx:		} END_CONSISTENT;
grantabx.cxx:void GrandNodeStepper::verifyEntry (){
grantabx.cxx:RPTR(GrandEntry) GrandNodeStepper::entry (){
grantabx.cxx:		WPTR(GrandEntry) 	returnValue;
grantabx.cxx:		returnValue = overflowStepper->entry();
grantabx.cxx:		WPTR(GrandEntry) 	returnValue;
grantabx.cxx:		returnValue = pageStepper->entry();
grantabx.cxx:	BLAST(SHOULD_NOT_IMPLEMENT);
grantabx.cxx:			this->verifyEntry();
grantabx.cxx:	this->verifyEntry();
grantabx.cxx:/* This class has a comment
grantabx.cxx:	SPTR(GrandEntry) entry;
grantabx.cxx:	localIndex = originalIndex = aHash / depth % numEntries;
grantabx.cxx:	entry = CAST(GrandEntry,entries->fetch(localIndex));
grantabx.cxx:	while (entry != NULL) {
grantabx.cxx:		if (aHash == entry->hashForEqual()) {
grantabx.cxx:			if (entry->compare(toMatch)) {
grantabx.cxx:				returnValue = entry->value();
grantabx.cxx:		localIndex = (localIndex + 1) % numEntries;
grantabx.cxx:		entry = CAST(GrandEntry,entries->fetch(localIndex));
grantabx.cxx:			entry = NULL;
grantabx.cxx:RPTR(GrandOverflow) GrandOverflow::store (APTR(GrandEntry) newEntry){
grantabx.cxx:	WPTR(GrandEntry) entry;
grantabx.cxx:	localIndex = originalIndex = newEntry->hashForEqual() / depth % numEntries;
grantabx.cxx:	entry = CAST(GrandEntry,entries->fetch(localIndex));
grantabx.cxx:	while (entry != NULL) {
grantabx.cxx:		if (newEntry->hashForEqual() == entry->hashForEqual()) {
grantabx.cxx:			/* Note that this does not delete the contents */
grantabx.cxx:			if (newEntry->matches(entry)) {
grantabx.cxx:				BEGIN_CONSISTENT(2) {
grantabx.cxx:					{entry->destroy();  entry = NULL /* don't want stale (S/CHK)PTRs */;}
grantabx.cxx:					entries->store(localIndex, newEntry);
grantabx.cxx:				} END_CONSISTENT;
grantabx.cxx:		localIndex = (localIndex + 1) % numEntries;
grantabx.cxx:			childIndex = newEntry->hashForEqual() / depth % GrandOverflow::OTreeArity;
grantabx.cxx:				BEGIN_CONSISTENT(2) {
grantabx.cxx:					CONSTRUCT(newChild,GrandOverflow,(numEntries, depth * GrandOverflow::OTreeArity));
grantabx.cxx:				} END_CONSISTENT;
grantabx.cxx:			returnValue = CAST(GrandOverflow,children->fetch(childIndex))->store(newEntry);
grantabx.cxx:		entry = CAST(GrandEntry,entries->fetch(localIndex));
grantabx.cxx:	BEGIN_CONSISTENT(1) {
grantabx.cxx:		entries->store(localIndex, newEntry);
grantabx.cxx:	} END_CONSISTENT;
grantabx.cxx:	WPTR(GrandEntry) entry;
grantabx.cxx:	localIndex = originalIndex = aHash / depth % numEntries;
grantabx.cxx:	entry = CAST(GrandEntry,entries->fetch(localIndex));
grantabx.cxx:	while (entry != NULL) {
grantabx.cxx:		if (aHash == entry->hashForEqual()) {
grantabx.cxx:			/* Note that this does not delete the contents */
grantabx.cxx:			if (entry->compare(toMatch)) {
grantabx.cxx:				BEGIN_CONSISTENT(2) {
grantabx.cxx:					{entry->destroy();  entry = NULL /* don't want stale (S/CHK)PTRs */;}
grantabx.cxx:					entries->store(localIndex, NULL);
grantabx.cxx:				} END_CONSISTENT;
grantabx.cxx:		localIndex = (localIndex + 1) % numEntries;
grantabx.cxx:		entry = CAST(GrandEntry,entries->fetch(localIndex));
grantabx.cxx:			entry = NULL;
grantabx.cxx:GrandOverflow::GrandOverflow (Int32 maxEntries, UInt32 someDepth) {
grantabx.cxx:	numEntries = maxEntries;
grantabx.cxx:	entries = PtrArray::nulls(numEntries);
grantabx.cxx:	/* This repacks the entry table after a wipe to keep the 
grantabx.cxx:	table consistent with */
grantabx.cxx:	SPTR(PtrArray) OF1(GrandEntry) newEntries;
grantabx.cxx:	SPTR(GrandEntry) entry;
grantabx.cxx:	newEntries = PtrArray::nulls(numEntries);
grantabx.cxx:		Int32 LoopFinal = numEntries;
grantabx.cxx:				if ((entry = CAST(GrandEntry,entries->fetch(i))) != NULL) {
grantabx.cxx:					preferedIndex = entry->hashForEqual() / depth % numEntries;
grantabx.cxx:					if (newEntries->fetch(preferedIndex) != NULL) {
grantabx.cxx:						while (newEntries->fetch(preferedIndex) != NULL) {
grantabx.cxx:							preferedIndex = (preferedIndex + 1) % numEntries;
grantabx.cxx:					newEntries->store(preferedIndex, entry);
grantabx.cxx:	{entries->destroy();  entries = NULL /* don't want stale (S/CHK)PTRs */;}
grantabx.cxx:	entries = newEntries;
grantabx.cxx:void GrandOverflow::reinsertEntries (APTR(GrandNode) node){
grantabx.cxx:	/* Recursively insert all overflowed entries into a newly 
grantabx.cxx:	SPTR(GrandEntry) entry;
grantabx.cxx:	BEGIN_CONSISTENT(this->reinsertEntriesConsistency()) {
grantabx.cxx:			Int32 LoopFinal = numEntries;
grantabx.cxx:					entry = CAST(GrandEntry,entries->fetch(i));
grantabx.cxx:					if (entry != NULL) {
grantabx.cxx:						node->store(entry);
grantabx.cxx:						entries->store(i, NULL);
grantabx.cxx:	} END_CONSISTENT;
grantabx.cxx:IntegerVar GrandOverflow::reinsertEntriesConsistency (){
grantabx.cxx:	return 4 * numEntries + GrandOverflow::OTreeArity + 2;
grantabx.cxx:	BEGIN_CONSISTENT(1 + numEntries + GrandOverflow::OTreeArity) {
grantabx.cxx:		if (entries != NULL) {
grantabx.cxx:				Int32 LoopFinal = numEntries;
grantabx.cxx:						SPTR(GrandEntry) entry;
grantabx.cxx:						entry = CAST(GrandEntry,entries->fetch(i));
grantabx.cxx:						if (entry != NULL) {
grantabx.cxx:							{entry->destroy();  entry = NULL /* don't want stale (S/CHK)PTRs */;}
grantabx.cxx:			{entries->destroy();  entries = NULL /* don't want stale (S/CHK)PTRs */;}
grantabx.cxx:	} END_CONSISTENT;
grantabx.cxx:RPTR(GrandEntry) GrandOverflow::entryAt (IntegerVar idx){
grantabx.cxx:	return CAST(GrandEntry,entries->fetch(idx.asLong()));
grantabx.cxx:IntegerVar GrandOverflow::entryCount (){
grantabx.cxx:	return numEntries;
grantabx.cxx:UInt32 GrandOverflow::contentsHash (){
grantabx.cxx:	return this->Abraham::contentsHash() ^ IntegerPos::integerHash(numEntries) ^ entries->contentsHash() ^ children->contentsHash() ^ IntegerPos::integerHash(depth);
grantabx.cxx:void GrandOverflowStepper::verifyEntry (){
grantabx.cxx:	if (entryIndex < overflow->entryCount()) {
grantabx.cxx:			/* entryIndex < overflow->entryCount() && overflow->entryAt(entryIndex) == NULL */
grantabx.cxx:			crutch_Flag = entryIndex < overflow->entryCount();
grantabx.cxx:				crutch_Flag = overflow->entryAt(entryIndex) == NULL;
grantabx.cxx:				entryIndex += 1;
grantabx.cxx:	if (entryIndex < overflow->entryCount()) {
grantabx.cxx:RPTR(GrandEntry) GrandOverflowStepper::entry (){
grantabx.cxx:		WPTR(GrandEntry) 	returnValue;
grantabx.cxx:		returnValue = overflow->entryAt(entryIndex);
grantabx.cxx:		WPTR(GrandEntry) 	returnValue;
grantabx.cxx:		returnValue = childStepper->entry();
grantabx.cxx:	BLAST(SHOULD_NOT_IMPLEMENT);
grantabx.cxx:			/* entryIndex < overflow->entryCount() && childIndex < overflow->childCount() */
grantabx.cxx:			crutch_Flag = entryIndex < overflow->entryCount();
grantabx.cxx:		entryIndex += 1;
grantabx.cxx:	this->verifyEntry();
grantabx.cxx:	RETURN_CONSTRUCT(GrandOverflowStepper,(overflow, entryIndex, childStepper, childIndex));
grantabx.cxx:	entryIndex = childIndex = IntegerVar0;
grantabx.cxx:	this->verifyEntry();
grantabx.cxx:		IntegerVar entryIdx, 
grantabx.cxx:	entryIndex = entryIdx;
grantabx.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
grantabx.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
grantabx.hxx:/* Presently the values called 'shift' in this module are used with
grantabx.hxx:	/* NO CLASS COMMENT */
grantabx.hxx:	/*  reset it to zero.  This allows elements to be wiped from 
grantabx.hxx:	/* re-initialize the non-persistent part */
grantabx.hxx:	/* NO CLASS COMMENT */
grantabx.hxx:	/*  reset it to zero.  This allows elements to be wiped from 
grantabx.hxx:	/* re-initialize the non-persistent part */
grantabx.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
grantabx.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
grantabx.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
grantabx.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
htreex.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
htreex.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
htreex.cxx:#ifndef ENTX_HXX
htreex.cxx:#include "entx.hxx"
htreex.cxx:#endif /* ENTX_HXX */
htreex.cxx:		 and increment.  This should actually do spread the hashes. */
htreex.cxx:/* invariant:  the parent's trace >= the child's trace
htreex.cxx:The subclasses should differentiate between the number 
htreex.cxx:body of the ent have one child if they are at the top 
htreex.cxx:almost always have a canopyCrum to represent the join 
htreex.cxx:no parents can appear in the middle of the ent.  If so, then 
htreex.cxx:	BEGIN_CONSISTENT(-1) {
htreex.cxx:		RETURN_CONSTRUCT(HUpperCrum,(CurrentTrace.fluidGet(), CurrentBertCrum.fluidGet()));
htreex.cxx:	} END_CONSISTENT;
htreex.cxx:	RETURN_CONSTRUCT(HUpperCrum,(CurrentTrace.fluidGet(), bertCrum));
htreex.cxx:RPTR(ImmuSet) OF1(OPart) HUpperCrum::oParents (){
htreex.cxx:void HUpperCrum::addOParent (APTR(OPart) newCrum){
htreex.cxx:	/* If this hcrum represents a fork, then it must get its own 
htreex.cxx:void HUpperCrum::removeOParent (APTR(OPart) newCrum){
htreex.cxx:		BEGIN_FOR_EACH(OPart,o,(this->oParents()->stepper())) {
htreex.cxx:	/* Make my bertCrum the join of its current value and bCrum. */
htreex.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
htreex.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
htreex.hxx:	/* invariant:  the parent's trace >= the child's trace
htreex.hxx:	The subclasses should differentiate between the number 
htreex.hxx:	body of the ent have one child if they are at the top 
htreex.hxx:	almost always have a canopyCrum to represent the join 
htreex.hxx:	no parents can appear in the middle of the ent.  If so, then 
htreex.hxx:		 and increment.  This should actually do spread the hashes. */
htreex.hxx:	/* See comment in HistoryCrum>>delayedStoreBackfollow:with:with: */
htreex.hxx:	as argument */
htreex.hxx:	virtual RPTR(ImmuSet) OF1(OPart) oParents () DEFERRED_FUNC;
htreex.hxx:	/* NO CLASS COMMENT */
htreex.hxx:	virtual RPTR(ImmuSet) OF1(OPart) oParents ();
htreex.hxx:	/* If this hcrum represents a fork, then it must get its own 
htreex.hxx:	virtual void addOParent (APTR(OPart) ARG(newCrum));
htreex.hxx:	virtual void removeOParent (APTR(OPart) ARG(newCrum));
htreex.hxx:	/* Make my bertCrum the join of its current value and bCrum. */
htreex.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
htreex.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
htreex.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
htreex.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
idp.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
idp.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
idp.hxx:	/* NO CLASS COMMENT */
idp.hxx:	/* NO CLASS COMMENT */
idp.hxx:	/* NO CLASS COMMENT */
idp.hxx:	virtual RPTR(Arrangement) arrange (APTR(XnRegion) ARG(region));
idp.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
idp.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
idp.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
idp.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
idt.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
idt.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
idt.cxx:	backend = FeServer::identifier();
idt.cxx:		result->step(iD->asRegion()->complement());
idt.cxx:			result step: (s iDsFromServer: backend) complement.
idt.cxx:		7))complement.
idt.cxx:		9))complement. */
idt.cxx:			oo << "2nd import " << importedAgain << " is different from " << original << "\n";
idt.cxx:			oo << "import " << imported << " is different from " << original << "\n";
idt.cxx:			oo << "original " << importedAgain << " is different from " << original << "\n";
idt.cxx:	if (!exported->contentsEqual(exportedAgain)) {
idt.cxx:	if (!exported->contentsEqual(exportedAgain)) {
idt.cxx:			ID::usingx(special, CurrentGrandMap.fluidGet()->identifier()->withLast(33), 1));
idt.cxx:	s = IDSpace::make (CurrentGrandMap.fluidGet()->identifier()->withLast(22), 7);
idt.cxx:	s = CurrentGrandMap.fluidGet()->newIDSpace();
idt.cxx:	this->testIDSpaceOn(oo, CurrentGrandMap.fluidGet()->globalIDSpace(), NULL);
idt.cxx:	/* automatic 0-argument constructor */
idt.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
idt.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
idt.hxx:	/* NO CLASS COMMENT */
idt.hxx:	/* automatic 0-argument constructor */
idt.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
idt.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
idt.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
idt.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
idx.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
idx.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
idx.cxx:		/* backend == NULL || backend->isEqual(Sequence::zero()) || backend->isEqual(FeServer::identifier()) */
idx.cxx:			crutch_Flag = backend->isEqual(FeServer::identifier());
idx.cxx:	/* Essential. Take some information describing an ID and 
idx.cxx:	if (space->isEqual(CurrentGrandMap.fluidGet()->globalIDSpace())) {
idx.cxx:/* Implementation note:
idx.cxx:created it, along with a number identifying the ID uniquely. If 
idx.cxx:is NULL, then this ID was generated by the current Server (unless 
idx.cxx:	/* Essential. Export this iD in a form which can be handed to 
idx.cxx:	oo << CAST(IDSpace,this->coordinateSpace())->identifier() << ":" << this->identifier();
idx.cxx:	/* Essential. A Sequence identifying the server on which this 
idx.cxx:			returnValue = FeServer::identifier();
idx.cxx:	/* Essential. The number identifying this ID from all others 
idx.cxx:RPTR(Sequence) ID::identifier (){
idx.cxx:	/* A sequence of numbers which uniquely identify this ID 
idx.cxx:	/* get rid of this, and clients */
idx.cxx:/* Initializer inherited from IdentityDsp */
idx.cxx:IdentityDsp * IDDsp::theDsp = NULL;
idx.cxx:/* Initializer inherited from IdentityDsp */
idx.cxx:	CONSTRUCT_ON(PERSISTENT,IDDsp::theDsp,IDDsp,());
idx.cxx:/* Initializer inherited from IdentityDsp */
idx.cxx:/* Initializer inherited from IdentityDsp */
idx.cxx:	/* Essential. Take some information describing an IDRegion 
idx.cxx:	if (space->isEqual(CurrentGrandMap.fluidGet()->globalIDSpace())) {
idx.cxx:all IDs in the region that were generated by the current backend. The 
idx.cxx:this region which were generated by other backends. If an entry in 
idx.cxx:and the region is empty, then the entry should be omitted).
idx.cxx:	/* make this more efficient and return fullRegion less often */
idx.cxx:	/* Essential. Export the IDRegion in a form that can be used 
idx.cxx:	BLAST(NotOneElement);
idx.cxx:			result = result->without(FeServer::identifier());
idx.cxx:			result = result->with(FeServer::identifier());
idx.cxx:		result = result->with(FeServer::identifier());
idx.cxx:	if (backend->isEqual(FeServer::identifier())) {
idx.cxx:RPTR(XnRegion) IDRegion::complement (){
idx.cxx:	returnValue = IDRegion::make (mySpace, CAST(IntegerRegion,myLocalIDs->complement()), resTable, !myIncludesRest);
idx.cxx:	oo << "{" << CAST(IDSpace,this->coordinateSpace())->identifier() << " |";
idx.cxx:		oo << " " << FeServer::identifier() << "." << iDs;
idx.cxx:	returnValue = CurrentGrandMap.fluidGet()->globalIDSpace();
idx.cxx:	/* Essential. Take some information describing an IDSpace and 
idx.cxx:	/* Essential. Create a new globally unique space of IDs */
idx.cxx:	returnValue = CurrentGrandMap.fluidGet()->newIDSpace();
idx.cxx:RPTR(IDSpace) IDSpace::make (APTR(Sequence) OR(NULL) identifier, IntegerVar number){
idx.cxx:	returnValue = IDSpace::make (identifier, number, CurrentGrandMap.fluidGet()->getOrMakeIDCounter(identifier, number));
idx.cxx:		APTR(Sequence) OR(NULL) identifier, 
idx.cxx:	cgm = CurrentGrandMap.fluidFetch();
idx.cxx:		/* identifier != NULL && (identifier->isZero() || cgm != NULL && identifier->isEqual(cgm->identifier())) */
idx.cxx:		crutch_Flag = identifier != NULL;
idx.cxx:			crutch_Flag = identifier->isZero();
idx.cxx:					crutch_Flag = identifier->isEqual(cgm->identifier());
idx.cxx:	RETURN_CONSTRUCT(IDSpace,(identifier, number, counter));
idx.cxx:Implementation note:
idx.cxx:	myBackend - the identifier of the Server which generated this space. 
idx.cxx:If NULL, then it was generated by the current Server (unless 
idx.cxx:	mySpaceNumber - identifies which space this is. If -1, then it is 
idx.cxx:RPTR(IDRegion) IDSpace::iDsFromServer (APTR(Sequence) identifier){
idx.cxx:	/* Essential. The Region of IDs in this space which might be 
idx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
idx.cxx:	/* Essential. A new ID guaranteed to be different from every 
idx.cxx:	returnValue = ID::make (this->fetchIDSpace(), NULL, myNewIDCounter->increment());
idx.cxx:	returnValue = IDRegion::make (this->fetchIDSpace(), IntegerRegion::integerExtent(myNewIDCounter->incrementBy(count), count), NULL, FALSE);
idx.cxx:	/* Essential. The Server which created this IDSpace */
idx.cxx:			returnValue = FeServer::identifier();
idx.cxx:		if (backend->isEqual(FeServer::identifier())) {
idx.cxx:	/* Essential. Identifies this particular space among all 
idx.cxx:	/* Essential. Produce an array which can be handed to 
idx.cxx:RPTR(Sequence) IDSpace::identifier (){
idx.cxx:	/* A Sequence uniquely identifying this IDSpace, so that
idx.cxx:			FeServer::current ()->oldIDSpace (this->identifier ())
idx.cxx:	/* get rid of this message and its clients */
idx.cxx:					/* more efficient comparison */
idx.cxx:RPTR(Arrangement) IDUpOrder::arrange (APTR(XnRegion) region){
idx.cxx:		BLAST(NOT_YET_IMPLEMENTED);
idx.cxx:	WPTR(Arrangement) 	returnValue;
idx.cxx:	returnValue = ExplicitArrangement::make (array);
idx.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
idx.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
idx.hxx:	/* Implementation note:
idx.hxx:	which created it, along with a number identifying the ID 
idx.hxx:	the current Server (unless myNumber is negative, in which 
idx.hxx:	ON_CLIENT(ID)
idx.hxx:	/* Essential. Take some information describing an ID and 
idx.hxx:	static CLIENT RPTR(ID) import (APTR(PrimIntArray) ARG(data));
idx.hxx:	/* Essential. Export this iD in a form which can be handed to 
idx.hxx:	virtual CLIENT RPTR(UInt8Array) export ();
idx.hxx:	/* Essential. A Sequence identifying the server on which this 
idx.hxx:	/* Essential. The number identifying this ID from all others 
idx.hxx:	/* A sequence of numbers which uniquely identify this ID 
idx.hxx:	virtual RPTR(Sequence) identifier ();
idx.hxx:/* Declaration inherited from IdentityDsp */
idx.hxx:/* Declaration inherited from IdentityDsp */
idx.hxx:class IDDsp : public IdentityDsp {
idx.hxx:/* Declaration inherited from IdentityDsp */
idx.hxx:/* Declaration inherited from IdentityDsp */
idx.hxx:	static IdentityDsp  * theDsp;
idx.hxx:	current backend. The negative part contains all IDs which 
idx.hxx:	backends. If an entry in the table could be omitted without 
idx.hxx:	is empty, then the entry should be omitted).
idx.hxx:	ON_CLIENT(IDRegion)
idx.hxx:	/* Essential. Take some information describing an IDRegion 
idx.hxx:	static CLIENT RPTR(IDRegion) import (APTR(PrimIntArray) ARG(data));
idx.hxx:	/* Essential. Export the IDRegion in a form that can be used 
idx.hxx:	virtual CLIENT RPTR(UInt8Array) export ();
idx.hxx:	virtual RPTR(XnRegion) complement ();
idx.hxx:	Implementation note:
idx.hxx:		myBackend - the identifier of the Server which generated 
idx.hxx:	this space. If NULL, then it was generated by the current 
idx.hxx:		mySpaceNumber - identifies which space this is. If -1, then 
idx.hxx:	ON_CLIENT(IDSpace)
idx.hxx:	static CLIENT RPTR(IDSpace) global ();
idx.hxx:	/* Essential. Take some information describing an IDSpace and 
idx.hxx:	static CLIENT RPTR(IDSpace) import (APTR(PrimIntArray) ARG(data));
idx.hxx:	/* Essential. Create a new globally unique space of IDs */
idx.hxx:	static CLIENT RPTR(IDSpace) unique ();
idx.hxx:	static RPTR(IDSpace) make (APTR(Sequence) OR(NULL) ARG(identifier), IntegerVar ARG(number));
idx.hxx:			APTR(Sequence) OR(NULL) ARG(identifier), 
idx.hxx:	/* Essential. The Region of IDs in this space which might be 
idx.hxx:	virtual CLIENT RPTR(IDRegion) iDsFromServer (APTR(Sequence) ARG(identifier));
idx.hxx:	/* Essential. A new ID guaranteed to be different from every 
idx.hxx:	virtual CLIENT RPTR(ID) newID ();
idx.hxx:	virtual CLIENT RPTR(IDRegion) newIDs (IntegerVar ARG(count));
idx.hxx:	/* Essential. The Server which created this IDSpace */
idx.hxx:	/* Essential. Identifies this particular space among all 
idx.hxx:	/* Essential. Produce an array which can be handed to 
idx.hxx:	virtual CLIENT RPTR(UInt8Array) export ();
idx.hxx:	/* A Sequence uniquely identifying this IDSpace, so that
idx.hxx:			FeServer::current ()->oldIDSpace (this->identifier ())
idx.hxx:	virtual RPTR(Sequence) identifier ();
idx.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
idx.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
idx.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
idx.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
loavesp.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
loavesp.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
loavesp.hxx:	/* NO CLASS COMMENT */
loavesp.hxx:	/* Look up the range element for the key.  If it is embedded 
loavesp.hxx:		 structure, then make a virtual range element using the 
loavesp.hxx:	virtual RPTR(FeRangeElement) OR(NULL) fetch (
loavesp.hxx:	/* Make an FeRangeElement for each position. */
loavesp.hxx:			APTR(Arrangement) ARG(toArrange), 
loavesp.hxx:	/* Get or Make the BeRangeElement at the location. */
loavesp.hxx:	virtual RPTR(BeRangeElement) getBe (APTR(Position) ARG(key));
loavesp.hxx:	/* add oparent to the set of upward pointers and update the 
loavesp.hxx:	virtual void addOParent (APTR(OPart) ARG(oparent));
loavesp.hxx:	virtual void storeRecordingAgents (APTR(RecorderFossil) ARG(recorder), APTR(Agenda) ARG(agenda));
loavesp.hxx:	virtual UInt32 contentsHash ();
loavesp.hxx:	/* NO CLASS COMMENT */
loavesp.hxx:	virtual RPTR(FeRangeElement) OR(NULL) fetch (
loavesp.hxx:	/* Get or make the BeRangeElement at the location. */
loavesp.hxx:	virtual RPTR(BeRangeElement) getBe (APTR(Position) ARG(key));
loavesp.hxx:	/* Return the owner of the atoms represented by the receiver. */
loavesp.hxx:	/* Return the PrimSpec that describes the representation of 
loavesp.hxx:	/* Make an FeRangeElement for each position. */
loavesp.hxx:			APTR(Arrangement) ARG(toArrange), 
loavesp.hxx:	/* If the CurrentKeyMaster includes the owner of this loaf
loavesp.hxx:	/* NO CLASS COMMENT */
loavesp.hxx:	virtual RPTR(FeRangeElement) OR(NULL) fetch (
loavesp.hxx:	/* Get or make the BeRangeElement at the location. */
loavesp.hxx:	virtual RPTR(BeRangeElement) getBe (APTR(Position) ARG(key));
loavesp.hxx:	/* Return the owner of the atoms represented by the receiver. */
loavesp.hxx:			APTR(Arrangement) ARG(toArrange), 
loavesp.hxx:	/* If the CurrentKeyMaster includes the owner of this loaf
loavesp.hxx:	virtual UInt32 contentsHash ();
loavesp.hxx:	/* NO CLASS COMMENT */
loavesp.hxx:	virtual RPTR(FeRangeElement) OR(NULL) fetch (
loavesp.hxx:	/* Make an FeRangeElement for each position. */
loavesp.hxx:			APTR(Arrangement) ARG(toArrange), 
loavesp.hxx:	virtual void forwardTo (APTR(BeRangeElement) ARG(rangeElement));
loavesp.hxx:	virtual RPTR(BeRangeElement) getBe (APTR(Position) ARG(key));
loavesp.hxx:	/* Return the owner of the atoms represented by the receiver. */
loavesp.hxx:	/* Return the PrimSpec that describes the representation of 
loavesp.hxx:	/* If the CurrentKeyMaster includes the owner of this loaf
loavesp.hxx:			APTR(BeRangeElement) ARG(element), 
loavesp.hxx:			APTR(BeRangeElement) ARG(element), 
loavesp.hxx:	/* add oparent to the set of upward pointers and update the 
loavesp.hxx:	virtual void addOParent (APTR(OPart) ARG(oparent));
loavesp.hxx:	range-element identity with other o-leafs.  The range element 
loavesp.hxx:	identity is in myRangeElement rather than myself, so I 
loavesp.hxx:	south one more step to myRangeElement. */
loavesp.hxx:	virtual void storeRecordingAgents (APTR(RecorderFossil) ARG(recorder), APTR(Agenda) ARG(agenda));
loavesp.hxx:	virtual UInt32 contentsHash ();
loavesp.hxx:	CHKPTR(BeRangeElement) myRangeElement;
loavesp.hxx:	/* NO CLASS COMMENT */
loavesp.hxx:	virtual UInt32 contentsHash ();
loavesp.hxx:	arrangement and his arrangement. */
loavesp.hxx:			APTR(Arrangement) ARG(toArrange), 
loavesp.hxx:	SharedData (APTR(PrimDataArray) ARG(data), APTR(Arrangement) ARG(arrange));
loavesp.hxx:	CHKPTR(Arrangement) myArrangement;
loavesp.hxx:	/* NO CLASS COMMENT */
loavesp.hxx:	/* Look up the range element for the key.  If it is embedded 
loavesp.hxx:		 structure, then make a virtual range element using the 
loavesp.hxx:	virtual RPTR(FeRangeElement) OR(NULL) fetch (
loavesp.hxx:	/* Get or Make the BeRangeElement at the location. */
loavesp.hxx:	virtual RPTR(BeRangeElement) getBe (APTR(Position) ARG(key));
loavesp.hxx:	/* This effectively copies the region represented by my distinction. */
loavesp.hxx:	/* Make an FeRangeElement for each position. */
loavesp.hxx:			APTR(Arrangement) ARG(toArrange), 
loavesp.hxx:	/* add oparent to the set of upward pointers and update the 
loavesp.hxx:	virtual void addOParent (APTR(OPart) ARG(oparent));
loavesp.hxx:	virtual void storeRecordingAgents (APTR(RecorderFossil) ARG(recorder), APTR(Agenda) ARG(agenda));
loavesp.hxx:		 parent to the new loaves first in case the only ent reference
loavesp.hxx:		guarantee the hTree property. Optimization: look at parents of the 
loavesp.hxx:		new loaves to find a pre-existing parent with the same trace and 
loavesp.hxx:	virtual UInt32 contentsHash ();
loavesp.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
loavesp.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
loavesp.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
loavesp.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
loavesr.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
loavesr.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
loavesr.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
loavesr.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
loavesr.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
loavesr.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
loavesx.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
loavesx.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
loavesx.cxx:#ifndef ENTX_HXX
loavesx.cxx:#include "entx.hxx"
loavesx.cxx:#endif /* ENTX_HXX */
loavesx.cxx:RPTR(Loaf) Loaf::make (APTR(XnRegion) region, APTR(BeCarrier) element){
loavesx.cxx:	BEGIN_CONSISTENT(7) {
loavesx.cxx:		RETURN_CONSTRUCT(RegionLoaf,(region, element->fetchLabel(), element->rangeElement(), NULL));
loavesx.cxx:	} END_CONSISTENT;
loavesx.cxx:	BEGIN_CONSISTENT(3) {
loavesx.cxx:	} END_CONSISTENT;
loavesx.cxx:RPTR(Loaf) Loaf::make (APTR(PrimDataArray) values, APTR(Arrangement) arrangement){
loavesx.cxx:	BEGIN_CONSISTENT(4) {
loavesx.cxx:		CONSTRUCT(tmp,SharedData,(values, arrangement));
loavesx.cxx:		RETURN_CONSTRUCT(OVirtualLoaf,(arrangement->region(), tmp));
loavesx.cxx:	} END_CONSISTENT;
loavesx.cxx:	if (externalDsp->isIdentity()) {
loavesx.cxx:	if (globalDsp->isIdentity()) {
loavesx.cxx:		Full containment cases can be handled generically. */
loavesx.cxx:void Loaf::addOParent (APTR(OPart) oParent){
loavesx.cxx:	/* This should probably take a bertCanopyCrum argument, as well. */
loavesx.cxx:	/* add oParent to the set of upward pointers. */
loavesx.cxx:	myHCrum->addOParent(oParent);
loavesx.cxx:		 Not in a consistent block:  It spawns unbounded work.  */
loavesx.cxx:void Loaf::removeOParent (APTR(OPart) oparent){
loavesx.cxx:	/* remove oparent from the set of upward pointers. */
loavesx.cxx:	myHCrum->removeOParent(oparent);
loavesx.cxx:	{	FLUID_BIND(CurrentTrace,this->hCrum()->hCut()) {
loavesx.cxx:			{	FLUID_BIND(CurrentBertCrum,this->hCrum()->bertCrum()) {
loavesx.cxx:	BEGIN_INSISTENT(2) {
loavesx.cxx:	} END_INSISTENT;
loavesx.cxx:UInt32 Loaf::contentsHash (){
loavesx.cxx:	return this->OPart::contentsHash() ^ myHCrum->hashForEqual();
loavesx.cxx:	/* Make a loaf that transforms the contents of newO. */
loavesx.cxx:	BEGIN_CONSISTENT(11) {
loavesx.cxx:	} END_CONSISTENT;
loavesx.cxx:	/* The contents of newIn must be completely contained in newSplit. 
loavesx.cxx:	BEGIN_CONSISTENT(-1) {
loavesx.cxx:	} END_CONSISTENT;
loavesx.cxx:	/* The contents of newIn must be completely contained in newSplit. 
loavesx.cxx:	BEGIN_CONSISTENT(6) {
loavesx.cxx:	} END_CONSISTENT;
loavesx.cxx:		hisOut = him->copy(split->complement());
loavesx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
loavesx.cxx:		Handle the containment cases using myRegion. */
loavesx.cxx:void OExpandingLoaf::storeRecordingAgents (APTR(RecorderFossil) recorder, APTR(Agenda) agenda){
loavesx.cxx:	agenda->registerItem(this->sensorCrum()->recordingAgent(recorder));
loavesx.cxx:	returnValue = this->hCrum()->mappingTo(trace, region->coordinateSpace()->identityDsp()->restrict(region));
loavesx.cxx:UInt32 OExpandingLoaf::contentsHash (){
loavesx.cxx:	return this->Loaf::contentsHash() ^ myRegion->hashForEqual();
loavesx.cxx:RPTR(FeRangeElement) OR(NULL) DspLoaf::fetch (
loavesx.cxx:	/* Look up the range element for the key.  If it is embedded 
loavesx.cxx:		 structure, then make a virtual range element using the 
loavesx.cxx:	WPTR(FeRangeElement) OR(NULL) 	returnValue;
loavesx.cxx:		APTR(Arrangement) toArrange, 
loavesx.cxx:	/* Make an FeRangeElement for each position. */
loavesx.cxx:RPTR(BeRangeElement) DspLoaf::getBe (APTR(Position) key){
loavesx.cxx:	/* Get or Make the BeRangeElement at the location. */
loavesx.cxx:	WPTR(BeRangeElement) 	returnValue;
loavesx.cxx:	if (externalDsp->isIdentity()) {
loavesx.cxx:	if (externalDsp->isIdentity()) {
loavesx.cxx:void DspLoaf::addOParent (APTR(OPart) oparent){
loavesx.cxx:	/* add oparent to the set of upward pointers and update the 
loavesx.cxx:	this->InnerLoaf::addOParent(oparent);
loavesx.cxx:void DspLoaf::storeRecordingAgents (APTR(RecorderFossil) recorder, APTR(Agenda) agenda){
loavesx.cxx:	myO->storeRecordingAgents(recorder, agenda);
loavesx.cxx:	myO->addOParent(this);
loavesx.cxx:	BEGIN_CONSISTENT(3) {
loavesx.cxx:			myO->removeOParent(this);
loavesx.cxx:	} END_CONSISTENT;
loavesx.cxx:UInt32 DspLoaf::contentsHash (){
loavesx.cxx:	return this->InnerLoaf::contentsHash() ^ myDsp->hashForEqual() ^ myO->hashForEqual();
loavesx.cxx:RPTR(FeRangeElement) OR(NULL) OPartialLoaf::fetch (
loavesx.cxx:		WPTR(FeRangeElement) OR(NULL) 	returnValue;
loavesx.cxx:RPTR(BeRangeElement) OPartialLoaf::getBe (APTR(Position) key){
loavesx.cxx:	/* Get or make the BeRangeElement at the location. */
loavesx.cxx:	SPTR(BeRangeElement) element;
loavesx.cxx:	BEGIN_CONSISTENT(-1) {
loavesx.cxx:				{	FLUID_BIND(CurrentTrace,this->hCrum()->hCut()) {
loavesx.cxx:						{	FLUID_BIND(CurrentBertCrum,BertCrum::make ()) {
loavesx.cxx:								CONSTRUCT(element,BePlaceHolder,(myTrailBlazer, tcsj));
loavesx.cxx:		new (this) RegionLoaf(domain, element, hcrum, hash, info);
loavesx.cxx:	} END_CONSISTENT;
loavesx.cxx:	WPTR(BeRangeElement) 	returnValue;
loavesx.cxx:	returnValue = element;
loavesx.cxx:	/* Return the owner of the atoms represented by the receiver. */
loavesx.cxx:	/* Return the PrimSpec that describes the representation of 
loavesx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
loavesx.cxx:		APTR(Arrangement) toArrange, 
loavesx.cxx:	/* Make an FeRangeElement for each position. */
loavesx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
loavesx.cxx:	/* If the CurrentKeyMaster includes the owner of this loaf
loavesx.cxx:	if (CurrentKeyMaster.fluidGet()->hasAuthority(myOwner)) {
loavesx.cxx:	BEGIN_CONSISTENT(3) {
loavesx.cxx:	} END_CONSISTENT;
loavesx.cxx:	BEGIN_CONSISTENT(3) {
loavesx.cxx:		CONSTRUCT(tmp2,OPartialLoaf,(this->domain()->intersect(region->complement()), HUpperCrum::make (CAST(HUpperCrum,this->hCrum())), CAST(SensorCrum,crums->right()), myOwner, myTrailBlazer));
loavesx.cxx:	} END_CONSISTENT;
loavesx.cxx:		BEGIN_CONSISTENT(1) {
loavesx.cxx:		} END_CONSISTENT;
loavesx.cxx:	BEGIN_CONSISTENT(5) {
loavesx.cxx:	} END_CONSISTENT;
loavesx.cxx:	BEGIN_CONSISTENT(4) {
loavesx.cxx:	} END_CONSISTENT;
loavesx.cxx:	BEGIN_CONSISTENT(2) {
loavesx.cxx:	} END_CONSISTENT;
loavesx.cxx:	BEGIN_CONSISTENT(2) {
loavesx.cxx:	} END_CONSISTENT;
loavesx.cxx:RPTR(FeRangeElement) OR(NULL) OVirtualLoaf::fetch (
loavesx.cxx:		WPTR(FeRangeElement) OR(NULL) 	returnValue;
loavesx.cxx:RPTR(BeRangeElement) OVirtualLoaf::getBe (APTR(Position) key){
loavesx.cxx:	/* Get or make the BeRangeElement at the location. */
loavesx.cxx:	SPTR(BeRangeElement) element;
loavesx.cxx:	BEGIN_CONSISTENT(-1) {
loavesx.cxx:				{	FLUID_BIND(CurrentTrace,this->hCrum()->hCut()) {
loavesx.cxx:						{	FLUID_BIND(CurrentBertCrum,BertCrum::make ()) {
loavesx.cxx:								CONSTRUCT(element,BeDataHolder,(CAST(PrimValue,myData->fetch(key)), tcsj));
loavesx.cxx:		new (this) RegionLoaf(domain, element, hcrum, hash, info);
loavesx.cxx:	} END_CONSISTENT;
loavesx.cxx:	WPTR(BeRangeElement) 	returnValue;
loavesx.cxx:	returnValue = element;
loavesx.cxx:	/* Return the owner of the atoms represented by the receiver. */
loavesx.cxx:		APTR(Arrangement) toArrange, 
loavesx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
loavesx.cxx:	/* If the CurrentKeyMaster includes the owner of this loaf
loavesx.cxx:	if (CurrentKeyMaster.fluidGet()->hasAuthority(myOwner)) {
loavesx.cxx:			BEGIN_CONSISTENT(3) {
loavesx.cxx:			} END_CONSISTENT;
loavesx.cxx:			BEGIN_CONSISTENT(3) {
loavesx.cxx:				CONSTRUCT(tmp2,OVirtualLoaf,(this->domain()->intersect(region->complement()), myData, HUpperCrum::make (CAST(HUpperCrum,this->hCrum())), CAST(SensorCrum,crums->right())));
loavesx.cxx:			} END_CONSISTENT;
loavesx.cxx:			BEGIN_CONSISTENT(5) {
loavesx.cxx:			} END_CONSISTENT;
loavesx.cxx:UInt32 OVirtualLoaf::contentsHash (){
loavesx.cxx:	return this->OExpandingLoaf::contentsHash() ^ myData->contentsHash();
loavesx.cxx:	returnValue = myRangeElement->mappingTo(trace, region->coordinateSpace()->identityDsp()->restrict(region));
loavesx.cxx:RPTR(FeRangeElement) OR(NULL) RegionLoaf::fetch (
loavesx.cxx:		WPTR(FeRangeElement) OR(NULL) 	returnValue;
loavesx.cxx:		returnValue = myRangeElement->makeFe(myLabel);
loavesx.cxx:		APTR(Arrangement) toArrange, 
loavesx.cxx:	/* Make an FeRangeElement for each position. */
loavesx.cxx:		SPTR(FeRangeElement) fe;
loavesx.cxx:		fe = myRangeElement->makeFe(myLabel);
loavesx.cxx:void RegionLoaf::forwardTo (APTR(BeRangeElement) rangeElement){
loavesx.cxx:	BEGIN_CONSISTENT(-1) {
loavesx.cxx:		rangeElement->addOParent(this);
loavesx.cxx:		myRangeElement->removeOParent(this);
loavesx.cxx:		myRangeElement = rangeElement;
loavesx.cxx:	} END_CONSISTENT;
loavesx.cxx:RPTR(BeRangeElement) RegionLoaf::getBe (APTR(Position) key){
loavesx.cxx:		return (BeRangeElement*) myRangeElement;
loavesx.cxx:	/* Return the owner of the atoms represented by the receiver. */
loavesx.cxx:	returnValue = myRangeElement->owner();
loavesx.cxx:	if (myRangeElement->inTrace(trace)) {
loavesx.cxx:	/* Return the PrimSpec that describes the representation of 
loavesx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
loavesx.cxx:	returnValue = Stepper::itemStepper(FeElementBundle::make (bundleRegion, myRangeElement->makeFe(myLabel)));
loavesx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
loavesx.cxx:	/* If the CurrentKeyMaster includes the owner of this loaf
loavesx.cxx:	if (CurrentKeyMaster.fluidGet()->hasAuthority(myRangeElement->owner())) {
loavesx.cxx:		myRangeElement->setOwner(owner);
loavesx.cxx:	aStream << this->getCategory()->name() << "(" << this->domain() << ", " << myRangeElement << ")";
loavesx.cxx:	BEGIN_CONSISTENT(4) {
loavesx.cxx:		CONSTRUCT(tmp1,RegionLoaf,(this->domain()->intersect(region), myLabel, myRangeElement, HUpperCrum::make (CAST(HUpperCrum,this->hCrum()))));
loavesx.cxx:	} END_CONSISTENT;
loavesx.cxx:	BEGIN_CONSISTENT(4) {
loavesx.cxx:		CONSTRUCT(tmp2,RegionLoaf,(this->domain()->intersect(region->complement()), myLabel, myRangeElement, HUpperCrum::make (CAST(HUpperCrum,this->hCrum()))));
loavesx.cxx:	} END_CONSISTENT;
loavesx.cxx:	BEGIN_CONSISTENT(4) {
loavesx.cxx:	} END_CONSISTENT;
loavesx.cxx:		APTR(BeRangeElement) element, 
loavesx.cxx:		, element->sensorCrum()) 
loavesx.cxx:	myRangeElement = element;
loavesx.cxx:	myRangeElement->addOParent(this);
loavesx.cxx:		APTR(BeRangeElement) element, 
loavesx.cxx:		, element->sensorCrum()) 
loavesx.cxx:	if (element->isKindOf(cat_BeEdition)) {
loavesx.cxx:	myRangeElement = element;
loavesx.cxx:	myRangeElement->addOParent(this);
loavesx.cxx:void RegionLoaf::addOParent (APTR(OPart) oparent){
loavesx.cxx:	/* add oparent to the set of upward pointers and update the 
loavesx.cxx:	this->OExpandingLoaf::addOParent(oparent);
loavesx.cxx:		myRangeElement->updateBCrumTo(newBCrum);
loavesx.cxx:	BEGIN_CHOOSE(myRangeElement) {
loavesx.cxx:	myRangeElement->checkRecorders(finder, this->sensorCrum());
loavesx.cxx:	BEGIN_CHOOSE(myRangeElement) {
loavesx.cxx:	range-element identity with other o-leafs.  The range element 
loavesx.cxx:	identity is in myRangeElement rather than myself, so I 
loavesx.cxx:	south one more step to myRangeElement. */
loavesx.cxx:	recorder->delayedStoreMatching(myRangeElement, finder, fossil, hCrumCache);
loavesx.cxx:	BEGIN_CHOOSE(myRangeElement) {
loavesx.cxx:void RegionLoaf::storeRecordingAgents (APTR(RecorderFossil) recorder, APTR(Agenda) agenda){
loavesx.cxx:	recorder->storeRangeElementRecordingAgents(myRangeElement, myRangeElement->sensorCrum(), agenda);
loavesx.cxx:	return (Heaper * ) myRangeElement->hCrum() == child;
loavesx.cxx:	if (!myRangeElement->isKindOf(cat_BePlaceHolder)) {
loavesx.cxx:		myRangeElement->updateBCrumTo(newBCrum);
loavesx.cxx:	BEGIN_CONSISTENT(4) {
loavesx.cxx:		if (::isConstructed(myRangeElement)) {
loavesx.cxx:			myRangeElement->removeOParent(this);
loavesx.cxx:	} END_CONSISTENT;
loavesx.cxx:UInt32 RegionLoaf::contentsHash (){
loavesx.cxx:	return this->OExpandingLoaf::contentsHash() ^ myRangeElement->hashForEqual();
loavesx.cxx:UInt32 SharedData::contentsHash (){
loavesx.cxx:	return this->Abraham::contentsHash() ^ myData->contentsHash();
loavesx.cxx:	returnValue = myData->fetchValue(myArrangement->indexOf(key).asLong());
loavesx.cxx:		APTR(Arrangement) toArrange, 
loavesx.cxx:	arrangement and his arrangement. */
loavesx.cxx:		toArrange->copyElements(toArray, dsp, myData, myArrangement, dsp->inverseOfAll(keys));
loavesx.cxx:SharedData::SharedData (APTR(PrimDataArray) data, APTR(Arrangement) arrange) {
loavesx.cxx:	myArrangement = arrange;
loavesx.cxx:	if ( ! (myData->count() == myArrangement->region()->count().asLong()) ) {
loavesx.cxx:		BLAST(Invalid_arrangement);
loavesx.cxx:RPTR(FeRangeElement) OR(NULL) SplitLoaf::fetch (
loavesx.cxx:	/* Look up the range element for the key.  If it is embedded 
loavesx.cxx:		 structure, then make a virtual range element using the 
loavesx.cxx:		WPTR(FeRangeElement) OR(NULL) 	returnValue;
loavesx.cxx:		WPTR(FeRangeElement) OR(NULL) 	returnValue;
loavesx.cxx:RPTR(BeRangeElement) SplitLoaf::getBe (APTR(Position) key){
loavesx.cxx:	/* Get or Make the BeRangeElement at the location. */
loavesx.cxx:		WPTR(BeRangeElement) 	returnValue;
loavesx.cxx:		WPTR(BeRangeElement) 	returnValue;
loavesx.cxx:	/* This effectively copies the region represented by my distinction. */
loavesx.cxx:	if (mySplit->complement()->intersects(positions)) {
loavesx.cxx:	if (mySplit->complement()->intersects(local)) {
loavesx.cxx:	globalOut = globalIn->complement();
loavesx.cxx:		APTR(Arrangement) toArrange, 
loavesx.cxx:	/* Make an FeRangeElement for each position. */
loavesx.cxx:	myOut->fill(keys->intersect(mySplit->complement()), toArrange, toArray, globalDsp, edition);
loavesx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
loavesx.cxx:		returnValue = myIn->sharedRegion(trace, limitRegion->intersect(mySplit))->unionWith(myOut->sharedRegion(trace, limitRegion->intersect(mySplit->complement())));
loavesx.cxx:	myIn->addOParent(this);
loavesx.cxx:	myOut->addOParent(this);
loavesx.cxx:	myIn->addOParent(this);
loavesx.cxx:	myOut->addOParent(this);
loavesx.cxx:	myIn->addOParent(this);
loavesx.cxx:	myOut->addOParent(this);
loavesx.cxx:	myIn->addOParent(this);
loavesx.cxx:	myOut->addOParent(this);
loavesx.cxx:void SplitLoaf::addOParent (APTR(OPart) oparent){
loavesx.cxx:	/* add oparent to the set of upward pointers and update the 
loavesx.cxx:	this->InnerLoaf::addOParent(oparent);
loavesx.cxx:void SplitLoaf::storeRecordingAgents (APTR(RecorderFossil) recorder, APTR(Agenda) agenda){
loavesx.cxx:	myIn->storeRecordingAgents(recorder, agenda);
loavesx.cxx:	myOut->storeRecordingAgents(recorder, agenda);
loavesx.cxx:	out = myOut->splay(region, mySplit->complement()->intersect(limitRegion));
loavesx.cxx:	BEGIN_CONSISTENT(19) {
loavesx.cxx:				/* The splayed region represents the 
loavesx.cxx:	} END_CONSISTENT;
loavesx.cxx:		 parent to the new loaves first in case the only ent reference
loavesx.cxx:	newIn->addOParent(this);
loavesx.cxx:	newOut->addOParent(this);
loavesx.cxx:	myIn->removeOParent(this);
loavesx.cxx:	myOut->removeOParent(this);
loavesx.cxx:		guarantee the hTree property. Optimization: look at parents of the 
loavesx.cxx:		new loaves to find a pre-existing parent with the same trace and 
loavesx.cxx:	mySplit = mySplit->complement();
loavesx.cxx:	BEGIN_CONSISTENT(4) {
loavesx.cxx:			myIn->removeOParent(this);
loavesx.cxx:			myOut->removeOParent(this);
loavesx.cxx:	} END_CONSISTENT;
loavesx.cxx:UInt32 SplitLoaf::contentsHash (){
loavesx.cxx:	return this->InnerLoaf::contentsHash() ^ mySplit->hashForEqual() ^ myIn->hashForEqual() ^ myOut->hashForEqual();
loavesx.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
loavesx.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
loavesx.hxx:	/* NO CLASS COMMENT */
loavesx.hxx:	static RPTR(Loaf) make (APTR(XnRegion) ARG(region), APTR(BeCarrier) ARG(element));
loavesx.hxx:	static RPTR(Loaf) make (APTR(PrimDataArray) ARG(values), APTR(Arrangement) ARG(arrangement));
loavesx.hxx:	/* Look up the range element for the key.  If it is embedded 
loavesx.hxx:		 structure, then make a virtual range element using the 
loavesx.hxx:	virtual RPTR(FeRangeElement) OR(NULL) fetch (
loavesx.hxx:	/* Fill an array with my contents */
loavesx.hxx:			APTR(Arrangement) ARG(toArrange), 
loavesx.hxx:	/* Get or Make the BeRangeElement at the location. */
loavesx.hxx:	virtual RPTR(BeRangeElement) getBe (APTR(Position) ARG(key)) DEFERRED_FUNC;
loavesx.hxx:		Full containment cases can be handled generically. */
loavesx.hxx:	/* This should probably take a bertCanopyCrum argument, as well. */
loavesx.hxx:	/* add oParent to the set of upward pointers. */
loavesx.hxx:	virtual void addOParent (APTR(OPart) ARG(oParent));
loavesx.hxx:		 Not in a consistent block:  It spawns unbounded work.  */
loavesx.hxx:	/* remove oparent from the set of upward pointers. */
loavesx.hxx:	virtual void removeOParent (APTR(OPart) ARG(oparent));
loavesx.hxx:	directly because our client needs to schedule something else 
loavesx.hxx:	virtual void storeRecordingAgents (APTR(RecorderFossil) ARG(recorder), APTR(Agenda) ARG(agenda)) DEFERRED_SUBR;
loavesx.hxx:	/* A Detector has been added to my parent. Walk down and 
loavesx.hxx:	virtual UInt32 contentsHash ();
loavesx.hxx:	/* NO CLASS COMMENT */
loavesx.hxx:	/* Make a loaf that transforms the contents of newO. */
loavesx.hxx:	/* The contents of newIn must be completely contained in newSplit. 
loavesx.hxx:	/* The contents of newIn must be completely contained in newSplit. 
loavesx.hxx:	virtual RPTR(FeRangeElement) OR(NULL) fetch (
loavesx.hxx:			APTR(Arrangement) ARG(toArrange), 
loavesx.hxx:	/* Get or Make the BeRangeElement at the location. */
loavesx.hxx:	virtual RPTR(BeRangeElement) getBe (APTR(Position) ARG(key)) DEFERRED_FUNC;
loavesx.hxx:	virtual void storeRecordingAgents (APTR(RecorderFossil) ARG(recorder), APTR(Agenda) ARG(agenda)) DEFERRED_SUBR;
loavesx.hxx:		Handle the containment cases using myRegion. */
loavesx.hxx:	virtual void storeRecordingAgents (APTR(RecorderFossil) ARG(recorder), APTR(Agenda) ARG(agenda));
loavesx.hxx:	virtual RPTR(FeRangeElement) OR(NULL) fetch (
loavesx.hxx:	/* Fill an array with my contents */
loavesx.hxx:			APTR(Arrangement) ARG(toArrange), 
loavesx.hxx:	/* Get or Make the BeRangeElement at the location. */
loavesx.hxx:	virtual RPTR(BeRangeElement) getBe (APTR(Position) ARG(key)) DEFERRED_FUNC;
loavesx.hxx:	/* Return the owner of the atoms represented by the receiver. */
loavesx.hxx:	/* If the CurrentKeyMaster includes the owner of this loaf
loavesx.hxx:	/* Return the PrimSpec that describes the representation of 
loavesx.hxx:	will fail!  implementations
loavesx.hxx:	virtual UInt32 contentsHash ();
loavesx.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
loavesx.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
loavesx.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
loavesx.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
nadminp.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
nadminp.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
nadminp.hxx:	virtual CLIENT void endSession (BooleanVar ARG(withPrejudice) = FALSE);
nadminp.hxx:	/* Essential. A system-specific description of the actual 
nadminp.hxx:	virtual CLIENT RPTR(UInt8Array) port ();
nadminp.hxx:	/* automatic 0-argument constructor */
nadminp.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
nadminp.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
nadminp.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
nadminp.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
nadminx.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
nadminx.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
nadminx.cxx:	Ignore other contents. */
nadminx.cxx:		BEGIN_FOR_EACH(FeRangeElement,r,(sub->stepper())) {
nadminx.cxx:	/* Change the entire membership list */
nadminx.cxx:		/* edition->domain()->isEqual(IntegerRegion::make (IntegerVarZero, 3)) && CAST(PrimIntegerArray,CAST(FeArrayBundle,edition->retrieve()->theOne())->array())->contentsEqual(UInt8Array::string("boo")) */
nadminx.cxx:			crutch_Flag = CAST(PrimIntegerArray,CAST(FeArrayBundle,edition->retrieve()->theOne())->array())->contentsEqual(UInt8Array::string("boo"));
nadminx.cxx:/* Makes BooLocks; see the comment there */
nadminx.cxx:/* Makes ChallengeLocks; see the comment there */
nadminx.cxx:/* Makes MatchLocks; see the comment there */
nadminx.cxx:/* Makes MultiLocks; see the comment there */
nadminx.cxx:		/* edition->domain()->isEqual(IntegerRegion::make (IntegerVarZero, 4)) && CAST(PrimIntegerArray,CAST(FeArrayBundle,edition->retrieve()->theOne())->array())->contentsEqual(UInt8Array::string("wall")) */
nadminx.cxx:			crutch_Flag = CAST(PrimIntegerArray,CAST(FeArrayBundle,edition->retrieve()->theOne())->array())->contentsEqual(UInt8Array::string("wall"));
nadminx.cxx:/* Makes WallLocks; see the comment there */
nadminx.cxx:BUILD_FLUID(FeSession,CurrentSession, DefaultSession::make (), ServerChunk::emulsion());	/* in FeSession */
nadminx.cxx:	/* CurrentSessions fluidFetch == NULL
nadminx.cxx:			ifTrue: [^Stepper itemStepper: CurrentSession fluidGet]
nadminx.cxx:				cur _ CurrentSessions fluidGet.
nadminx.cxx:RPTR(FeSession) FeSession::current (){
nadminx.cxx:	returnValue = CurrentSession.fluidGet();
nadminx.cxx:/* Represent a single unique connection to the server over some 
nadminx.cxx:	/* Essential. The clock time at which the connection was initiated. */
nadminx.cxx:	/* Essential. The ID of the club that the session logged into 
nadminx.cxx:	myConnectTime = FeServer::currentTime();
nadminx.cxx:	CurrentSession.fluidSet(this);
nadminx.cxx:which creates it. Each ClubManager has a LockSmith sub-document, and 
nadminx.cxx:LockSmith document Wrapper to create a newLock. The LockSmith then 
nadminx.cxx:stored in the LockSmith document, such as a password or scramblerName. */
nadminx.cxx:	/* This should eventually be done by manipulating the cookbooks */
nadminx.cxx:	if (!FeSession::current()->isLoggedIn()) {
nadminx.cxx:		FeSession::current()->setInitialLogin(myLoginClubID);
nadminx.cxx:	/* Essential. The LockSmith which made this Lock. */
nadminx.cxx:	/* Essential.  This is a very easy lock to open. Just say `boo'. */
nadminx.cxx:/* A ChallengeLock challenges the client with a random piece of data 
nadminx.cxx:identified by the encrypterName. The client must decrypt it using the 
nadminx.cxx:	/* Essential.  The challenge which must be signed correctly 
nadminx.cxx:	/* Essential.  The correctly signed challenge will open the lock. */
nadminx.cxx:		/* this->fetchLoginClubID() != NULL && myResponse->contentsEqual(CAST(UInt8Array,signedChallenge)) */
nadminx.cxx:			crutch_Flag = myResponse->contentsEqual(CAST(UInt8Array,signedChallenge));
nadminx.cxx:Scrambler identified by scramblerName(). The scrambled cleartext 
nadminx.cxx:supplies a password in clear, which is encrypted with the current 
nadminx.cxx:system public key and then sent to the server. There, it is first 
nadminx.cxx:	cs = CurrentServer.fluidGet();
nadminx.cxx:		/* this->fetchLoginClubID() != NULL && CAST(FeMatchLockSmith,this->lockSmith())->scrambledPassword()->contentsEqual(cs->encrypter()->decrypt(CAST(UInt8Array,encrypted))) */
nadminx.cxx:			crutch_Flag = CAST(FeMatchLockSmith,this->lockSmith())->scrambledPassword()->contentsEqual(cs->encrypter()->decrypt(CAST(UInt8Array,encrypted)));
nadminx.cxx:/* A MultiLock allows the client to open the lock with any of a list 
nadminx.cxx:of Locks. This allows a Club to have different passwords for 
nadminx.cxx:different people; or, the Locks can use different kinds of native 
nadminx.cxx:authentication systems such as NIS or Kerberos. */
nadminx.cxx:	/* Essential. The names identifying the locks in the list */
nadminx.cxx:represent groups of users, and to which noone should be able to login 
nadminx.cxx:WallLockSmiths. Or, if you want to make a document read-only, remove 
nadminx.cxx:	/* Essential. A system-specific description of the actual 
nadminx.cxx:	/* automatic 0-argument constructor */
nadminx.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
nadminx.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
nadminx.hxx:	ON_CLIENT(FeClubDescription)
nadminx.hxx:	Ignore other contents. */
nadminx.hxx:	static CLIENT RPTR(FeClubDescription) make (APTR(FeSet) OR(NULL) OF1(FeClub) ARG(membership), APTR(FeLockSmith) ARG(lockSmith) = NULL);
nadminx.hxx:	virtual CLIENT RPTR(FeLockSmith) lockSmith ();
nadminx.hxx:	virtual CLIENT RPTR(FeSet) OF1(FeClub) membership ();
nadminx.hxx:	virtual CLIENT RPTR(FeClubDescription) withLockSmith (APTR(FeLockSmith) ARG(lockSmith));
nadminx.hxx:	/* Change the entire membership list */
nadminx.hxx:	virtual CLIENT RPTR(FeClubDescription) withMembership (APTR(FeSet) OF1(FeClub) ARG(members));
nadminx.hxx:	ON_CLIENT(FeLockSmith)
nadminx.hxx:	/* Makes BooLocks; see the comment there */
nadminx.hxx:	ON_CLIENT(FeBooLockSmith)
nadminx.hxx:	static CLIENT RPTR(FeBooLockSmith) make ();
nadminx.hxx:	/* Makes ChallengeLocks; see the comment there */
nadminx.hxx:	ON_CLIENT(FeChallengeLockSmith)
nadminx.hxx:	static CLIENT RPTR(FeChallengeLockSmith) make (APTR(PrimIntArray) ARG(publicKey), APTR(Sequence) ARG(encrypterName));
nadminx.hxx:	virtual CLIENT RPTR(UInt8Array) encrypterName ();
nadminx.hxx:	virtual CLIENT RPTR(UInt8Array) publicKey ();
nadminx.hxx:	/* Makes MatchLocks; see the comment there */
nadminx.hxx:	ON_CLIENT(FeMatchLockSmith)
nadminx.hxx:	static CLIENT RPTR(FeMatchLockSmith) make (APTR(PrimIntArray) ARG(scrambledPassword), APTR(Sequence) ARG(scramblerName));
nadminx.hxx:	virtual CLIENT RPTR(UInt8Array) scrambledPassword ();
nadminx.hxx:	virtual CLIENT RPTR(UInt8Array) scramblerName ();
nadminx.hxx:	/* Makes MultiLocks; see the comment there */
nadminx.hxx:	ON_CLIENT(FeMultiLockSmith)
nadminx.hxx:	static CLIENT RPTR(FeMultiLockSmith) make ();
nadminx.hxx:	virtual CLIENT RPTR(FeLockSmith) lockSmith (APTR(Sequence) ARG(name));
nadminx.hxx:	virtual CLIENT RPTR(SequenceRegion) OF1(Sequence) lockSmithNames ();
nadminx.hxx:	virtual CLIENT RPTR(FeMultiLockSmith) with (APTR(Sequence) ARG(name), APTR(FeLockSmith) ARG(smith));
nadminx.hxx:	virtual CLIENT RPTR(FeMultiLockSmith) without (APTR(Sequence) ARG(name));
nadminx.hxx:	/* Makes WallLocks; see the comment there */
nadminx.hxx:	ON_CLIENT(FeWallLockSmith)
nadminx.hxx:	static CLIENT RPTR(FeWallLockSmith) make ();
nadminx.hxx:DESIGN_FLUID(FeSession,CurrentSession);	/* in FeSession */
nadminx.hxx:	/* Represent a single unique connection to the server over 
nadminx.hxx:	ON_CLIENT(FeSession)
nadminx.hxx:	/* CurrentSessions fluidFetch == NULL
nadminx.hxx:			ifTrue: [^Stepper itemStepper: CurrentSession fluidGet]
nadminx.hxx:				cur _ CurrentSessions fluidGet.
nadminx.hxx:	static CLIENT RPTR(FeSession) current ();
nadminx.hxx:	/* Essential. The clock time at which the connection was initiated. */
nadminx.hxx:	virtual CLIENT IntegerVar connectTime ();
nadminx.hxx:	/* Essential. Terminate this connection.  If withPrejudice is 
nadminx.hxx:	false, it completes the current request and flushes all 
nadminx.hxx:	virtual CLIENT void endSession (BooleanVar ARG(withPrejudice) = FALSE) DEFERRED_SUBR;
nadminx.hxx:	/* Essential. The ID of the club that the session logged into 
nadminx.hxx:	virtual CLIENT RPTR(ID) initialLogin ();
nadminx.hxx:	virtual CLIENT BooleanVar isConnected () DEFERRED_FUNC;
nadminx.hxx:	/* Essential. A system-specific description of the actual 
nadminx.hxx:	virtual CLIENT RPTR(UInt8Array) port () DEFERRED_FUNC;
nadminx.hxx:	sub-document, and when you ask the server for a Lock to that 
nadminx.hxx:	club, it asks the club`s LockSmith document Wrapper to create 
nadminx.hxx:	document, such as a password or scramblerName. */
nadminx.hxx:	ON_CLIENT(Lock)
nadminx.hxx:	/* Essential. The LockSmith which made this Lock. */
nadminx.hxx:	ON_CLIENT(BooLock)
nadminx.hxx:	/* Essential.  This is a very easy lock to open. Just say `boo'. */
nadminx.hxx:	virtual CLIENT RPTR(FeKeyMaster) boo ();
nadminx.hxx:	/* A ChallengeLock challenges the client with a random piece 
nadminx.hxx:	algorithm identified by the encrypterName. The client must 
nadminx.hxx:	ON_CLIENT(ChallengeLock)
nadminx.hxx:	/* Essential.  The challenge which must be signed correctly 
nadminx.hxx:	virtual CLIENT RPTR(UInt8Array) challenge ();
nadminx.hxx:	/* Essential.  The correctly signed challenge will open the lock. */
nadminx.hxx:	virtual CLIENT RPTR(FeKeyMaster) response (APTR(PrimIntArray) ARG(signedChallenge));
nadminx.hxx:	form, using a Scrambler identified by scramblerName(). The 
nadminx.hxx:	the current system public key and then sent to the server. 
nadminx.hxx:	ON_CLIENT(MatchLock)
nadminx.hxx:	virtual CLIENT RPTR(FeKeyMaster) encryptedPassword (APTR(PrimIntArray) ARG(encrypted));
nadminx.hxx:	/* A MultiLock allows the client to open the lock with any of 
nadminx.hxx:	a list of Locks. This allows a Club to have different 
nadminx.hxx:	passwords for different people; or, the Locks can use 
nadminx.hxx:	different kinds of native authentication systems such as NIS 
nadminx.hxx:	ON_CLIENT(MultiLock)
nadminx.hxx:	virtual CLIENT RPTR(Lock) lock (APTR(Sequence) ARG(name));
nadminx.hxx:	/* Essential. The names identifying the locks in the list */
nadminx.hxx:	virtual CLIENT RPTR(SequenceRegion) lockNames ();
nadminx.hxx:	that represent groups of users, and to which noone should be 
nadminx.hxx:	to make a document read-only, remove all the members from its 
nadminx.hxx:	ON_CLIENT(WallLock)
nadminx.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
nadminx.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
nadminx.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
nadminx.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
nkernelp.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
nkernelp.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
nkernelp.hxx:	/* NO CLASS COMMENT */
nkernelp.hxx:	/* Actually has a persistent individual DataHolder on the Server */
nkernelp.hxx:  public: /* client accessing */
nkernelp.hxx:	virtual RPTR(FeRangeElement) again ();
nkernelp.hxx:	virtual RPTR(BeRangeElement) OR(NULL) fetchBe ();
nkernelp.hxx:	virtual RPTR(BeRangeElement) getOrMakeBe ();
nkernelp.hxx:	/* Actually has a persistent individual PlaceHolder on the 
nkernelp.hxx:	Server, or used to, and now has a pointer to the rangeElement 
nkernelp.hxx:  public: /* client accessing */
nkernelp.hxx:	virtual RPTR(FeRangeElement) again ();
nkernelp.hxx:	virtual BooleanVar canMakeIdentical (APTR(FeRangeElement) ARG(newIdentity));
nkernelp.hxx:	/* Consolidate this PlaceHolder to the newIdentity.  Return 
nkernelp.hxx:			and forward the operation after coercing the newIdentity
nkernelp.hxx:			 to a persistent RangeElement. */
nkernelp.hxx:	/* myRangeElement will tell me to forward to another RangeElement. */
nkernelp.hxx:	virtual void makeIdentical (APTR(FeRangeElement) ARG(newIdentity));
nkernelp.hxx:	/* MyBeRangeElement will know it. */
nkernelp.hxx:	virtual RPTR(BeRangeElement) OR(NULL) fetchBe ();
nkernelp.hxx:	/* myRangeElement has become something else.  Forward to the 
nkernelp.hxx:	virtual void forwardTo (APTR(BeRangeElement) ARG(element));
nkernelp.hxx:	virtual RPTR(BeRangeElement) getOrMakeBe ();
nkernelp.hxx:	FeActualPlaceHolder (APTR(BeRangeElement) ARG(be), TCSJ);
nkernelp.hxx:	CHKPTR(BeRangeElement) myRangeElement;
nkernelp.hxx:	virtual RPTR(FeRangeElement) again ();
nkernelp.hxx:	virtual BooleanVar isIdentical (APTR(FeRangeElement) ARG(other));
nkernelp.hxx:	virtual RPTR(BeRangeElement) OR(NULL) fetchBe ();
nkernelp.hxx:	/* Force the ent to generate a beRangeElement at myKey. */
nkernelp.hxx:	virtual RPTR(BeRangeElement) getOrMakeBe ();
nkernelp.hxx:  public: /* client accessing */
nkernelp.hxx:	virtual RPTR(FeRangeElement) again ();
nkernelp.hxx:	virtual BooleanVar canMakeIdentical (APTR(FeRangeElement) ARG(newIdentity));
nkernelp.hxx:	/* Consolidate this PlaceHolder to the newIdentity.  Return 
nkernelp.hxx:			and coerce both of us and have the BeRangeElements try. */
nkernelp.hxx:	virtual void makeIdentical (APTR(FeRangeElement) ARG(newIdentity));
nkernelp.hxx:	virtual RPTR(BeRangeElement) OR(NULL) fetchBe ();
nkernelp.hxx:	/* Force the ent to generate a beRangeElement at myKey. */
nkernelp.hxx:	virtual RPTR(BeRangeElement) getOrMakeBe ();
nkernelp.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
nkernelp.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
nkernelp.ixx:/* client accessing */
nkernelp.ixx:/* client accessing */
nkernelp.ixx:/* client accessing */
nkernelp.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
nkernelp.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
nkernelt.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
nkernelt.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
nkernelt.cxx:	CurrentKeyMaster.fluidSet(CAST(BooLock,FeServer::loginByName(WorksTester::sequence("Test")))->boo());
nkernelt.cxx:	CurrentKeyMaster.fluidGet()->incorporate(FeKeyMaster::makePublic());
nkernelt.cxx:	CurrentAuthor.fluidSet(testID);
nkernelt.cxx:				BEGIN_FOR_EACH(FeElementBundle,bundle,(doc->copy(cross->extrusion(j, IntegerSpace::make ()->above(IntegerPos::make (10), TRUE)))->retrieve())) {
nkernelt.cxx:					oo << "found " << bundle->element() << " at " << bundle->region() << myCR;
nkernelt.cxx:	edition = edition->with(IntegerPos::make (Int32Zero), FeRangeElement::placeHolder());
nkernelt.cxx:	BEGIN_FOR_POSITIONS(Position,p,FeRangeElement,v,(edition->stepper(IntegerSpace::make ()->interval(IntegerPos::make (IntegerVarZero), IntegerPos::make (2))))) {
nkernelt.cxx:	oo << "combined: " << edition->combine(FeEdition::fromOne(IntegerPos::make (5), FeRangeElement::placeHolder())) << myCR;
nkernelt.cxx:	oo << "replaced: " << edition->replace(FeEdition::fromOne(IntegerPos::make (1), FeRangeElement::placeHolder())) << myCR;
nkernelt.cxx:	oo << "Initial endorsements:" << myCR << "  on Edition: " << e1->endorsements() << myCR << "  on Work: " << w1->endorsements() << myCR << myCR;
nkernelt.cxx:	userRegion = CAST(IDRegion,CurrentAuthor.fluidGet()->asRegion());
nkernelt.cxx:	e1->endorse(FeServer::endorsementRegion(userRegion, userRegion));
nkernelt.cxx:	w1->endorse(FeServer::endorsementRegion(userRegion, CAST(IDRegion,iD->asRegion())));
nkernelt.cxx:	oo << "After endorsing:" << myCR << "  on Edition: " << e1->endorsements() << myCR << "  on Work: " << w1->endorsements() << myCR;
nkernelt.cxx:	e1->retract(FeServer::endorsementRegion(userRegion, userRegion));
nkernelt.cxx:	w1->retract(FeServer::endorsementRegion(userRegion, CAST(IDRegion,iD->asRegion())));
nkernelt.cxx:	oo << "After unendorsing:" << myCR << "  on Edition: " << e1->endorsements() << myCR << "  on Work: " << w1->endorsements() << myCR;
nkernelt.cxx:	AS(SPTR(FeRangeElement),FePlaceHolder) p1;
nkernelt.cxx:	AS(SPTR(FeRangeElement),FePlaceHolder) p2;
nkernelt.cxx:	p1 = FeRangeElement::placeHolder();
nkernelt.cxx:	p2 = FeRangeElement::placeHolder();
nkernelt.cxx:	oo << "Global ID assignment test successful\n";
nkernelt.cxx:	km = CurrentKeyMaster.fluidGet()->copy();
nkernelt.cxx:	{	FLUID_BIND(CurrentKeyMaster,km) {
nkernelt.cxx:			test = CAST(FeClub,FeServer::get(CurrentAuthor.fluidGet()));
nkernelt.cxx:			oo << "Club1 " << FeServer::iDOf(club1) << " is initially " << clubspec->wrap(club1->edition()) << myCR << "and CurrentKeyMaster is " << km->actualAuthority() << myCR << myCR;
nkernelt.cxx:			oo << "Club 2 " << FeServer::iDOf(club2) << " is initially " << clubspec->wrap(club2->edition()) << myCR << "and CurrentKeyMaster is " << km->actualAuthority() << myCR << myCR;
nkernelt.cxx:			oo << "Club 1 should now have Test as a member: " << clubspec->wrap(club1->edition()) << myCR << "So CurrentKeyMaster should have Club 1 authority: " << km->actualAuthority() << myCR << "and Work 1 should have become grabbed: " << work1->canRevise() << myCR << myCR;
nkernelt.cxx:			oo << "Club 2 should now have Club 1 as a member: " << clubspec->wrap(club2->edition()) << myCR << "So CurrentKeyMaster should have Club 2 authority: " << km->actualAuthority() << myCR << "and Work 2 should have become grabbed: " << work2->canRevise() << myCR << myCR;
nkernelt.cxx:			oo << "Club 2 should have Public but not Club 1 as a member: " << clubspec->wrap(club2->edition()) << myCR << "So CurrentKeyMaster should retain Club 2 authority: " << km->actualAuthority() << myCR << "and Work 2 should remain grabbed: " << work2->canRevise() << myCR << myCR;
nkernelt.cxx:			oo << "Club 1 should no longer have Test as a member: " << clubspec->wrap(club1->edition()) << myCR << "So CurrentKeyMaster should not have Club 1 authority: " << km->actualAuthority() << myCR << "and Work 1 should have become released and unreadable:" << " canRevise " << work1->canRevise() << " canRead " << work1->canRead() << myCR << myCR;
nkernelt.cxx:	/* Clean up persistent information in Server */
nkernelt.cxx:	e1prime = CAST(FeEdition,edition->fetch(IntegerPos::make (IntegerVarZero)))->with(IntegerPos::make (1), FeRangeElement::placeHolder());
nkernelt.cxx:	SPTR(FeRangeElement) place;
nkernelt.cxx:	place = FeRangeElement::placeHolder();
nkernelt.cxx:	{	FLUID_BIND(InitialOwner,CurrentAuthor.fluidGet()) {
nkernelt.cxx:			FeEdition::fromArray(PrimSpec::pointer()->arrayWithTwo(work, club), WorksTester::sequence("changeable")->asRegion()->with(WorksTester::sequence("permanent")), SequenceSpace::make ()->ascending());
nkernelt.cxx:	testClub = CAST(FeClub,FeServer::get(CurrentAuthor.fluidGet()));
nkernelt.cxx:	club = FeClub::make (FeClubDescription::make (FeSet::make (CAST(PtrArray,PrimSpec::pointer()->arrayWith(FeServer::get(CurrentAuthor.fluidGet())))), FeWallLockSmith::make ())->edition());
nkernelt.cxx:	w1->sponsor(CAST(IDRegion,CurrentAuthor.fluidGet()->asRegion()));
nkernelt.cxx:	w2->sponsor(CAST(IDRegion,CurrentAuthor.fluidGet()->asRegion()->with(FeServer::iDOf(club))));
nkernelt.cxx:	w1->unsponsor(CAST(IDRegion,CurrentAuthor.fluidGet()->asRegion()));
nkernelt.cxx:	w2->unsponsor(CAST(IDRegion,CurrentAuthor.fluidGet()->asRegion()->with(FeServer::iDOf(club))));
nkernelt.cxx:	/* get rid of persistent info */
nkernelt.cxx:	text = text->extract(CAST(IntegerRegion,IntegerRegion::integerExtent(n / 4, n / 4)->complement()));
nkernelt.cxx:	{	FLUID_BIND(CurrentKeyMaster,CAST(BooLock,FeServer::loginByName(Sequence::string("Test")))->boo()) {
nkernelt.cxx:	{	FLUID_BIND(CurrentKeyMaster,km) {
nkernelt.cxx:	km->removeLogins(CAST(IDRegion,CurrentAuthor.fluidGet()->asRegion()));
nkernelt.cxx:	/* Print the state and contents of a Work */
nkernelt.cxx:	/* automatic 0-argument constructor */
nkernelt.cxx:void WorksTestFillDetector::filled (APTR(FeRangeElement) transclusion){
nkernelt.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
nkernelt.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
nkernelt.hxx:	/* NO CLASS COMMENT */
nkernelt.hxx:	/* Print the state and contents of a Work */
nkernelt.hxx:	/* automatic 0-argument constructor */
nkernelt.hxx:	/* NO CLASS COMMENT */
nkernelt.hxx:	virtual void filled (APTR(FeRangeElement) ARG(transclusion));
nkernelt.hxx:	/* NO CLASS COMMENT */
nkernelt.hxx:	/* NO CLASS COMMENT */
nkernelt.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
nkernelt.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
nkernelt.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
nkernelt.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
nkernelx.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
nkernelx.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
nkernelx.cxx:	/* Essential. The positions in the Edition for which I 
nkernelx.cxx:	describe the contents */
nkernelx.cxx:/* Describes a chunk of information represented as an array. The 
nkernelx.cxx:number of elements in the array are the same as my region, and they 
nkernelx.cxx:	/* Essential. The array of elements in this bundle */
nkernelx.cxx:	/* Essential. The order relating the elements in the array to 
nkernelx.cxx: *                    Class   FeElementBundle 
nkernelx.cxx:RPTR(FeElementBundle) FeElementBundle::make (APTR(XnRegion) region, APTR(FeRangeElement) element){
nkernelx.cxx:	RETURN_CONSTRUCT(FeElementBundle,(region, element));
nkernelx.cxx:hold the same RangeElement. */
nkernelx.cxx:RPTR(FeRangeElement) FeElementBundle::element (){
nkernelx.cxx:	/* Essential. The RangeElement which is at every position in 
nkernelx.cxx:	return (FeRangeElement*) myElement;
nkernelx.cxx:FeElementBundle::FeElementBundle (APTR(XnRegion) region, APTR(FeRangeElement) element) 
nkernelx.cxx:	myElement = element;
nkernelx.cxx:	returnValue = FeKeyMaster::make (CAST(IDRegion,clubID->asRegion()), CurrentGrandMap.fluidGet()->getClub(clubID)->transitiveSuperClubIDs());
nkernelx.cxx:	gm = CurrentGrandMap.fluidGet();
nkernelx.cxx:		CAST(BeClub,CurrentGrandMap.fluidGet()->get(loginClubID))->registerKeyMaster(result);
nkernelx.cxx:	/* Blast if the CurrentKeyMaster doesn't have Admin authority. */
nkernelx.cxx:	if (!CurrentKeyMaster.fluidGet()->hasAuthority(CurrentGrandMap.fluidGet()->adminClubID())) {
nkernelx.cxx:	/* Blast if the CurrentKeyMaster doesn't have signature 
nkernelx.cxx:	authority for the CurrentAuthor. */
nkernelx.cxx:	if (!CurrentKeyMaster.fluidGet()->hasSignatureAuthority(CurrentAuthor.fluidGet())) {
nkernelx.cxx:	/* If there is a currentSponsor, then the CurrentKeyMaster 
nkernelx.cxx:	ckm = CurrentKeyMaster.fluidGet();
nkernelx.cxx:	cgm = CurrentGrandMap.fluidGet();
nkernelx.cxx:client`s activities on the BackEnd. A client can have any number of 
nkernelx.cxx:different KeyMasters, each with different authority. FeServer_login 
nkernelx.cxx:	/* Essential.  The Clubs whose authority is actually being 
nkernelx.cxx:	/* Essential.  A different KeyMaster with the same login and 
nkernelx.cxx:	/* Whether this KeyMaster is currently holding the authority 
nkernelx.cxx:	of the given Club. Equivalent to
nkernelx.cxx:	/* Essential.  Add the other KeyMaster's login and actual 
nkernelx.cxx:		CAST(BeClub,CurrentGrandMap.fluidGet()->get(login))->registerKeyMaster(this);
nkernelx.cxx:	/* Essential.  The Clubs whose authority was obtained 
nkernelx.cxx:	/* Essential.  Remove the listed IDs from the set of Clubs 
nkernelx.cxx:	not hold login authority will be silently ignored. */
nkernelx.cxx:		CAST(BeClub,CurrentGrandMap.fluidGet()->get(login))->unregisterKeyMaster(this);
nkernelx.cxx:	cgm = CurrentGrandMap.fluidGet();
nkernelx.cxx:		myActualAuthority = CAST(IDRegion,myActualAuthority->unionWith(CAST(BeClub,CurrentGrandMap.fluidGet()->get(login))->transitiveSuperClubIDs()));
nkernelx.cxx:	/* Notify all my dependents of a change in authority */
nkernelx.cxx:	returnValue = CurrentGrandMap.fluidGet()->globalIDFilterSpace()->anyFilter(myActualAuthority);
nkernelx.cxx: *                    Class FeRangeElement 
nkernelx.cxx:void FeRangeElement::validateEndorsement (APTR(CrossRegion) endorsements, APTR(FeKeyMaster) km){
nkernelx.cxx:	/* Check whether the endorsements are valid and authorized.
nkernelx.cxx:	if (!endorsements->isFinite()) {
nkernelx.cxx:		BLAST(EndorsementMustBeFinite);
nkernelx.cxx:	FeRangeElement::validateSignature(CAST(IDRegion,endorsements->projection(Int32Zero)), km);
nkernelx.cxx:void FeRangeElement::validateSignature (APTR(IDRegion) clubs, APTR(FeKeyMaster) km){
nkernelx.cxx:RPTR(FeRangeElement) FeRangeElement::placeHolder (){
nkernelx.cxx:	WPTR(FeRangeElement) 	returnValue;
nkernelx.cxx:	returnValue = FePlaceHolder::on(CurrentGrandMap.fluidGet()->newPlaceHolder());
nkernelx.cxx:void FeRangeElement::addFillDetector (APTR(FeFillDetector) detector){
nkernelx.cxx:	/* Essential.  When this PlaceHolder becomes any other kind 
nkernelx.cxx:	of RangeElement, then the Detector will be triggered with the 
nkernelx.cxx:	new RangeElement. If this is already not a PlaceHolder, then 
nkernelx.cxx:	the Detector is triggered immediately with this RangeElement.
nkernelx.cxx:		See FillRangeDetector::filled (RangeElement * newIdentity). */
nkernelx.cxx:BooleanVar FeRangeElement::canMakeIdentical (APTR(FeRangeElement) newIdentity){
nkernelx.cxx:	/* Essential.  Whether the identity of this object could be 
nkernelx.cxx:		Does not check whether the CurrentKeyMaster has authority to do it.
nkernelx.cxx:	can only become another of the same type with the same content. */
nkernelx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:RPTR(FeFillDetector) FeRangeElement::fillDetector (){
nkernelx.cxx:	/* Essential.  Return a FillDetector that will be triggered 
nkernelx.cxx:	when this RangeElement becomes something other than a 
nkernelx.cxx:	PlaceHolder, or immeditely if this RangeElement is not 
nkernelx.cxx:	currently a PlaceHolder.
nkernelx.cxx:		See FillRangeDetector::filled (RangeElement * newIdentity). */
nkernelx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:BooleanVar FeRangeElement::isIdentical (APTR(FeRangeElement) other){
nkernelx.cxx:	/* Essential.  Return whether two objects have the same 
nkernelx.cxx:	identity on the Server.  Note that this can change over time, 
nkernelx.cxx:	if makeIdentical is used.  However, for a given pair of 
nkernelx.cxx:	FeRangeElements, it can only change from not being the same 
nkernelx.cxx:			return vd->isIdentical(this);
nkernelx.cxx:			return vp->isIdentical(this);
nkernelx.cxx:RPTR(ID) FeRangeElement::owner (){
nkernelx.cxx:	/* Essential.  The Club which owns this RangeElement, and has 
nkernelx.cxx:void FeRangeElement::removeFillDetector (APTR(FeFillDetector) detector){
nkernelx.cxx:	/* Essential.  Remove a Detector which had been added to this 
nkernelx.cxx:	RangeElement. You should remove every Detector you add, 
nkernelx.cxx:	although they will go away automatically when a client 
nkernelx.cxx:void FeRangeElement::setOwner (APTR(ID) clubID){
nkernelx.cxx:	/* Essential.  Change the owner; must have the authority of 
nkernelx.cxx:	the current owner. */
nkernelx.cxx:	if (!CurrentKeyMaster.fluidGet()->hasAuthority(this->owner())) {
nkernelx.cxx:	/* Need to make it into a reified range element in order to 
nkernelx.cxx:	CurrentGrandMap.fluidGet()->getClub(clubID);
nkernelx.cxx:RPTR(FeEdition) FeRangeElement::transcluders (
nkernelx.cxx:	/* All Editions which the CurrentKeyMaster can see, which 
nkernelx.cxx:	transclude this RangeElement.
nkernelx.cxx:		If a directFilter is given, then the visibleEndorsements on 
nkernelx.cxx:	visibleEndorsements match the filter.
nkernelx.cxx:	Edition must contain this directly as a RangeElement; 
nkernelx.cxx:	otherwise, indirect containment through Editions is allowed.
nkernelx.cxx:		If the localPresentOnly flag is set, then only Editions 
nkernelx.cxx:	currently known to this Server are guaranteed to end up in 
nkernelx.cxx:		Equivalent to
nkernelx.cxx:			FeServer::current ()->newEditionWith (<any position>, this)
nkernelx.cxx:RPTR(FeEdition) FeRangeElement::works (
nkernelx.cxx:	/* Essential.  Works which contain this RangeElement and can 
nkernelx.cxx:	be read by the CurrentKeyMaster. Returns an IDSpace Edition 
nkernelx.cxx:		If a filter is given, then only Works whose endorsements 
nkernelx.cxx:		If localPresentOnly flag is set, then only Works currently 
nkernelx.cxx:		theFilter = CAST(Filter,CurrentGrandMap.fluidGet()->endorsementFilterSpace()->fullRegion());
nkernelx.cxx:			this->getOrMakeBe()->works(CurrentKeyMaster.fluidGet()->actualAuthority(), theFilter, flags));
nkernelx.cxx:RPTR(BeCarrier) FeRangeElement::carrier (){
nkernelx.cxx:RPTR(FeLabel) FeRangeElement::label (){
nkernelx.cxx:	/* Essential. Return the label attached to this 
nkernelx.cxx:	FeRangeElement. (An FeRangeElement holds a BeRangeElement and 
nkernelx.cxx:	a label.)  All FeRangeElements have a label attached to them 
nkernelx.cxx:	when they are created (in the various Server::newRangeElement 
nkernelx.cxx:	label() will blast if sent to other kinds of FeEditions.) */
nkernelx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:RPTR(FeRangeElement) FeRangeElement::relabelled (APTR(FeLabel) label){
nkernelx.cxx:	/* Essential. Return a new FeRangeElement with the same 
nkernelx.cxx:	identity and contents (i.e. holding the same BeRangeElement), 
nkernelx.cxx:	but with a different label.  (Get new labels from 
nkernelx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:	/* automatic 0-argument constructor */
nkernelx.cxx:FeRangeElement::FeRangeElement() {}
nkernelx.cxx:	returnValue = FeDataHolder::on(CurrentGrandMap.fluidGet()->newDataHolder(value));
nkernelx.cxx:	be->addFeRangeElement(result);
nkernelx.cxx:/* The kind of FeRangeElement that represents a piece of data in the 
nkernelx.cxx:Server, along with its identity. */
nkernelx.cxx:/* client accessing */
nkernelx.cxx:BooleanVar FeDataHolder::canMakeIdentical (APTR(FeRangeElement) newIdentity){
nkernelx.cxx:			and forward the operation after coercing the newIdentity to 
nkernelx.cxx:	a persistent RangeElement. */
nkernelx.cxx:		/* newIdentity->isKindOf(cat_FeDataHolder) && CAST(FeDataHolder,newIdentity)->value()->isEqual(this->value()) */
nkernelx.cxx:		crutch_Flag = newIdentity->isKindOf(cat_FeDataHolder);
nkernelx.cxx:			crutch_Flag = CAST(FeDataHolder,newIdentity)->value()->isEqual(this->value());
nkernelx.cxx:void FeDataHolder::makeIdentical (APTR(FeRangeElement) newIdentity){
nkernelx.cxx:			and forward the operation after coercing the newIdentity to 
nkernelx.cxx:	a persistent RangeElement. */
nkernelx.cxx:	ckm = CurrentKeyMaster.fluidGet();
nkernelx.cxx:		/* newIdentity->isKindOf(cat_FeDataHolder) && CAST(FeDataHolder,newIdentity)->value()->isEqual(this->value()) && ckm->hasAuthority(this->owner()) */
nkernelx.cxx:		crutch_Flag = newIdentity->isKindOf(cat_FeDataHolder);
nkernelx.cxx:			crutch_Flag = CAST(FeDataHolder,newIdentity)->value()->isEqual(this->value());
nkernelx.cxx:			BLAST(CantMakeIdentical);
nkernelx.cxx:	this->getOrMakeBe()->makeIdentical(newIdentity->getOrMakeBe());
nkernelx.cxx:	/* automatic 0-argument constructor */
nkernelx.cxx:	/* An empty Edition, with the given CoordinateSpace but no contents. */
nkernelx.cxx:	returnValue = FeEdition::on(CurrentGrandMap.fluidGet()->newEmptyEdition(keySpace));
nkernelx.cxx:RPTR(FeEdition) FeEdition::fromAll (APTR(XnRegion) keys, APTR(FeRangeElement) value){
nkernelx.cxx:	/* Essential.  A singleton Edition mapping from a Region of 
nkernelx.cxx:	keys (potentially infinite) to a single value. */
nkernelx.cxx:	returnValue = FeEdition::on(CurrentGrandMap.fluidGet()->newEditionWithAll(keys, value->carrier()));
nkernelx.cxx:		APTR(PrimArray) OF1(FeRangeElement) values, 
nkernelx.cxx:	/* Essential.  Creates an Edition mapping from a Region of 
nkernelx.cxx:					CurrentGrandMap.fluidGet()->newDataEdition(data, theKeys, theOrdering));
nkernelx.cxx:					CurrentGrandMap.fluidGet()->newValueEdition(ptr, theKeys, theOrdering));
nkernelx.cxx:RPTR(FeEdition) FeEdition::fromOne (APTR(Position) key, APTR(FeRangeElement) value){
nkernelx.cxx:	returnValue = FeEdition::on(CurrentGrandMap.fluidGet()->newEditionWith(key, value->carrier()));
nkernelx.cxx:	be->addFeRangeElement(result);
nkernelx.cxx:	be->addFeRangeElement(result);
nkernelx.cxx:	/* Essential.  Create a new Edition mapping from each key in 
nkernelx.cxx:	returnValue = FeEdition::on(CurrentGrandMap.fluidGet()->newPlaceHolders(keys));
nkernelx.cxx:/* The kind of FeRangeElement that consists of an immutable 
nkernelx.cxx:organization of RangeElements, indexed by Positions in some CoordinateSpace.
nkernelx.cxx: R1 prohibits cyclic containment.
nkernelx.cxx:Set notation is used in the comments documenting some of the methods 
nkernelx.cxx:	/* Essential.  Return a new FeEdition containing the contents 
nkernelx.cxx:	of boththe receiver and the argument Editions, and with the 
nkernelx.cxx:	they must have the same RangeElement.  Currently the two may 
nkernelx.cxx:	from an implementation restriction to a specification.  The 
nkernelx.cxx:	independent, i.e. a failing combine could otherwise succeed 
nkernelx.cxx:	after the differing range elements were unified (by 
nkernelx.cxx:	FeRangeElement::makeIdentical()).  See FeEdition::mapSharedOnt
nkernelx.cxx:			currently: { k | <k,la,v1> in self and <k,lb,v2> in other } is empty
nkernelx.cxx:			eventually maybe: { k | v1 not same as v2 
nkernelx.cxx:	/* Return a new FeEdition with the label of the current 
nkernelx.cxx:	Edition and the contents of both Editions; where they share 
nkernelx.cxx:	positions, use the contents and labels of the other Edition. 
nkernelx.cxx:	Equivalent to
nkernelx.cxx:			this->copy (other->domain ()->complement ())->combine (other).
nkernelx.cxx:	/* Essential.  Return a new FeEdition containing the contents 
nkernelx.cxx:	and label of the current Edition with the positions 
nkernelx.cxx:	the range, this Edition must have the same RangeElement and 
nkernelx.cxx:	label at all the domain positions.  Currently the mapping 
nkernelx.cxx:	elevate this from an implementation restriction to a 
nkernelx.cxx:			Currently: not exists k1a, k1b : k1a != k1b and <k1a,k2> in 
nkernelx.cxx:			Maybe eventually: for all v1, v2 : <k,l1,v1> in result and 
nkernelx.cxx:RPTR(FeEdition) FeEdition::with (APTR(Position) position, APTR(FeRangeElement) value){
nkernelx.cxx:	/* Return a new FeEditionwith the same contents and label as 
nkernelx.cxx:	RangeElement at a specified position.
nkernelx.cxx:	installs the label attached to the value argument.)
nkernelx.cxx:		Equivalent to:
nkernelx.cxx:			this->replace (FeServer::current ()->makeEditionWith 
nkernelx.cxx:RPTR(FeEdition) FeEdition::withAll (APTR(XnRegion) positions, APTR(FeRangeElement) value){
nkernelx.cxx:	/* Return a new FeEdition with the same contents and label as 
nkernelx.cxx:	by the value argument.
nkernelx.cxx:		Equivalent to:
nkernelx.cxx:			this->replace (FeServer::current ()->makeEditionWithAll 
nkernelx.cxx:	/* Return a new FeEdition with the same contents and label as 
nkernelx.cxx:		Equivalent to:
nkernelx.cxx:			this->copy (position->asRegion ()->complement ()) */
nkernelx.cxx:	/* Return a new FeEdition with the same contents and label as 
nkernelx.cxx:		Equivalent to
nkernelx.cxx:			this->copy (positions->complement ()) */
nkernelx.cxx:	are positions. Equivalent to
nkernelx.cxx:	/* Essential. Retiurn how much space this Edition is taking 
nkernelx.cxx:	sharing it; if totalShared, its entire cost is counted. This 
nkernelx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:	infinite. Equivalent to
nkernelx.cxx:	/* Essential.  Return the region consisting of all the 
nkernelx.cxx:RPTR(FeRangeElement) FeEdition::get (APTR(Position) position){
nkernelx.cxx:	WPTR(FeRangeElement) 	returnValue;
nkernelx.cxx:	/* Return whether the given position is in the Edition. Equivalent to
nkernelx.cxx:	Equivalent to
nkernelx.cxx:	this Edition. Equivalent to
nkernelx.cxx:	/* Essential.  This is the fundamental retrieval operation.  
nkernelx.cxx:	between a region in the domain and the range elements 
nkernelx.cxx:	the data elements.
nkernelx.cxx:	contents will be returned.  If it is not given, the entire 
nkernelx.cxx:	content of the Edition will be returned.
nkernelx.cxx:	returned by the operation can be ordered differently from the 
nkernelx.cxx:	/* The above comment is still horribly insufficient. */
nkernelx.cxx:RPTR(TableStepper) OF1(FeRangeElement) FeEdition::stepper (APTR(XnRegion) region/* = NULL*/, APTR(OrderSpec) ordering/* = NULL*/){
nkernelx.cxx:	RangeElements of this Edition. If a region is specified, then 
nkernelx.cxx:RPTR(FeRangeElement) FeEdition::theOne (){
nkernelx.cxx:	RangeElement at that position; if not, blasts. Equivalent to
nkernelx.cxx:	WPTR(FeRangeElement) 	returnValue;
nkernelx.cxx:BooleanVar FeEdition::isRangeIdentical (APTR(FeEdition) other, APTR(XnRegion) region/* = NULL*/){
nkernelx.cxx:	RangeElement isIdentical to the corresponding RangeElement in 
nkernelx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:	/* Return a mapping such that for each range element that 
nkernelx.cxx:	appearances in the argument edition to some appearance in 
nkernelx.cxx:	unmapped or mapped to multiple appearances in the argument 
nkernelx.cxx:	position.  Such a mapping is suitable as an argument to 
nkernelx.cxx:	'transformedBy', and represents the minimal transformation 
nkernelx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:	/* Essential.  Return a Mapping from each of the positions in 
nkernelx.cxx:	which have the same RangeElement.
nkernelx.cxx:	this Edition whose RangeElements are not in the other Edition.
nkernelx.cxx:		Equivalent to:
nkernelx.cxx:			this->copy (this->sharedRegion (other)->complement ()).
nkernelx.cxx:RPTR(XnRegion) FeEdition::positionsOf (APTR(FeRangeElement) value){
nkernelx.cxx:	Edition at which the given RangeElement can be found.
nkernelx.cxx:		Equivalent to:
nkernelx.cxx:	/* Essential.  Return a new FeEdition containing all Editions 
nkernelx.cxx:	which can be read with the authority of the CurrentKeyMaster, 
nkernelx.cxx:	and which transclude RangeElements in this Edition. 
nkernelx.cxx:	subset at those positions (i.e. equivalent to this->copy 
nkernelx.cxx:		If a directFilter is given, then the endorsements on the 
nkernelx.cxx:	resulting Editions, unioned with the endorsements on any 
nkernelx.cxx:	CurrentKeyMaster has read permission, must pass the filter.
nkernelx.cxx:	whose endorsements (unioned with its readable Works 
nkernelx.cxx:	endorsements) pass the filter. (Giving a non-NULL 
nkernelx.cxx:	RangeElements; otherwise, the result includes Editions which 
nkernelx.cxx:		If the fromTransitiveContents flag is set, then the result 
nkernelx.cxx:	includes transclusions of RangeElements of sub-Editions of 
nkernelx.cxx:	this one, in addition to the RangeElements in this Edition. 
nkernelx.cxx:		If localPresentOnly flag is clear, a persistent request will 
nkernelx.cxx:	are currently known to transclude by this Backend are sure to 
nkernelx.cxx:		theDirectFilter = CAST(Filter,FeServer::endorsementFilterSpace()->fullRegion());
nkernelx.cxx:		theIndirectFilter = CAST(Filter,FeServer::endorsementFilterSpace()->fullRegion());
nkernelx.cxx:	/* Essential.  Return a new FeEdition containing all Works 
nkernelx.cxx:	which contain RangeElements of this Edition and can be read 
nkernelx.cxx:	by the CurrentKeyMaster. Returns an IDSpace Edition full of 
nkernelx.cxx:		If a filter is given, then only Works whose endorsements 
nkernelx.cxx:		If the localPresentOnly flag is clear, a persistent request 
nkernelx.cxx:	it is set, only Works currently known to this Server are sure 
nkernelx.cxx:		If the fromTransitiveContents flag is set, then the result 
nkernelx.cxx:	includes Works which contain RangeElements transitively 
nkernelx.cxx:	directly on Editions which are RangeElements of this Edition 
nkernelx.cxx:		theFilter = CAST(Filter,FeServer::endorsementFilterSpace()->fullRegion());
nkernelx.cxx:	have RangeElements that are in the other Edition.
nkernelx.cxx:	RangeElements which are in the other, but also positions of 
nkernelx.cxx:	Editions which have RangeElements which are in the other, or 
nkernelx.cxx:	RangeElements which are values of the other Edition, but also 
nkernelx.cxx:		If both flags are false, then equivalent to:
nkernelx.cxx:	/* Essential.  Return a new FeEdition consisting of the 
nkernelx.cxx:	subset of this Edition whose RangeElements are in the other 
nkernelx.cxx:	Edition. If the same RangeElement is in this Edition at 
nkernelx.cxx:	several different positions, all positions will be in the 
nkernelx.cxx:	result (provided the RangeElement is also in the other Edition).
nkernelx.cxx:		Equivalent to:
nkernelx.cxx:void FeEdition::endorse (APTR(CrossRegion) additionalEndorsements){
nkernelx.cxx:	/* Essential.  Adds to the endorsements on this Edition.  The 
nkernelx.cxx:	region of additionalEndorsements must consist of a finite 
nkernelx.cxx:	number of (club ID, token ID) pairs.  CurrentKeyMaster must 
nkernelx.cxx:	FeRangeElement::validateEndorsement(additionalEndorsements, CurrentKeyMaster.fluidGet());
nkernelx.cxx:	myBeEdition->endorse(additionalEndorsements);
nkernelx.cxx:RPTR(CrossRegion) FeEdition::endorsements (){
nkernelx.cxx:	/* Essential.  Return all of the endorsements which have been 
nkernelx.cxx:	returnValue = myBeEdition->endorsements();
nkernelx.cxx:void FeEdition::retract (APTR(CrossRegion) endorsements){
nkernelx.cxx:	/* Essential.  Removes endorsements from this Edition.  This 
nkernelx.cxx:	requires that the CurrentKeyMaster hold signature authority 
nkernelx.cxx:	for all of the Clubs whose endorsements are in the list; will 
nkernelx.cxx:	lacking, even if the endorsements weren't there to be 
nkernelx.cxx:	retracted.  Ignores all endorsements which you could have 
nkernelx.cxx:		In the current release removed endorsements aren't 
nkernelx.cxx:	release removed endorsements will become inactive, but it 
nkernelx.cxx:	will be possible to detect that they once had been present.  
nkernelx.cxx:	The intent is for a removed endorsement to be analogous to a 
nkernelx.cxx:	FeRangeElement::validateEndorsement(endorsements, CurrentKeyMaster.fluidGet());
nkernelx.cxx:	myBeEdition->retract(endorsements);
nkernelx.cxx:RPTR(CrossRegion) FeEdition::visibleEndorsements (){
nkernelx.cxx:	/* Essential.  Return all the unretracted endorsements on 
nkernelx.cxx:	which the CurrentKeyMaster has permission to read. */
nkernelx.cxx:	returnValue = myBeEdition->visibleEndorsements();
nkernelx.cxx:	/* Essential.  Connect a FillRangeDetector to the underlying 
nkernelx.cxx:	Edition become any other kind of RangeElement, then the 
nkernelx.cxx:	RangeElements (but not necessarily at the same positions, or 
nkernelx.cxx:	with those RangeElements.
nkernelx.cxx:		See FillRangeDetector::allFilled (Edition * newIdentities). */
nkernelx.cxx:RPTR(XnRegion) FeEdition::canMakeRangeIdentical (APTR(FeEdition) newIdentities, APTR(XnRegion) positions/* = NULL*/){
nkernelx.cxx:	/* Essential.  Return the region consisting of all locations 
nkernelx.cxx:	at which my RangeElements can NOT be made identical to the 
nkernelx.cxx:	corresponding RangeElements in the other Edition. (This seems 
nkernelx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:	/* Essential.  Return a FillRangeDetector so that when any of 
nkernelx.cxx:	RangeElement, then the Detector will be triggered with an 
nkernelx.cxx:	Edition containing the new RangeElements (but not necessarily 
nkernelx.cxx:	triggered immediately with those RangeElements.
nkernelx.cxx:		See FillRangeDetector::allFilled (Edition * newIdentities). */
nkernelx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:RPTR(FeEdition) FeEdition::makeRangeIdentical (APTR(FeEdition) newIdentities, APTR(XnRegion) positions/* = NULL*/){
nkernelx.cxx:	/* Essential.  Try to change the identity of each 
nkernelx.cxx:	RangeElements of this Edition which are in the Region (or all 
nkernelx.cxx:	if no Region supplied) to that of the RangeElement at the 
nkernelx.cxx:	this Edition which did not end up with the new identities, because of
nkernelx.cxx:			- different contents
nkernelx.cxx:			- contents of other edition unreadable
nkernelx.cxx:			- no corresponding new identity
nkernelx.cxx:	Note that the labels on the RangeElements need not match and 
nkernelx.cxx:	if (!this->coordinateSpace()->isEqual(newIdentities->coordinateSpace())) {
nkernelx.cxx:	never = CurrentGrandMap.fluidGet()->newEmptyEdition(this->coordinateSpace());
nkernelx.cxx:	trial = newIdentities->beEdition()->copy(theRegion);
nkernelx.cxx:	/* The owners of all the RangeElements in the given Region, 
nkernelx.cxx:	or in the entire 
nkernelx.cxx:	/* Essential.  Remove a Detector which had been added to this 
nkernelx.cxx:	they will go away automatically when a client session terminates. */
nkernelx.cxx:	/* Changes the owner of all RangeElements in the Edition (but 
nkernelx.cxx:	current owner of each range element. If a Region is supplied, 
nkernelx.cxx:	unchanged.  Equivalent to
nkernelx.cxx:	non-edition RangeElement is at the given position.
nkernelx.cxx:RPTR(FeRangeElement) FeEdition::relabelled (APTR(FeLabel) label){
nkernelx.cxx:	WPTR(FeRangeElement) 	returnValue;
nkernelx.cxx:RPTR(FeRangeElement) FeEdition::fetch (APTR(Position) position){
nkernelx.cxx:	WPTR(FeRangeElement) 	returnValue;
nkernelx.cxx:RPTR(BeRangeElement) OR(NULL) FeEdition::fetchBe (){
nkernelx.cxx:RPTR(BeRangeElement) FeEdition::getOrMakeBe (){
nkernelx.cxx:/* client implementation */
nkernelx.cxx:RPTR(FeRangeElement) FeEdition::again (){
nkernelx.cxx:BooleanVar FeEdition::canMakeIdentical (APTR(FeRangeElement) newIdentity){
nkernelx.cxx:	if (!this->isIdentical(newIdentity)) {
nkernelx.cxx:		BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:void FeEdition::makeIdentical (APTR(FeRangeElement) newIdentity){
nkernelx.cxx:	if (!this->isIdentical(newIdentity)) {
nkernelx.cxx:		BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:			BEGIN_KIND(FeElementBundle,range) {
nkernelx.cxx:				oo << range->element();
nkernelx.cxx:	/* Whether the given position is in the Edition. Equivalent to
nkernelx.cxx:RPTR(XnRegion) FeEdition::keysOf (APTR(FeRangeElement) value){
nkernelx.cxx:	RangeElement can be found. Equivalent to
nkernelx.cxx:	myBeEdition->removeFeRangeElement(this);
nkernelx.cxx:	this->FeRangeElement::destruct();
nkernelx.cxx:	/* Essential. Make a single IDHolder with the given ID. 
nkernelx.cxx:	Tentative feature. */
nkernelx.cxx:	returnValue = FeIDHolder::on(CurrentGrandMap.fluidGet()->newIDHolder(iD));
nkernelx.cxx:	be->addFeRangeElement(result);
nkernelx.cxx:/* An object for having an ID in the range of an Edition. Tentative feature. */
nkernelx.cxx:RPTR(FeRangeElement) FeIDHolder::again (){
nkernelx.cxx:BooleanVar FeIDHolder::canMakeIdentical (APTR(FeRangeElement) newIdentity){
nkernelx.cxx:	if (!this->isIdentical(newIdentity)) {
nkernelx.cxx:		BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:	/* Essential.  The ID in this holder. */
nkernelx.cxx:void FeIDHolder::makeIdentical (APTR(FeRangeElement) newIdentity){
nkernelx.cxx:	if (!this->isIdentical(newIdentity)) {
nkernelx.cxx:		BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:RPTR(BeRangeElement) OR(NULL) FeIDHolder::fetchBe (){
nkernelx.cxx:RPTR(BeRangeElement) FeIDHolder::getOrMakeBe (){
nkernelx.cxx:	myBeIDHolder->removeFeRangeElement(this);
nkernelx.cxx:	this->FeRangeElement::destruct();
nkernelx.cxx:	/* Essential. Create a new unique Label */
nkernelx.cxx:		label->addFeRangeElement(result);
nkernelx.cxx:/* An identity attached to a RangeElement within an Edition. */
nkernelx.cxx:RPTR(BeRangeElement) OR(NULL) FeLabel::fetchBe (){
nkernelx.cxx:RPTR(BeRangeElement) FeLabel::getOrMakeBe (){
nkernelx.cxx:		myBeLabel = CurrentGrandMap.fluidGet()->newLabel();
nkernelx.cxx:		myBeLabel->addFeRangeElement(this);
nkernelx.cxx:/* client accessing */
nkernelx.cxx:RPTR(FeRangeElement) FeLabel::again (){
nkernelx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:BooleanVar FeLabel::canMakeIdentical (APTR(FeRangeElement) newIdentity){
nkernelx.cxx:	if (!this->isIdentical(newIdentity)) {
nkernelx.cxx:		BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:void FeLabel::makeIdentical (APTR(FeRangeElement) newIdentity){
nkernelx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:		myBeLabel->removeFeRangeElement(this);
nkernelx.cxx:	this->FeRangeElement::destruct();
nkernelx.cxx:RPTR(FePlaceHolder) FePlaceHolder::on (APTR(BeRangeElement) be){
nkernelx.cxx:	SPTR(FeRangeElement) result;
nkernelx.cxx:	be->addFeRangeElement(result);
nkernelx.cxx:/* Represents a piece of pure identity in the Server. */
nkernelx.cxx:	/* automatic 0-argument constructor */
nkernelx.cxx:RPTR(FeWork) FeWork::make (APTR(FeEdition) contents){
nkernelx.cxx:	/* Essential.  Create a new Work whose initial contents are 
nkernelx.cxx:	KeyMaster come from the fluid environment. If the KeyMaster 
nkernelx.cxx:	returnValue = CurrentGrandMap.fluidGet()->newWork(contents)->makeLockedFeWork();
nkernelx.cxx:	be->addFeRangeElement(result);
nkernelx.cxx:/* A persistent identity for a changeable object. */
nkernelx.cxx:	/* Essential.  Add a detector which will be notified whenever 
nkernelx.cxx:	released, then returns whether the CurrentKeyMaster has 
nkernelx.cxx:	sufficient permission to read the work.  (Read or Edit 
nkernelx.cxx:	ckm = CurrentKeyMaster.fluidFetch();
nkernelx.cxx:	/* Essential.  Grab the Work to prevent other clients from 
nkernelx.cxx:	CurrentKeyMaster and CurrentAuthor (to be used to maintain 
nkernelx.cxx:			- the CurrentKeyMaster does not have edit permission
nkernelx.cxx:			- the CurrentKeyMaster does not have signature authority of 
nkernelx.cxx:	the CurrentAuthor
nkernelx.cxx:	by loss of connection} it will be deallocated 'eventually') */
nkernelx.cxx:	if (!myBeWork->canBeEditedBy(CurrentKeyMaster.fluidGet())) {
nkernelx.cxx:	if (!CurrentKeyMaster.fluidGet()->hasSignatureAuthority(CurrentAuthor.fluidGet())) {
nkernelx.cxx:	myAuthor = CurrentAuthor.fluidFetch();
nkernelx.cxx:	myKeyMaster = CurrentKeyMaster.fluidFetch();
nkernelx.cxx:	/* Essential.  If you have edit authority, and someone has 
nkernelx.cxx:	value of his CurrentAuthor when he grabbed it; otherwise blast.
nkernelx.cxx:	who can read the current trail can see the revision, but the 
nkernelx.cxx:	ckm = CurrentKeyMaster.fluidGet();
nkernelx.cxx:	/* Essential.  Release the grab on this Work; if a 
nkernelx.cxx:	/* Essential.  Last detector has gone away */
nkernelx.cxx:	/* Essential.  Registers a request so that the next time this 
nkernelx.cxx:	outstanding the CurrentKeyMaster (as of making the request) 
nkernelx.cxx:	CurrentAuthor (as of making the request), it will be grabbed 
nkernelx.cxx:		if (!myBeWork->canBeEditedBy(CurrentKeyMaster.fluidGet())) {
nkernelx.cxx:		if (!CurrentKeyMaster.fluidGet()->hasSignatureAuthority(CurrentAuthor.fluidGet())) {
nkernelx.cxx:		myAuthor = CurrentAuthor.fluidFetch();
nkernelx.cxx:		myKeyMaster = CurrentKeyMaster.fluidFetch();
nkernelx.cxx:	myKeyMaster = CurrentKeyMaster.fluidGet();
nkernelx.cxx:	myAuthor = CurrentAuthor.fluidGet();
nkernelx.cxx:	/* Essential.  Return a detector which will be notified 
nkernelx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:/* contents */
nkernelx.cxx:	/* Essential.  Return the current Edition.  Succeeds if the 
nkernelx.cxx:	Work is already grabbed, or if the CurrentKeyMaster has 
nkernelx.cxx:	/* Essential.  Change the current Edition of this work to 
nkernelx.cxx:		 (This is the fundamental write operation.) */
nkernelx.cxx:	{	FLUID_BIND(CurrentKeyMaster,myKeyMaster) {
nkernelx.cxx:			{	FLUID_BIND(CurrentAuthor,myAuthor) {
nkernelx.cxx:	/* Essential.  Return the club which has permission to revise 
nkernelx.cxx:	/* Essential. Return the club which will be recorded as the 
nkernelx.cxx:	/* Essential.  Return the club which has permission to read 
nkernelx.cxx:	/* Essential.  Irrevocably remove edit permission. Requires 
nkernelx.cxx:	if (!CurrentKeyMaster.fluidGet()->hasAuthority(this->owner())) {
nkernelx.cxx:	/* Essential.  Irrevocably remove read permission (although 
nkernelx.cxx:	if (!CurrentKeyMaster.fluidGet()->hasAuthority(this->owner())) {
nkernelx.cxx:	/* Essential.  Change who has edit permission. Requires 
nkernelx.cxx:	if (!CurrentKeyMaster.fluidGet()->hasAuthority(this->owner())) {
nkernelx.cxx:	/* Essential.  Change the initial read Club for frozen Works 
nkernelx.cxx:	if (!CurrentKeyMaster.fluidGet()->hasAuthority(this->owner())) {
nkernelx.cxx:	/* Essential.  Change who has read permission. Requires 
nkernelx.cxx:	if (!CurrentKeyMaster.fluidGet()->hasAuthority(this->owner())) {
nkernelx.cxx:void FeWork::endorse (APTR(CrossRegion) additionalEndorsements){
nkernelx.cxx:	/* Essential.  Adds to the endorsements on this Work. The set 
nkernelx.cxx:	of endorsements must be a finite number of (club ID, token 
nkernelx.cxx:	FeRangeElement::validateEndorsement(additionalEndorsements, CurrentKeyMaster.fluidGet());
nkernelx.cxx:	myBeWork->endorse(additionalEndorsements);
nkernelx.cxx:RPTR(CrossRegion) FeWork::endorsements (){
nkernelx.cxx:	/* Essential.  Return all of the endorsements which have been 
nkernelx.cxx:	placed on this Work and are not currently retracted.
nkernelx.cxx:		(Endorsements are used to filter various operations which 
nkernelx.cxx:	one way to find this work by filtering for its endorsements.) */
nkernelx.cxx:	returnValue = myBeWork->endorsements();
nkernelx.cxx:void FeWork::retract (APTR(CrossRegion) removedEndorsements){
nkernelx.cxx:	/* Essential.  Removes endorsements from this Work. This 
nkernelx.cxx:	endorsements are in the list; will blast and do nothing if 
nkernelx.cxx:	endorsements which you could have removed, but which don't 
nkernelx.cxx:	FeRangeElement::validateEndorsement(removedEndorsements, CurrentKeyMaster.fluidGet());
nkernelx.cxx:	myBeWork->retract(removedEndorsements);
nkernelx.cxx:	/* Essential.  Add to the list of sponsors of this Work. 
nkernelx.cxx:	FeRangeElement::validateSignature(clubs, CurrentKeyMaster.fluidGet());
nkernelx.cxx:	/* Essential.  All of the Clubs which are sponsoring this 
nkernelx.cxx:	/* Essential.  End sponsorship of this Work by all of the 
nkernelx.cxx:	Clubs in the set, even if they are not currently sponsors.
nkernelx.cxx:		Should this use the CurrentKeyMaster? Or the internal 
nkernelx.cxx:	FeRangeElement::validateSignature(clubs, CurrentKeyMaster.fluidGet());
nkernelx.cxx:/* server contents */
nkernelx.cxx:		APTR(FeEdition) contents, 
nkernelx.cxx:			CAST(FeRevisionDetector,pair->right())->revised(this, contents, author, time, sequence);
nkernelx.cxx:RPTR(BeRangeElement) OR(NULL) FeWork::fetchBe (){
nkernelx.cxx:RPTR(BeRangeElement) FeWork::getOrMakeBe (){
nkernelx.cxx:	myBeWork->removeFeRangeElement(this);
nkernelx.cxx:	this->FeRangeElement::destruct();
nkernelx.cxx:		oo << " contents: " << this->edition();
nkernelx.cxx:RPTR(FeRangeElement) FeWork::again (){
nkernelx.cxx:BooleanVar FeWork::canMakeIdentical (APTR(FeRangeElement) newIdentity){
nkernelx.cxx:	if (!this->isIdentical(newIdentity)) {
nkernelx.cxx:		BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:void FeWork::makeIdentical (APTR(FeRangeElement) newIdentity){
nkernelx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:	/* Essential. Trigger a Detector whenever there is a revision 
nkernelx.cxx:	to the Work which the CurrentKeyMaster can see. If this 
nkernelx.cxx:	associated with it is replaced with the CurrentKeyMaster.
nkernelx.cxx:		See RevisionDetector::revised (Edition * contents,
nkernelx.cxx:	myRevisionDetectors->introduce(Pair::make (CurrentKeyMaster.fluidGet(), detector));
nkernelx.cxx:	its current Edition, or its creation if it hasn't been 
nkernelx.cxx:	CurrentKeyMaster must be able to exercise the authority of 
nkernelx.cxx:	its current Edition, or its creation if it hasn't been 
nkernelx.cxx:	CurrentKeyMaster must be able to exercise the authority of 
nkernelx.cxx:	/* The time of the last revision of this Work to its current 
nkernelx.cxx:	Work must be grabbed, or the CurrentKeyMaster must be able to 
nkernelx.cxx:	/* Essential. Inform the work that its last revision detector 
nkernelx.cxx:	/* Essential. Return a detector tht will trigger whenever 
nkernelx.cxx:	there is a revision to the Work which the CurrentKeyMaster can see.
nkernelx.cxx:		See RevisionDetector::revised (Edition * contents,
nkernelx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:	/* self canRead or CurrentKeyMaster has authority of the historyClub */
nkernelx.cxx:	ckm = CurrentKeyMaster.fluidFetch();
nkernelx.cxx:	/* Essential.  Create a new Club whose initial status is 
nkernelx.cxx:	editor and owner are taken from the current settings. If the 
nkernelx.cxx:	by the CurrentSponsor.
nkernelx.cxx:	return CAST(FeClub,CurrentGrandMap.fluidGet()->newClub(status)->makeLockedFeWork());
nkernelx.cxx:	be->addFeRangeElement(result);
nkernelx.cxx:/* A persistent Club on the Server. */
nkernelx.cxx:	/* Essential.  Irrevocably remove signature authority for 
nkernelx.cxx:	if (!CurrentKeyMaster.fluidGet()->hasAuthority(this->owner())) {
nkernelx.cxx:	/* Essential.  Change who has signature authority for this 
nkernelx.cxx:	if (!CurrentKeyMaster.fluidGet()->hasAuthority(this->owner())) {
nkernelx.cxx:	/* Essential. The Club which has 'signature authority' for 
nkernelx.cxx:	/* Essential.  All of the Works sponsored by this Club. If a 
nkernelx.cxx:			/* filter == NULL || filter->match(be->endorsements()) */
nkernelx.cxx:				crutch_Flag = filter->match(be->endorsements());
nkernelx.cxx:			CurrentGrandMap.fluidGet()->newValueEdition(array, iDSpace->newIDs(array->count()), iDSpace->getAscending()));
nkernelx.cxx:BUILD_FLUID(FeServer,CurrentServer, NULL, ServerChunk::emulsion());	/* in FeServer */
nkernelx.cxx:BUILD_FLUID(FeKeyMaster,CurrentKeyMaster, NULL, ServerChunk::emulsion());	/* in FeServer */
nkernelx.cxx:BUILD_FLUID(ID,CurrentAuthor, NULL, ServerChunk::emulsion());	/* in FeServer */
nkernelx.cxx:RPTR(FilterSpace) FeServer::endorsementFilterSpace (){
nkernelx.cxx:	/* The CoordinateSpace used for filtering endorsements on 
nkernelx.cxx:	this Server. Equivalent to
nkernelx.cxx:			this->filterSpace (this->endorsementSpace ()) */
nkernelx.cxx:	returnValue = CurrentGrandMap.fluidGet()->endorsementFilterSpace();
nkernelx.cxx:RPTR(CrossRegion) OF2(IDRegion,IDRegion) FeServer::endorsementRegion (APTR(IDRegion) OR(NULL) clubs, APTR(IDRegion) OR(NULL) tokens){
nkernelx.cxx:	/* A set of endorsements for each Club endorsing with each token */
nkernelx.cxx:	returnValue = FeServer::endorsementSpace()->crossOfRegions(CAST(PtrArray,PrimSpec::pointer()->arrayWithTwo(clubs, tokens)));
nkernelx.cxx:RPTR(CrossSpace) OF2(IDSpace,IDSpace) FeServer::endorsementSpace (){
nkernelx.cxx:	/* A set of endorsements for each Club endorsing with each token */
nkernelx.cxx:	returnValue = CurrentGrandMap.fluidGet()->endorsementSpace();
nkernelx.cxx:	/* Return true if the current session has successfully logged 
nkernelx.cxx:	returnValue = CurrentServer.fluidGet();
nkernelx.cxx:	CurrentServer.fluidSet(result);
nkernelx.cxx:	returnValue = CurrentServer.fluidGet();
nkernelx.cxx:	/* Essential.  The ID of the System Access Club. */
nkernelx.cxx:	returnValue = CurrentGrandMap.fluidGet()->accessClubID();
nkernelx.cxx:	/* Essential.  The ID of the System Admin Club. */
nkernelx.cxx:	returnValue = CurrentGrandMap.fluidGet()->adminClubID();
nkernelx.cxx:	/* Essential.  The ID of the System Archive Club. */
nkernelx.cxx:	returnValue = CurrentGrandMap.fluidGet()->archiveClubID();
nkernelx.cxx:	/* Essential.  The ID of the Universal Empty Club. */
nkernelx.cxx:	returnValue = CurrentGrandMap.fluidGet()->emptyClubID();
nkernelx.cxx:	/* Essential. The encryption scheme to be used for sending 
nkernelx.cxx:	returnValue = CurrentServer.fluidGet()->getEncrypterName();
nkernelx.cxx:	/* Essential.  Return a lock which, if satisfied, will give a 
nkernelx.cxx:	cgm = CurrentGrandMap.fluidGet();
nkernelx.cxx:		/* club != NULL && (FeSession::current()->isLoggedIn() || cgm->getClub(FeServer::accessClubID())->membershipIncludes(club)) */
nkernelx.cxx:			crutch_Flag = FeSession::current()->isLoggedIn();
nkernelx.cxx:	/* Essential.  Return a lock which, if satisfied, will give a 
nkernelx.cxx:	cgm = CurrentGrandMap.fluidGet();
nkernelx.cxx:		/* club != NULL && (FeSession::current()->isLoggedIn() || cgm->getClub(FeServer::accessClubID())->membershipIncludes(club)) */
nkernelx.cxx:			crutch_Flag = FeSession::current()->isLoggedIn();
nkernelx.cxx:	/* Essential.  The ID of the Universal Public Club. */
nkernelx.cxx:	returnValue = CurrentGrandMap.fluidGet()->publicClubID();
nkernelx.cxx:	/* Essential. The public key to be used for sending sensitive 
nkernelx.cxx:	returnValue = CurrentServer.fluidGet()->encrypter()->publicKey();
nkernelx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:NOACK FeServer::setCurrentAuthor (APTR(ID) iD){
nkernelx.cxx:	/* Set the Server side fluid for the CurrentAuthor. */
nkernelx.cxx:	CurrentAuthor.fluidSet(iD);
nkernelx.cxx:NOACK FeServer::setCurrentKeyMaster (APTR(FeKeyMaster) km){
nkernelx.cxx:	/* Set the Server side fluid for the CurrentKeyMaster. */
nkernelx.cxx:	CurrentKeyMaster.fluidSet(km);
nkernelx.cxx:RPTR(ID) FeServer::assignID (APTR(FeRangeElement) range, APTR(ID) iD/* = NULL*/){
nkernelx.cxx:	/* Essential.  Assign a new global ID to a RangeElement. If 
nkernelx.cxx:	CurrentKeyMaster must have been granted authority to assign 
nkernelx.cxx:	gm = CurrentGrandMap.fluidGet();
nkernelx.cxx:	if (!CurrentKeyMaster.fluidGet()->hasAuthority(gm->grantAt(iD))) {
nkernelx.cxx:	returnValue = CurrentGrandMap.fluidGet()->clubDirectoryID();
nkernelx.cxx:RPTR(FeRangeElement) FeServer::get (APTR(ID) iD){
nkernelx.cxx:	/* Essential.  Get the object associated with the given 
nkernelx.cxx:	WPTR(FeRangeElement) 	returnValue;
nkernelx.cxx:	returnValue = CurrentGrandMap.fluidGet()->getFe(iD);
nkernelx.cxx:RPTR(ID) FeServer::iDOf (APTR(FeRangeElement) value){
nkernelx.cxx:	assigned to this RangeElement. Blast if there is none, or 
nkernelx.cxx:		Equivalent to
nkernelx.cxx:	SPTR(BeRangeElement) be;
nkernelx.cxx:		returnValue = CurrentGrandMap.fluidGet()->iDOf(be);
nkernelx.cxx:RPTR(IDRegion) FeServer::iDsOf (APTR(FeRangeElement) value){
nkernelx.cxx:	/* Essential.  Find all the global IDs on this Server that 
nkernelx.cxx:	have been assigned to this RangeElement */
nkernelx.cxx:	SPTR(BeRangeElement) be;
nkernelx.cxx:		returnValue = CurrentGrandMap.fluidGet()->iDsOf(be);
nkernelx.cxx:	assigned to any of the RangeElements in an Edition */
nkernelx.cxx:	/* fix this grossly inefficient algorithm so that at least it 
nkernelx.cxx:	BEGIN_FOR_EACH(FeRangeElement,value,(edition->stepper())) {
nkernelx.cxx:		SPTR(BeRangeElement) be;
nkernelx.cxx:			result = result->unionWith(CurrentGrandMap.fluidGet()->iDsOf(be));
nkernelx.cxx:IntegerVar FeServer::currentTime (){
nkernelx.cxx:	/* The current clock time on the Server, in seconds since the 
nkernelx.cxx:	/* The LockSmith which hands out locks when a client tries to 
nkernelx.cxx:	return CAST(FeLockSmith,FeLockSmith::spec()->wrap(CurrentGrandMap.fluidGet()->gateLockSmithEdition()));
nkernelx.cxx:RPTR(Sequence) FeServer::identifier (){
nkernelx.cxx:	/* Essential. A sequence of numbers uniquely identifying this Server */
nkernelx.cxx:	returnValue = CurrentGrandMap.fluidGet()->identifier();
nkernelx.cxx:	/* This is currently a no-op. */
nkernelx.cxx:	/* Essential.  The Detector will be triggered when the 
nkernelx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:	/* Essential.  The Detector will be triggered when the 
nkernelx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:	/* Essential.  The Detector will be triggered when the 
nkernelx.cxx:	current state of the Server has been reliably written to disk.
nkernelx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:	/* Essential.  The Detector will be triggered when the 
nkernelx.cxx:	current state of the Server has been reliably written to disk.
nkernelx.cxx:	CurrentPacker.fluidGet()->purge();
nkernelx.cxx:/* The fundamental Server object. Used for managing the global name 
nkernelx.cxx:management operations.
nkernelx.cxx:	FeServer defineClientFluid: #CurrentServer with: Listener emulsion 
nkernelx.cxx:CurrentKeyMaster - a KeyMaster for providing authority to read and/or edit
nkernelx.cxx:CurrentAuthor - the ID of the Club under whose name Work revisions 
nkernelx.cxx:InitialOwner - the ID of the Club which owns newly created RangeElements
nkernelx.cxx:	/* Essential. A specification for arrays of pointers. */
nkernelx.cxx:	/* Essential. The encryption scheme to be used for sending 
nkernelx.cxx:/* Actually has a persistent individual DataHolder on the Server */
nkernelx.cxx:/* client accessing */
nkernelx.cxx:RPTR(FeRangeElement) FeActualDataHolder::again (){
nkernelx.cxx:RPTR(BeRangeElement) OR(NULL) FeActualDataHolder::fetchBe (){
nkernelx.cxx:RPTR(BeRangeElement) FeActualDataHolder::getOrMakeBe (){
nkernelx.cxx:	myBeDataHolder->removeFeRangeElement(this);
nkernelx.cxx:/* Actually has a persistent individual PlaceHolder on the Server, or 
nkernelx.cxx:used to, and now has a pointer to the rangeElement it became. */
nkernelx.cxx:/* client accessing */
nkernelx.cxx:RPTR(FeRangeElement) FeActualPlaceHolder::again (){
nkernelx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:	/* This must hold onto an FeRangeElement so that the label is 
nkernelx.cxx:	BEGIN_CHOOSE(myRangeElement) {
nkernelx.cxx:			WPTR(FeRangeElement) 	returnValue;
nkernelx.cxx:			returnValue = myRangeElement->makeFe(NULL);
nkernelx.cxx:BooleanVar FeActualPlaceHolder::canMakeIdentical (APTR(FeRangeElement) newIdentity){
nkernelx.cxx:	if (!this->isIdentical(newIdentity)) {
nkernelx.cxx:		BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:void FeActualPlaceHolder::makeIdentical (APTR(FeRangeElement) newIdentity){
nkernelx.cxx:	/* Consolidate this PlaceHolder to the newIdentity.  Return 
nkernelx.cxx:			and forward the operation after coercing the newIdentity
nkernelx.cxx:			 to a persistent RangeElement. */
nkernelx.cxx:	/* myRangeElement will tell me to forward to another RangeElement. */
nkernelx.cxx:	if (!CurrentKeyMaster.fluidGet()->hasAuthority(this->owner())) {
nkernelx.cxx:	myRangeElement->makeIdentical(newIdentity->getOrMakeBe());
nkernelx.cxx:	/* MyBeRangeElement will know it. */
nkernelx.cxx:	returnValue = myRangeElement->owner();
nkernelx.cxx:	if (!::isDestructed(myRangeElement)) {
nkernelx.cxx:		BEGIN_CHOOSE(myRangeElement) {
nkernelx.cxx:RPTR(BeRangeElement) OR(NULL) FeActualPlaceHolder::fetchBe (){
nkernelx.cxx:	return (BeRangeElement*) myRangeElement;
nkernelx.cxx:void FeActualPlaceHolder::forwardTo (APTR(BeRangeElement) element){
nkernelx.cxx:	/* myRangeElement has become something else.  Forward to the 
nkernelx.cxx:	myRangeElement->removeFeRangeElement(this);
nkernelx.cxx:	myRangeElement = element;
nkernelx.cxx:	myRangeElement->addFeRangeElement(this);
nkernelx.cxx:RPTR(BeRangeElement) FeActualPlaceHolder::getOrMakeBe (){
nkernelx.cxx:	return (BeRangeElement*) myRangeElement;
nkernelx.cxx:FeActualPlaceHolder::FeActualPlaceHolder (APTR(BeRangeElement) be, TCSJ) {
nkernelx.cxx:	myRangeElement = be;
nkernelx.cxx:	myRangeElement->removeFeRangeElement(this);
nkernelx.cxx:RPTR(FeRangeElement) FeVirtualDataHolder::again (){
nkernelx.cxx:	WPTR(FeRangeElement) 	returnValue;
nkernelx.cxx:BooleanVar FeVirtualDataHolder::isIdentical (APTR(FeRangeElement) other){
nkernelx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:RPTR(BeRangeElement) OR(NULL) FeVirtualDataHolder::fetchBe (){
nkernelx.cxx:RPTR(BeRangeElement) FeVirtualDataHolder::getOrMakeBe (){
nkernelx.cxx:	/* Force the ent to generate a beRangeElement at myKey. */
nkernelx.cxx:	WPTR(BeRangeElement) 	returnValue;
nkernelx.cxx:/* client accessing */
nkernelx.cxx:RPTR(FeRangeElement) FeVirtualPlaceHolder::again (){
nkernelx.cxx:	WPTR(FeRangeElement) 	returnValue;
nkernelx.cxx:BooleanVar FeVirtualPlaceHolder::canMakeIdentical (APTR(FeRangeElement) newIdentity){
nkernelx.cxx:	if (!this->isIdentical(newIdentity)) {
nkernelx.cxx:		BLAST(NOT_YET_IMPLEMENTED);
nkernelx.cxx:void FeVirtualPlaceHolder::makeIdentical (APTR(FeRangeElement) newIdentity){
nkernelx.cxx:	/* Consolidate this PlaceHolder to the newIdentity.  Return 
nkernelx.cxx:			and coerce both of us and have the BeRangeElements try. */
nkernelx.cxx:	/* This doesn't need to force newIdentity into a BeRangeElement. */
nkernelx.cxx:	if (!CurrentKeyMaster.fluidGet()->hasAuthority(this->owner())) {
nkernelx.cxx:	this->getOrMakeBe()->makeIdentical(newIdentity->getOrMakeBe());
nkernelx.cxx:RPTR(BeRangeElement) OR(NULL) FeVirtualPlaceHolder::fetchBe (){
nkernelx.cxx:RPTR(BeRangeElement) FeVirtualPlaceHolder::getOrMakeBe (){
nkernelx.cxx:	/* Force the ent to generate a beRangeElement at myKey. */
nkernelx.cxx:	WPTR(BeRangeElement) 	returnValue;
nkernelx.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
nkernelx.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
nkernelx.hxx:	ON_CLIENT(FeBundle)
nkernelx.hxx:	/* Essential. The positions in the Edition for which I 
nkernelx.hxx:	describe the contents */
nkernelx.hxx:	virtual CLIENT RPTR(XnRegion) region ();
nkernelx.hxx:	/* Describes a chunk of information represented as an array. 
nkernelx.hxx:	The number of elements in the array are the same as my 
nkernelx.hxx:	ON_CLIENT(FeArrayBundle)
nkernelx.hxx:	/* Essential. The array of elements in this bundle */
nkernelx.hxx:	virtual CLIENT RPTR(PrimArray) array ();
nkernelx.hxx:	/* Essential. The order relating the elements in the array to 
nkernelx.hxx:	virtual CLIENT RPTR(OrderSpec) ordering ();
nkernelx.hxx: *                    Class   FeElementBundle 
nkernelx.hxx:	my region hold the same RangeElement. */
nkernelx.hxx:class FeElementBundle : public FeBundle {
nkernelx.hxx:/* Attributes for class FeElementBundle */
nkernelx.hxx:	CONCRETE(FeElementBundle)
nkernelx.hxx:	ON_CLIENT(FeElementBundle)
nkernelx.hxx:	AUTO_GC(FeElementBundle)
nkernelx.hxx:	static RPTR(FeElementBundle) make (APTR(XnRegion) ARG(region), APTR(FeRangeElement) ARG(element));
nkernelx.hxx:	/* Essential. The RangeElement which is at every position in 
nkernelx.hxx:	virtual CLIENT RPTR(FeRangeElement) element ();
nkernelx.hxx:	FeElementBundle (APTR(XnRegion) ARG(region), APTR(FeRangeElement) ARG(element));
nkernelx.hxx:	CHKPTR(FeRangeElement) myElement;
nkernelx.hxx:};  /* end class FeElementBundle */
nkernelx.hxx:	ON_CLIENT(FePlaceHolderBundle)
nkernelx.hxx:	for a client`s activities on the BackEnd. A client can have 
nkernelx.hxx:	any number of different KeyMasters, each with different 
nkernelx.hxx:	ON_CLIENT(FeKeyMaster)
nkernelx.hxx:	/* Blast if the CurrentKeyMaster doesn't have Admin authority. */
nkernelx.hxx:	/* Blast if the CurrentKeyMaster doesn't have signature 
nkernelx.hxx:	authority for the CurrentAuthor. */
nkernelx.hxx:	/* If there is a currentSponsor, then the CurrentKeyMaster 
nkernelx.hxx:	/* Essential.  The Clubs whose authority is actually being 
nkernelx.hxx:	virtual CLIENT RPTR(IDRegion) actualAuthority ();
nkernelx.hxx:	/* Essential.  A different KeyMaster with the same login and 
nkernelx.hxx:	virtual CLIENT RPTR(FeKeyMaster) copy ();
nkernelx.hxx:	/* Whether this KeyMaster is currently holding the authority 
nkernelx.hxx:	of the given Club. Equivalent to
nkernelx.hxx:	virtual CLIENT BooleanVar hasAuthority (APTR(ID) ARG(clubID));
nkernelx.hxx:	/* Essential.  Add the other KeyMaster's login and actual 
nkernelx.hxx:	virtual CLIENT void incorporate (APTR(FeKeyMaster) ARG(other));
nkernelx.hxx:	/* Essential.  The Clubs whose authority was obtained 
nkernelx.hxx:	virtual CLIENT RPTR(IDRegion) loginAuthority ();
nkernelx.hxx:	/* Essential.  Remove the listed IDs from the set of Clubs 
nkernelx.hxx:	not hold login authority will be silently ignored. */
nkernelx.hxx:	virtual CLIENT void removeLogins (APTR(IDRegion) ARG(oldLogins));
nkernelx.hxx:	/* Notify all my dependents of a change in authority */
nkernelx.hxx: *                    Class FeRangeElement 
nkernelx.hxx:class FeRangeElement : public Heaper {
nkernelx.hxx:/* Attributes for class FeRangeElement */
nkernelx.hxx:	DEFERRED(FeRangeElement)
nkernelx.hxx:	ON_CLIENT(FeRangeElement)
nkernelx.hxx:	EQ(FeRangeElement)
nkernelx.hxx:	NO_GC(FeRangeElement)
nkernelx.hxx:	/* Check whether the endorsements are valid and authorized.
nkernelx.hxx:	static void validateEndorsement (APTR(CrossRegion) ARG(endorsements), APTR(FeKeyMaster) ARG(km));
nkernelx.hxx:	static CLIENT RPTR(FeRangeElement) placeHolder ();
nkernelx.hxx:	/* Essential.  When this PlaceHolder becomes any other kind 
nkernelx.hxx:	of RangeElement, then the Detector will be triggered with the 
nkernelx.hxx:	new RangeElement. If this is already not a PlaceHolder, then 
nkernelx.hxx:	the Detector is triggered immediately with this RangeElement.
nkernelx.hxx:		See FillRangeDetector::filled (RangeElement * newIdentity). */
nkernelx.hxx:	/* Essential.  An object reflecting the current identity of 
nkernelx.hxx:	virtual CLIENT RPTR(FeRangeElement) again () DEFERRED_FUNC;
nkernelx.hxx:	/* Essential.  Whether the identity of this object could be 
nkernelx.hxx:		Does not check whether the CurrentKeyMaster has authority to do it.
nkernelx.hxx:	can only become another of the same type with the same content. */
nkernelx.hxx:	virtual CLIENT BooleanVar canMakeIdentical (APTR(FeRangeElement) ARG(newIdentity));
nkernelx.hxx:	/* Essential.  Return a FillDetector that will be triggered 
nkernelx.hxx:	when this RangeElement becomes something other than a 
nkernelx.hxx:	PlaceHolder, or immeditely if this RangeElement is not 
nkernelx.hxx:	currently a PlaceHolder.
nkernelx.hxx:		See FillRangeDetector::filled (RangeElement * newIdentity). */
nkernelx.hxx:	virtual CLIENT RPTR(FeFillDetector) fillDetector ();
nkernelx.hxx:	/* Essential.  Return whether two objects have the same 
nkernelx.hxx:	identity on the Server.  Note that this can change over time, 
nkernelx.hxx:	if makeIdentical is used.  However, for a given pair of 
nkernelx.hxx:	FeRangeElements, it can only change from not being the same 
nkernelx.hxx:	virtual CLIENT BooleanVar isIdentical (APTR(FeRangeElement) ARG(other));
nkernelx.hxx:	/* Essential.  Change the identity of this object to the 
nkernelx.hxx:		Requires authority of the current owner; if the operation is 
nkernelx.hxx:		Also requires enough permission on newIdentity to determine, 
nkernelx.hxx:	by comparing content, whether the operation would succeed.
nkernelx.hxx:	can only become another of the same type with the same content. */
nkernelx.hxx:	virtual CLIENT void makeIdentical (APTR(FeRangeElement) ARG(newIdentity)) DEFERRED_SUBR;
nkernelx.hxx:	/* Essential.  The Club which owns this RangeElement, and has 
nkernelx.hxx:	virtual CLIENT RPTR(ID) owner ();
nkernelx.hxx:	/* Essential.  Remove a Detector which had been added to this 
nkernelx.hxx:	RangeElement. You should remove every Detector you add, 
nkernelx.hxx:	although they will go away automatically when a client 
nkernelx.hxx:	/* Essential.  Change the owner; must have the authority of 
nkernelx.hxx:	the current owner. */
nkernelx.hxx:	virtual CLIENT void setOwner (APTR(ID) ARG(clubID));
nkernelx.hxx:	/* All Editions which the CurrentKeyMaster can see, which 
nkernelx.hxx:	transclude this RangeElement.
nkernelx.hxx:		If a directFilter is given, then the visibleEndorsements on 
nkernelx.hxx:	visibleEndorsements match the filter.
nkernelx.hxx:	Edition must contain this directly as a RangeElement; 
nkernelx.hxx:	otherwise, indirect containment through Editions is allowed.
nkernelx.hxx:		If the localPresentOnly flag is set, then only Editions 
nkernelx.hxx:	currently known to this Server are guaranteed to end up in 
nkernelx.hxx:		Equivalent to
nkernelx.hxx:			FeServer::current ()->newEditionWith (<any position>, this)
nkernelx.hxx:	virtual CLIENT RPTR(FeEdition) transcluders (
nkernelx.hxx:	/* Essential.  Works which contain this RangeElement and can 
nkernelx.hxx:	be read by the CurrentKeyMaster. Returns an IDSpace Edition 
nkernelx.hxx:		If a filter is given, then only Works whose endorsements 
nkernelx.hxx:		If localPresentOnly flag is set, then only Works currently 
nkernelx.hxx:	virtual CLIENT RPTR(FeEdition) works (
nkernelx.hxx:	virtual RPTR(BeRangeElement) OR(NULL) fetchBe () DEFERRED_FUNC;
nkernelx.hxx:	/* An individual BeRangeElement for this identity. If the 
nkernelx.hxx:	virtual RPTR(BeRangeElement) getOrMakeBe () DEFERRED_FUNC;
nkernelx.hxx:	/* Essential. Return the label attached to this 
nkernelx.hxx:	FeRangeElement. (An FeRangeElement holds a BeRangeElement and 
nkernelx.hxx:	a label.)  All FeRangeElements have a label attached to them 
nkernelx.hxx:	when they are created (in the various Server::newRangeElement 
nkernelx.hxx:	label() will blast if sent to other kinds of FeEditions.) */
nkernelx.hxx:	virtual CLIENT RPTR(FeLabel) label ();
nkernelx.hxx:	/* Essential. Return a new FeRangeElement with the same 
nkernelx.hxx:	identity and contents (i.e. holding the same BeRangeElement), 
nkernelx.hxx:	but with a different label.  (Get new labels from 
nkernelx.hxx:	virtual CLIENT RPTR(FeRangeElement) relabelled (APTR(FeLabel) ARG(label));
nkernelx.hxx:	/* automatic 0-argument constructor */
nkernelx.hxx:	FeRangeElement();
nkernelx.hxx:};  /* end class FeRangeElement */
nkernelx.hxx:	/* The kind of FeRangeElement that represents a piece of data 
nkernelx.hxx:	in the Server, along with its identity. */
nkernelx.hxx:class FeDataHolder : public FeRangeElement {
nkernelx.hxx:	ON_CLIENT(FeDataHolder)
nkernelx.hxx:	static CLIENT RPTR(FeDataHolder) make (APTR(PrimValue) ARG(value));
nkernelx.hxx:  public: /* client accessing */
nkernelx.hxx:	virtual RPTR(FeRangeElement) again () DEFERRED_FUNC;
nkernelx.hxx:			and forward the operation after coercing the newIdentity to 
nkernelx.hxx:	a persistent RangeElement. */
nkernelx.hxx:	virtual BooleanVar canMakeIdentical (APTR(FeRangeElement) ARG(newIdentity));
nkernelx.hxx:	virtual void makeIdentical (APTR(FeRangeElement) ARG(newIdentity));
nkernelx.hxx:	/* Essential.  The actual data value */
nkernelx.hxx:	virtual CLIENT RPTR(PrimValue) value () DEFERRED_FUNC;
nkernelx.hxx:	virtual RPTR(BeRangeElement) OR(NULL) fetchBe () DEFERRED_FUNC;
nkernelx.hxx:	virtual RPTR(BeRangeElement) getOrMakeBe () DEFERRED_FUNC;
nkernelx.hxx:	/* automatic 0-argument constructor */
nkernelx.hxx:	/* The kind of FeRangeElement that consists of an immutable 
nkernelx.hxx:	organization of RangeElements, indexed by Positions in some 
nkernelx.hxx:	 R1 prohibits cyclic containment.
nkernelx.hxx:	Set notation is used in the comments documenting some of the 
nkernelx.hxx:class FeEdition : public FeRangeElement {
nkernelx.hxx:	ON_CLIENT(FeEdition)
nkernelx.hxx:	/* An empty Edition, with the given CoordinateSpace but no contents. */
nkernelx.hxx:	static CLIENT RPTR(FeEdition) empty (APTR(CoordinateSpace) ARG(keySpace));
nkernelx.hxx:	/* Essential.  A singleton Edition mapping from a Region of 
nkernelx.hxx:	keys (potentially infinite) to a single value. */
nkernelx.hxx:	static CLIENT RPTR(FeEdition) fromAll (APTR(XnRegion) ARG(keys), APTR(FeRangeElement) ARG(value));
nkernelx.hxx:	/* Essential.  Creates an Edition mapping from a Region of 
nkernelx.hxx:	static CLIENT RPTR(FeEdition) fromArray (
nkernelx.hxx:			APTR(PrimArray) OF1(FeRangeElement) ARG(values), 
nkernelx.hxx:	static CLIENT RPTR(FeEdition) fromOne (APTR(Position) ARG(key), APTR(FeRangeElement) ARG(value));
nkernelx.hxx:	/* Essential.  Create a new Edition mapping from each key in 
nkernelx.hxx:	static CLIENT RPTR(FeEdition) placeHolders (APTR(XnRegion) ARG(keys));
nkernelx.hxx:	static CLIENT INLINE Int32 DIRECT_CONTAINERS_ONLY () CONST;
nkernelx.hxx:	RangeElements contained transitively within the other Edition */
nkernelx.hxx:	static CLIENT INLINE Int32 FROM_OTHER_TRANSITIVE_CONTENTS () CONST;
nkernelx.hxx:	RangeElements contained transitively inside the Edition, as 
nkernelx.hxx:	well as just its immediate RangeElements */
nkernelx.hxx:	static CLIENT INLINE Int32 FROM_TRANSITIVE_CONTENTS () CONST;
nkernelx.hxx:	be organized according to a different ordering. */
nkernelx.hxx:	static CLIENT INLINE Int32 IGNORE_ARRAY_ORDERING () CONST;
nkernelx.hxx:	presented in any order. */
nkernelx.hxx:	static CLIENT INLINE Int32 IGNORE_TOTAL_ORDERING () CONST;
nkernelx.hxx:	return items which are currently known to this server */
nkernelx.hxx:	static CLIENT INLINE Int32 LOCAL_PRESENT_ONLY () CONST;
nkernelx.hxx:	static CLIENT INLINE Int32 OMIT_SHARED () CONST;
nkernelx.hxx:	static CLIENT INLINE Int32 otherTransitiveContents () CONST;
nkernelx.hxx:	static CLIENT INLINE Int32 PRORATE_SHARED () CONST;
nkernelx.hxx:	static CLIENT INLINE Int32 SEPARATE_OWNERS () CONST;
nkernelx.hxx:	static CLIENT INLINE Int32 thisTransitiveContents () CONST;
nkernelx.hxx:	static CLIENT INLINE Int32 TO_TRANSITIVE_CONTENTS () CONST;
nkernelx.hxx:	/* For cost - count the entire cost of shared material */
nkernelx.hxx:	static CLIENT INLINE Int32 TOTAL_SHARED () CONST;
nkernelx.hxx:	/* Essential.  Return a new FeEdition containing the contents 
nkernelx.hxx:	of boththe receiver and the argument Editions, and with the 
nkernelx.hxx:	they must have the same RangeElement.  Currently the two may 
nkernelx.hxx:	from an implementation restriction to a specification.  The 
nkernelx.hxx:	independent, i.e. a failing combine could otherwise succeed 
nkernelx.hxx:	after the differing range elements were unified (by 
nkernelx.hxx:	FeRangeElement::makeIdentical()).  See FeEdition::mapSharedOnt
nkernelx.hxx:			currently: { k | <k,la,v1> in self and <k,lb,v2> in other } is empty
nkernelx.hxx:			eventually maybe: { k | v1 not same as v2 
nkernelx.hxx:	virtual CLIENT RPTR(FeEdition) combine (APTR(FeEdition) ARG(other));
nkernelx.hxx:	virtual CLIENT RPTR(FeEdition) copy (APTR(XnRegion) ARG(positions));
nkernelx.hxx:	/* Return a new FeEdition with the label of the current 
nkernelx.hxx:	Edition and the contents of both Editions; where they share 
nkernelx.hxx:	positions, use the contents and labels of the other Edition. 
nkernelx.hxx:	Equivalent to
nkernelx.hxx:			this->copy (other->domain ()->complement ())->combine (other).
nkernelx.hxx:	virtual CLIENT RPTR(FeEdition) replace (APTR(FeEdition) ARG(other));
nkernelx.hxx:	/* Essential.  Return a new FeEdition containing the contents 
nkernelx.hxx:	and label of the current Edition with the positions 
nkernelx.hxx:	the range, this Edition must have the same RangeElement and 
nkernelx.hxx:	label at all the domain positions.  Currently the mapping 
nkernelx.hxx:	elevate this from an implementation restriction to a 
nkernelx.hxx:			Currently: not exists k1a, k1b : k1a != k1b and <k1a,k2> in 
nkernelx.hxx:			Maybe eventually: for all v1, v2 : <k,l1,v1> in result and 
nkernelx.hxx:	virtual CLIENT RPTR(FeEdition) transformedBy (APTR(Mapping) ARG(mapping));
nkernelx.hxx:	/* Return a new FeEditionwith the same contents and label as 
nkernelx.hxx:	RangeElement at a specified position.
nkernelx.hxx:	installs the label attached to the value argument.)
nkernelx.hxx:		Equivalent to:
nkernelx.hxx:			this->replace (FeServer::current ()->makeEditionWith 
nkernelx.hxx:	virtual CLIENT RPTR(FeEdition) with (APTR(Position) ARG(position), APTR(FeRangeElement) ARG(value));
nkernelx.hxx:	/* Return a new FeEdition with the same contents and label as 
nkernelx.hxx:	by the value argument.
nkernelx.hxx:		Equivalent to:
nkernelx.hxx:			this->replace (FeServer::current ()->makeEditionWithAll 
nkernelx.hxx:	virtual CLIENT RPTR(FeEdition) withAll (APTR(XnRegion) ARG(positions), APTR(FeRangeElement) ARG(value));
nkernelx.hxx:	/* Return a new FeEdition with the same contents and label as 
nkernelx.hxx:		Equivalent to:
nkernelx.hxx:			this->copy (position->asRegion ()->complement ()) */
nkernelx.hxx:	virtual CLIENT RPTR(FeEdition) without (APTR(Position) ARG(position));
nkernelx.hxx:	/* Return a new FeEdition with the same contents and label as 
nkernelx.hxx:		Equivalent to
nkernelx.hxx:			this->copy (positions->complement ()) */
nkernelx.hxx:	virtual CLIENT RPTR(FeEdition) withoutAll (APTR(XnRegion) ARG(positions));
nkernelx.hxx:	are positions. Equivalent to
nkernelx.hxx:	virtual CLIENT RPTR(CoordinateSpace) coordinateSpace ();
nkernelx.hxx:	/* Essential. Retiurn how much space this Edition is taking 
nkernelx.hxx:	sharing it; if totalShared, its entire cost is counted. This 
nkernelx.hxx:	virtual CLIENT IntegerVar cost (Int32 ARG(method));
nkernelx.hxx:	infinite. Equivalent to
nkernelx.hxx:	virtual CLIENT IntegerVar count ();
nkernelx.hxx:	/* Essential.  Return the region consisting of all the 
nkernelx.hxx:	virtual CLIENT RPTR(XnRegion) domain ();
nkernelx.hxx:	virtual CLIENT RPTR(FeRangeElement) get (APTR(Position) ARG(position));
nkernelx.hxx:	/* Return whether the given position is in the Edition. Equivalent to
nkernelx.hxx:	virtual CLIENT BooleanVar hasPosition (APTR(Position) ARG(position));
nkernelx.hxx:	Equivalent to
nkernelx.hxx:	virtual CLIENT BooleanVar isEmpty ();
nkernelx.hxx:	this Edition. Equivalent to
nkernelx.hxx:	virtual CLIENT BooleanVar isFinite ();
nkernelx.hxx:	/* Essential.  This is the fundamental retrieval operation.  
nkernelx.hxx:	between a region in the domain and the range elements 
nkernelx.hxx:	the data elements.
nkernelx.hxx:	contents will be returned.  If it is not given, the entire 
nkernelx.hxx:	content of the Edition will be returned.
nkernelx.hxx:	returned by the operation can be ordered differently from the 
nkernelx.hxx:	virtual CLIENT RPTR(Stepper) OF1(Bundle) retrieve (
nkernelx.hxx:	RangeElements of this Edition. If a region is specified, then 
nkernelx.hxx:	virtual CLIENT RPTR(TableStepper) OF1(FeRangeElement) stepper (APTR(XnRegion) ARG(region) = NULL, APTR(OrderSpec) ARG(ordering) = NULL);
nkernelx.hxx:	RangeElement at that position; if not, blasts. Equivalent to
nkernelx.hxx:	virtual CLIENT RPTR(FeRangeElement) theOne ();
nkernelx.hxx:	RangeElement isIdentical to the corresponding RangeElement in 
nkernelx.hxx:	virtual CLIENT BooleanVar isRangeIdentical (APTR(FeEdition) ARG(other), APTR(XnRegion) ARG(region) = NULL);
nkernelx.hxx:	/* Return a mapping such that for each range element that 
nkernelx.hxx:	appearances in the argument edition to some appearance in 
nkernelx.hxx:	unmapped or mapped to multiple appearances in the argument 
nkernelx.hxx:	position.  Such a mapping is suitable as an argument to 
nkernelx.hxx:	'transformedBy', and represents the minimal transformation 
nkernelx.hxx:	virtual CLIENT RPTR(Mapping) mapSharedOnto (APTR(FeEdition) ARG(other));
nkernelx.hxx:	/* Essential.  Return a Mapping from each of the positions in 
nkernelx.hxx:	which have the same RangeElement.
nkernelx.hxx:	virtual CLIENT RPTR(Mapping) mapSharedTo (APTR(FeEdition) ARG(other));
nkernelx.hxx:	this Edition whose RangeElements are not in the other Edition.
nkernelx.hxx:		Equivalent to:
nkernelx.hxx:			this->copy (this->sharedRegion (other)->complement ()).
nkernelx.hxx:	virtual CLIENT RPTR(FeEdition) notSharedWith (APTR(FeEdition) ARG(other), Int32 ARG(flags) = Int32Zero);
nkernelx.hxx:	Edition at which the given RangeElement can be found.
nkernelx.hxx:		Equivalent to:
nkernelx.hxx:	virtual CLIENT RPTR(XnRegion) positionsOf (APTR(FeRangeElement) ARG(value));
nkernelx.hxx:	/* Essential.  Return a new FeEdition containing all Editions 
nkernelx.hxx:	which can be read with the authority of the CurrentKeyMaster, 
nkernelx.hxx:	and which transclude RangeElements in this Edition. 
nkernelx.hxx:	subset at those positions (i.e. equivalent to this->copy 
nkernelx.hxx:		If a directFilter is given, then the endorsements on the 
nkernelx.hxx:	resulting Editions, unioned with the endorsements on any 
nkernelx.hxx:	CurrentKeyMaster has read permission, must pass the filter.
nkernelx.hxx:	whose endorsements (unioned with its readable Works 
nkernelx.hxx:	endorsements) pass the filter. (Giving a non-NULL 
nkernelx.hxx:	RangeElements; otherwise, the result includes Editions which 
nkernelx.hxx:		If the fromTransitiveContents flag is set, then the result 
nkernelx.hxx:	includes transclusions of RangeElements of sub-Editions of 
nkernelx.hxx:	this one, in addition to the RangeElements in this Edition. 
nkernelx.hxx:		If localPresentOnly flag is clear, a persistent request will 
nkernelx.hxx:	are currently known to transclude by this Backend are sure to 
nkernelx.hxx:	virtual CLIENT RPTR(FeEdition) rangeTranscluders (
nkernelx.hxx:	/* Essential.  Return a new FeEdition containing all Works 
nkernelx.hxx:	which contain RangeElements of this Edition and can be read 
nkernelx.hxx:	by the CurrentKeyMaster. Returns an IDSpace Edition full of 
nkernelx.hxx:		If a filter is given, then only Works whose endorsements 
nkernelx.hxx:		If the localPresentOnly flag is clear, a persistent request 
nkernelx.hxx:	it is set, only Works currently known to this Server are sure 
nkernelx.hxx:		If the fromTransitiveContents flag is set, then the result 
nkernelx.hxx:	includes Works which contain RangeElements transitively 
nkernelx.hxx:	directly on Editions which are RangeElements of this Edition 
nkernelx.hxx:	virtual CLIENT RPTR(FeEdition) rangeWorks (
nkernelx.hxx:	have RangeElements that are in the other Edition.
nkernelx.hxx:	RangeElements which are in the other, but also positions of 
nkernelx.hxx:	Editions which have RangeElements which are in the other, or 
nkernelx.hxx:	RangeElements which are values of the other Edition, but also 
nkernelx.hxx:		If both flags are false, then equivalent to:
nkernelx.hxx:	virtual CLIENT RPTR(XnRegion) sharedRegion (APTR(FeEdition) ARG(other), Int32 ARG(flags) = Int32Zero);
nkernelx.hxx:	/* Essential.  Return a new FeEdition consisting of the 
nkernelx.hxx:	subset of this Edition whose RangeElements are in the other 
nkernelx.hxx:	Edition. If the same RangeElement is in this Edition at 
nkernelx.hxx:	several different positions, all positions will be in the 
nkernelx.hxx:	result (provided the RangeElement is also in the other Edition).
nkernelx.hxx:		Equivalent to:
nkernelx.hxx:	virtual CLIENT RPTR(FeEdition) sharedWith (APTR(FeEdition) ARG(other), Int32 ARG(flags) = Int32Zero);
nkernelx.hxx:	/* Essential.  Adds to the endorsements on this Edition.  The 
nkernelx.hxx:	region of additionalEndorsements must consist of a finite 
nkernelx.hxx:	number of (club ID, token ID) pairs.  CurrentKeyMaster must 
nkernelx.hxx:	virtual CLIENT void endorse (APTR(CrossRegion) ARG(additionalEndorsements));
nkernelx.hxx:	/* Essential.  Return all of the endorsements which have been 
nkernelx.hxx:	virtual CLIENT RPTR(CrossRegion) endorsements ();
nkernelx.hxx:	/* Essential.  Removes endorsements from this Edition.  This 
nkernelx.hxx:	requires that the CurrentKeyMaster hold signature authority 
nkernelx.hxx:	for all of the Clubs whose endorsements are in the list; will 
nkernelx.hxx:	lacking, even if the endorsements weren't there to be 
nkernelx.hxx:	retracted.  Ignores all endorsements which you could have 
nkernelx.hxx:		In the current release removed endorsements aren't 
nkernelx.hxx:	release removed endorsements will become inactive, but it 
nkernelx.hxx:	will be possible to detect that they once had been present.  
nkernelx.hxx:	The intent is for a removed endorsement to be analogous to a 
nkernelx.hxx:	virtual CLIENT void retract (APTR(CrossRegion) ARG(endorsements));
nkernelx.hxx:	/* Essential.  Return all the unretracted endorsements on 
nkernelx.hxx:	which the CurrentKeyMaster has permission to read. */
nkernelx.hxx:	virtual CLIENT RPTR(CrossRegion) visibleEndorsements ();
nkernelx.hxx:	/* Essential.  Connect a FillRangeDetector to the underlying 
nkernelx.hxx:	Edition become any other kind of RangeElement, then the 
nkernelx.hxx:	RangeElements (but not necessarily at the same positions, or 
nkernelx.hxx:	with those RangeElements.
nkernelx.hxx:		See FillRangeDetector::allFilled (Edition * newIdentities). */
nkernelx.hxx:	/* Essential.  Return the region consisting of all locations 
nkernelx.hxx:	at which my RangeElements can NOT be made identical to the 
nkernelx.hxx:	corresponding RangeElements in the other Edition. (This seems 
nkernelx.hxx:	virtual CLIENT RPTR(XnRegion) canMakeRangeIdentical (APTR(FeEdition) ARG(newIdentities), APTR(XnRegion) ARG(positions) = NULL);
nkernelx.hxx:	/* Essential.  Return a FillRangeDetector so that when any of 
nkernelx.hxx:	RangeElement, then the Detector will be triggered with an 
nkernelx.hxx:	Edition containing the new RangeElements (but not necessarily 
nkernelx.hxx:	triggered immediately with those RangeElements.
nkernelx.hxx:		See FillRangeDetector::allFilled (Edition * newIdentities). */
nkernelx.hxx:	virtual CLIENT RPTR(FeFillRangeDetector) fillRangeDetector ();
nkernelx.hxx:	/* Essential.  Try to change the identity of each 
nkernelx.hxx:	RangeElements of this Edition which are in the Region (or all 
nkernelx.hxx:	if no Region supplied) to that of the RangeElement at the 
nkernelx.hxx:	this Edition which did not end up with the new identities, because of
nkernelx.hxx:			- different contents
nkernelx.hxx:			- contents of other edition unreadable
nkernelx.hxx:			- no corresponding new identity
nkernelx.hxx:	Note that the labels on the RangeElements need not match and 
nkernelx.hxx:	virtual CLIENT RPTR(FeEdition) makeRangeIdentical (APTR(FeEdition) ARG(newIdentities), APTR(XnRegion) ARG(positions) = NULL);
nkernelx.hxx:	/* The owners of all the RangeElements in the given Region, 
nkernelx.hxx:	or in the entire 
nkernelx.hxx:	virtual CLIENT RPTR(IDRegion) rangeOwners (APTR(XnRegion) ARG(positions) = NULL);
nkernelx.hxx:	/* Essential.  Remove a Detector which had been added to this 
nkernelx.hxx:	they will go away automatically when a client session terminates. */
nkernelx.hxx:	/* Changes the owner of all RangeElements in the Edition (but 
nkernelx.hxx:	current owner of each range element. If a Region is supplied, 
nkernelx.hxx:	virtual CLIENT RPTR(FeEdition) setRangeOwners (APTR(ID) ARG(newOwner), APTR(XnRegion) ARG(region) = NULL);
nkernelx.hxx:	virtual CLIENT RPTR(XnRegion) positionsLabelled (APTR(FeLabel) ARG(label));
nkernelx.hxx:	unchanged.  Equivalent to
nkernelx.hxx:	non-edition RangeElement is at the given position.
nkernelx.hxx:	virtual CLIENT RPTR(FeEdition) rebind (APTR(Position) ARG(position), APTR(FeEdition) ARG(edition));
nkernelx.hxx:	virtual RPTR(FeRangeElement) relabelled (APTR(FeLabel) ARG(label));
nkernelx.hxx:	virtual RPTR(FeRangeElement) fetch (APTR(Position) ARG(position));
nkernelx.hxx:	virtual RPTR(BeRangeElement) OR(NULL) fetchBe ();
nkernelx.hxx:	virtual RPTR(BeRangeElement) getOrMakeBe ();
nkernelx.hxx:  public: /* client implementation */
nkernelx.hxx:	virtual RPTR(FeRangeElement) again ();
nkernelx.hxx:	virtual BooleanVar canMakeIdentical (APTR(FeRangeElement) ARG(newIdentity));
nkernelx.hxx:	virtual void makeIdentical (APTR(FeRangeElement) ARG(newIdentity));
nkernelx.hxx:	/* Whether the given position is in the Edition. Equivalent to
nkernelx.hxx:	RangeElement can be found. Equivalent to
nkernelx.hxx:	virtual RPTR(XnRegion) keysOf (APTR(FeRangeElement) ARG(value));
nkernelx.hxx:	Tentative feature. */
nkernelx.hxx:class FeIDHolder : public FeRangeElement {
nkernelx.hxx:	ON_CLIENT(FeIDHolder)
nkernelx.hxx:	/* Essential. Make a single IDHolder with the given ID. 
nkernelx.hxx:	Tentative feature. */
nkernelx.hxx:	static CLIENT RPTR(FeIDHolder) make (APTR(ID) ARG(iD));
nkernelx.hxx:	virtual RPTR(FeRangeElement) again ();
nkernelx.hxx:	virtual BooleanVar canMakeIdentical (APTR(FeRangeElement) ARG(newIdentity));
nkernelx.hxx:	/* Essential.  The ID in this holder. */
nkernelx.hxx:	virtual CLIENT RPTR(ID) iD ();
nkernelx.hxx:	virtual void makeIdentical (APTR(FeRangeElement) ARG(newIdentity));
nkernelx.hxx:	virtual RPTR(BeRangeElement) OR(NULL) fetchBe ();
nkernelx.hxx:	virtual RPTR(BeRangeElement) getOrMakeBe ();
nkernelx.hxx:	/* An identity attached to a RangeElement within an Edition. */
nkernelx.hxx:class FeLabel : public FeRangeElement {
nkernelx.hxx:	ON_CLIENT(FeLabel)
nkernelx.hxx:	/* Essential. Create a new unique Label */
nkernelx.hxx:	static CLIENT RPTR(FeLabel) make ();
nkernelx.hxx:	virtual RPTR(BeRangeElement) OR(NULL) fetchBe ();
nkernelx.hxx:	virtual RPTR(BeRangeElement) getOrMakeBe ();
nkernelx.hxx:  public: /* client accessing */
nkernelx.hxx:	virtual RPTR(FeRangeElement) again ();
nkernelx.hxx:	virtual BooleanVar canMakeIdentical (APTR(FeRangeElement) ARG(newIdentity));
nkernelx.hxx:	virtual void makeIdentical (APTR(FeRangeElement) ARG(newIdentity));
nkernelx.hxx:	/* Represents a piece of pure identity in the Server. */
nkernelx.hxx:class FePlaceHolder : public FeRangeElement {
nkernelx.hxx:	static RPTR(FePlaceHolder) on (APTR(BeRangeElement) ARG(be));
nkernelx.hxx:	virtual RPTR(FeRangeElement) again () DEFERRED_FUNC;
nkernelx.hxx:	virtual BooleanVar canMakeIdentical (APTR(FeRangeElement) ARG(newIdentity)) DEFERRED_FUNC;
nkernelx.hxx:	virtual void makeIdentical (APTR(FeRangeElement) ARG(newIdentity)) DEFERRED_SUBR;
nkernelx.hxx:	virtual RPTR(BeRangeElement) OR(NULL) fetchBe () DEFERRED_FUNC;
nkernelx.hxx:	virtual RPTR(BeRangeElement) getOrMakeBe () DEFERRED_FUNC;
nkernelx.hxx:	/* automatic 0-argument constructor */
nkernelx.hxx:	/* A persistent identity for a changeable object. */
nkernelx.hxx:class FeWork : public FeRangeElement {
nkernelx.hxx:	ON_CLIENT(FeWork)
nkernelx.hxx:	/* Essential.  Create a new Work whose initial contents are 
nkernelx.hxx:	KeyMaster come from the fluid environment. If the KeyMaster 
nkernelx.hxx:	static CLIENT RPTR(FeWork) make (APTR(FeEdition) ARG(contents));
nkernelx.hxx:	/* Essential.  Add a detector which will be notified whenever 
nkernelx.hxx:	released, then returns whether the CurrentKeyMaster has 
nkernelx.hxx:	sufficient permission to read the work.  (Read or Edit 
nkernelx.hxx:	virtual CLIENT BooleanVar canRead ();
nkernelx.hxx:	virtual CLIENT BooleanVar canRevise ();
nkernelx.hxx:	/* Essential.  Grab the Work to prevent other clients from 
nkernelx.hxx:	CurrentKeyMaster and CurrentAuthor (to be used to maintain 
nkernelx.hxx:			- the CurrentKeyMaster does not have edit permission
nkernelx.hxx:			- the CurrentKeyMaster does not have signature authority of 
nkernelx.hxx:	the CurrentAuthor
nkernelx.hxx:	by loss of connection} it will be deallocated 'eventually') */
nkernelx.hxx:	virtual CLIENT void grab ();
nkernelx.hxx:	/* Essential.  If you have edit authority, and someone has 
nkernelx.hxx:	value of his CurrentAuthor when he grabbed it; otherwise blast.
nkernelx.hxx:	who can read the current trail can see the revision, but the 
nkernelx.hxx:	virtual CLIENT RPTR(ID) grabber ();
nkernelx.hxx:	/* Essential.  Release the grab on this Work; if a 
nkernelx.hxx:	virtual CLIENT void release ();
nkernelx.hxx:	/* Essential.  Last detector has gone away */
nkernelx.hxx:	/* Essential.  Registers a request so that the next time this 
nkernelx.hxx:	outstanding the CurrentKeyMaster (as of making the request) 
nkernelx.hxx:	CurrentAuthor (as of making the request), it will be grabbed 
nkernelx.hxx:	virtual CLIENT void requestGrab ();
nkernelx.hxx:	/* Essential.  Return a detector which will be notified 
nkernelx.hxx:	virtual CLIENT RPTR(FeStatusDetector) statusDetector ();
nkernelx.hxx:  public: /* contents */
nkernelx.hxx:	/* Essential.  Return the current Edition.  Succeeds if the 
nkernelx.hxx:	Work is already grabbed, or if the CurrentKeyMaster has 
nkernelx.hxx:	virtual CLIENT RPTR(FeEdition) edition ();
nkernelx.hxx:	/* Essential.  Change the current Edition of this work to 
nkernelx.hxx:		 (This is the fundamental write operation.) */
nkernelx.hxx:	virtual CLIENT void revise (APTR(FeEdition) ARG(newEdition));
nkernelx.hxx:	/* Essential.  Return the club which has permission to revise 
nkernelx.hxx:	virtual CLIENT RPTR(ID) editClub ();
nkernelx.hxx:	/* Essential. Return the club which will be recorded as the 
nkernelx.hxx:	virtual CLIENT RPTR(ID) historyClub ();
nkernelx.hxx:	/* Essential.  Return the club which has permission to read 
nkernelx.hxx:	virtual CLIENT RPTR(ID) readClub ();
nkernelx.hxx:	/* Essential.  Irrevocably remove edit permission. Requires 
nkernelx.hxx:	virtual CLIENT void removeEditClub ();
nkernelx.hxx:	/* Essential.  Irrevocably remove read permission (although 
nkernelx.hxx:	virtual CLIENT void removeReadClub ();
nkernelx.hxx:	/* Essential.  Change who has edit permission. Requires 
nkernelx.hxx:	virtual CLIENT void setEditClub (APTR(ID) OR(NULL) ARG(club));
nkernelx.hxx:	/* Essential.  Change the initial read Club for frozen Works 
nkernelx.hxx:	virtual CLIENT void setHistoryClub (APTR(ID) OR(NULL) ARG(club));
nkernelx.hxx:	/* Essential.  Change who has read permission. Requires 
nkernelx.hxx:	virtual CLIENT void setReadClub (APTR(ID) OR(NULL) ARG(club));
nkernelx.hxx:	/* Essential.  Adds to the endorsements on this Work. The set 
nkernelx.hxx:	of endorsements must be a finite number of (club ID, token 
nkernelx.hxx:	virtual CLIENT void endorse (APTR(CrossRegion) ARG(additionalEndorsements));
nkernelx.hxx:	/* Essential.  Return all of the endorsements which have been 
nkernelx.hxx:	placed on this Work and are not currently retracted.
nkernelx.hxx:		(Endorsements are used to filter various operations which 
nkernelx.hxx:	one way to find this work by filtering for its endorsements.) */
nkernelx.hxx:	virtual CLIENT RPTR(CrossRegion) endorsements ();
nkernelx.hxx:	/* Essential.  Removes endorsements from this Work. This 
nkernelx.hxx:	endorsements are in the list; will blast and do nothing if 
nkernelx.hxx:	endorsements which you could have removed, but which don't 
nkernelx.hxx:	virtual CLIENT void retract (APTR(CrossRegion) ARG(removedEndorsements));
nkernelx.hxx:	/* Essential.  Add to the list of sponsors of this Work. 
nkernelx.hxx:	virtual CLIENT void sponsor (APTR(IDRegion) ARG(clubs));
nkernelx.hxx:	/* Essential.  All of the Clubs which are sponsoring this 
nkernelx.hxx:	virtual CLIENT RPTR(IDRegion) sponsors ();
nkernelx.hxx:	/* Essential.  End sponsorship of this Work by all of the 
nkernelx.hxx:	Clubs in the set, even if they are not currently sponsors.
nkernelx.hxx:		Should this use the CurrentKeyMaster? Or the internal 
nkernelx.hxx:	virtual CLIENT void unsponsor (APTR(IDRegion) ARG(clubs));
nkernelx.hxx:  public: /* server contents */
nkernelx.hxx:			APTR(FeEdition) ARG(contents), 
nkernelx.hxx:	virtual RPTR(BeRangeElement) OR(NULL) fetchBe ();
nkernelx.hxx:	virtual RPTR(BeRangeElement) getOrMakeBe ();
nkernelx.hxx:	virtual RPTR(FeRangeElement) again ();
nkernelx.hxx:	virtual BooleanVar canMakeIdentical (APTR(FeRangeElement) ARG(newIdentity));
nkernelx.hxx:	virtual void makeIdentical (APTR(FeRangeElement) ARG(newIdentity));
nkernelx.hxx:	/* Essential. Trigger a Detector whenever there is a revision 
nkernelx.hxx:	to the Work which the CurrentKeyMaster can see. If this 
nkernelx.hxx:	associated with it is replaced with the CurrentKeyMaster.
nkernelx.hxx:		See RevisionDetector::revised (Edition * contents,
nkernelx.hxx:	its current Edition, or its creation if it hasn't been 
nkernelx.hxx:	CurrentKeyMaster must be able to exercise the authority of 
nkernelx.hxx:	virtual CLIENT RPTR(ID) lastRevisionAuthor ();
nkernelx.hxx:	its current Edition, or its creation if it hasn't been 
nkernelx.hxx:	CurrentKeyMaster must be able to exercise the authority of 
nkernelx.hxx:	virtual CLIENT IntegerVar lastRevisionNumber ();
nkernelx.hxx:	/* The time of the last revision of this Work to its current 
nkernelx.hxx:	Work must be grabbed, or the CurrentKeyMaster must be able to 
nkernelx.hxx:	virtual CLIENT IntegerVar lastRevisionTime ();
nkernelx.hxx:	/* Essential. Inform the work that its last revision detector 
nkernelx.hxx:	/* Essential. Return a detector tht will trigger whenever 
nkernelx.hxx:	there is a revision to the Work which the CurrentKeyMaster can see.
nkernelx.hxx:		See RevisionDetector::revised (Edition * contents,
nkernelx.hxx:	virtual CLIENT RPTR(FeRevisionDetector) revisionDetector ();
nkernelx.hxx:	virtual CLIENT RPTR(FeEdition) revisions ();
nkernelx.hxx:	/* self canRead or CurrentKeyMaster has authority of the historyClub */
nkernelx.hxx:	/* A persistent Club on the Server. */
nkernelx.hxx:	ON_CLIENT(FeClub)
nkernelx.hxx:	/* Essential.  Create a new Club whose initial status is 
nkernelx.hxx:	editor and owner are taken from the current settings. If the 
nkernelx.hxx:	by the CurrentSponsor.
nkernelx.hxx:	static CLIENT RPTR(FeClub) make (APTR(FeEdition) ARG(status));
nkernelx.hxx:	/* Essential.  Irrevocably remove signature authority for 
nkernelx.hxx:	virtual CLIENT void removeSignatureClub ();
nkernelx.hxx:	/* Essential.  Change who has signature authority for this 
nkernelx.hxx:	virtual CLIENT void setSignatureClub (APTR(ID) OR(NULL) ARG(club));
nkernelx.hxx:	/* Essential. The Club which has 'signature authority' for 
nkernelx.hxx:	virtual CLIENT RPTR(ID) signatureClub ();
nkernelx.hxx:	/* Essential.  All of the Works sponsored by this Club. If a 
nkernelx.hxx:	virtual CLIENT RPTR(FeEdition) sponsoredWorks (APTR(Filter) ARG(filter) = NULL);
nkernelx.hxx:DESIGN_FLUID(FeServer,CurrentServer);	/* in FeServer */
nkernelx.hxx:DESIGN_FLUID(FeKeyMaster,CurrentKeyMaster);	/* in FeServer */
nkernelx.hxx:DESIGN_FLUID(ID,CurrentAuthor);	/* in FeServer */
nkernelx.hxx:	/* The fundamental Server object. Used for managing the 
nkernelx.hxx:	other general server management operations.
nkernelx.hxx:		FeServer defineClientFluid: #CurrentServer with: Listener 
nkernelx.hxx:	CurrentKeyMaster - a KeyMaster for providing authority to 
nkernelx.hxx:	CurrentAuthor - the ID of the Club under whose name Work 
nkernelx.hxx:	RangeElements
nkernelx.hxx:	ON_CLIENT(FeServer)
nkernelx.hxx:	/* The CoordinateSpace used for filtering endorsements on 
nkernelx.hxx:	this Server. Equivalent to
nkernelx.hxx:			this->filterSpace (this->endorsementSpace ()) */
nkernelx.hxx:	static RPTR(FilterSpace) endorsementFilterSpace ();
nkernelx.hxx:	/* A set of endorsements for each Club endorsing with each token */
nkernelx.hxx:	static RPTR(CrossRegion) OF2(IDRegion,IDRegion) endorsementRegion (APTR(IDRegion) OR(NULL) ARG(clubs), APTR(IDRegion) OR(NULL) ARG(tokens));
nkernelx.hxx:	/* A set of endorsements for each Club endorsing with each token */
nkernelx.hxx:	static RPTR(CrossSpace) OF2(IDSpace,IDSpace) endorsementSpace ();
nkernelx.hxx:	/* Return true if the current session has successfully logged 
nkernelx.hxx:	/* Essential.  The ID of the System Access Club. */
nkernelx.hxx:	static CLIENT RPTR(ID) accessClubID ();
nkernelx.hxx:	/* Essential.  The ID of the System Admin Club. */
nkernelx.hxx:	static CLIENT RPTR(ID) adminClubID ();
nkernelx.hxx:	/* Essential.  The ID of the System Archive Club. */
nkernelx.hxx:	static CLIENT RPTR(ID) archiveClubID ();
nkernelx.hxx:	/* Essential.  The ID of the Universal Empty Club. */
nkernelx.hxx:	static CLIENT RPTR(ID) emptyClubID ();
nkernelx.hxx:	/* Essential. The encryption scheme to be used for sending 
nkernelx.hxx:	static CLIENT RPTR(Sequence) encrypterName ();
nkernelx.hxx:	/* Essential.  Return a lock which, if satisfied, will give a 
nkernelx.hxx:	static CLIENT RPTR(Lock) login (APTR(ID) ARG(clubID));
nkernelx.hxx:	/* Essential.  Return a lock which, if satisfied, will give a 
nkernelx.hxx:	static CLIENT RPTR(Lock) loginByName (APTR(Sequence) ARG(clubName));
nkernelx.hxx:	/* Essential.  The ID of the Universal Public Club. */
nkernelx.hxx:	static CLIENT RPTR(ID) publicClubID ();
nkernelx.hxx:	/* Essential. The public key to be used for sending sensitive 
nkernelx.hxx:	static CLIENT RPTR(UInt8Array) publicKey ();
nkernelx.hxx:	static CLIENT NOACK force ();
nkernelx.hxx:	/* Set the Server side fluid for the CurrentAuthor. */
nkernelx.hxx:	static CLIENT NOACK setCurrentAuthor (APTR(ID) ARG(iD));
nkernelx.hxx:	/* Set the Server side fluid for the CurrentKeyMaster. */
nkernelx.hxx:	static CLIENT NOACK setCurrentKeyMaster (APTR(FeKeyMaster) ARG(km));
nkernelx.hxx:	static CLIENT NOACK setInitialEditClub (APTR(ID) ARG(iD));
nkernelx.hxx:	static CLIENT NOACK setInitialOwner (APTR(ID) ARG(iD));
nkernelx.hxx:	static CLIENT NOACK setInitialReadClub (APTR(ID) ARG(iD));
nkernelx.hxx:	static CLIENT NOACK setInitialSponsor (APTR(ID) ARG(iD));
nkernelx.hxx:	/* Essential.  Assign a new global ID to a RangeElement. If 
nkernelx.hxx:	CurrentKeyMaster must have been granted authority to assign 
nkernelx.hxx:	static CLIENT RPTR(ID) assignID (APTR(FeRangeElement) ARG(range), APTR(ID) ARG(iD) = NULL);
nkernelx.hxx:	static CLIENT RPTR(ID) clubDirectoryID ();
nkernelx.hxx:	/* Essential.  Get the object associated with the given 
nkernelx.hxx:	static CLIENT RPTR(FeRangeElement) get (APTR(ID) ARG(iD));
nkernelx.hxx:	assigned to this RangeElement. Blast if there is none, or 
nkernelx.hxx:		Equivalent to
nkernelx.hxx:	static CLIENT RPTR(ID) iDOf (APTR(FeRangeElement) ARG(value));
nkernelx.hxx:	/* Essential.  Find all the global IDs on this Server that 
nkernelx.hxx:	have been assigned to this RangeElement */
nkernelx.hxx:	static CLIENT RPTR(IDRegion) iDsOf (APTR(FeRangeElement) ARG(value));
nkernelx.hxx:	assigned to any of the RangeElements in an Edition */
nkernelx.hxx:	static CLIENT RPTR(IDRegion) iDsOfRange (APTR(FeEdition) ARG(edition));
nkernelx.hxx:	/* The current clock time on the Server, in seconds since the 
nkernelx.hxx:	static CLIENT IntegerVar currentTime ();
nkernelx.hxx:	/* The LockSmith which hands out locks when a client tries to 
nkernelx.hxx:	/* Essential. A sequence of numbers uniquely identifying this Server */
nkernelx.hxx:	static CLIENT RPTR(Sequence) identifier ();
nkernelx.hxx:	/* This is currently a no-op. */
nkernelx.hxx:	/* Essential.  The Detector will be triggered when the 
nkernelx.hxx:	static CLIENT RPTR(FeWaitDetector) waitForConsequences ();
nkernelx.hxx:	/* Essential.  The Detector will be triggered when the 
nkernelx.hxx:	/* Essential.  The Detector will be triggered when the 
nkernelx.hxx:	current state of the Server has been reliably written to disk.
nkernelx.hxx:	static CLIENT RPTR(FeWaitDetector) waitForWrite ();
nkernelx.hxx:	/* Essential.  The Detector will be triggered when the 
nkernelx.hxx:	current state of the Server has been reliably written to disk.
nkernelx.hxx:	/* Essential. A specification for arrays of pointers. */
nkernelx.hxx:	/* Essential. The encryption scheme to be used for sending 
nkernelx.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
nkernelx.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
nkernelx.ixx: *                    Class   FeElementBundle 
nkernelx.ixx: *                    Class FeRangeElement 
nkernelx.ixx:/* client accessing */
nkernelx.ixx:INLINE Int32 FeEdition::FROM_OTHER_TRANSITIVE_CONTENTS () CONST{
nkernelx.ixx:	RangeElements contained transitively within the other Edition */
nkernelx.ixx:INLINE Int32 FeEdition::FROM_TRANSITIVE_CONTENTS () CONST{
nkernelx.ixx:	RangeElements contained transitively inside the Edition, as 
nkernelx.ixx:	well as just its immediate RangeElements */
nkernelx.ixx:	be organized according to a different ordering. */
nkernelx.ixx:	presented in any order. */
nkernelx.ixx:INLINE Int32 FeEdition::LOCAL_PRESENT_ONLY () CONST{
nkernelx.ixx:	return items which are currently known to this server */
nkernelx.ixx:INLINE Int32 FeEdition::otherTransitiveContents () CONST{
nkernelx.ixx:INLINE Int32 FeEdition::thisTransitiveContents () CONST{
nkernelx.ixx:INLINE Int32 FeEdition::TO_TRANSITIVE_CONTENTS () CONST{
nkernelx.ixx:	/* For cost - count the entire cost of shared material */
nkernelx.ixx:/* client implementation */
nkernelx.ixx:/* client accessing */
nkernelx.ixx:/* contents */
nkernelx.ixx:/* server contents */
nkernelx.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
nkernelx.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
nkernelx.oxx:OPAQUE_TYPE_3(FeElementBundle,FeBundle,Heaper);
nkernelx.oxx:OPAQUE_TYPE_2(FeRangeElement,Heaper);
nkernelx.oxx:OPAQUE_TYPE_3(FeDataHolder,FeRangeElement,Heaper);
nkernelx.oxx:OPAQUE_TYPE_3(FeEdition,FeRangeElement,Heaper);
nkernelx.oxx:OPAQUE_TYPE_3(FeIDHolder,FeRangeElement,Heaper);
nkernelx.oxx:OPAQUE_TYPE_3(FeLabel,FeRangeElement,Heaper);
nkernelx.oxx:OPAQUE_TYPE_3(FePlaceHolder,FeRangeElement,Heaper);
nkernelx.oxx:OPAQUE_TYPE_3(FeWork,FeRangeElement,Heaper);
nkernelx.oxx:OPAQUE_TYPE_4(FeClub,FeWork,FeRangeElement,Heaper);
nlinksx.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
nlinksx.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
nlinksx.cxx:	Ignore other contents. */
nlinksx.cxx:		BEGIN_FOR_EACH(FeRangeElement,r,(sub->stepper())) {
nlinksx.cxx:	edition->endorse(FeServer::endorsementRegion(CAST(IDRegion,CurrentAuthor.fluidGet()->asRegion()), FeServer::iDsOfRange(CAST(FeEdition,edition->get(Sequence::string("Link:LinkTypes"))))));
nlinksx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
nlinksx.cxx:	BEGIN_FOR_EACH(FeRangeElement,t,(types->stepper())) {
nlinksx.cxx:		BLAST(MustUseDifferentLinkEndKey);
nlinksx.cxx:	/* The various type documents describing this kind of Link. 
nlinksx.cxx:	These documents are typically Editions with descriptions at 
nlinksx.cxx:		BLAST(MustUseDifferentLinkEndName);
nlinksx.cxx:	/* Replace the set of type documents describing this kind of Link */
nlinksx.cxx:		BLAST(MustUseDifferentLinkEndName);
nlinksx.cxx:	Ignore other contents. */
nlinksx.cxx:/* Represents a single attachment to some material in context. */
nlinksx.cxx:	/* A Work frozen on the contents of the Work at the time the 
nlinksx.cxx:	Ignore other contents. */
nlinksx.cxx:/* An undifferentiated set of HyperRefs */
nlinksx.cxx:	/* With a different refs Edition */
nlinksx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
nlinksx.cxx:		returnValue = this->withRefsEdition(this->refsEdition()->copy(keys->complement()));
nlinksx.cxx:	/* Make a new HyperRef of the same type with different contents */
nlinksx.cxx:	Ignore other contents. */
nlinksx.cxx:/* Represents a single attachment to some material in the context of 
nlinksx.cxx:	/* Make this Ref point at different material. */
nlinksx.cxx:	/* Make a new HyperRef of the same type with different contents */
nlinksx.cxx:RPTR(FeRangeElement) FePath::follow (APTR(FeEdition) edition){
nlinksx.cxx:	SPTR(FeRangeElement) result;
nlinksx.cxx:	WPTR(FeRangeElement) 	returnValue;
nlinksx.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
nlinksx.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
nlinksx.hxx:	ON_CLIENT(FeHyperLink)
nlinksx.hxx:	Ignore other contents. */
nlinksx.hxx:	static CLIENT RPTR(FeHyperLink) make (
nlinksx.hxx:	virtual CLIENT RPTR(FeHyperRef) endAt (APTR(Sequence) ARG(name));
nlinksx.hxx:	virtual CLIENT RPTR(SequenceRegion) endNames ();
nlinksx.hxx:	/* The various type documents describing this kind of Link. 
nlinksx.hxx:	These documents are typically Editions with descriptions at 
nlinksx.hxx:	virtual CLIENT RPTR(FeSet) OF1(FeWork) linkTypes ();
nlinksx.hxx:	virtual CLIENT RPTR(FeHyperLink) withEnd (APTR(Sequence) ARG(name), APTR(FeHyperRef) ARG(linkEnd));
nlinksx.hxx:	/* Replace the set of type documents describing this kind of Link */
nlinksx.hxx:	virtual CLIENT RPTR(FeHyperLink) withLinkTypes (APTR(FeSet) OF1(FeWork) ARG(types));
nlinksx.hxx:	virtual CLIENT RPTR(FeHyperLink) withoutEnd (APTR(Sequence) ARG(name));
nlinksx.hxx:	/* Represents a single attachment to some material in context. */
nlinksx.hxx:	ON_CLIENT(FeHyperRef)
nlinksx.hxx:	Ignore other contents. */
nlinksx.hxx:	/* A Work frozen on the contents of the Work at the time the 
nlinksx.hxx:	virtual CLIENT RPTR(FeWork) originalContext ();
nlinksx.hxx:	virtual CLIENT RPTR(FePath) pathContext ();
nlinksx.hxx:	virtual CLIENT RPTR(FeHyperRef) withOriginalContext (APTR(FeWork) OR(NULL) ARG(work));
nlinksx.hxx:	virtual CLIENT RPTR(FeHyperRef) withPathContext (APTR(FePath) OR(NULL) ARG(path));
nlinksx.hxx:	virtual CLIENT RPTR(FeHyperRef) withWorkContext (APTR(FeWork) OR(NULL) ARG(work));
nlinksx.hxx:	virtual CLIENT RPTR(FeWork) workContext ();
nlinksx.hxx:	/* Make a new HyperRef of the same type with different contents */
nlinksx.hxx:	/* An undifferentiated set of HyperRefs */
nlinksx.hxx:	ON_CLIENT(FeMultiRef)
nlinksx.hxx:	Ignore other contents. */
nlinksx.hxx:	static CLIENT RPTR(FeMultiRef) make (
nlinksx.hxx:	/* With a different refs Edition */
nlinksx.hxx:	virtual CLIENT RPTR(FeMultiRef) intersect (APTR(FeMultiRef) ARG(other));
nlinksx.hxx:	virtual CLIENT RPTR(FeMultiRef) minus (APTR(FeMultiRef) ARG(other));
nlinksx.hxx:	virtual CLIENT RPTR(Stepper) OF1(FeHyperRef) refs ();
nlinksx.hxx:	virtual CLIENT RPTR(FeMultiRef) unionWith (APTR(FeMultiRef) ARG(other));
nlinksx.hxx:	virtual CLIENT RPTR(FeMultiRef) with (APTR(FeHyperRef) ARG(ref));
nlinksx.hxx:	virtual CLIENT RPTR(FeMultiRef) without (APTR(FeHyperRef) ARG(ref));
nlinksx.hxx:	/* Make a new HyperRef of the same type with different contents */
nlinksx.hxx:	/* Represents a single attachment to some material in the 
nlinksx.hxx:	ON_CLIENT(FeSingleRef)
nlinksx.hxx:	Ignore other contents. */
nlinksx.hxx:	static CLIENT RPTR(FeSingleRef) make (
nlinksx.hxx:	virtual CLIENT RPTR(FeEdition) excerpt ();
nlinksx.hxx:	/* Make this Ref point at different material. */
nlinksx.hxx:	virtual CLIENT RPTR(FeSingleRef) withExcerpt (APTR(FeEdition) ARG(excerpt));
nlinksx.hxx:	/* Make a new HyperRef of the same type with different contents */
nlinksx.hxx:	ON_CLIENT(FePath)
nlinksx.hxx:	static CLIENT RPTR(FePath) make (APTR(PtrArray) OF1(FeLabel) ARG(labels));
nlinksx.hxx:	virtual CLIENT RPTR(FeRangeElement) follow (APTR(FeEdition) ARG(edition));
nlinksx.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
nlinksx.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
nlinksx.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
nlinksx.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
orootp.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
orootp.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
orootp.hxx:	/* NO CLASS COMMENT */
orootp.hxx:	virtual RPTR(ImmuSet) OF1(OPart) oParents ();
orootp.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
orootp.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
orootp.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
orootp.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
orootx.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
orootx.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
orootx.cxx:#ifndef ENTX_HXX
orootx.cxx:#include "entx.hxx"
orootx.cxx:#endif /* ENTX_HXX */
orootx.cxx:	BEGIN_INSISTENT(2) {
orootx.cxx:	} END_INSISTENT;
orootx.cxx:UInt32 OPart::contentsHash (){
orootx.cxx:	return this->Abraham::contentsHash() ^ mySensorCrum->hashForEqual();
orootx.cxx:	BEGIN_CONSISTENT(4) {
orootx.cxx:	} END_CONSISTENT;
orootx.cxx:		APTR(PtrArray) OF1(FeRangeElement) values)
orootx.cxx:		SPTR(BeCarrier) element;
orootx.cxx:			BEGIN_KIND(FeRangeElement,fe){
orootx.cxx:				element = fe->carrier();
orootx.cxx:					BLAST(MustNotHaveNullElements);
orootx.cxx:		result = result->combine(ActualOrglRoot::make (Loaf::make (region, element), region));
orootx.cxx:RPTR(OrglRoot) OrglRoot::makeData (APTR(PrimDataArray) values, APTR(Arrangement) arrangement){
orootx.cxx:	returnValue = ActualOrglRoot::make (Loaf::make (values, arrangement), arrangement->region());
orootx.cxx:	BEGIN_CONSISTENT(3) {
orootx.cxx:	} END_CONSISTENT;
orootx.cxx:UInt32 OrglRoot::contentsHash (){
orootx.cxx:	return this->OPart::contentsHash() ^ myHCrum->hashForEqual();
orootx.cxx:	BEGIN_CONSISTENT(13) {
orootx.cxx:	} END_CONSISTENT;
orootx.cxx:	/* Cache for optimization: Frequently, in going northwards on 
orootx.cxx:void ActualOrglRoot::storeRecordingAgents (APTR(RecorderFossil) recorder, APTR(Agenda) agenda){
orootx.cxx:	myO->storeRecordingAgents(recorder, agenda);
orootx.cxx:	/* the kind of domain elements allowed */
orootx.cxx:RPTR(FeRangeElement) OR(NULL) ActualOrglRoot::fetch (APTR(Position) key, APTR(BeEdition) edition){
orootx.cxx:	/* get an individual element */
orootx.cxx:	WPTR(FeRangeElement) OR(NULL) 	returnValue;
orootx.cxx:RPTR(BeRangeElement) ActualOrglRoot::getBe (APTR(Position) key){
orootx.cxx:	/* Get or Make the BeRangeElement at the location. */
orootx.cxx:	{	FLUID_BIND(CurrentTrace,this->hCrum()->hCut()) {
orootx.cxx:			{	FLUID_BIND(CurrentBertCrum,this->hCrum()->bertCrum()) {
orootx.cxx:					WPTR(BeRangeElement) 	returnValue;
orootx.cxx:	/* Change the identities of the RangeElements of this Edition 
orootx.cxx:			- different contents
orootx.cxx:			- no corresponding new identity
orootx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
orootx.cxx:	returnValue = myO->bundleStepper(region, order, region->coordinateSpace()->identityDsp());
orootx.cxx:	returnValue = myO->combine(him, myRegion, this->coordinateSpace()->identityDsp());
orootx.cxx:		APTR(Arrangement) toArrange, 
orootx.cxx:	if (externalDsp->isIdentity()) {
orootx.cxx:	if (externalDsp->isIdentity()) {
orootx.cxx:	myO->addOParent(this);
orootx.cxx:		myOut = this->copy(bound->complement());
orootx.cxx:	BEGIN_CONSISTENT(4) {
orootx.cxx:			myO->removeOParent(this);
orootx.cxx:	} END_CONSISTENT;
orootx.cxx:UInt32 ActualOrglRoot::contentsHash (){
orootx.cxx:	return this->OrglRoot::contentsHash() ^ myO->hashForEqual() ^ myRegion->hashForEqual();
orootx.cxx:void EmptyOrglRoot::storeRecordingAgents (APTR(RecorderFossil) recorder, APTR(Agenda) agenda){
orootx.cxx:	/* the kind of domain elements allowed */
orootx.cxx:RPTR(FeRangeElement) OR(NULL) EmptyOrglRoot::fetch (APTR(Position) key, APTR(BeEdition) edition){
orootx.cxx:RPTR(BeRangeElement) EmptyOrglRoot::getBe (APTR(Position) key){
orootx.cxx:	/* Get or Make the BeRangeElement at the location. */
orootx.cxx:	returnValue = this->coordinateSpace()->identityDsp();
orootx.cxx:	/* There aren't any contents, so just return self. */
orootx.cxx:	/* I have no contents, so I can't shared anything. */
orootx.cxx:UInt32 EmptyOrglRoot::contentsHash (){
orootx.cxx:	return this->OrglRoot::contentsHash() ^ myCS->hashForEqual();
orootx.cxx:	RETURN_CONSTRUCT(HBottomCrum,(CurrentTrace.fluidGet(), CurrentBertCrum.fluidGet()));
orootx.cxx:RPTR(ImmuSet) OF1(OPart) HBottomCrum::oParents (){
orootx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
orootx.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
orootx.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
orootx.hxx:	/* NO CLASS COMMENT */
orootx.hxx:	virtual UInt32 contentsHash ();
orootx.hxx:	/* NO CLASS COMMENT */
orootx.hxx:			APTR(PtrArray) OF1(FeRangeElement) ARG(values))
orootx.hxx:	static RPTR(OrglRoot) makeData (APTR(PrimDataArray) ARG(values), APTR(Arrangement) ARG(arrangement));
orootx.hxx:	/* A Detector has been added to my parent. Walk down and 
orootx.hxx:	/* the kind of domain elements allowed */
orootx.hxx:	/* get an individual element */
orootx.hxx:	virtual RPTR(FeRangeElement) OR(NULL) fetch (APTR(Position) ARG(key), APTR(BeEdition) ARG(edition)) DEFERRED_FUNC;
orootx.hxx:	/* Get or Make the BeRangeElement at the location. */
orootx.hxx:	virtual RPTR(BeRangeElement) getBe (APTR(Position) ARG(key)) DEFERRED_FUNC;
orootx.hxx:	directly because our client needs to schedule something else 
orootx.hxx:	virtual void storeRecordingAgents (APTR(RecorderFossil) ARG(recorder), APTR(Agenda) ARG(agenda)) DEFERRED_SUBR;
orootx.hxx:	virtual UInt32 contentsHash ();
orootx.hxx:	/* NO CLASS COMMENT */
orootx.hxx:	virtual void storeRecordingAgents (APTR(RecorderFossil) ARG(recorder), APTR(Agenda) ARG(agenda));
orootx.hxx:	/* the kind of domain elements allowed */
orootx.hxx:	/* get an individual element */
orootx.hxx:	virtual RPTR(FeRangeElement) OR(NULL) fetch (APTR(Position) ARG(key), APTR(BeEdition) ARG(edition));
orootx.hxx:	/* Get or Make the BeRangeElement at the location. */
orootx.hxx:	virtual RPTR(BeRangeElement) getBe (APTR(Position) ARG(key));
orootx.hxx:	/* Change the identities of the RangeElements of this Edition 
orootx.hxx:			- different contents
orootx.hxx:			- no corresponding new identity
orootx.hxx:			APTR(Arrangement) ARG(toArrange), 
orootx.hxx:	virtual UInt32 contentsHash ();
orootx.hxx:	/* NO CLASS COMMENT */
orootx.hxx:	virtual NOLOCK void storeRecordingAgents (APTR(RecorderFossil) ARG(recorder), APTR(Agenda) ARG(agenda));
orootx.hxx:	/* the kind of domain elements allowed */
orootx.hxx:	virtual NOLOCK RPTR(FeRangeElement) OR(NULL) fetch (APTR(Position) ARG(key), APTR(BeEdition) ARG(edition));
orootx.hxx:	/* Get or Make the BeRangeElement at the location. */
orootx.hxx:	virtual RPTR(BeRangeElement) getBe (APTR(Position) ARG(key));
orootx.hxx:	/* There aren't any contents, so just return self. */
orootx.hxx:	/* I have no contents, so I can't shared anything. */
orootx.hxx:	virtual UInt32 contentsHash ();
orootx.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
orootx.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
orootx.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
orootx.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
propsp.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
propsp.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
propsp.hxx:	endorsement filters */
propsp.hxx:			APTR(Filter) OF1(CrossRegion OF1(ID)) ARG(endorsementsFilter))
propsp.hxx:	virtual RPTR(Filter) OF1(XnRegion OF1(ID)) endorsementsFilter ();
propsp.hxx:	CHKPTR(Filter) OF1(XnRegion OF1(ID)) myEndorsementsFilter;
propsp.hxx:	/* Currently unused but will be re-instated.  Used to find 
propsp.hxx:			APTR(BeRangeElement) ARG(element), 
propsp.hxx:	/* automatic 0-argument constructor */
propsp.hxx:			APTR(BeRangeElement) ARG(element), 
propsp.hxx:	/* automatic 0-argument constructor */
propsp.hxx: *                    Class EndorsementsChange 
propsp.hxx:	/* Used when the Endorsement part of a BertProp changed */
propsp.hxx:class EndorsementsChange : public PropChange {
propsp.hxx:/* Attributes for class EndorsementsChange */
propsp.hxx:	CONCRETE(EndorsementsChange)
propsp.hxx:	COPY(EndorsementsChange,DiskCuisine)
propsp.hxx:	NOT_A_TYPE(EndorsementsChange)
propsp.hxx:	NO_GC(EndorsementsChange)
propsp.hxx:			APTR(BeRangeElement) ARG(element), 
propsp.hxx:	/* automatic 0-argument constructor */
propsp.hxx:	EndorsementsChange();
propsp.hxx:};  /* end class EndorsementsChange */
propsp.hxx:			APTR(BeRangeElement) ARG(element), 
propsp.hxx:	/* automatic 0-argument constructor */
propsp.hxx:			APTR(BeRangeElement) ARG(element), 
propsp.hxx:	/* automatic 0-argument constructor */
propsp.hxx:			APTR(BeRangeElement) ARG(element), 
propsp.hxx:	/* automatic 0-argument constructor */
propsp.hxx:			APTR(BeRangeElement) ARG(element), 
propsp.hxx:	/* automatic 0-argument constructor */
propsp.hxx:		 looking for recorders that represent queries that are newly 
propsp.hxx:	itself are represented by my state,
propsp.hxx:		 See class comments of the various subclasses for details on 
propsp.hxx:	all recorders, and all elements they might find, resulting 
propsp.hxx:	in endorsements. Also remembers the (approximate) permissions 
propsp.hxx:	on the object whose endorsements changed */
propsp.hxx:	static RPTR(PropFinder) make (APTR(IDRegion) ARG(permissions), APTR(RegionDelta) OF1(CrossRegion) ARG(endorsementsDelta));
propsp.hxx:			APTR(RegionDelta) OF1(CrossRegion) ARG(endorsementsDelta), 
propsp.hxx:			APTR(CrossRegion) ARG(newEndorsements))
propsp.hxx:	virtual RPTR(RegionDelta) OF1(CrossRegion) endorsementsDelta ();
propsp.hxx:	virtual RPTR(CrossRegion) newEndorsements ();
propsp.hxx:			APTR(RegionDelta) OF1(CrossRegion) ARG(endorsementsDelta), 
propsp.hxx:			APTR(CrossRegion) ARG(newEndorsements))
propsp.hxx:	CHKPTR(RegionDelta) OF1(CrossRegion) myEndorsementsDelta;
propsp.hxx:	CHKPTR(CrossRegion) myNewEndorsements;
propsp.hxx:	interested in it, and picking up all elements which might 
propsp.hxx:	triggered by specific Works or Editions. The current set 
propsp.hxx:	contains those which might record the current edition, and 
propsp.hxx:			APTR(ImmuSet) OF1(SimpleRecorderFinder) ARG(current), 
propsp.hxx:			APTR(ImmuSet) OF1(SimpleRecorderFinder) ARG(current), 
propsp.hxx:	virtual RPTR(ImmuSet) OF1(AnyRecorderFinder) current ();
propsp.hxx:	virtual RPTR(PropFinder) pass (APTR(CanopyCrum) ARG(parent));
propsp.hxx:	CHKPTR(ImmuSet) OF1(SimpleRecorderFinder) myCurrent;
propsp.hxx:	/* A finder which holds onto a RangeElement and looks for 
propsp.hxx:	/* Whether the recorder should be triggered with my RangeElement */
propsp.hxx:	SimpleRecorderFinder (UInt32 ARG(flags), APTR(BeRangeElement) ARG(element));
propsp.hxx:	virtual RPTR(BeRangeElement) rangeElement ();
propsp.hxx:	CHKPTR(BeRangeElement) myRangeElement;
propsp.hxx:	increase in endorsements in something containing my edition. 
propsp.hxx:	Keep the total endorsements on my edition for quick reject? */
propsp.hxx:			APTR(BeRangeElement) ARG(element), 
propsp.hxx:			APTR(RegionDelta) OF1(CrossRegion) ARG(endorsementsDelta))
propsp.hxx:			APTR(BeRangeElement) ARG(element), 
propsp.hxx:			APTR(RegionDelta) OF1(CrossRegion) ARG(endorsementsDelta), 
propsp.hxx:			APTR(CrossRegion) ARG(newEndorsements))
propsp.hxx:	virtual RPTR(RegionDelta) OF1(CrossRegion) endorsementsDelta ();
propsp.hxx:	virtual RPTR(CrossRegion) newEndorsements ();
propsp.hxx:			APTR(BeRangeElement) ARG(element), 
propsp.hxx:			APTR(RegionDelta) OF1(CrossRegion) ARG(endorsementsDelta), 
propsp.hxx:			APTR(CrossRegion) ARG(newEndorsements))
propsp.hxx:	CHKPTR(RegionDelta) OF1(CrossRegion) myEndorsementsDelta;
propsp.hxx:	CHKPTR(CrossRegion) myNewEndorsements;
propsp.hxx:	increase in endorsements on my RangeElement itself */
propsp.hxx:			APTR(BeRangeElement) ARG(element), 
propsp.hxx:			APTR(RegionDelta) OF1(CrossRegion) ARG(endorsementsDelta))
propsp.hxx:			APTR(BeRangeElement) ARG(element), 
propsp.hxx:			APTR(RegionDelta) OF1(CrossRegion) ARG(endorsementsDelta), 
propsp.hxx:			APTR(CrossRegion) ARG(newEndorsements))
propsp.hxx:	virtual RPTR(RegionDelta) OF1(CrossRegion) endorsementsDelta ();
propsp.hxx:	virtual RPTR(CrossRegion) newEndorsements ();
propsp.hxx:			APTR(BeRangeElement) ARG(element), 
propsp.hxx:			APTR(RegionDelta) OF1(CrossRegion) ARG(endorsementsDelta), 
propsp.hxx:			APTR(CrossRegion) ARG(newEndorsements))
propsp.hxx:	CHKPTR(RegionDelta) OF1(CrossRegion) myEndorsementsDelta;
propsp.hxx:	CHKPTR(CrossRegion) myNewEndorsements;
propsp.hxx:	in visibility of my RangeElement */
propsp.hxx:			APTR(BeRangeElement) ARG(element), 
propsp.hxx:			APTR(CrossRegion) ARG(endorsements))
propsp.hxx:			APTR(BeRangeElement) ARG(element), 
propsp.hxx:			APTR(CrossRegion) ARG(endorsements))
propsp.hxx:			APTR(BeRangeElement) ARG(element), 
propsp.hxx:			APTR(CrossRegion) ARG(endorsements))
propsp.hxx:	virtual RPTR(CrossRegion) endorsements ();
propsp.hxx:	CHKPTR(CrossRegion) myEndorsements;
propsp.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
propsp.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
propsp.ixx: *                    Class EndorsementsChange 
propsp.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
propsp.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
propsp.oxx:class EndorsementsChange;
propsp.oxx:extern Category * cat_EndorsementsChange;
propsx.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
propsx.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
propsx.cxx:	/* automatic 0-argument constructor */
propsx.cxx:GPTR(BertProp) BertProp::TheIdentityBertProp = NULL;
propsx.cxx:	returnValue = BertProp::make (IDSpace::global()->emptyRegion(), CurrentGrandMap.fluidGet()->endorsementSpace()->emptyRegion(), FALSE, TRUE);
propsx.cxx:	returnValue = BertProp::make (CurrentGrandMap.fluidGet()->globalIDSpace()->emptyRegion(), CurrentGrandMap.fluidGet()->endorsementSpace()->emptyRegion(), TRUE, FALSE);
propsx.cxx:RPTR(BertProp) BertProp::endorsementsProp (APTR(XnRegion) endorsements){
propsx.cxx:	returnValue = BertProp::make (IDSpace::global()->emptyRegion(), endorsements, FALSE, FALSE);
propsx.cxx:	if (BertProp::TheIdentityBertProp == NULL) {
propsx.cxx:		BertProp::TheIdentityBertProp = 
propsx.cxx:				BertProp::make (IDSpace::global()->emptyRegion(), CurrentGrandMap.fluidGet()->endorsementSpace()->emptyRegion(), FALSE, FALSE);
propsx.cxx:	returnValue = BertProp::TheIdentityBertProp;
propsx.cxx:		APTR(XnRegion) endorsements, 
propsx.cxx:	RETURN_CONSTRUCT(BertProp,(permissions, endorsements, isSensorWaiting, isNotPartializable));
propsx.cxx:	returnValue = BertProp::make (iDs, CurrentGrandMap.fluidGet()->endorsementSpace()->emptyRegion(), FALSE, FALSE);
propsx.cxx:RPTR(CrossRegion) BertProp::endorsements (){
propsx.cxx:	return CAST(CrossRegion,myEndorsements);
propsx.cxx:	return BertCrum::flagsFor(CAST(IDRegion,myPermissions), CAST(CrossRegion,myEndorsements), myCannotPartializeFlag, mySensorWaitingFlag);
propsx.cxx:	returnValue = BertProp::make (myPermissions->unionWith(o->permissions()), myEndorsements->unionWith(o->endorsements()), mySensorWaitingFlag || o->isSensorWaiting(), myCannotPartializeFlag || o->isNotPartializable());
propsx.cxx:		APTR(XnRegion) OF1(ID) endorsements, 
propsx.cxx:	myEndorsements = endorsements;
propsx.cxx:	return myPermissions->hashForEqual() ^ myEndorsements->hashForEqual();
propsx.cxx:		/* myEndorsements->isEmpty() && myPermissions->isEmpty() */
propsx.cxx:		crutch_Flag = myEndorsements->isEmpty();
propsx.cxx:				/* b->endorsements()->isEqual(myEndorsements) && b->permissions()->isEqual(myPermissions) && b->isSensorWaiting() == mySensorWaitingFlag && b->isNotPartializable() == myCannotPartializeFlag */
propsx.cxx:				crutch_Flag = b->endorsements()->isEqual(myEndorsements);
propsx.cxx:	oo << this->getCategory()->name() << "(P: " << myPermissions << "; E: " << myEndorsements;
propsx.cxx:GPTR(SensorProp) SensorProp::TheIdentitySensorProp = NULL;
propsx.cxx:	if (SensorProp::TheIdentitySensorProp == NULL) {
propsx.cxx:		CONSTRUCT(SensorProp::TheIdentitySensorProp,SensorProp,(CAST(IDRegion,CurrentGrandMap.fluidGet()->globalIDSpace()->emptyRegion()), CAST(CrossRegion,CurrentGrandMap.fluidGet()->endorsementSpace()->emptyRegion()), FALSE));
propsx.cxx:	returnValue = SensorProp::TheIdentitySensorProp;
propsx.cxx:		APTR(CrossRegion) relevantEndorsements, 
propsx.cxx:	RETURN_CONSTRUCT(SensorProp,(relevantPermissions, relevantEndorsements, isPartial));
propsx.cxx:		CONSTRUCT(SensorProp::ThePartialSensorProp,SensorProp,(CAST(IDRegion,CurrentGrandMap.fluidGet()->globalIDSpace()->emptyRegion()), CAST(CrossRegion,CurrentGrandMap.fluidGet()->endorsementSpace()->emptyRegion()), TRUE));
propsx.cxx:Canopy.  The permissions and endorsements are those whose changes may 
propsx.cxx:		APTR(CrossRegion) OF2(IDRegion,IDRegion) relevantEndorsements, 
propsx.cxx:	myRelevantEndorsements = relevantEndorsements;
propsx.cxx:	return SensorCrum::flagsFor(myRelevantPermissions, myRelevantEndorsements, myPartialFlag);
propsx.cxx:RPTR(CrossRegion) SensorProp::relevantEndorsements (){
propsx.cxx:	return (CrossRegion*) myRelevantEndorsements;
propsx.cxx:			returnValue = SensorProp::make (CAST(IDRegion,myRelevantPermissions->unionWith(o->relevantPermissions())), CAST(CrossRegion,myRelevantEndorsements->unionWith(o->relevantEndorsements())), myPartialFlag || o->isPartial());
propsx.cxx:	return myRelevantPermissions->hashForEqual() ^ myRelevantEndorsements->hashForEqual();
propsx.cxx:				/* myRelevantEndorsements->isEqual(prop->relevantEndorsements()) && myRelevantPermissions->isEqual(prop->relevantPermissions()) && myPartialFlag == prop->isPartial() */
propsx.cxx:				crutch_Flag = myRelevantEndorsements->isEqual(prop->relevantEndorsements());
propsx.cxx:	oo << "SensorProp(P: " << myRelevantPermissions << "; E: " << myRelevantEndorsements;
propsx.cxx:GPTR(PropChange) PropChange::TheEndorsementsChange = NULL;
propsx.cxx:	CONSTRUCT(PropChange::TheEndorsementsChange,EndorsementsChange,());
propsx.cxx:RPTR(PropChange) PropChange::endorsementsChange (){
propsx.cxx:	returnValue = PropChange::TheEndorsementsChange;
propsx.cxx:	(permissions and endorsement filters).  A better name would 
propsx.cxx:A PropChange is used to represent which property aspect changed (such 
propsx.cxx:as permission vs endorsement vs both). */
propsx.cxx:	/* automatic 0-argument constructor */
propsx.cxx:RPTR(PropFinder) PropFinder::backfollowFinder (APTR(Filter) OF1(XnRegion OF1(ID)) permissionsFilter, APTR(Filter) OF1(XnRegion OF1(ID)) endorsementsFilter){
propsx.cxx:		/* permissionsFilter->isEmpty() || endorsementsFilter->isEmpty() */
propsx.cxx:			crutch_Flag = endorsementsFilter->isEmpty();
propsx.cxx:	if (endorsementsFilter->isFull()) {
propsx.cxx:		BertCrum::flagsFor(CAST(IDRegion,permissionsFilter->relevantRegion()), CAST(CrossRegion,endorsementsFilter->relevantRegion()), FALSE, FALSE), permissionsFilter, endorsementsFilter));
propsx.cxx:BooleanVar PropFinder::doesPass (APTR(CanopyCrum) parent){
propsx.cxx:	return (myFlags | parent->flags()) != UInt32Zero;
propsx.cxx:RPTR(PropFinder) PropFinder::pass (APTR(CanopyCrum) parent){
propsx.cxx:	if (this->doesPass(parent)) {
propsx.cxx:a backFollow which uses both permissions and endorsement filters */
propsx.cxx:		APTR(Filter) OF1(CrossRegion OF1(ID)) endorsementsFilter) 
propsx.cxx:	myEndorsementsFilter = endorsementsFilter;
propsx.cxx:RPTR(Filter) OF1(XnRegion OF1(ID)) BackfollowFinder::endorsementsFilter (){
propsx.cxx:	return (Filter*) myEndorsementsFilter;
propsx.cxx:	SPTR(XnRegion) endorsements;
propsx.cxx:	endorsements = edition->endorsements();
propsx.cxx:	BEGIN_FOR_EACH(BeWork,work,(edition->currentWorks()->stepper())) {
propsx.cxx:				endorsements = endorsements->unionWith(work->endorsements());
propsx.cxx:	if (myEndorsementsFilter->match(endorsements)) {
propsx.cxx:		/* myPermissionsFilter->match(p->permissions()) && myEndorsementsFilter->match(p->endorsements()) */
propsx.cxx:			crutch_Flag = myEndorsementsFilter->match(p->endorsements());
propsx.cxx:	return this->getCategory()->hashForEqual() ^ myPermissionsFilter->hashForEqual() ^ myEndorsementsFilter->hashForEqual();
propsx.cxx:				/* myPermissionsFilter->isEqual(o->permissionsFilter()) && myEndorsementsFilter->isEqual(o->endorsementsFilter()) */
propsx.cxx:					crutch_Flag = myEndorsementsFilter->isEqual(o->endorsementsFilter());
propsx.cxx:	BEGIN_FOR_EACH(BeWork,work,(edition->currentWorks()->stepper())) {
propsx.cxx:/* Currently unused but will be re-instated.  Used to find which 
propsx.cxx:	returnValue = BertProp::make (bp->permissions(), bp->endorsements(), bp->isSensorWaiting(), abp->isNotPartializable());
propsx.cxx:		APTR(BeRangeElement) /* element */, 
propsx.cxx:			returnValue = BertProp::make (bp->permissions(), bp->endorsements(), bp->isSensorWaiting(), abp->isNotPartializable());
propsx.cxx:	/* automatic 0-argument constructor */
propsx.cxx:	returnValue = BertProp::make (bp->permissions(), bp->endorsements(), abp->isSensorWaiting(), bp->isNotPartializable());
propsx.cxx:		APTR(BeRangeElement) /* element */, 
propsx.cxx:			returnValue = BertProp::make (bp->permissions(), bp->endorsements(), abp->isSensorWaiting(), bp->isNotPartializable());
propsx.cxx:	/* automatic 0-argument constructor */
propsx.cxx: *                    Class EndorsementsChange 
propsx.cxx:/* Used when the Endorsement part of a BertProp changed */
propsx.cxx:BooleanVar EndorsementsChange::areEqualProps (APTR(Prop) a, APTR(Prop) b){
propsx.cxx:	return CAST(BertProp,a)->endorsements()->isEqual(CAST(BertProp,b)->endorsements());
propsx.cxx:RPTR(Prop) EndorsementsChange::changed (APTR(Prop) old, APTR(Prop) a){
propsx.cxx:	returnValue = BertProp::make (bp->permissions(), CAST(BertProp,a)->endorsements(), bp->isSensorWaiting(), bp->isNotPartializable());
propsx.cxx:RPTR(PropFinder) OR(NULL) EndorsementsChange::fetchFinder (
propsx.cxx:		APTR(BeRangeElement) element, 
propsx.cxx:					delta = RegionDelta::make (b->endorsements(), a->endorsements());
propsx.cxx:							OriginalResultRecorderEFinder::make (element, CAST(IDRegion,a->permissions()), delta);
propsx.cxx:										CumulativeRecorderFinder::make (anys, simples, crf->current()->unionWith(crf->others()));
propsx.cxx:BooleanVar EndorsementsChange::isFull (){
propsx.cxx:RPTR(Prop) EndorsementsChange::with (APTR(Prop) old, APTR(Prop) a){
propsx.cxx:	returnValue = BertProp::make (bp->permissions(), CAST(BertProp,a)->endorsements()->unionWith(bp->endorsements()), bp->isSensorWaiting(), bp->isNotPartializable());
propsx.cxx:	/* automatic 0-argument constructor */
propsx.cxx:EndorsementsChange::EndorsementsChange() {}
propsx.cxx:	/* automatic 0-argument constructor */
propsx.cxx:		APTR(BeRangeElement) element, 
propsx.cxx:			PropChange::permissionsChange()->fetchFinder(before, after, element, oldFinder);
propsx.cxx:			PropChange::endorsementsChange()->fetchFinder(before, after, element, oldFinder);
propsx.cxx:					returnValue = CumulativeRecorderFinder::make (pcrf->generators()->unionWith(ecrf->generators()), pcrf->current()->unionWith(ecrf->current()), pcrf->others()->unionWith(ecrf->others()));
propsx.cxx:	/* automatic 0-argument constructor */
propsx.cxx:		APTR(BeRangeElement) /* element */, 
propsx.cxx:	/* automatic 0-argument constructor */
propsx.cxx:	returnValue = BertProp::make (CAST(BertProp,a)->permissions(), bp->endorsements(), bp->isSensorWaiting(), bp->isNotPartializable());
propsx.cxx:		APTR(BeRangeElement) element, 
propsx.cxx:							ResultRecorderPFinder::make (element, delta, a->endorsements());
propsx.cxx:										CumulativeRecorderFinder::make (anys, simples, crf->current()->unionWith(crf->others()));
propsx.cxx:	returnValue = BertProp::make (CAST(BertProp,a)->permissions()->unionWith(bp->permissions()), bp->endorsements(), bp->isSensorWaiting(), bp->isNotPartializable());
propsx.cxx:	/* automatic 0-argument constructor */
propsx.cxx:recorders, and all elements they might find, resulting from a given change. */
propsx.cxx:RPTR(PropFinder) AnyRecorderEFinder::make (APTR(IDRegion) permissions, APTR(RegionDelta) OF1(CrossRegion) endorsementsDelta){
propsx.cxx:	returnValue = AnyRecorderEFinder::make (permissions, endorsementsDelta, CAST(CrossRegion,endorsementsDelta->after()->minus(endorsementsDelta->before())));
propsx.cxx:		APTR(RegionDelta) OF1(CrossRegion) endorsementsDelta, 
propsx.cxx:		APTR(CrossRegion) newEndorsements)
propsx.cxx:		/* permissions->isEmpty() || newEndorsements->isEmpty() */
propsx.cxx:			crutch_Flag = newEndorsements->isEmpty();
propsx.cxx:		SensorCrum::flagsFor(permissions, newEndorsements, FALSE), permissions, endorsementsDelta, newEndorsements));
propsx.cxx:endorsements. Also remembers the (approximate) permissions on the 
propsx.cxx:object whose endorsements changed */
propsx.cxx:RPTR(RegionDelta) OF1(CrossRegion) AnyRecorderEFinder::endorsementsDelta (){
propsx.cxx:	return (RegionDelta*) myEndorsementsDelta;
propsx.cxx:				/* p->relevantPermissions()->intersects(myPermissions) && p->relevantEndorsements()->intersects(myNewEndorsements) */
propsx.cxx:					crutch_Flag = p->relevantEndorsements()->intersects(myNewEndorsements);
propsx.cxx:RPTR(CrossRegion) AnyRecorderEFinder::newEndorsements (){
propsx.cxx:	return (CrossRegion*) myNewEndorsements;
propsx.cxx:	returnValue = ContainedEditionRecorderEFinder::make (edition, myPermissions, myEndorsementsDelta, myNewEndorsements);
propsx.cxx:		APTR(RegionDelta) OF1(CrossRegion) endorsementsDelta, 
propsx.cxx:		APTR(CrossRegion) newEndorsements) 
propsx.cxx:	myEndorsementsDelta = endorsementsDelta;
propsx.cxx:	myNewEndorsements = newEndorsements;
propsx.cxx:	return myPermissions->hashForEqual() ^ myEndorsementsDelta->hashForEqual() ^ myNewEndorsements->hashForEqual();
propsx.cxx:				/* myPermissions->isEqual(other->permissions()) && myEndorsementsDelta->isEqual(other->endorsementsDelta()) && myNewEndorsements->isEqual(other->newEndorsements()) */
propsx.cxx:					crutch_Flag = myEndorsementsDelta->isEqual(other->endorsementsDelta());
propsx.cxx:						crutch_Flag = myNewEndorsements->isEqual(other->newEndorsements());
propsx.cxx:	returnValue = ResultRecorderPFinder::make (edition, myPermissionsDelta, myPermissions, edition->totalEndorsements());
propsx.cxx:		APTR(ImmuSet) OF1(SimpleRecorderFinder) current, 
propsx.cxx:	/* since current & generators can have at most two elements, 
propsx.cxx:		represent them explicitly as two OR(NULL) pointers? 
propsx.cxx:	BEGIN_FOR_EACH(SimpleRecorderFinder,c,(current->stepper())) {
propsx.cxx:	RETURN_CONSTRUCT(CumulativeRecorderFinder,(f, generators, current, others));
propsx.cxx:it, and picking up all elements which might newly be made visible by 
propsx.cxx:for recorders triggered by specific Works or Editions. The current 
propsx.cxx:set contains those which might record the current edition, and are 
propsx.cxx:	BEGIN_FOR_EACH(SimpleRecorderFinder,current,(myCurrent->stepper())) {
propsx.cxx:		current->checkRecorder(recorder, fossil);
propsx.cxx:		APTR(ImmuSet) OF1(SimpleRecorderFinder) current, 
propsx.cxx:	myCurrent = current;
propsx.cxx:RPTR(ImmuSet) OF1(AnyRecorderFinder) CumulativeRecorderFinder::current (){
propsx.cxx:	return (ImmuSet*) myCurrent;
propsx.cxx:	SPTR(SetAccumulator) newCurrent;
propsx.cxx:	newCurrent = SetAccumulator::make ();
propsx.cxx:			newCurrent->step(CAST(SimpleRecorderFinder,next));
propsx.cxx:	returnValue = CumulativeRecorderFinder::make (myGenerators, CAST(ImmuSet,newCurrent->value()), myOthers->unionWith(myCurrent));
propsx.cxx:RPTR(PropFinder) CumulativeRecorderFinder::pass (APTR(CanopyCrum) parent){
propsx.cxx:	BEGIN_CHOOSE(parent) {
propsx.cxx:			SPTR(SetAccumulator) newCurrent;
propsx.cxx:			newCurrent = SetAccumulator::make ();
propsx.cxx:			BEGIN_FOR_EACH(PropFinder,current,(myCurrent->stepper())) {
propsx.cxx:				past = current->pass(p);
propsx.cxx:					newCurrent->step(past);
propsx.cxx:			returnValue = CumulativeRecorderFinder::make (CAST(ImmuSet,newGenerators->value()), CAST(ImmuSet,newCurrent->value()), CAST(ImmuSet,newOthers->value()));
propsx.cxx:	return myGenerators->hashForEqual() ^ myCurrent->hashForEqual() ^ myOthers->hashForEqual();
propsx.cxx:				/* myGenerators->isEqual(other->generators()) && myCurrent->isEqual(other->current()) && myOthers->isEqual(other->others()) */
propsx.cxx:					crutch_Flag = myCurrent->isEqual(other->current());
propsx.cxx:/* A finder which holds onto a RangeElement and looks for 
propsx.cxx:		/* recorder->accepts(this->rangeElement()) && this->shouldTrigger(recorder, fossil) */
propsx.cxx:		crutch_Flag = recorder->accepts(this->rangeElement());
propsx.cxx:			RecorderTrigger::make (fossil, myRangeElement)->schedule();
propsx.cxx:SimpleRecorderFinder::SimpleRecorderFinder (UInt32 flags, APTR(BeRangeElement) element) 
propsx.cxx:	myRangeElement = element;
propsx.cxx:	return CAST(BeEdition,myRangeElement);
propsx.cxx:RPTR(BeRangeElement) SimpleRecorderFinder::rangeElement (){
propsx.cxx:	return (BeRangeElement*) myRangeElement;
propsx.cxx:	return CAST(BeWork,myRangeElement);
propsx.cxx:		APTR(BeRangeElement) element, 
propsx.cxx:		APTR(RegionDelta) OF1(CrossRegion) endorsementsDelta)
propsx.cxx:	/* Separate out relevant endorsements from new endorsements; 
propsx.cxx:	moment all spawned Contained...Finders will vanish at the 
propsx.cxx:	same time, i.e. when noone cares about the new endorsements 
propsx.cxx:	any more. Putting in the relevant endorsements as well allows 
propsx.cxx:	self edition totalEndorsements in match and pass. */
propsx.cxx:	returnValue = ContainedEditionRecorderEFinder::make (element, permissions, endorsementsDelta, CAST(CrossRegion,endorsementsDelta->after()->minus(endorsementsDelta->before())));
propsx.cxx:		APTR(BeRangeElement) element, 
propsx.cxx:		APTR(RegionDelta) OF1(CrossRegion) endorsementsDelta, 
propsx.cxx:		APTR(CrossRegion) newEndorsements)
propsx.cxx:		/* permissions->isEmpty() || newEndorsements->isEmpty() */
propsx.cxx:			crutch_Flag = newEndorsements->isEmpty();
propsx.cxx:		SensorCrum::flagsFor(permissions, newEndorsements, FALSE), element, permissions, endorsementsDelta, newEndorsements));
propsx.cxx:endorsements in something containing my edition. Keep the total 
propsx.cxx:endorsements on my edition for quick reject? */
propsx.cxx:			{	FLUID_BIND(CurrentKeyMaster,er->keyMaster()) {
propsx.cxx:						/* er->indirectFilter()->isSwitchedOnBy(myEndorsementsDelta) && er->directFilter()->match(this->edition()->visibleEndorsements()) && this->edition()->anyPasses(PropFinder::backfollowFinder(er->permissionsFilter())) */
propsx.cxx:						crutch_Flag = er->indirectFilter()->isSwitchedOnBy(myEndorsementsDelta);
propsx.cxx:							crutch_Flag = er->directFilter()->match(this->edition()->visibleEndorsements());
propsx.cxx:RPTR(RegionDelta) OF1(CrossRegion) ContainedEditionRecorderEFinder::endorsementsDelta (){
propsx.cxx:	return (RegionDelta*) myEndorsementsDelta;
propsx.cxx:				/* p->relevantPermissions()->intersects(myPermissions) && p->relevantEndorsements()->intersects(myNewEndorsements) */
propsx.cxx:					crutch_Flag = p->relevantEndorsements()->intersects(myNewEndorsements);
propsx.cxx:RPTR(CrossRegion) ContainedEditionRecorderEFinder::newEndorsements (){
propsx.cxx:	return (CrossRegion*) myNewEndorsements;
propsx.cxx:		APTR(BeRangeElement) element, 
propsx.cxx:		APTR(RegionDelta) OF1(CrossRegion) endorsementsDelta, 
propsx.cxx:		APTR(CrossRegion) newEndorsements) 
propsx.cxx:	: SimpleRecorderFinder(flags, element) {
propsx.cxx:	myEndorsementsDelta = endorsementsDelta;
propsx.cxx:	myNewEndorsements = newEndorsements;
propsx.cxx:	return this->rangeElement()->hashForEqual() ^ myPermissions->hashForEqual() ^ myEndorsementsDelta->hashForEqual() ^ myNewEndorsements->hashForEqual();
propsx.cxx:				/* this->rangeElement()->isEqual(other->rangeElement()) && myPermissions->isEqual(other->permissions()) && myEndorsementsDelta->isEqual(other->endorsementsDelta()) && myNewEndorsements->isEqual(other->newEndorsements()) */
propsx.cxx:				crutch_Flag = this->rangeElement()->isEqual(other->rangeElement());
propsx.cxx:						crutch_Flag = myEndorsementsDelta->isEqual(other->endorsementsDelta());
propsx.cxx:							crutch_Flag = myNewEndorsements->isEqual(other->newEndorsements());
propsx.cxx:		APTR(BeRangeElement) element, 
propsx.cxx:		APTR(RegionDelta) OF1(CrossRegion) endorsementsDelta)
propsx.cxx:	returnValue = OriginalResultRecorderEFinder::make (element, permissions, endorsementsDelta, CAST(CrossRegion,endorsementsDelta->after()->minus(endorsementsDelta->before())));
propsx.cxx:		APTR(BeRangeElement) element, 
propsx.cxx:		APTR(RegionDelta) OF1(CrossRegion) endorsementsDelta, 
propsx.cxx:		APTR(CrossRegion) newEndorsements)
propsx.cxx:		/* permissions->isEmpty() || newEndorsements->isEmpty() */
propsx.cxx:			crutch_Flag = newEndorsements->isEmpty();
propsx.cxx:		SensorCrum::flagsFor(permissions, newEndorsements, FALSE), element, permissions, endorsementsDelta, newEndorsements));
propsx.cxx:endorsements on my RangeElement itself */
propsx.cxx:				/* er->directFilter()->isSwitchedOnBy(myEndorsementsDelta) && this->edition()->anyPasses(PropFinder::backfollowFinder(er->permissionsFilter(), er->indirectFilter())) */
propsx.cxx:				crutch_Flag = er->directFilter()->isSwitchedOnBy(myEndorsementsDelta);
propsx.cxx:				/* wr->endorsementsFilter()->isSwitchedOnBy(myEndorsementsDelta) && this->work()->canBeReadBy(wr->keyMaster()) */
propsx.cxx:				crutch_Flag = wr->endorsementsFilter()->isSwitchedOnBy(myEndorsementsDelta);
propsx.cxx:RPTR(RegionDelta) OF1(CrossRegion) OriginalResultRecorderEFinder::endorsementsDelta (){
propsx.cxx:	return (RegionDelta*) myEndorsementsDelta;
propsx.cxx:				/* p->relevantEndorsements()->intersects(myNewEndorsements) && p->relevantPermissions()->intersects(myPermissions) */
propsx.cxx:				crutch_Flag = p->relevantEndorsements()->intersects(myNewEndorsements);
propsx.cxx:RPTR(CrossRegion) OriginalResultRecorderEFinder::newEndorsements (){
propsx.cxx:	return (CrossRegion*) myNewEndorsements;
propsx.cxx:		APTR(BeRangeElement) element, 
propsx.cxx:		APTR(RegionDelta) OF1(CrossRegion) endorsementsDelta, 
propsx.cxx:		APTR(CrossRegion) newEndorsements) 
propsx.cxx:	: SimpleRecorderFinder(flags, element) {
propsx.cxx:	myEndorsementsDelta = endorsementsDelta;
propsx.cxx:	myNewEndorsements = newEndorsements;
propsx.cxx:	return this->rangeElement()->hashForEqual() ^ myPermissions->hashForEqual() ^ myEndorsementsDelta->hashForEqual() ^ myNewEndorsements->hashForEqual();
propsx.cxx:				/* this->rangeElement()->isEqual(other->rangeElement()) && myPermissions->isEqual(other->permissions()) && myEndorsementsDelta->isEqual(other->endorsementsDelta()) && myNewEndorsements->isEqual(other->newEndorsements()) */
propsx.cxx:				crutch_Flag = this->rangeElement()->isEqual(other->rangeElement());
propsx.cxx:						crutch_Flag = myEndorsementsDelta->isEqual(other->endorsementsDelta());
propsx.cxx:							crutch_Flag = myNewEndorsements->isEqual(other->newEndorsements());
propsx.cxx:		APTR(BeRangeElement) element, 
propsx.cxx:		APTR(CrossRegion) endorsements)
propsx.cxx:	returnValue = ResultRecorderPFinder::make (element, permissionsDelta, CAST(IDRegion,permissionsDelta->after()->minus(permissionsDelta->before())), endorsements);
propsx.cxx:		APTR(BeRangeElement) element, 
propsx.cxx:		APTR(CrossRegion) endorsements)
propsx.cxx:		/* newPermissions->isEmpty() || endorsements->isEmpty() */
propsx.cxx:			crutch_Flag = endorsements->isEmpty();
propsx.cxx:		SensorCrum::flagsFor(newPermissions, endorsements, FALSE), element, permissionsDelta, newPermissions, endorsements));
propsx.cxx:visibility of my RangeElement */
propsx.cxx:		APTR(BeRangeElement) element, 
propsx.cxx:		APTR(CrossRegion) endorsements) 
propsx.cxx:	: SimpleRecorderFinder(flags, element) {
propsx.cxx:	myEndorsements = endorsements;
propsx.cxx:RPTR(CrossRegion) ResultRecorderPFinder::endorsements (){
propsx.cxx:	return (CrossRegion*) myEndorsements;
propsx.cxx:				/* p->relevantPermissions()->intersects(myPermissionsDelta->after()) && p->relevantEndorsements()->intersects(myEndorsements) */
propsx.cxx:					crutch_Flag = p->relevantEndorsements()->intersects(myEndorsements);
propsx.cxx:				{	FLUID_BIND(CurrentKeyMaster,er->keyMaster()) {
propsx.cxx:						return er->directFilter()->match(this->edition()->visibleEndorsements());
propsx.cxx:				return wr->endorsementsFilter()->match(this->work()->endorsements());
propsx.cxx:	return myPermissionsDelta->hashForEqual() ^ myNewPermissions->hashForEqual() ^ myEndorsements->hashForEqual();
propsx.cxx:				/* myPermissionsDelta->isEqual(other->permissionsDelta()) && myNewPermissions->isEqual(other->newPermissions()) && myEndorsements->isEqual(other->endorsements()) */
propsx.cxx:						crutch_Flag = myEndorsements->isEqual(other->endorsements());
propsx.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
propsx.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
propsx.hxx:	/* automatic 0-argument constructor */
propsx.hxx:	static RPTR(BertProp) endorsementsProp (APTR(XnRegion) ARG(endorsements));
propsx.hxx:			APTR(XnRegion) ARG(endorsements), 
propsx.hxx:	virtual RPTR(CrossRegion) endorsements ();
propsx.hxx:			APTR(XnRegion) OF1(ID) ARG(endorsements), 
propsx.hxx:	CHKPTR(XnRegion) OF1(ID) myEndorsements;
propsx.hxx:	static GPTR(BertProp) TheIdentityBertProp;
propsx.hxx:	Sensor Canopy.  The permissions and endorsements are those 
propsx.hxx:			APTR(CrossRegion) ARG(relevantEndorsements), 
propsx.hxx:			APTR(CrossRegion) OF2(IDRegion,IDRegion) ARG(relevantEndorsements), 
propsx.hxx:	virtual RPTR(CrossRegion) relevantEndorsements ();
propsx.hxx:	CHKPTR(CrossRegion) OF2(IDRegion,IDRegion) myRelevantEndorsements;
propsx.hxx:	static GPTR(SensorProp) TheIdentitySensorProp;
propsx.hxx:	state.  A PropChange is used to represent which property 
propsx.hxx:	aspect changed (such as permission vs endorsement vs both). */
propsx.hxx:	static RPTR(PropChange) endorsementsChange ();
propsx.hxx:	(permissions and endorsement filters).  A better name would 
propsx.hxx:	I don't represent as changing, and 'a' for aspects that I do 
propsx.hxx:	represent as changing.
propsx.hxx:			APTR(BeRangeElement) ARG(element), 
propsx.hxx:	I don't represent as changing, and the union of 'old' and 'a' 
propsx.hxx:	for aspects that I do represent as changing.
propsx.hxx:	/* automatic 0-argument constructor */
propsx.hxx:	static GPTR(PropChange) TheEndorsementsChange;
propsx.hxx:	static RPTR(PropFinder) backfollowFinder (APTR(Filter) OF1(XnRegion OF1(ID)) ARG(permissionsFilter), APTR(Filter) OF1(XnRegion OF1(ID)) ARG(endorsementsFilter));
propsx.hxx:	virtual BooleanVar doesPass (APTR(CanopyCrum) ARG(parent));
propsx.hxx:	virtual RPTR(PropFinder) pass (APTR(CanopyCrum) ARG(parent));
propsx.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
propsx.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
propsx.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
propsx.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
shephp.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
shephp.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
shephp.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
shephp.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
shephp.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
shephp.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
shepht.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
shepht.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
shepht.cxx:	/* automatic 0-argument constructor */
shepht.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
shepht.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
shepht.hxx:	/* NO CLASS COMMENT */
shepht.hxx:	/* NO CLASS COMMENT */
shepht.hxx:	/* automatic 0-argument constructor */
shepht.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
shepht.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
shepht.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
shepht.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
shephx.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
shephx.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
shephx.cxx:	table = CurrentPacker.fluidGet()->flockTable();
shephx.cxx:	/* Each subclass of Abraham will have an implementation of the form: 
shephx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
shephx.cxx:		CurrentPacker.fluidGet()->dropFlock(myToken);
shephx.cxx:	packer = CurrentPacker.fluidGet();
shephx.cxx:	/* The receiver has changed and so must eventually be 
shephx.cxx:		CurrentPacker.fluidGet()->storeAlmostNewShepherd(this);
shephx.cxx:		CurrentPacker.fluidGet()->diskUpdate(myInfo);
shephx.cxx:	/* Record on disk that there are no more persistent pointers 
shephx.cxx:	receiver can be dismantled from disk.  That will happen eventually. */
shephx.cxx:	CurrentPacker.fluidGet()->forgetFlock(myInfo);
shephx.cxx:	CurrentPacker.fluidGet()->storeNewFlock(this);
shephx.cxx:	/* Record that there are now persistent pointers to the receiver. */
shephx.cxx:	CurrentPacker.fluidGet()->rememberFlock(myInfo);
shephx.cxx:		exits a consistent block. This avoids Jackpotting 
shephx.cxx:	/* [myToken < CurrentPacker fluidGet flockTable count 
shephx.cxx:			ifTrue: [CurrentPacker fluidGet flockTable at: myToken 
shephx.cxx:	CurrentPacker.fluidGet()->destroyFlock(myInfo);
shephx.cxx:UInt32 Abraham::contentsHash (){
shephx.cxx:	/* A hash of the contents of this flock */
shephx.cxx:		 defined unlocked classes will reimplement this. */
shephx.cxx:	flocks = CurrentPacker.fluidGet()->flockTable();
shephx.cxx:			CurrentPacker.fluidGet()->flockTable(CAST(WeakPtrArray,flocks->copyGrow(myToken)));
shephx.cxx:			flocks = CurrentPacker.fluidGet()->flockTable();
shephx.cxx:	Shepherd Patriarch classes reimplement this to use more 
shephx.cxx:	myHash = CurrentPacker.fluidGet()->nextHashForEqual();
shephx.cxx:			 prevents intermediate diskUpdates from forcing a 
shephx.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
shephx.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
shephx.hxx:/* Prototype Constructor Identification Junk */
shephx.hxx:/* Used to identify calls on a constructor intended to be used only  */
shephx.hxx:	/* NO CLASS COMMENT */
shephx.hxx:	/* Each subclass of Abraham will have an implementation of the form: 
shephx.hxx:	/* The receiver has changed and so must eventually be 
shephx.hxx:	/* Record on disk that there are no more persistent pointers 
shephx.hxx:	receiver can be dismantled from disk.  That will happen eventually. */
shephx.hxx:	/* Record that there are now persistent pointers to the receiver. */
shephx.hxx:		exits a consistent block. This avoids Jackpotting 
shephx.hxx:	/* [myToken < CurrentPacker fluidGet flockTable count 
shephx.hxx:			ifTrue: [CurrentPacker fluidGet flockTable at: myToken 
shephx.hxx:	/* A hash of the contents of this flock */
shephx.hxx:	virtual UInt32 contentsHash ();
shephx.hxx:		 defined unlocked classes will reimplement this. */
shephx.hxx:	Shepherd Patriarch classes reimplement this to use more 
shephx.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
shephx.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
shephx.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
shephx.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
sysadmx.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
sysadmx.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
sysadmx.cxx:/* A client interface for system administration operations. This 
sysadmx.cxx:	/* Essential. Enable or disable the ability of the Server to 
sysadmx.cxx:	accept communications connections from client machines. 
sysadmx.cxx:	CurrentGrandMap.fluidGet()->acceptConnections(open);
sysadmx.cxx:	/* Essential. Return a list of all active sessions. */
sysadmx.cxx:	/* Essential. Execute a sequence of server configuration commands. */
sysadmx.cxx:	/* Essential. Grant a Club the authority to assign global IDs 
sysadmx.cxx:	CurrentGrandMap.fluidGet()->grant(clubID, globalIDs);
sysadmx.cxx:	/* Essential. List who has been granted authority to various 
sysadmx.cxx:	returnValue = CurrentGrandMap.fluidGet()->grants(clubIDs, globalIDs);
sysadmx.cxx:	/* Essential. Whether the Server is accepting communications 
sysadmx.cxx:	connections from client machines.  */
sysadmx.cxx:	return CurrentGrandMap.fluidGet()->isAcceptingConnections();
sysadmx.cxx:	/* Essential. Shutdown the Server immediately, taking down 
sysadmx.cxx:	all the connections and writing all current changes to disk. */
sysadmx.cxx:	CurrentPacker.fluidFetch()->purge();
sysadmx.cxx:	/* Essential. The LockSmith which hands out locks when a 
sysadmx.cxx:	client tries to login through the GateKeeper with an invalid 
sysadmx.cxx:	return CAST(FeLockSmith,FeLockSmith::spec()->wrap(CurrentGrandMap.fluidGet()->gateLockSmithEdition()));
sysadmx.cxx:	/* Essential. Set the LockSmith which creates locks to hand 
sysadmx.cxx:	out when a client tries to login with an invalid Club ID or 
sysadmx.cxx:	CurrentGrandMap.fluidFetch()->setGateLockSmithEdition(lockSmith->edition());
sysadmx.cxx:	/* automatic 0-argument constructor */
sysadmx.cxx:	/* Essential.  Copy the entire contents of a set of Works 
sysadmx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
sysadmx.cxx:	/* Essential. Mark the contents of a set of Works as archived 
sysadmx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
sysadmx.cxx:	/* Essential.  Restore information from a backup tape. If a 
sysadmx.cxx:	backup medium, otherwise just reads the entire contents. Must 
sysadmx.cxx:	BLAST(NOT_YET_IMPLEMENTED);
sysadmx.cxx:	/* automatic 0-argument constructor */
sysadmx.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
sysadmx.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
sysadmx.hxx:	/* A client interface for system administration operations. 
sysadmx.hxx:	ON_CLIENT(FeAdminer)
sysadmx.hxx:	static CLIENT RPTR(FeAdminer) make ();
sysadmx.hxx:	/* Essential. Enable or disable the ability of the Server to 
sysadmx.hxx:	accept communications connections from client machines. 
sysadmx.hxx:	virtual CLIENT void acceptConnections (BooleanVar ARG(open));
sysadmx.hxx:	/* Essential. Return a list of all active sessions. */
sysadmx.hxx:	virtual CLIENT RPTR(Stepper) OF1(FeSession) activeSessions ();
sysadmx.hxx:	/* Essential. Execute a sequence of server configuration commands. */
sysadmx.hxx:	virtual CLIENT void execute (APTR(PrimIntArray) ARG(commands));
sysadmx.hxx:	/* Essential. Grant a Club the authority to assign global IDs 
sysadmx.hxx:	virtual CLIENT void grant (APTR(ID) ARG(clubID), APTR(IDRegion) ARG(globalIDs));
sysadmx.hxx:	/* Essential. List who has been granted authority to various 
sysadmx.hxx:	virtual CLIENT RPTR(TableStepper) OF2(ID,IDRegion) grants (APTR(IDRegion) ARG(clubIDs) = NULL, APTR(IDRegion) ARG(globalIDs) = NULL);
sysadmx.hxx:	/* Essential. Whether the Server is accepting communications 
sysadmx.hxx:	connections from client machines.  */
sysadmx.hxx:	virtual CLIENT BooleanVar isAcceptingConnections ();
sysadmx.hxx:	/* Essential. Shutdown the Server immediately, taking down 
sysadmx.hxx:	all the connections and writing all current changes to disk. */
sysadmx.hxx:	virtual CLIENT void shutdown ();
sysadmx.hxx:	/* Essential. The LockSmith which hands out locks when a 
sysadmx.hxx:	client tries to login through the GateKeeper with an invalid 
sysadmx.hxx:	virtual CLIENT RPTR(FeLockSmith) gateLockSmith ();
sysadmx.hxx:	/* Essential. Set the LockSmith which creates locks to hand 
sysadmx.hxx:	out when a client tries to login with an invalid Club ID or 
sysadmx.hxx:	virtual CLIENT void setGateLockSmith (APTR(FeLockSmith) ARG(lockSmith));
sysadmx.hxx:	/* automatic 0-argument constructor */
sysadmx.hxx:	ON_CLIENT(FeArchiver)
sysadmx.hxx:	static CLIENT RPTR(FeArchiver) make ();
sysadmx.hxx:	/* Essential.  Copy the entire contents of a set of Works 
sysadmx.hxx:	virtual CLIENT RPTR(FeEdition) archive (APTR(FeEdition) ARG(works), APTR(FeEdition) ARG(medium));
sysadmx.hxx:	/* Essential. Mark the contents of a set of Works as archived 
sysadmx.hxx:	virtual CLIENT void markArchived (APTR(FeEdition) ARG(edition));
sysadmx.hxx:	/* Essential.  Restore information from a backup tape. If a 
sysadmx.hxx:	backup medium, otherwise just reads the entire contents. Must 
sysadmx.hxx:	virtual CLIENT RPTR(FeEdition) restore (APTR(FeEdition) OR(NULL) ARG(works), APTR(FeEdition) ARG(medium));
sysadmx.hxx:	/* automatic 0-argument constructor */
sysadmx.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
sysadmx.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
sysadmx.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
sysadmx.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
tcludep.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
tcludep.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
tcludep.hxx:	/* Represents the a persistent transcluders or 
tcludep.hxx:	/* Represents the a persistent works or rangeWorks query with 
tcludep.hxx:	DirectWorkRecorder (APTR(Filter) ARG(endorsementsFilter), APTR(TrailBlazer) ARG(trailBlazer));
tcludep.hxx:			APTR(BeRangeElement) ARG(element), 
tcludep.hxx:	/* Represents the a persistent transcluders or 
tcludep.hxx:	/* Represents the a persistent works or rangeWorks query with 
tcludep.hxx:	IndirectWorkRecorder (APTR(Filter) ARG(endorsementsFilter), APTR(TrailBlazer) ARG(trailBlazer));
tcludep.hxx:			APTR(BeRangeElement) ARG(element), 
tcludep.hxx:	virtual NOLOCK RPTR(Filter) endorsementsFilter ();
tcludep.hxx:			APTR(Filter) ARG(endorsementsFilter), 
tcludep.hxx:	CHKPTR(Filter) myEndorsementsFilter;
tcludep.hxx:			APTR(Filter) ARG(endorsementsFilter), 
tcludep.hxx:	virtual NOLOCK void storeDataRecordingAgents (APTR(SensorCrum) ARG(sensorCrum), APTR(Agenda) ARG(agenda));
tcludep.hxx:	virtual void storeRangeElementRecordingAgents (
tcludep.hxx:			APTR(BeRangeElement) ARG(rangeElement), 
tcludep.hxx:			APTR(Filter) ARG(endorsementsFilter), 
tcludep.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
tcludep.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
tcludep.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
tcludep.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
tcludex.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
tcludex.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
tcludex.cxx:	val = myElements->fetch(index);
tcludex.cxx:	myElements->store(index, aHeaper);
tcludex.cxx:	val = myElements->fetch(index);
tcludex.cxx:			myElements->store(index, NULL);
tcludex.cxx:	myElements = PtrArray::nulls(mySize);
tcludex.cxx:	myElements = NULL;
tcludex.cxx:	BEGIN_CONSISTENT(2) {
tcludex.cxx:	} END_CONSISTENT;
tcludex.cxx:	BEGIN_CONSISTENT(1) {
tcludex.cxx:	} END_CONSISTENT;
tcludex.cxx:	BEGIN_CONSISTENT(3) {
tcludex.cxx:	} END_CONSISTENT;
tcludex.cxx:See comment in SouthRecorderChecker for constraints and relationships 
tcludex.cxx:		BEGIN_CONSISTENT(1) {
tcludex.cxx:		} END_CONSISTENT;
tcludex.cxx:	BEGIN_CONSISTENT(2) {
tcludex.cxx:	} END_CONSISTENT;
tcludex.cxx:		APTR(Filter) OF1(Tuple OF2(ID,ID)) endorsementsFilter, 
tcludex.cxx:	BEGIN_CONSISTENT(2) {
tcludex.cxx:			RETURN_CONSTRUCT(DirectWorkRecorderFossil,(loginAuthority, endorsementsFilter, trailBlazer));
tcludex.cxx:			RETURN_CONSTRUCT(IndirectWorkRecorderFossil,(loginAuthority, endorsementsFilter, trailBlazer));
tcludex.cxx:	} END_CONSISTENT;
tcludex.cxx:	BEGIN_INSISTENT(1) {
tcludex.cxx:	} END_INSISTENT;
tcludex.cxx:	BEGIN_INSISTENT(1) {
tcludex.cxx:	} END_INSISTENT;
tcludex.cxx:	BEGIN_INSISTENT(1) {
tcludex.cxx:	} END_INSISTENT;
tcludex.cxx:			bind a new current KeyMaster (recovering the fossilized permissions)
tcludex.cxx:							and explicitly using the fossilized endorsements
tcludex.cxx:		{	FLUID_BIND(CurrentKeyMaster,FeKeyMaster::makeAll(myLoginAuthority)) {
tcludex.cxx:	/* A Fossil (unlike a Grabber or an Orgl) does not prevent 
tcludex.cxx:	BEGIN_CONSISTENT(2) {
tcludex.cxx:	} END_CONSISTENT;
tcludex.cxx:void RecorderFossil::storeDataRecordingAgents (APTR(SensorCrum) sensorCrum, APTR(Agenda) agenda){
tcludex.cxx:	/* Store recording agents into a SensorCrum on data in the 
tcludex.cxx:	agenda->registerItem(sensorCrum->recordingAgent(this));
tcludex.cxx:void RecorderFossil::storePartialityRecordingAgents (APTR(SensorCrum) sensorCrum, APTR(Agenda) agenda){
tcludex.cxx:	/* Store recording agents into a SensorCrum on partiality in 
tcludex.cxx:	agenda->registerItem(sensorCrum->recordingAgent(this));
tcludex.cxx:void RecorderFossil::storeRangeElementRecordingAgents (
tcludex.cxx:		APTR(BeRangeElement) /* rangeElement */, 
tcludex.cxx:	/* Store recording agents into a SensorCrum on a RangeElement 
tcludex.cxx:	agenda->registerItem(sensorCrum->recordingAgent(this));
tcludex.cxx:	BEGIN_CONSISTENT(1) {
tcludex.cxx:	} END_CONSISTENT;
tcludex.cxx:incremental. */
tcludex.cxx:	/* See class comment for a constraint I impose on another class.
tcludex.cxx:	/* update comment after we move height calculation to 
tcludex.cxx:	BEGIN_CONSISTENT(3) {
tcludex.cxx:		crum = this->fetchCrum()->fetchParent();
tcludex.cxx:			though I hoist recorders into my parent 
tcludex.cxx:	} END_CONSISTENT;
tcludex.cxx:RPTR(RecorderTrigger) RecorderTrigger::make (APTR(RecorderFossil) fossil, APTR(BeRangeElement) element){
tcludex.cxx:	BEGIN_CONSISTENT(2) {
tcludex.cxx:		RETURN_CONSTRUCT(RecorderTrigger,(fossil, element));
tcludex.cxx:	} END_CONSISTENT;
tcludex.cxx:Asks myFossil to record myElement.
tcludex.cxx:			Inform myFossil with myElement
tcludex.cxx:			recorder->record(myElement);
tcludex.cxx:	BEGIN_CONSISTENT(2) {
tcludex.cxx:	} END_CONSISTENT;
tcludex.cxx:RecorderTrigger::RecorderTrigger (APTR(RecorderFossil) fossil, APTR(BeRangeElement) element) {
tcludex.cxx:	myElement = element;
tcludex.cxx:	BEGIN_CONSISTENT(2) {
tcludex.cxx:	} END_CONSISTENT;
tcludex.cxx:/* Represents the persistent embodiment of a query operation. Can be 
tcludex.cxx:	- managing persistent permissions
tcludex.cxx:	- checking whether a good candidate (identified by the canopy props) 
tcludex.cxx:	/* Something to find potential candidates given a source for 
tcludex.cxx:	returnValue = PropFinder::backfollowFinder(this->permissionsFilter(), this->endorsementsFilter());
tcludex.cxx:RPTR(Filter) ResultRecorder::endorsementsFilter (){
tcludex.cxx:	/* The endorsements I am looking for */
tcludex.cxx:	return (Filter*) myEndorsementsFilter;
tcludex.cxx:	returnValue = SensorProp::make (CAST(IDRegion,this->permissionsFilter()->relevantRegion()), myRelevantEndorsements, FALSE);
tcludex.cxx:void ResultRecorder::record (APTR(BeRangeElement) answer){
tcludex.cxx:		APTR(Filter) endorsementsFilter, 
tcludex.cxx:		APTR(CrossRegion) relevantEndorsements, 
tcludex.cxx:	myEndorsementsFilter = endorsementsFilter;
tcludex.cxx:	myRelevantEndorsements = relevantEndorsements;
tcludex.cxx:	myKeyMaster = CurrentKeyMaster.fluidGet();
tcludex.cxx:	myPermissionsFilter = CurrentGrandMap.fluidGet()->globalIDFilterSpace()->anyFilter(myKeyMaster->actualAuthority());
tcludex.cxx:		APTR(BeRangeElement) element, 
tcludex.cxx:	RangeElement of the original Edition. I now get to decide 
tcludex.cxx:	/* this is a default implementation, which subclasses may 
tcludex.cxx:	element->delayedStoreBackfollow(finder, fossil, this, hCrumCache);
tcludex.cxx:/* Represents the a persistent transcluders or rangeTranscluders query */
tcludex.cxx:BooleanVar EditionRecorder::accepts (APTR(BeRangeElement) element){
tcludex.cxx:	return element->isKindOf(cat_BeEdition);
tcludex.cxx:	{	FLUID_BIND(CurrentKeyMaster,this->keyMaster()) {
tcludex.cxx:				/* myDirectFilter->match(edition->visibleEndorsements()) && edition->anyPasses(PropFinder::backfollowFinder(this->permissionsFilter(), myIndirectFilter)) */
tcludex.cxx:				crutch_Flag = myDirectFilter->match(edition->visibleEndorsements());
tcludex.cxx:/* Represents the a persistent works or rangeWorks query */
tcludex.cxx:WorkRecorder::WorkRecorder (APTR(Filter) endorsementsFilter, APTR(TrailBlazer) trailBlazer) 
tcludex.cxx:	: ResultRecorder(endorsementsFilter
tcludex.cxx:		, CAST(CrossRegion,endorsementsFilter->relevantRegion())
tcludex.cxx:BooleanVar WorkRecorder::accepts (APTR(BeRangeElement) element){
tcludex.cxx:	return element->isKindOf(cat_BeWork);
tcludex.cxx:void WorkRecorder::recordImmediateWorks (APTR(BeRangeElement) element, APTR(RecorderFossil) fossil){
tcludex.cxx:	/* If there are any Works directly on the RangeElement which 
tcludex.cxx:	BEGIN_CHOOSE(element) {
tcludex.cxx:			BEGIN_FOR_EACH(BeWork,work,(edition->currentWorks()->stepper())) {
tcludex.cxx:					/* work->canBeReadBy(this->keyMaster()) && this->endorsementsFilter()->match(work->endorsements()) */
tcludex.cxx:						crutch_Flag = this->endorsementsFilter()->match(work->endorsements());
tcludex.cxx:	BEGIN_CONSISTENT(2) {
tcludex.cxx:	} END_CONSISTENT;
tcludex.cxx:interleaved with an incremental southward walk by a RecorderChecker 
tcludex.cxx:Keeping track of whether persistent objects are garbage-on-disk 
tcludex.cxx:held by a persistent Stamp, from which it can be easily obtained, so 
tcludex.cxx:	BEGIN_CONSISTENT(3) {
tcludex.cxx:	} END_CONSISTENT;
tcludex.cxx:	/* See class comment for a constraint on this method.
tcludex.cxx:	BEGIN_CONSISTENT(1) {
tcludex.cxx:	} END_CONSISTENT;
tcludex.cxx:	BEGIN_CONSISTENT(1) {
tcludex.cxx:	} END_CONSISTENT;
tcludex.cxx:	BEGIN_CONSISTENT(1) {
tcludex.cxx:	} END_CONSISTENT;
tcludex.cxx:void TrailBlazer::record (APTR(BeRangeElement) answer){
tcludex.cxx:			myTrail->get(iD)->makeIdentical(answer->makeFe(NULL));
tcludex.cxx:		BEGIN_CONSISTENT(1) {
tcludex.cxx:		} END_CONSISTENT;
tcludex.cxx:	/* Increment the reference count */
tcludex.cxx:	BEGIN_CONSISTENT(1) {
tcludex.cxx:	} END_CONSISTENT;
tcludex.cxx:	/* Decrement the reference count */
tcludex.cxx:	BEGIN_CONSISTENT(1) {
tcludex.cxx:	} END_CONSISTENT;
tcludex.cxx:/* Represents the a persistent transcluders or rangeTranscluders 
tcludex.cxx:/* Represents the a persistent works or rangeWorks query with the 
tcludex.cxx:DirectWorkRecorder::DirectWorkRecorder (APTR(Filter) endorsementsFilter, APTR(TrailBlazer) trailBlazer) 
tcludex.cxx:	: WorkRecorder(endorsementsFilter, trailBlazer) {
tcludex.cxx:		APTR(BeRangeElement) element, 
tcludex.cxx:	this->recordImmediateWorks(element, fossil);
tcludex.cxx:/* Represents the a persistent transcluders or rangeTranscluders 
tcludex.cxx:/* Represents the a persistent works or rangeWorks query with the 
tcludex.cxx:IndirectWorkRecorder::IndirectWorkRecorder (APTR(Filter) endorsementsFilter, APTR(TrailBlazer) trailBlazer) 
tcludex.cxx:	: WorkRecorder(endorsementsFilter, trailBlazer) {
tcludex.cxx:		APTR(BeRangeElement) element, 
tcludex.cxx:	this->recordImmediateWorks(element, fossil);
tcludex.cxx:	this->WorkRecorder::delayedStoreMatching(element, finder, fossil, hCrumCache);
tcludex.cxx:RPTR(Filter) WorkRecorderFossil::endorsementsFilter (){
tcludex.cxx:	return (Filter*) myEndorsementsFilter;
tcludex.cxx:		APTR(Filter) endorsementsFilter, 
tcludex.cxx:	myEndorsementsFilter = endorsementsFilter;
tcludex.cxx:	RETURN_CONSTRUCT(DirectWorkRecorder,(this->endorsementsFilter(), this->trailBlazer()));
tcludex.cxx:		APTR(Filter) endorsementsFilter, 
tcludex.cxx:		, endorsementsFilter
tcludex.cxx:void DirectWorkRecorderFossil::storeDataRecordingAgents (APTR(SensorCrum) sensorCrum, APTR(Agenda) agenda){
tcludex.cxx:void DirectWorkRecorderFossil::storeRangeElementRecordingAgents (
tcludex.cxx:		APTR(BeRangeElement) rangeElement, 
tcludex.cxx:		/* rangeElement->isKindOf(cat_BeEdition) || rangeElement->isKindOf(cat_BePlaceHolder) */
tcludex.cxx:		crutch_Flag = rangeElement->isKindOf(cat_BeEdition);
tcludex.cxx:			crutch_Flag = rangeElement->isKindOf(cat_BePlaceHolder);
tcludex.cxx:			this->WorkRecorderFossil::storeRangeElementRecordingAgents(rangeElement, sensorCrum, agenda);
tcludex.cxx:	RETURN_CONSTRUCT(IndirectWorkRecorder,(this->endorsementsFilter(), this->trailBlazer()));
tcludex.cxx:		APTR(Filter) endorsementsFilter, 
tcludex.cxx:		, endorsementsFilter
tcludex.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
tcludex.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
tcludex.hxx:	/* NO CLASS COMMENT */
tcludex.hxx:	CHKPTR(PtrArray) myElements;
tcludex.hxx:	See comment in SouthRecorderChecker for constraints and 
tcludex.hxx:			APTR(Filter) OF1(Tuple OF2(ID,ID)) ARG(endorsementsFilter), 
tcludex.hxx:	/* A Fossil (unlike a Grabber or an Orgl) does not prevent 
tcludex.hxx:	/* Store recording agents into a SensorCrum on data in the 
tcludex.hxx:	virtual void storeDataRecordingAgents (APTR(SensorCrum) ARG(sensorCrum), APTR(Agenda) ARG(agenda));
tcludex.hxx:	/* Store recording agents into a SensorCrum on partiality in 
tcludex.hxx:	virtual void storePartialityRecordingAgents (APTR(SensorCrum) ARG(sensorCrum), APTR(Agenda) ARG(agenda));
tcludex.hxx:	/* Store recording agents into a SensorCrum on a RangeElement 
tcludex.hxx:	virtual void storeRangeElementRecordingAgents (
tcludex.hxx:			APTR(BeRangeElement) ARG(rangeElement), 
tcludex.hxx:	RecorderCheckers were incremental. */
tcludex.hxx:	Asks myFossil to record myElement.
tcludex.hxx:	static RPTR(RecorderTrigger) make (APTR(RecorderFossil) ARG(fossil), APTR(BeRangeElement) ARG(element));
tcludex.hxx:	RecorderTrigger (APTR(RecorderFossil) ARG(fossil), APTR(BeRangeElement) ARG(element));
tcludex.hxx:	CHKPTR(BeRangeElement) myElement;
tcludex.hxx:	/* Represents the persistent embodiment of a query operation. 
tcludex.hxx:		- managing persistent permissions
tcludex.hxx:		- checking whether a good candidate (identified by the 
tcludex.hxx:	/* Whether this recorder accepts this kind of RangeElement */
tcludex.hxx:	virtual BooleanVar accepts (APTR(BeRangeElement) ARG(element)) DEFERRED_FUNC;
tcludex.hxx:	/* Something to find potential candidates given a source for 
tcludex.hxx:	/* The endorsements I am looking for */
tcludex.hxx:	virtual RPTR(Filter) endorsementsFilter ();
tcludex.hxx:	virtual void record (APTR(BeRangeElement) ARG(answer));
tcludex.hxx:			APTR(Filter) ARG(endorsementsFilter), 
tcludex.hxx:			APTR(CrossRegion) ARG(relevantEndorsements), 
tcludex.hxx:	RangeElement of the original Edition. I now get to decide 
tcludex.hxx:			APTR(BeRangeElement) ARG(element), 
tcludex.hxx:	CHKPTR(Filter) myEndorsementsFilter;
tcludex.hxx:	CHKPTR(CrossRegion) myRelevantEndorsements;
tcludex.hxx:	/* Represents the a persistent transcluders or 
tcludex.hxx:	virtual BooleanVar accepts (APTR(BeRangeElement) ARG(element));
tcludex.hxx:	/* Represents the a persistent works or rangeWorks query */
tcludex.hxx:	WorkRecorder (APTR(Filter) ARG(endorsementsFilter), APTR(TrailBlazer) ARG(trailBlazer));
tcludex.hxx:	virtual BooleanVar accepts (APTR(BeRangeElement) ARG(element));
tcludex.hxx:	/* If there are any Works directly on the RangeElement which 
tcludex.hxx:	virtual void recordImmediateWorks (APTR(BeRangeElement) ARG(element), APTR(RecorderFossil) ARG(fossil));
tcludex.hxx:	that, if it were interleaved with an incremental southward 
tcludex.hxx:	Keeping track of whether persistent objects are 
tcludex.hxx:	OrglRoot.  The OrglRoot is itself held by a persistent Stamp, 
tcludex.hxx:PROBLEM_LIST(RecordFailureFilter,3,(MustBeOwner,CantMakeIdentical,NotInTable));
tcludex.hxx:	virtual void record (APTR(BeRangeElement) ARG(answer));
tcludex.hxx:	/* Increment the reference count */
tcludex.hxx:	/* Decrement the reference count */
tcludex.hxx:	CHKPTR(HashSetCache) OF1(BeRangeElement) myRecorded;
tcludex.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
tcludex.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
tcludex.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
tcludex.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
tracepx.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
tracepx.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
tracepx.cxx:	/* automatic 0-argument constructor */
tracepx.cxx:/* Trace Positions represent absolute coordinates in a tree-ordered space.  
tracepx.cxx:The ent navigates to O-roots from H-roots in the northern direction using 
tracepx.cxx:TracePositions.  Refer to the Ent document for a description of the current 
tracepx.cxx:implementation.  TracePositions are generated by asking another tracePosition
tracepx.cxx:		less than the argument. The argument is put in the cache so that  
tracepx.cxx:		even when the arguments are swapped. */
tracepx.cxx:	/* This consistent count is upperbound over 12 runs of works test.
tracepx.cxx:	BEGIN_CONSISTENT(14) {
tracepx.cxx:	} END_CONSISTENT;
tracepx.cxx:	/* This consistent count is upperbound over 12 runs of works test.
tracepx.cxx:	BEGIN_CONSISTENT(14) {
tracepx.cxx:	} END_CONSISTENT;
tracepx.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
tracepx.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
tracepx.hxx:	/* NO CLASS COMMENT */
tracepx.hxx:	/* automatic 0-argument constructor */
tracepx.hxx:	/* Trace Positions represent absolute coordinates in a 
tracepx.hxx:	The ent navigates to O-roots from H-roots in the northern 
tracepx.hxx:	TracePositions.  Refer to the Ent document for a description 
tracepx.hxx:	of the current 
tracepx.hxx:	implementation.  TracePositions are generated by asking 
tracepx.hxx:		less than the argument. The argument is put in the cache so that  
tracepx.hxx:		even when the arguments are swapped. */
tracepx.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
tracepx.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
tracepx.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
tracepx.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
worksrvx.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
worksrvx.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
worksrvx.cxx:	/* automatic 0-argument constructor */
worksrvx.cxx:	/* CurrentGrandMap fluidFetch == NULL ifFalse: [Heaper BLAST: 
worksrvx.cxx:		CurrentGrandMap.fluidSet(CAST(BeGrandMap,GrandConnection.fluidGet()->bootHeaper()));
worksrvx.cxx:			commented out in getInitialFlock /ravi/10/22/92/ */
worksrvx.cxx:		BEGIN_CONSISTENT(-1) {
worksrvx.cxx:		} END_CONSISTENT;
worksrvx.cxx:	/* automatic 0-argument constructor */
worksrvx.cxx:clubs and homedocs to prepare a backend for ordinary client use. It 
worksrvx.cxx:is pretty sparse right now, but will eventually have much more stuff */
worksrvx.cxx:	CurrentKeyMaster.fluidSet(CAST(BooLock,FeServer::loginByName(Sequence::string("System Admin")))->boo());
worksrvx.cxx:	CurrentKeyMaster.fluidGet()->incorporate(FeKeyMaster::makePublic());
worksrvx.cxx:	CurrentAuthor.fluidSet(adminID);
worksrvx.cxx:	CurrentPacker.fluidGet()->purge();
worksrvx.cxx:	/* automatic 0-argument constructor */
worksrvx.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
worksrvx.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
worksrvx.hxx:	/* NO CLASS COMMENT */
worksrvx.hxx:	/* automatic 0-argument constructor */
worksrvx.hxx:	/* NO CLASS COMMENT */
worksrvx.hxx:	/* automatic 0-argument constructor */
worksrvx.hxx:	ordinary client use. It is pretty sparse right now, but will 
worksrvx.hxx:	eventually have much more stuff */
worksrvx.hxx:	/* automatic 0-argument constructor */
worksrvx.hxx:	virtual CLIENT NOACK done ();
worksrvx.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
worksrvx.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
worksrvx.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
worksrvx.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
wrapperp.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
wrapperp.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
wrapperp.hxx:	/* NO CLASS COMMENT */
wrapperp.hxx:	/* NO CLASS COMMENT */
wrapperp.hxx:	/* NO CLASS COMMENT */
wrapperp.hxx:	/* NO CLASS COMMENT */
wrapperp.hxx:	/* NO CLASS COMMENT */
wrapperp.hxx:	/* NO CLASS COMMENT */
wrapperp.hxx:	/* NO CLASS COMMENT */
wrapperp.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
wrapperp.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
wrapperp.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
wrapperp.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
wrapperx.cxx:* The information contained herein is confidential, proprietary to Xanadu    *
wrapperx.cxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
wrapperx.cxx:		APTR(FeEdition) parent, 
wrapperx.cxx:	SPTR(FeRangeElement) value;
wrapperx.cxx:	value = parent->fetch(key);
wrapperx.cxx:		APTR(FeEdition) parent, 
wrapperx.cxx:		if (!FeWrapper::checkSubEdition(parent, key, spec, required)) {
wrapperx.cxx:	SPTR(FeRangeElement) value;
wrapperx.cxx:		APTR(FeEdition) parent, 
wrapperx.cxx:	SPTR(FeRangeElement) value;
wrapperx.cxx:	value = parent->fetch(key);
wrapperx.cxx:Implementation note:
wrapperx.cxx:	/* Essential. The primitive Edition this is wrapping. */
wrapperx.cxx:	/* Essential. The next Wrapper inside this one; blasts if 
wrapperx.cxx:	/* Essential. Return TRUE if this is wrapped as the given 
wrapperx.cxx:RPTR(FeSet) FeSet::make (APTR(PtrArray) OF1(FeRangeElement) works){
wrapperx.cxx:/* An undifferentiated set of RangeElements. */
wrapperx.cxx:	/* The number of elements in the set */
wrapperx.cxx:BooleanVar FeSet::includes (APTR(FeRangeElement) value){
wrapperx.cxx:	/* Whether the set includes the given RangeElement */
wrapperx.cxx:	/* Return those elements which are in both sets */
wrapperx.cxx:	/* Remove some RangeElements from the set */
wrapperx.cxx:RPTR(Stepper) OF1(FeRangeElement) FeSet::stepper (){
wrapperx.cxx:	/* A stepper over the elements in the set */
wrapperx.cxx:	WPTR(Stepper) OF1(FeRangeElement) 	returnValue;
wrapperx.cxx:RPTR(FeRangeElement) FeSet::theOne (){
wrapperx.cxx:	/* If there is exactly one element, then return it */
wrapperx.cxx:	WPTR(FeRangeElement) 	returnValue;
wrapperx.cxx:	/* Return those elements which are in either set */
wrapperx.cxx:RPTR(FeSet) FeSet::with (APTR(FeRangeElement) value){
wrapperx.cxx:	/* Add a RangeElement to the set */
wrapperx.cxx:RPTR(FeSet) FeSet::without (APTR(FeRangeElement) value){
wrapperx.cxx:	/* Remove a RangeElement from the set */
wrapperx.cxx:	BEGIN_FOR_EACH(FeRangeElement,object,(this->stepper())) {
wrapperx.cxx:	Editions. Does not check the contents; assumes that it will 
wrapperx.cxx:RangeElements */
wrapperx.cxx:RPTR(FeEdition) FeText::contents (){
wrapperx.cxx:	/* The Edition of the actual contents, without any style 
wrapperx.cxx:	Future styled text implementations will not store the 
wrapperx.cxx:	contents as directly as we do now. */
wrapperx.cxx:	/* The number of elements in the string */
wrapperx.cxx:	given position, and remove it from its current location. If 
wrapperx.cxx:	another document.
wrapperx.cxx:			BLAST(AmbiguousReplacement) if the region is empty.
wrapperx.cxx:		May be used to copy information within a single document.
wrapperx.cxx:				BLAST(AmbiguousReplacement);
wrapperx.cxx:	returnValue = this->extract(CAST(IntegerRegion,dest->complement()))->insert(to, other);
wrapperx.cxx:				cast: FeElementBundle into: [ :element |
wrapperx.cxx:GPTR(MuTable) OF2(Tumbler,CrossRegion) FeWrapperSpec::TheWrapperEndorsements = NULL;
wrapperx.cxx:GPTR(MuTable) OF2(Tuple,FeWrapperSpec) FeWrapperSpec::TheWrappersFromEndorsements = NULL;
wrapperx.cxx:	if (FeWrapperSpec::TheWrapperEndorsements == NULL) {
wrapperx.cxx:		FeWrapperSpec::setWrapperEndorsements(CurrentGrandMap.fluidGet()->wrapperEndorsements());
wrapperx.cxx:RPTR(FeWrapperSpec) OR(NULL) FeWrapperSpec::fetch (APTR(Sequence) identifier){
wrapperx.cxx:	/* Get the local Wrapper spec with the given identifier, or 
wrapperx.cxx:	return CAST(FeWrapperSpec,FeWrapperSpec::TheWrapperSpecs->fetch(identifier));
wrapperx.cxx:RPTR(FeWrapperSpec) FeWrapperSpec::get (APTR(Sequence) identifier){
wrapperx.cxx:	/* Get the local Wrapper spec with the given identifier, or 
wrapperx.cxx:	result = FeWrapperSpec::fetch(identifier);
wrapperx.cxx:RPTR(CrossRegion) FeWrapperSpec::getEndorsements (APTR(Sequence) identifier){
wrapperx.cxx:	/* Get the endorsements for the named wrapper space */
wrapperx.cxx:	return CAST(CrossRegion,FeWrapperSpec::TheWrapperEndorsements->get(identifier));
wrapperx.cxx:RPTR(FeWrapperSpec) FeWrapperSpec::getFromEndorsement (APTR(Tuple) endorsement){
wrapperx.cxx:	/* Get the wrapper spec corresponding to the given endorsement */
wrapperx.cxx:	return CAST(FeWrapperSpec,FeWrapperSpec::TheWrappersFromEndorsements->get(endorsement));
wrapperx.cxx:	/* Get the local Wrapper spec with the given identifier, or 
wrapperx.cxx:void FeWrapperSpec::setWrapperEndorsements (APTR(ScruTable) OF2(Sequence,CrossRegion) endorsements){
wrapperx.cxx:	/* A table mapping from wrapper names to endorsements */
wrapperx.cxx:	FeWrapperSpec::TheWrapperEndorsements = endorsements->asMuTable();
wrapperx.cxx:	FeWrapperSpec::TheWrappersFromEndorsements = MuTable::make (CurrentGrandMap.fluidGet()->endorsementSpace());
wrapperx.cxx:	BEGIN_FOR_POSITIONS(Sequence,seq,CrossRegion,endorses,(endorsements->stepper())) {
wrapperx.cxx:		/* implement stepper so that endorsements are allowed 
wrapperx.cxx:						TheWrappersFromEndorsements at: endorse
wrapperx.cxx:		FeWrapperSpec::TheWrappersFromEndorsements->introduce(endorses->theOne(), FeWrapperSpec::get(seq));
wrapperx.cxx:		myFilter = CAST(Filter,CurrentGrandMap.fluidGet()->endorsementFilterSpace()->emptyRegion());
wrapperx.cxx:	type. Equivalent to
wrapperx.cxx:			this->filter ()->match (edition->endorsements ()) */
wrapperx.cxx:	return this->filter()->match(edition->endorsements());
wrapperx.cxx:	not have endorsements, will attempt to certify. Blasts if 
wrapperx.cxx:void FeWrapperSpec::addToFilter (APTR(CrossRegion) endorsements){
wrapperx.cxx:	/* Add some more endorsements to filter for */
wrapperx.cxx:	myFilter = CAST(Filter,this->filter()->unionWith(CurrentGrandMap.fluidGet()->endorsementFilterSpace()->anyFilter(endorsements)));
wrapperx.cxx:			end = FeWrapperSpec::getEndorsements(this->name());
wrapperx.cxx:			myEndorsements = CAST(CrossRegion,this->endorsements()->unionWith(end));
wrapperx.cxx:	myEndorsements = NULL;
wrapperx.cxx:RPTR(CrossRegion) FeWrapperSpec::endorsements (){
wrapperx.cxx:	if (myEndorsements == NULL) {
wrapperx.cxx:		myEndorsements = CAST(CrossRegion,CurrentGrandMap.fluidGet()->endorsementSpace()->emptyRegion());
wrapperx.cxx:	return (CrossRegion*) myEndorsements;
wrapperx.cxx:	/* remember its endorsements */
wrapperx.cxx:	this->addToFilter(spec->endorsements());
wrapperx.cxx:	/* Recur upwards to add the spec to my parent */
wrapperx.cxx:		/* If there are any endorsements that match mine, 
wrapperx.cxx:	BEGIN_FOR_EACH(Tuple,end,(edition->endorsements()->intersect(this->endorsements())->stepper())) {
wrapperx.cxx:		other = CAST(FeConcreteWrapperSpec,FeWrapperSpec::getFromEndorsement(end));
wrapperx.cxx:	/* There are no endorsements. Just walk through the 
wrapperx.cxx:	edition->beEdition()->endorse(this->endorsements());
wrapperx.hxx:* The information contained herein is confidential, proprietary to Xanadu    *
wrapperx.hxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
wrapperx.hxx:	Implementation note:
wrapperx.hxx:	ON_CLIENT(FeWrapper)
wrapperx.hxx:			APTR(FeEdition) ARG(parent), 
wrapperx.hxx:			APTR(FeEdition) ARG(parent), 
wrapperx.hxx:			APTR(FeEdition) ARG(parent), 
wrapperx.hxx:	/* Essential. The primitive Edition this is wrapping. */
wrapperx.hxx:	virtual CLIENT RPTR(FeEdition) edition ();
wrapperx.hxx:	/* Essential. The next Wrapper inside this one; blasts if 
wrapperx.hxx:	virtual CLIENT RPTR(FeWrapper) inner ();
wrapperx.hxx:	/* Essential. Return TRUE if this is wrapped as the given 
wrapperx.hxx:	/* An undifferentiated set of RangeElements. */
wrapperx.hxx:	ON_CLIENT(FeSet)
wrapperx.hxx:	static CLIENT RPTR(FeSet) make ();
wrapperx.hxx:	static CLIENT RPTR(FeSet) make (APTR(PtrArray) OF1(FeRangeElement) ARG(works));
wrapperx.hxx:	/* The number of elements in the set */
wrapperx.hxx:	virtual CLIENT IntegerVar count ();
wrapperx.hxx:	/* Whether the set includes the given RangeElement */
wrapperx.hxx:	virtual CLIENT BooleanVar includes (APTR(FeRangeElement) ARG(value));
wrapperx.hxx:	/* Return those elements which are in both sets */
wrapperx.hxx:	virtual CLIENT RPTR(FeSet) intersect (APTR(FeSet) ARG(other));
wrapperx.hxx:	/* Remove some RangeElements from the set */
wrapperx.hxx:	virtual CLIENT RPTR(FeSet) minus (APTR(FeSet) ARG(other));
wrapperx.hxx:	/* A stepper over the elements in the set */
wrapperx.hxx:	virtual RPTR(Stepper) OF1(FeRangeElement) stepper ();
wrapperx.hxx:	/* If there is exactly one element, then return it */
wrapperx.hxx:	virtual CLIENT RPTR(FeRangeElement) theOne ();
wrapperx.hxx:	/* Return those elements which are in either set */
wrapperx.hxx:	virtual CLIENT RPTR(FeSet) unionWith (APTR(FeSet) ARG(other));
wrapperx.hxx:	/* Add a RangeElement to the set */
wrapperx.hxx:	virtual CLIENT RPTR(FeSet) with (APTR(FeRangeElement) ARG(value));
wrapperx.hxx:	/* Remove a RangeElement from the set */
wrapperx.hxx:	virtual CLIENT RPTR(FeSet) without (APTR(FeRangeElement) ARG(value));
wrapperx.hxx:	of RangeElements */
wrapperx.hxx:	ON_CLIENT(FeText)
wrapperx.hxx:	Editions. Does not check the contents; assumes that it will 
wrapperx.hxx:	static CLIENT RPTR(FeText) make (APTR(PrimArray) ARG(data) = NULL);
wrapperx.hxx:	/* The Edition of the actual contents, without any style 
wrapperx.hxx:	Future styled text implementations will not store the 
wrapperx.hxx:	contents as directly as we do now. */
wrapperx.hxx:	virtual CLIENT RPTR(FeEdition) contents ();
wrapperx.hxx:	/* The number of elements in the string */
wrapperx.hxx:	virtual CLIENT IntegerVar count ();
wrapperx.hxx:	virtual CLIENT RPTR(FeText) extract (APTR(IntegerRegion) ARG(region));
wrapperx.hxx:	virtual CLIENT RPTR(FeText) insert (IntegerVar ARG(position), APTR(FeText) ARG(text));
wrapperx.hxx:	given position, and remove it from its current location. If 
wrapperx.hxx:	virtual CLIENT RPTR(FeText) move (IntegerVar ARG(pos), APTR(IntegerRegion) ARG(region));
wrapperx.hxx:	another document.
wrapperx.hxx:			BLAST(AmbiguousReplacement) if the region is empty.
wrapperx.hxx:		May be used to copy information within a single document.
wrapperx.hxx:	virtual CLIENT RPTR(FeText) replace (APTR(IntegerRegion) ARG(dest), APTR(FeText) ARG(other));
wrapperx.hxx:	ON_CLIENT(FeWrapperSpec)
wrapperx.hxx:	/* Get the local Wrapper spec with the given identifier, or 
wrapperx.hxx:	static RPTR(FeWrapperSpec) OR(NULL) fetch (APTR(Sequence) ARG(identifier));
wrapperx.hxx:	/* Get the local Wrapper spec with the given identifier, or 
wrapperx.hxx:	static CLIENT RPTR(FeWrapperSpec) get (APTR(Sequence) ARG(identifier));
wrapperx.hxx:	/* Get the endorsements for the named wrapper space */
wrapperx.hxx:	static RPTR(CrossRegion) getEndorsements (APTR(Sequence) ARG(identifier));
wrapperx.hxx:	/* Get the wrapper spec corresponding to the given endorsement */
wrapperx.hxx:	static RPTR(FeWrapperSpec) getFromEndorsement (APTR(Tuple) ARG(endorsement));
wrapperx.hxx:	/* Get the local Wrapper spec with the given identifier, or 
wrapperx.hxx:	/* A table mapping from wrapper names to endorsements */
wrapperx.hxx:	static void setWrapperEndorsements (APTR(ScruTable) OF2(Sequence,CrossRegion) ARG(endorsements));
wrapperx.hxx:	that it could be certified. Always checks the actual contents 
wrapperx.hxx:	virtual CLIENT RPTR(Filter) filter ();
wrapperx.hxx:	type. Equivalent to
wrapperx.hxx:			this->filter ()->match (edition->endorsements ()) */
wrapperx.hxx:	virtual CLIENT RPTR(Sequence) name ();
wrapperx.hxx:	not have endorsements, will attempt to certify. Blasts if 
wrapperx.hxx:	virtual CLIENT RPTR(FeWrapper) wrap (APTR(FeEdition) ARG(edition));
wrapperx.hxx:	/* Add some more endorsements to filter for */
wrapperx.hxx:	virtual void addToFilter (APTR(CrossRegion) ARG(endorsements));
wrapperx.hxx:		Should only be called from the code implementing the type, 
wrapperx.hxx:	or code which it trusts. We may eventually add a system to 
wrapperx.hxx:	virtual RPTR(CrossRegion) endorsements ();
wrapperx.hxx:	CHKPTR(CrossRegion) myEndorsements;
wrapperx.hxx:	static GPTR(MuTable) OF2(Tumbler,CrossRegion) TheWrapperEndorsements;
wrapperx.hxx:	static GPTR(MuTable) OF2(Tuple,FeWrapperSpec) TheWrappersFromEndorsements;
wrapperx.ixx:* The information contained herein is confidential, proprietary to Xanadu    *
wrapperx.ixx:* only under a  written non-disclosure agreement, expressly prescribing      * 
wrapperx.oxx:* The information contained herein is confidential, proprietary to Xanadu    *
wrapperx.oxx:* only under a  written non-disclosure agreement, expressly prescribing      * 
zx:branchx.hxx:	static RPTR(BranchDescription) make (APTR(DagWood) ARG(xfulltrace), APTR(TracePosition) ARG(parent));
zx:brange1x.hxx:	static RPTR(BeCarrier) label (APTR(BeRangeElement) ARG(element));
zx:brange1x.hxx:	static RPTR(BeCarrier) make (APTR(BeRangeElement) ARG(element));
zx:brange1x.hxx:	static RPTR(BeCarrier) make (APTR(BeLabel) OR(NULL) ARG(label), APTR(BeRangeElement) ARG(element));
zx:brange2x.hxx:	static RPTR(BeClub) make (APTR(FeEdition) ARG(contents));
zx:canopyx.hxx:	static UInt32 endorsementsFlags (APTR(CrossRegion) ARG(endorsements));
zx:canopyx.hxx:	static Int32 endorsementFlagLimit ();
zx:canopyx.hxx:	static UInt32 firstEndorsementsFlag ();
zx:canopyx.hxx:	static UInt32 otherEndorsementsFlag ();
zx:canopyx.hxx:	static void useEndorsementFlags (APTR(PtrArray) OF1(Position OR(XnRegion)) ARG(endorsements));
zx:canopyx.hxx:	static GPTR(PtrArray) OF1(Position OR(XnRegion)) FlagEndorsements;
zx:canopyx.hxx:	static GPTR(CrossRegion) OtherEndorsements;
zx:cryptox.hxx:	static void remember (APTR(Sequence) ARG(identifier), EncrypterConstructor ARG(constructor));
zx:cryptox.hxx:	static void remember (APTR(Sequence) ARG(identifier), APTR(Scrambler) ARG(scrambler));
zx:cryptox.hxx:	static RPTR(Scrambler) make (APTR(UInt8Array) ARG(identifier));
zx:detectx.hxx:	static INLINE CLIENT Int32 EDIT_PERMISSION_CHANGED ();
zx:detectx.hxx:	static INLINE CLIENT Int32 KEYMASTER_CHANGED ();
zx:detectx.hxx:	static INLINE CLIENT Int32 SIGNATURE_AUTHORITY ();
zx:entx.hxx:	static RPTR(Ent) make ();
zx:entx.hxx:	static INLINE IntegerVar tableSegmentMaxSize ();
zx:grantabp.hxx:	static INLINE UInt32 exponentialMap (UInt32 ARG(aHash));
zx:grantabp.hxx:	static GPTR(ExponentialHashMap) TheExponentialMap;
zx:grantabp.hxx:	static RPTR(GrandEntry) make (APTR(Heaper) ARG(value), UInt32 ARG(hash));
zx:grantabp.hxx:	static RPTR(GrandEntry) make (
zx:idx.hxx:	static CLIENT RPTR(ID) import (APTR(PrimIntArray) ARG(data));
zx:idx.hxx:	static IdentityDsp  * theDsp;
zx:idx.hxx:	static CLIENT RPTR(IDRegion) import (APTR(PrimIntArray) ARG(data));
zx:idx.hxx:	static CLIENT RPTR(IDSpace) global ();
zx:idx.hxx:	static CLIENT RPTR(IDSpace) import (APTR(PrimIntArray) ARG(data));
zx:idx.hxx:	static CLIENT RPTR(IDSpace) unique ();
zx:idx.hxx:	static RPTR(IDSpace) make (APTR(Sequence) OR(NULL) ARG(identifier), IntegerVar ARG(number));
zx:loavesx.hxx:	static RPTR(Loaf) make (APTR(XnRegion) ARG(region), APTR(BeCarrier) ARG(element));
zx:loavesx.hxx:	static RPTR(Loaf) make (APTR(PrimDataArray) ARG(values), APTR(Arrangement) ARG(arrangement));
zx:nadminx.hxx:	static CLIENT RPTR(FeClubDescription) make (APTR(FeSet) OR(NULL) OF1(FeClub) ARG(membership), APTR(FeLockSmith) ARG(lockSmith) = NULL);
zx:nadminx.hxx:	static CLIENT RPTR(FeBooLockSmith) make ();
zx:nadminx.hxx:	static CLIENT RPTR(FeChallengeLockSmith) make (APTR(PrimIntArray) ARG(publicKey), APTR(Sequence) ARG(encrypterName));
zx:nadminx.hxx:	static CLIENT RPTR(FeMatchLockSmith) make (APTR(PrimIntArray) ARG(scrambledPassword), APTR(Sequence) ARG(scramblerName));
zx:nadminx.hxx:	static CLIENT RPTR(FeMultiLockSmith) make ();
zx:nadminx.hxx:	static CLIENT RPTR(FeWallLockSmith) make ();
zx:nadminx.hxx:	static CLIENT RPTR(FeSession) current ();
zx:nkernelx.hxx:	static RPTR(FeElementBundle) make (APTR(XnRegion) ARG(region), APTR(FeRangeElement) ARG(element));
zx:nkernelx.hxx:	static void validateEndorsement (APTR(CrossRegion) ARG(endorsements), APTR(FeKeyMaster) ARG(km));
zx:nkernelx.hxx:	static CLIENT RPTR(FeRangeElement) placeHolder ();
zx:nkernelx.hxx:	static CLIENT RPTR(FeDataHolder) make (APTR(PrimValue) ARG(value));
zx:nkernelx.hxx:	static CLIENT RPTR(FeEdition) empty (APTR(CoordinateSpace) ARG(keySpace));
zx:nkernelx.hxx:	static CLIENT RPTR(FeEdition) fromAll (APTR(XnRegion) ARG(keys), APTR(FeRangeElement) ARG(value));
zx:nkernelx.hxx:	static CLIENT RPTR(FeEdition) fromArray (
zx:nkernelx.hxx:	static CLIENT RPTR(FeEdition) fromOne (APTR(Position) ARG(key), APTR(FeRangeElement) ARG(value));
zx:nkernelx.hxx:	static CLIENT RPTR(FeEdition) placeHolders (APTR(XnRegion) ARG(keys));
zx:nkernelx.hxx:	static CLIENT INLINE Int32 DIRECT_CONTAINERS_ONLY () CONST;
zx:nkernelx.hxx:	static CLIENT INLINE Int32 FROM_OTHER_TRANSITIVE_CONTENTS () CONST;
zx:nkernelx.hxx:	static CLIENT INLINE Int32 FROM_TRANSITIVE_CONTENTS () CONST;
zx:nkernelx.hxx:	static CLIENT INLINE Int32 IGNORE_ARRAY_ORDERING () CONST;
zx:nkernelx.hxx:	static CLIENT INLINE Int32 IGNORE_TOTAL_ORDERING () CONST;
zx:nkernelx.hxx:	static CLIENT INLINE Int32 LOCAL_PRESENT_ONLY () CONST;
zx:nkernelx.hxx:	static CLIENT INLINE Int32 OMIT_SHARED () CONST;
zx:nkernelx.hxx:	static CLIENT INLINE Int32 otherTransitiveContents () CONST;
zx:nkernelx.hxx:	static CLIENT INLINE Int32 PRORATE_SHARED () CONST;
zx:nkernelx.hxx:	static CLIENT INLINE Int32 SEPARATE_OWNERS () CONST;
zx:nkernelx.hxx:	static CLIENT INLINE Int32 thisTransitiveContents () CONST;
zx:nkernelx.hxx:	static CLIENT INLINE Int32 TO_TRANSITIVE_CONTENTS () CONST;
zx:nkernelx.hxx:	static CLIENT INLINE Int32 TOTAL_SHARED () CONST;
zx:nkernelx.hxx:	static CLIENT RPTR(FeIDHolder) make (APTR(ID) ARG(iD));
zx:nkernelx.hxx:	static CLIENT RPTR(FeLabel) make ();
zx:nkernelx.hxx:	static RPTR(FePlaceHolder) on (APTR(BeRangeElement) ARG(be));
zx:nkernelx.hxx:	static CLIENT RPTR(FeWork) make (APTR(FeEdition) ARG(contents));
zx:nkernelx.hxx:	static CLIENT RPTR(FeClub) make (APTR(FeEdition) ARG(status));
zx:nkernelx.hxx:	static RPTR(FilterSpace) endorsementFilterSpace ();
zx:nkernelx.hxx:	static RPTR(CrossRegion) OF2(IDRegion,IDRegion) endorsementRegion (APTR(IDRegion) OR(NULL) ARG(clubs), APTR(IDRegion) OR(NULL) ARG(tokens));
zx:nkernelx.hxx:	static RPTR(CrossSpace) OF2(IDSpace,IDSpace) endorsementSpace ();
zx:nkernelx.hxx:	static CLIENT RPTR(ID) accessClubID ();
zx:nkernelx.hxx:	static CLIENT RPTR(ID) adminClubID ();
zx:nkernelx.hxx:	static CLIENT RPTR(ID) archiveClubID ();
zx:nkernelx.hxx:	static CLIENT RPTR(ID) emptyClubID ();
zx:nkernelx.hxx:	static CLIENT RPTR(Sequence) encrypterName ();
zx:nkernelx.hxx:	static CLIENT RPTR(Lock) login (APTR(ID) ARG(clubID));
zx:nkernelx.hxx:	static CLIENT RPTR(Lock) loginByName (APTR(Sequence) ARG(clubName));
zx:nkernelx.hxx:	static CLIENT RPTR(ID) publicClubID ();
zx:nkernelx.hxx:	static CLIENT RPTR(UInt8Array) publicKey ();
zx:nkernelx.hxx:	static CLIENT NOACK force ();
zx:nkernelx.hxx:	static CLIENT NOACK setCurrentAuthor (APTR(ID) ARG(iD));
zx:nkernelx.hxx:	static CLIENT NOACK setCurrentKeyMaster (APTR(FeKeyMaster) ARG(km));
zx:nkernelx.hxx:	static CLIENT NOACK setInitialEditClub (APTR(ID) ARG(iD));
zx:nkernelx.hxx:	static CLIENT NOACK setInitialOwner (APTR(ID) ARG(iD));
zx:nkernelx.hxx:	static CLIENT NOACK setInitialReadClub (APTR(ID) ARG(iD));
zx:nkernelx.hxx:	static CLIENT NOACK setInitialSponsor (APTR(ID) ARG(iD));
zx:nkernelx.hxx:	static CLIENT RPTR(ID) assignID (APTR(FeRangeElement) ARG(range), APTR(ID) ARG(iD) = NULL);
zx:nkernelx.hxx:	static CLIENT RPTR(ID) clubDirectoryID ();
zx:nkernelx.hxx:	static CLIENT RPTR(FeRangeElement) get (APTR(ID) ARG(iD));
zx:nkernelx.hxx:	static CLIENT RPTR(ID) iDOf (APTR(FeRangeElement) ARG(value));
zx:nkernelx.hxx:	static CLIENT RPTR(IDRegion) iDsOf (APTR(FeRangeElement) ARG(value));
zx:nkernelx.hxx:	static CLIENT RPTR(IDRegion) iDsOfRange (APTR(FeEdition) ARG(edition));
zx:nkernelx.hxx:	static CLIENT IntegerVar currentTime ();
zx:nkernelx.hxx:	static CLIENT RPTR(Sequence) identifier ();
zx:nkernelx.hxx:	static CLIENT RPTR(FeWaitDetector) waitForConsequences ();
zx:nkernelx.hxx:	static CLIENT RPTR(FeWaitDetector) waitForWrite ();
zx:nlinksx.hxx:	static CLIENT RPTR(FeHyperLink) make (
zx:nlinksx.hxx:	static CLIENT RPTR(FeMultiRef) make (
zx:nlinksx.hxx:	static CLIENT RPTR(FeSingleRef) make (
zx:nlinksx.hxx:	static CLIENT RPTR(FePath) make (APTR(PtrArray) OF1(FeLabel) ARG(labels));
zx:orootx.hxx:	static RPTR(OrglRoot) makeData (APTR(PrimDataArray) ARG(values), APTR(Arrangement) ARG(arrangement));
zx:propsp.hxx:	static RPTR(PropFinder) make (APTR(IDRegion) ARG(permissions), APTR(RegionDelta) OF1(CrossRegion) ARG(endorsementsDelta));
zx:propsx.hxx:	static RPTR(BertProp) endorsementsProp (APTR(XnRegion) ARG(endorsements));
zx:propsx.hxx:	static GPTR(BertProp) TheIdentityBertProp;
zx:propsx.hxx:	static GPTR(SensorProp) TheIdentitySensorProp;
zx:propsx.hxx:	static RPTR(PropChange) endorsementsChange ();
zx:propsx.hxx:	static GPTR(PropChange) TheEndorsementsChange;
zx:propsx.hxx:	static RPTR(PropFinder) backfollowFinder (APTR(Filter) OF1(XnRegion OF1(ID)) ARG(permissionsFilter), APTR(Filter) OF1(XnRegion OF1(ID)) ARG(endorsementsFilter));
zx:sysadmx.hxx:	static CLIENT RPTR(FeAdminer) make ();
zx:sysadmx.hxx:	static CLIENT RPTR(FeArchiver) make ();
zx:tcludex.hxx:	static RPTR(RecorderTrigger) make (APTR(RecorderFossil) ARG(fossil), APTR(BeRangeElement) ARG(element));
zx:wrapperx.hxx:	static CLIENT RPTR(FeSet) make ();
zx:wrapperx.hxx:	static CLIENT RPTR(FeSet) make (APTR(PtrArray) OF1(FeRangeElement) ARG(works));
zx:wrapperx.hxx:	static CLIENT RPTR(FeText) make (APTR(PrimArray) ARG(data) = NULL);
zx:wrapperx.hxx:	static RPTR(FeWrapperSpec) OR(NULL) fetch (APTR(Sequence) ARG(identifier));
zx:wrapperx.hxx:	static CLIENT RPTR(FeWrapperSpec) get (APTR(Sequence) ARG(identifier));
zx:wrapperx.hxx:	static RPTR(CrossRegion) getEndorsements (APTR(Sequence) ARG(identifier));
zx:wrapperx.hxx:	static RPTR(FeWrapperSpec) getFromEndorsement (APTR(Tuple) ARG(endorsement));
zx:wrapperx.hxx:	static void setWrapperEndorsements (APTR(ScruTable) OF2(Sequence,CrossRegion) ARG(endorsements));
zx:wrapperx.hxx:	static GPTR(MuTable) OF2(Tumbler,CrossRegion) TheWrapperEndorsements;
zx:wrapperx.hxx:	static GPTR(MuTable) OF2(Tuple,FeWrapperSpec) TheWrappersFromEndorsements;
