The generic error raised by procedures in this interface. This Error is PFS.Error.

p=nullName => result is TRUE; otherwise, the standard PFS rules apply.

~ INLINE {RETURN PFSNames.Equal[n1, n2]};

A total ordering that is consistent with PFS's ordering.

NamePatternIsConstant[p] iff for all x1 and x2:

~ INLINE {RETURN [[egmt: [gmt, 0] ]]};

Returns [c.egmt.gmt, c#CreatedFromGMT[c.egmt.gmt]].

~ INLINE {RETURN [[c.egmt.gmt, c.egmt.usecs#0 OR c.host#[0, 0] ]]};

GMTPlus: TYPE ~ RECORD [gmt: BasicTime.GMT, other: BOOL];

~ INLINE {RETURN [p=nullCreated OR x=p]};

~ INLINE {RETURN [p=nullStamp OR x=p]};

name: Name ← nullName,

created: Created ← nullCreated,

stamp: VersionStamp ← nullStamp];

TMatches[t, p] iff NameMatch[t.name, p.name], CreatedMatch[t.created, p.created], and StampMatch[t.stamp, p.stamp].

TEqual[t1, t2] iff (TPCompare[t1, t2] = equal).

VersionTuples are totally ordered.

Returns one that matches every file having the given short name.

Returns one that matches every file having the given last component.

PatternIsConstant[p] iff for all x1 and x2:

~ INLINE {RETURN [NEW[Map ← map]]};

~ INLINE {RETURN map.class.Functional[map]};

~ INLINE {RETURN map.class.MMutability[map]};

readonly means the map contents may change, but not due to actions on this Map.

Does the given map contain the given tuple?

~ INLINE {RETURN map.class.Has[map, elt]};

Passes to Consume those tuples of map that pass the intersection of the filters. If and when Consume[t] returns TRUE, the enumeration is stopped and [TRUE, t] is returned; otherwise [FALSE, nullTuple] is returned. Tuples are passed in TCompare order if inOrder. Consume may call other procedures on the map; if the map is changed during enumeration, there are no guarantess about whether tuples added or removed are enumerated.

~ INLINE {RETURN map.class.Scan[map, Consume, inOrder, PatternFactorMapList[filters]]};

(NOT found) => (it = nullTuple).

noMaybe: MaybeTuple ~ [FALSE, nullTuple];

Always returns TRUE.

Equivalent to Scan[map, Consume, inOrder, PatternUnfactorMapList[pfml]].

~ INLINE {RETURN map.class.Scan[map, Consume, inOrder, pfml]};

TRUE iff for all m in maplist: Has[m, t].

TRUE iff there exists an m in maplist such that Has[m, t].

Equivalent to AllHave[PatternUnfactorMapList[pfml], t].

The passive form of Scan --- return a closure that can generate the elements under client control. Use of generators is covered in a later section.

~ INLINE {RETURN map.class.CreateGenerator[map, inOrder, PatternFactorMapList[filters]]};

~ INLINE {RETURN map.class.CreateGenerator[map, inOrder, pfml]};

See CreateMatcher for details about matching.

~ INLINE {RETURN map.class.Scan[map, Consume, inOrder, [pattern]]};

~ INLINE {RETURN map.class.CreateGenerator[map, inOrder, [pattern]]};

Raises Error[client, $NotUnique] if map.Size[] # 1; otherwise returns the one and only tuple in the map.

IF map.Size[]=0

Returns AnElt[map.Intersection[CreateMatcher[stamp: stamp]]].

Returns AnElt[map.Intersection[CreateMatcher[created: created]]].

Returns AnElt[map.Intersection[CreateMatcher[name: ShortNameToPattern[shortName]]]].

Result is anything in [MIN[size, limit] .. size]. This lets clients that don't care about the difference between 2 and infinity, and implementations whose cost is proportional to the answer, get along without much waste.

~ INLINE {RETURN map.class.Size[map, limit]};

~ INLINE {RETURN [Size[map, 1]=0]};

Possibly adds a tuple t into map, depending on whether it's OK to replace the pre-existing tuple with the same name (if there is one). For functional maps, if controls whether replacement is done and had reveals some information about the state of map before this operation; for non-functional maps if is ignored (the addition is always done) and there are no guarantees about had (it may even be unitialized).

~ INLINE {RETURN map.class.AddTuple[map, t, if]};

The OldCase for possibly adding a tuple t to a map m is:

When t is already in m, there's no question about whether to add t to m.

Such an array tells whether to add a tuple to a map, according to the case.

Some specific arrays of interest.

A Had partially reveals a state of a map m with respect to a tuple t and a dependent field f:

Adds the tuples of other into map, possibly replacing pre-existing tuples with equal names as necessary. For functional maps, if controls whether replaceent is done and some reveals some information about the state of map before this operation; for non-functional maps, if is ignored and there are no guarantees about some. other must be able to enumerate.

~ INLINE {RETURN map.class.AddMap[map, other, if]};

A HadSets summarizes a relation between two Maps (map and other). Specifically, hs[f][h] is TRUE iff there exists some tuple t in other such that the Had for map with respect to t and f is h.

Removes a tuple from a writable map, if that tuple was in the map. The previous state of the map is partially revealed by had if the map is functional; no guarantees about had for non-functional maps.

~ INLINE {RETURN map.class.RemTuple[map, t]};

Removes the tuples of other from map. The previous state of the map is partially revealed by had if the map is functional; no guarantees about had for non-functional maps. other must be able to enumerate.

~ INLINE {RETURN map.class.RemMap[map, other]};

Like RemMap[map, intersection of filters], except that no information is returned, and thus the filters need not be able to enumerate.

Produces a map that can test membership but may not be able to enumerate. Argument and result cannot both be functional.

~ INLINE {RETURN map.class.Negate[map]};

IsNegation[Negate[Negate[x]]] might return [FALSE, nullMap].

~ INLINE {RETURN map.class.IsNegation[map]};

(NOT found) => (it = nullMap).

Returns a map that contain exactly those tuples contained in both given maps. Implements enumeration by enumerating map and testing membership in other.

~ INLINE {RETURN map.class.Intersect[map, other]};

IsIntersection[x] does not imply that x was made with Intersect.

~ INLINE {RETURN map.class.IsIntersection[map]};

(NOT found) => (map = other = nullMap).

test=disjoint => map.Intersect[other].Emtpy

ordered => TBCompare[t, u] <= equal for all t in map, u in other.

test=map => enumeration implemented by enumerating map, enumerating other and testing membership in map.

test=other => enumeration implemented by enumerating other, enumerating map and testing membership in other.

~ INLINE {RETURN map.class.Union[map, other, test, ordered]};

~ INLINE {RETURN map.class.IsUnion[map]};

Enumeration implemented by enumerating map and testing membership in other.

~ INLINE {RETURN map.class.Difference[map, other]};

~ INLINE {RETURN map.class.IsDifference[map]};

Result can enumerate iff both args can; quickly only if both args can quickly test membership.

~ INLINE {RETURN map.class.SymmetricDifference[map, other]};

~ INLINE {RETURN map.class.IsSymmetricDifference[map]};

A constant map with no elements.

A constant map that contains every VersionTuple.

If map.Size[]=1, returns [TRUE, the T that map has], otherwise [FALSE, nullTuple].

The result is functional, writable, and initially empty.

Reads map contents from a file; assumeImmutable indicates whether MapFromFile can assume the file's contents will not change. MapFromFile always returns a constant map. Thus, if assumeImmutable, the returned map can use a RopeFile on the given file; otherwise, the entire file contents must be copied (into memory or another file).

MaybeFromFile: TYPE ~ RECORD [found: BOOL, fileName: Name, created: Created, assumeImmutable: BOOL];

(NOT found) => (it = nullName).

A `directories map' contains all the files in a set of directories. The directories are the members of dirs (created and stamp unimportant). If given, hints and cache are consulted before file contents to determine version stamps. If cache is given, stamps read from files are stored there.

Creates a Map that can test membership, but cannot enumerate (unless the pattern is constant). It contains every tuple t such that TMatches[t, pattern].

pattern: VersionTuple,

stampInd, general: Map

];

A factored representation for the intersection of CreateMatcher[pattern], stampInd, and general. Neither stampInd nor general is NIL; aFull is used to say `no more constraints'. Membership in stampInd (`stamp independent') does not depend on a tuple's stamp; that is, for all n, c, s1, and s2: <n, c, s1> is in stampInd if and only if <n, c, s2> is in stampInd.

Any map that can yield useful information without doing a lot of work is expected to do so.

~ INLINE {RETURN map.class.PatternFactorMap[map]};

pattern: VersionTuple ← nullTuple,

stampInd, general: MapList ← NIL

];

Represents the intersection of CreateMatcher[pattern], the members of stampInd, and the members of general. The members of stampInd do not care about the version stamps of tuples. Setting stampInd=listOfEmpty is a particularly obvious way to indicate the empty intersection.

If empty intersection detected, stampInd=listOfEmpty.

The inverse of PatternFactorMapList.

Result represents the intersection of the arguments.

Returns a constant map that matches every tuple whose name is the concatenation of prefix.name and one of the suffixes.

Next: PROC [Generator] RETURNS [VersionTuple],

Close: PROC [Generator],

data: REF ANY ← NIL];

Result generates elements of both generators, which must be disjoint. Result does not support concurrent calls. If sort, both generators are assumed to generate in order, and the result alternates between them to preserve order. Closes g1 and g2 when closed.

Result generates the same elements as the argument, but in order. Result does not support concurrent calls. Closes arg when closed.

Returns a more restricted generator. Result does not support concurrent calls. Closes given generator when closed.

If the generator has exactly one more tuple to generate, that one is returned; otherwise, raises Error[client, $NotUnique].

If the generator has exactly one more tuple to generate, returns [TRUE, the tuple]; otherwise, returns [FALSE, nullTuple].

Functional: PROC [map: Map] RETURNS [BOOL],

MMutability: PROC [map: Map] RETURNS [Mutability],

Has: PROC [map: Map, elt: VersionTuple] RETURNS [BOOL] ← NIL,

Scan: PROC [map: Map, Consume: TupleConsumer, inOrder: BOOL, pfml: PatternFactoredMapList] RETURNS [MaybeTuple] ← NIL,

CreateGenerator: PROC [map: Map, inOrder: BOOL, pfml: PatternFactoredMapList] RETURNS [Generator] ← NIL,

Size: PROC [map: Map, limit: INT] RETURNS [INT] ← NIL,

PatternFactorMap: PROC [map: Map] RETURNS [PatternFactoredMap] ← NIL,

AddTuple: PROC [map: Map, t: VersionTuple, if: IfHads] RETURNS [had: Hads] ← NIL,

AddMap: PROC [map, other: Map, if: IfHads] RETURNS [some: HadSets] ← NIL,

RemTuple: PROC [map: Map, t: VersionTuple] RETURNS [had: Hads] ← NIL,

RemMap: PROC [map, other: Map] RETURNS [some: HadSets] ← NIL,

Negate: PROC [map: Map] RETURNS [Map] ← NIL,

IsNegation: PROC [map: Map] RETURNS [MaybeMap] ← NIL,

Intersect: PROC [map, other: Map] RETURNS [Map] ← NIL,

IsIntersection: PROC [map: Map] RETURNS [Maybe2Maps] ← NIL,

Union: PROC [map, other: Map, test: UnionTest, ordered: BOOL] RETURNS [Map] ← NIL,

IsUnion: PROC [map: Map] RETURNS [Maybe2Maps] ← NIL,

Difference: PROC [map, other: Map] RETURNS [Map] ← NIL,

IsDifference: PROC [map: Map] RETURNS [Maybe2Maps] ← NIL,

SymmetricDifference: PROC [map, other: Map] RETURNS [Map] ← NIL,

IsSymmetricDifference: PROC [map: Map] RETURNS [Maybe2Maps] ← NIL,

other: Atom.PropList ← NIL,

data: REF ANY];