Prepares the given database for service. The name of the interest database is derived from the voice rope database name by adding "Refs" after the base name.

ENABLE LoganBerry.Error => ERROR Error[ec, explanation];

vrDB, interestDB: ROPE;

cp: FS.ComponentPositions;

IF dbName = NIL THEN RETURN[NIL];

[vrDB, cp] ← FS.ExpandName[dbName];

IF cp.ext.length = 0 THEN

interestDB ← Rope.Replace[base: vrDB, start: cp.base.start+cp.base.length, len: 0, with: "Refs"];

handle ← NEW[HandleRec ← [voiceRopeDBName: vrDB, voiceInterestDBName: interestDB]];

handle.voiceRopeDB ← LoganBerry.Open[dbName: handle.voiceRopeDBName];

handle.voiceInterestDB ← LoganBerry.Open[dbName: handle.voiceInterestDBName];

};

Returns the structure of the given voice rope.

ENABLE LoganBerry.Error => ERROR Error[ec, explanation];

IF handle = NIL THEN Error[$BadHandle, "NIL handle"];

header ← LoganBerry.ReadEntry[db: handle.voiceRopeDB, key: $VRID, value: ropeID].entry;

struct ← EntryToTuneList[header];

};

Writes the voice rope information into the LoganBerry database.

ENABLE LoganBerry.Error => ERROR Error[ec, explanation];

entry: LoganBerry.Entry;

interval: Thrush.VoiceInterval;

list: TuneList;

IF handle = NIL THEN Error[$BadHandle, "NIL handle"];

compute length of voice rope

list ← struct;

info.length ← 0;

UNTIL list = NIL DO

info.vrID ← GenerateUniqueID[];

will have to change how we get creator across RPC connection.

info.creator ← UserCredentials.Get[].name;

info.struct ← struct;

entry ← PackHeader[info];

LoganBerry.WriteEntry[db: handle.voiceRopeDB, entry: entry ! LoganBerry.Error => IF ec = $ValueNotUnique THEN {info.vrID ← ReplaceID[entry]; RETRY}];

};

Deletes the given voice rope (regardless of what interests may exist).

ENABLE LoganBerry.Error => ERROR Error[ec, explanation];

IF handle = NIL THEN Error[$BadHandle, "NIL handle"];

LoganBerry.DeleteEntry[db: handle.voiceRopeDB, key: $VRID, value: ropeID];

};

Returns a voice rope containing the given tune, if one exists.

ENABLE LoganBerry.Error => ERROR Error[ec, explanation];

IF handle = NIL THEN Error[$BadHandle, "NIL handle"];

header ← LoganBerry.ReadEntry[db: handle.voiceRopeDB, key: $TID, value: Convert.RopeFromInt[tune]].entry;

};

Calls the enumeration procedure for every voice rope with id greater than start; start=NIL represents the first element of the database. Stops when proc returns FALSE or the end of the database is encountered.

ENABLE LoganBerry.Error => ERROR Error[ec, explanation];

continue: BOOLEAN ← TRUE;

entry: LoganBerry.Entry;

info: VoiceRopeInfo;

cursor: LoganBerry.Cursor;

IF handle = NIL THEN Error[$BadHandle, "NIL handle"];

cursor ← LoganBerry.GenerateEntries[db: handle.voiceRopeDB, key: $VRID, start: start];

entry ← LoganBerry.NextEntry[cursor: cursor];

UNTIL entry = NIL OR NOT continue DO

LoganBerry.EndGenerate[cursor: cursor];

};

Builds a tune list with a single tune's information.

list ← LIST[[$TID, Convert.RopeFromInt[tune]], [$Key, MarshalKey[key]], [$SL, MarshalInterval[interval]]];

};

Returns information about the next tune on the list; assumes that list really points to a properly structured TuneList so doesn't bother to check attribute types. The rest of the list is returned so this routine can be repetitively called to get all the tunes on the list.

IF list = NIL THEN Error[$BadTuneList, "NIL tune list"];

tune ← Convert.IntFromRope[list.first.value];

key ← UnmarshalKey[list.rest.first.value];

interval ← UnmarshalInterval[list.rest.rest.first.value];

rest ← list.rest.rest.rest;

};

Returns the tune list representing the structure of the voice rope.

IF entry = NIL THEN RETURN[NIL];

UNTIL entry.first.type = $TID DO

struct ← entry;

};

Returns the tune list representing the structure of the voice rope interval. Warning: this operation modifies the original list!

tuneInterval: Thrush.VoiceInterval; -- the current tune's interval

prevSamples: INT; -- number of samples in entry excluding the current tune interval

samples: INT; -- number of samples in entry including the current tune interval

intervalMustChange: BOOLEAN ← FALSE;

IF list = NIL THEN RETURN[NIL];

IF interval.length = -1 THEN interval.length ← LAST[INT];

prevSamples ← 0;

tuneInterval ← UnmarshalInterval[list.rest.rest.first.value];

samples ← tuneInterval.length;

UNTIL samples > interval.start DO

at this point: prevSamples <= interval.start < samples

new ← list;

IF prevSamples # interval.start THEN { -- don't want first part of existing interval

Note: there's a possibility that interval.start + interval.length could cause an integer overflow; do I want to pay the cost to check for this?

IF (interval.length # LAST[INT]) AND (samples >= interval.start + interval.length) THEN { -- interval contained within a single tune interval

IF intervalMustChange THEN

IF (interval.length = LAST[INT]) OR (samples >= interval.start + interval.length) THEN -- no need to go on

UNTIL samples >= interval.start + interval.length DO

at this point: prevSamples <= interval.start + interval.length <= samples

IF samples # interval.start + interval.length THEN { -- want only first part of tune interval

list.rest.rest.rest ← NIL; -- truncate list since we have has much as we need

RETURN[new];

};

entry: LoganBerry.Entry;

entry ← info.struct;

entry ← CONS[[$Length, Convert.RopeFromInt[info.length]], entry];

the creator field is not really needed, but is included for compatibility with existing databases

entry ← CONS[[$Creator, info.creator], entry];

entry ← CONS[[$VRID, info.vrID], entry];

RETURN[entry];

};

newID ← BadUniqueID[];

header.first.value ← newID;

};

Returns the information associated with a voice rope header.

list: LoganBerry.Entry ← header;

IF header = NIL THEN RETURN;

info.vrID ← list.first.value;

list ← list.rest;

ignore creator field

list ← list.rest;

info.length ← Convert.IntFromRope[list.first.value];

[info.creator, info.timestamp] ← ParseUniqueID[info.vrID];

info.struct ← list.rest;

};

Adds an entry to the interest database if a similar entry does not already exist.

ENABLE LoganBerry.Error => ERROR Error[ec, explanation];

entry: LoganBerry.Entry ← NIL;

oldEntry: LoganBerry.Entry;

IF handle = NIL THEN Error[$BadHandle, "NIL handle"];

oldEntry ← ReadInterest[handle, interest.vrID, interest.class, interest.refID];

interest.interestID ← IF oldEntry = NIL THEN GenerateUniqueID[] ELSE oldEntry.first.value;

entry ← PackInterest[interest];

LoganBerry.WriteEntry[db: handle.voiceInterestDB, entry: entry, replace: oldEntry # NIL ! LoganBerry.Error => IF ec = $ValueNotUnique AND oldEntry = NIL THEN {interest.interestID ← ReplaceInterestID[entry]; RETRY}];

};

Removes an entry from the interest database.

ENABLE LoganBerry.Error => ERROR Error[ec, explanation];

entry: LoganBerry.Entry;

IF handle = NIL THEN Error[$BadHandle, "NIL handle"];

entry ← ReadInterest[handle, interest.vrID, interest.class, interest.refID];

IF entry = NIL THEN RETURN;

LoganBerry.DeleteEntry[db: handle.voiceInterestDB, key: $IID, value: entry.first.value];

};

Searches for an entry with matching ropeID, class, and refID.

info: InterestInfo;

cursor: LoganBerry.Cursor ← LoganBerry.GenerateEntries[db: handle.voiceInterestDB, key: $RefID, start: refID, end: refID];

entry ← LoganBerry.NextEntry[cursor: cursor];

UNTIL entry = NIL DO

LoganBerry.EndGenerate[cursor: cursor];

};

Returns an interest with the given class and refID, if one exists.

ENABLE LoganBerry.Error => ERROR Error[ec, explanation];

IF handle = NIL THEN Error[$BadHandle, "NIL handle"];

interest ← ReadInterest[handle: handle, class: class, refID: refID];

};

Returns an interest for the voice rope, if one exists.

ENABLE LoganBerry.Error => ERROR Error[ec, explanation];

IF handle = NIL THEN Error[$BadHandle, "NIL handle"];

interest ← LoganBerry.ReadEntry[db: handle.voiceInterestDB, key: $VRID, value: ropeID].entry;

};

Calls the enumeration procedure for every interest of the given class. Stops when proc returns FALSE or the end of the database is encountered.

ENABLE LoganBerry.Error => ERROR Error[ec, explanation];

continue: BOOLEAN ← TRUE;

entry: LoganBerry.Entry;

info: InterestInfo;

cursor: LoganBerry.Cursor;

IF handle = NIL THEN Error[$BadHandle, "NIL handle"];

IF proc = NIL THEN Error[$NoProc, "No procedure passed to EnumerateInterestClass"];

cursor ← LoganBerry.GenerateEntries[db: handle.voiceInterestDB, key: $Class, start: class, end: class];

entry ← LoganBerry.NextEntry[cursor: cursor];

UNTIL entry = NIL OR NOT continue DO

LoganBerry.EndGenerate[cursor: cursor];

};

interest ← NIL;

IF info.data # NIL THEN

interest ← CONS[[$RefID, info.refID], interest];

interest ← CONS[[$Class, info.class], interest];

interest ← CONS[[$VRID, info.vrID], interest];

interest ← CONS[[$IID, info.interestID], interest];

};

newID ← BadUniqueID[];

interest.first.value ← newID;

};

list: LoganBerry.Entry ← interest;

IF interest = NIL THEN RETURN;

info.interestID ← list.first.value;

list ← list.rest;

info.vrID ← list.first.value;

list ← list.rest;

info.class ← list.first.value;

list ← list.rest;

info.refID ← list.first.value;

list ← list.rest;

IF list # NIL THEN

[info.creator, info.timestamp] ← ParseUniqueID[info.interestID];

};

cardKey: LONG POINTER TO ARRAY[0..2) OF LONG CARDINAL=LOOPHOLE [LONG[@key]];

r ← IO.PutFR["%bB %bB", IO.card[cardKey[0]], IO.card[cardKey[1]]];

};

cardKey: LONG POINTER TO ARRAY[0..2) OF LONG CARDINAL=LOOPHOLE[LONG[@key]];

keyStream: IO.STREAM ← IO.RIS[r];

cardKey[0] ← IO.GetCard[keyStream];

cardKey[1] ← IO.GetCard[keyStream];

};

Writes a start and length field into a rope.

r ← IO.PutFR["%g %g", IO.int[interval.start], IO.int[interval.length]];

};

Parses the input rope into a start and length field.

s: IO.STREAM ← IO.RIS[r];

interval.start ← IO.GetInt[s];

interval.length ← IO.GetInt[s];

};

timestamp: INT ← MAX[counter, BasicTime.Period[BasicTime.earliestGMT, BasicTime.Now[]]];

id ← IO.PutFR["%g#%g", IO.rope[userName], IO.int[timestamp]];

counter ← counter + 1;

};

This routine should be called if some generated ID does not turn out to be unique. It trys once again to generate a unique ID after advancing the counter.

counter ← BasicTime.Period[BasicTime.earliestGMT, BasicTime.Now[]]+1; -- kick the counter

kicks ← kicks + 1;

id ← GenerateUniqueID[];

};

seconds: INT;

i: INT ← Rope.Find[s1: id, s2: "#"];

creator ← Rope.Substr[base: id, start: 0, len: i];

seconds ← Convert.IntFromRope[Rope.Substr[base: id, start: i+1]];

timestamp ← BasicTime.Update[BasicTime.earliestGMT, seconds];

};

userName ← UserCredentials.Get[].name;

};

counter ← BasicTime.Period[BasicTime.earliestGMT, BasicTime.Now[]];

kicks ← 0;

userName ← UserCredentials.Get[].name;

UserCredentials.RegisterForChange[NewUser];

};