VoiceRopeDBImpl.mesa
Copyright Ó 1986, 1987 by Xerox Corporation. All rights reserved.
Doug Terry, July 28, 1987 10:29:50 pm PDT
Swinehart, April 9, 1987 2:43:20 pm PDT
Routines for storing voice ropes in a database and manipulating their structure.
It is unresolved where a tune's encryption key should be stored. For now, it is kept with the tune interval; though this is the wrong place. Perhaps, it should be kept in the tune's header.
DIRECTORY
BasicTime USING [GMT, earliestGMT, Now, Period, Update],
Convert USING [IntFromRope, RopeFromInt],
FS USING [ComponentPositions, ExpandName],
IO USING [card, EndOfStream, GetCard, GetInt, GetTokenRope, IDProc, int, PutFR, RIS, rope, STREAM],
LoganBerry USING [AttributeType, AttributeValue, Cursor, DeleteEntry, EndGenerate, Entry, Error, GenerateEntries, NextEntry, Open, OpenDB, ReadEntry, WriteEntry],
Rope USING [Cat, Concat, Equal, Find, Replace, ROPE, Substr],
Thrush USING [EncryptionKey],
UserCredentials USING [Get],
VoiceRopeDB;
VoiceRopeDBImpl: CEDAR PROGRAM -- Should this be a monitor?
IMPORTS BasicTime, Convert, FS, IO, Rope, UserCredentials, LoganBerry
EXPORTS VoiceRopeDB
~
BEGIN
OPEN VoiceRopeDB;
ROPE: TYPE ~ Rope.ROPE;
STREAM: TYPE ~ IO.STREAM;
VoiceRope database operations
Voice ropes are stored in a LoganBerry database as a header followed by a list of tune intervals (a TuneList). Interests in voice ropes are also maintained in a LoganBerry database.
Error: PUBLIC ERROR [ec: ATOM, explanation: Rope.ROPE ← NIL] = CODE;
Open:
PUBLIC PROC[dbName: Rope.
ROPE]
RETURNS [handle: Handle ←
NIL] = {
Prepares the given database for service.
The name of the voice rope database is presumed to be <x>sLB.DF.
The name of the interest database is derived from it, producing <x>InterestsLB.DF.
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
vrDB ← Rope.Concat[vrDB, ".df"];
interestDB ←
Rope.Replace[base: vrDB, start: cp.base.start+cp.base.length-3, len: 0, with: "Interest"];
handle ← NEW[HandleRec ← [voiceRopeDBName: vrDB, voiceInterestDBName: interestDB]];
handle.voiceRopeDB ← LoganBerry.Open[dbName: handle.voiceRopeDBName];
handle.voiceInterestDB ← LoganBerry.Open[dbName: handle.voiceInterestDBName];
};
ReadVoiceRope:
PUBLIC
PROC [handle: Handle, ropeID:
ID]
RETURNS [header: Header, struct: TuneList] ~ {
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];
};
WriteVoiceRope:
PUBLIC PROC [handle: Handle, vr: VoiceRopeInfo, replace:
BOOLEAN ←
FALSE]
RETURNS [info: VoiceRopeInfo] ~ {
Writes the voice rope information into the LoganBerry database.
ENABLE LoganBerry.Error => ERROR Error[ec, explanation];
entry: LoganBerry.Entry;
IF handle = NIL THEN Error[$BadHandle, "NIL handle"];
IF vr.creator =
NIL
THEN
vr.creator ← UserCredentials.Get[].name;
IF vr.vrID =
NIL
THEN
vr.vrID ← GenerateUniqueID[vr.creator];
entry ← PackHeader[vr];
LoganBerry.WriteEntry[db: handle.voiceRopeDB, entry: entry, replace: replace ! LoganBerry.Error => IF ec = $ValueNotUnique THEN {vr.vrID ← ReplaceID[entry, vr.creator]; RETRY}];
RETURN[vr];
};
DeleteVoiceRope:
PUBLIC PROC [handle: Handle, ropeID: ID] ~ {
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];
};
VoiceRopeContainingTune:
PUBLIC PROC [handle: Handle, tune:
INT]
RETURNS [header: Header] ~ {
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;
};
EnumerateVoiceRopes:
PUBLIC PROC [handle: Handle, start:
ID ←
NIL, proc: EnumProc] ~ {
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
info ← UnpackHeader[entry];
continue ← proc[info];
entry ← LoganBerry.NextEntry[cursor: cursor];
ENDLOOP;
LoganBerry.EndGenerate[cursor: cursor];
};
Voice rope structure
WARNING: For efficiency reasons, much of this code relies on the exact structure of entries stored in a LoganBerry database. For instance, it assumes that the first attribute of an entry is a voice rope (or interest) ID and does not check the attribute type to verify this. Do NOT reorder attributes unless care is taken to change the code dependencies.
A tune list, the structure of a voice rope, is represented in a LoganBerry database as an ordered list of $TID (the tune's ID), $Key (the tune's encryption key), and $SL (the start and length of a tune interval) attributes. The tune's encryption key should probably be kept in the tune's header.
SimpleTuneList:
PUBLIC PROC [tune: TuneID, start:
INT, length:
INT, key: Thrush.EncryptionKey]
RETURNS [list: TuneList] ~ {
Builds a tune list with a single tune's information.
list ← LIST[[$TID, Convert.RopeFromInt[tune]], [$Key, MarshalKey[key]], [$SL, MarshalInterval[start, length]]];
};
NextTuneOnList:
PUBLIC PROC [list: TuneList]
RETURNS [tune: TuneID, start:
INT, length:
INT, key: Thrush.EncryptionKey, rest: TuneList] ~ {
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];
[start, length] ← UnmarshalInterval[list.rest.rest.first.value];
rest ← list.rest.rest.rest;
};
EntryToTuneList:
PROC [entry: LoganBerry.Entry]
RETURNS [struct: TuneList] ~ {
Returns the tune list representing the structure of the voice rope.
IF entry = NIL THEN RETURN[NIL];
UNTIL entry.first.type = $TID
DO
entry ← entry.rest;
IF entry = NIL THEN Error[$BadTuneList, "No TID in entry"];
ENDLOOP;
struct ← entry;
};
TuneListInterval:
PUBLIC PROC [list: TuneList, start:
INT ← 0, length:
INT ← -1]
RETURNS [new: TuneList] ~ {
Returns the tune list representing the structure of the voice rope interval. If the list contains intervals of unspecified length (-1) then the desired voice rope interval may not be determinable and an Error[$UnspecifiedInterval] is raised.
Warning: this operation modifies the original list!
tuneStart, tuneLength: INT; -- 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 length > (
LAST[
INT] - start)
THEN
-- start + length would cause an integer overflow
length ← -1; -- essentially want the whole length
prevSamples ← 0;
[tuneStart, tuneLength] ← UnmarshalInterval[list.rest.rest.first.value];
IF tuneLength < 0
THEN
ERROR Error[$UnspecifiedInterval, "Some tune interval has length=-1"];
samples ← tuneLength;
UNTIL samples > start
DO
prevSamples ← samples;
list ← list.rest.rest.rest;
IF list = NIL THEN RETURN[NIL];
[tuneStart, tuneLength] ← UnmarshalInterval[list.rest.rest.first.value];
IF tuneLength < 0
THEN
ERROR Error[$UnspecifiedInterval, "Some tune interval has length=-1"];
samples ← samples + tuneLength;
ENDLOOP;
at this point: prevSamples <= start < samples
new ← list;
IF prevSamples # start
THEN {
-- don't want first part of existing interval
tuneStart ← tuneStart + (start - prevSamples);
tuneLength ← tuneLength - (start - prevSamples);
intervalMustChange ← TRUE;
};
IF (length >= 0)
AND (samples >= start + length)
THEN {
-- interval contained within a single tune interval
tuneLength ← length;
new.rest.rest.rest ← NIL; -- truncate list since we have has much as we need
intervalMustChange ← TRUE;
};
IF intervalMustChange
THEN
new.rest.rest.first.value ← MarshalInterval[tuneStart, tuneLength];
IF (length < 0)
OR (samples >= start + length)
THEN
-- no need to go on
RETURN[new];
UNTIL samples >= start + length
DO
prevSamples ← samples;
list ← list.rest.rest.rest;
IF list = NIL THEN RETURN[new];
[tuneStart, tuneLength] ← UnmarshalInterval[list.rest.rest.first.value];
IF tuneLength < 0
THEN
ERROR Error[$UnspecifiedInterval, "Some tune interval has length=-1"];
samples ← samples + tuneLength;
ENDLOOP;
at this point: prevSamples <= start + length <= samples
IF samples # start + length
THEN {
-- want only first part of tune interval
list.rest.rest.first.value ← MarshalInterval[tuneStart, start + length - prevSamples];
};
list.rest.rest.rest ← NIL; -- truncate list since we have has much as we need
RETURN[new];
};
PackHeader:
PROC [info: VoiceRopeInfo]
RETURNS [header: Header] ~ {
entry: LoganBerry.Entry;
entry ← info.struct;
IF info.editAccess #
NIL
THEN
entry ← CONS[[$EAccess, MarshalList[info.editAccess]], entry];
IF info.playAccess #
NIL
THEN
entry ← CONS[[$PAccess, MarshalList[info.playAccess]], entry];
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];
};
ReplaceID:
PROC [header: Header, userName:
ROPE]
RETURNS [newID:
ID] ~ {
newID ← BadUniqueID[userName];
header.first.value ← newID;
};
UnpackHeader:
PUBLIC
PROC [header: Header]
RETURNS [info: VoiceRopeInfo] ~ {
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];
list ← list.rest;
IF list.first.type = $PAccess
THEN {
info.playAccess ← UnMarshalList[list.first.value];
list ← list.rest;
};
IF list.first.type = $EAccess
THEN {
info.editAccess ← UnMarshalList[list.first.value];
list ← list.rest;
};
[info.creator, info.timestamp] ← ParseUniqueID[info.vrID];
info.struct ← list;
};
Interests database
AddInterest:
PUBLIC PROC [handle: Handle, interest: InterestInfo]
RETURNS [info: InterestInfo] ~ {
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"];
IF interest.creator =
NIL
THEN
interest.creator ← UserCredentials.Get[].name;
oldEntry ← ReadInterest[handle, interest.vrID, interest.class, interest.refID];
interest.interestID ← IF oldEntry = NIL THEN GenerateUniqueID[interest.creator] 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, interest.creator]; RETRY}];
RETURN[interest];
};
DropInterest:
PUBLIC PROC [handle: Handle, interest: InterestInfo] ~ {
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];
};
ReadInterest:
PROC [handle: Handle, ropeID:
ID ← NIL, class: Rope.
ROPE ← NIL, refID: Rope.
ROPE]
RETURNS [entry: LoganBerry.Entry] ~ {
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
info ← UnpackInterest[entry];
IF (ropeID = NIL OR Rope.Equal[info.refID, refID]) AND (class = NIL OR Rope.Equal[info.class, class]) THEN EXIT;
entry ← LoganBerry.NextEntry[cursor: cursor];
ENDLOOP;
LoganBerry.EndGenerate[cursor: cursor];
};
InterestForRef:
PUBLIC PROC [handle: Handle, class: Rope.
ROPE, refID: Rope.
ROPE]
RETURNS [interest: Interest] ~ {
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];
};
InterestInVoiceRope:
PUBLIC PROC [handle: Handle, ropeID:
ID]
RETURNS [interest: Interest] ~ {
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;
};
EnumerateInterestClass:
PUBLIC PROC [handle: Handle, class: Rope.
ROPE, proc: InterestProc] ~ {
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
info ← UnpackInterest[entry];
continue ← proc[info];
entry ← LoganBerry.NextEntry[cursor: cursor];
ENDLOOP;
LoganBerry.EndGenerate[cursor: cursor];
};
PackInterest:
PUBLIC PROC [info: InterestInfo]
RETURNS [interest: Interest] ~ {
interest ← NIL;
IF info.data #
NIL
THEN
interest ← CONS[[$Data, info.data], interest];
interest ← CONS[[$RefID, info.refID], interest];
interest ← CONS[[$Class, info.class], interest];
interest ← CONS[[$VRID, info.vrID], interest];
interest ← CONS[[$IID, info.interestID], interest];
};
ReplaceInterestID:
PROC [interest: Interest, userName:
ROPE]
RETURNS [newID:
ID] ~ {
newID ← BadUniqueID[userName];
interest.first.value ← newID;
};
UnpackInterest:
PUBLIC PROC [interest: Interest]
RETURNS [info: InterestInfo] ~ {
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.data ← list.first.value;
[info.creator, info.timestamp] ← ParseUniqueID[info.interestID];
};
Conversions (marshalling)
MarshalKey:
PROC [key: Thrush.EncryptionKey]
RETURNS [r:
ROPE] ~
TRUSTED {
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]]];
};
UnmarshalKey:
PROC [r:
ROPE]
RETURNS [key: Thrush.EncryptionKey] ~
TRUSTED {
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];
};
MarshalInterval:
PROC [start:
INT, length:
INT]
RETURNS [r:
ROPE] ~
INLINE {
Writes a start and length field into a rope.
r ← IO.PutFR["%g %g", IO.int[start], IO.int[length]];
};
UnmarshalInterval:
PROC [r:
ROPE]
RETURNS [start:
INT, length:
INT] ~
INLINE {
Parses the input rope into a start and length field.
s: IO.STREAM ← IO.RIS[r];
start ← IO.GetInt[s];
length ← IO.GetInt[s];
};
MarshalList:
PROC [l:
LIST
OF
ROPE]
RETURNS [r:
ROPE] ~ {
Writes a list of names into a rope.
r ← NIL;
WHILE l#
NIL
DO
r ← Rope.Cat[r, l.first, " "];
l ← l.rest;
ENDLOOP;
};
UnMarshalList:
PROC [r:
ROPE]
RETURNS [l:
LIST
OF
ROPE] ~ {
Parses the input rope into a list of names.
s: IO.STREAM ← IO.RIS[r];
l ← NIL;
DO
n: ROPE ← IO.GetTokenRope[s, IO.IDProc ! IO.EndOfStream => EXIT].token;
l ← CONS[n, l];
ENDLOOP;
};
Generating unique identifiers
A unique identifier is generated by concatenating a user's Rname with a timestamp. The timestamp is taken to be the maximum of the current time (converted to an integer) and a simple counter. The current time alone is not sufficient since it has a granularity of seconds. Several voice ropes may be created within a second, but the long-term creation rate should be much less than one per second. The counter is initialized to the current time, which could cause some problems if this module is rerun before the current time has a chance to catch up to the old counter (or if a machine's clock is reset to an earlier time). This problem is detected by $ValueNotUnique errors from LoganBerry when one attempts to write a new voice rope.
Note that the counter, as maintain by these routines, is sufficient as a unique ID if this code is run on the voice server. However, having a user's name and current timestamp as part of the permanent voice rope ID provides information that might be useful.
counter: INT;
kicks: INT; -- for instrumentation purposes
GenerateUniqueID:
PROC [userName:
ROPE]
RETURNS [id:
ROPE] ~ {
timestamp: INT ← MAX[counter, BasicTime.Period[BasicTime.earliestGMT, BasicTime.Now[]]];
id ← IO.PutFR["%g#%g", IO.rope[userName], IO.int[timestamp]];
counter ← counter + 1;
};
BadUniqueID:
PROC [userName:
ROPE]
RETURNS [id:
ROPE] ~ {
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[userName];
};
ParseUniqueID:
PROC [id:
ROPE]
RETURNS [creator:
ROPE, timestamp: BasicTime.
GMT] ~ {
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];
};
InitUniqueID:
PROC []
RETURNS [] ~ {
counter ← BasicTime.Period[BasicTime.earliestGMT, BasicTime.Now[]];
kicks ← 0;
};
Initializations
InitUniqueID[];
END.
Doug Terry, June 3, 1986 4:19:14 pm PDT
Extracted database operations from VoiceRopeImpl.mesa.
changes to: VoiceRopeDBImpl, EXPORTS, ~, WriteVoiceRope
Doug Terry, June 3, 1986 5:23:23 pm PDT
changes to: VoiceRopeDBImpl, EXPORTS, ~, Open, WriteVoiceRope, END, DIRECTORY, IMPORTS, Read, SimpleTuneList, NextTuneOnList, TuneListInterval, EntryToTuneList
Doug Terry, June 5, 1986 11:47:40 am PDT
changes to: Open, Read, Write, EntryToTuneList, Error, DIRECTORY
Doug Terry, June 5, 1986 3:07:30 pm PDT
changes to: EntryToTuneList, TuneListInterval
Doug Terry, June 10, 1986 5:55:22 pm PDT
changes to: AddInterest, DropInterest, LookupInterest, Write, Delete, ~, LookupVoiceRope, LookupTune
Doug Terry, June 11, 1986 3:40:47 pm PDT
changes to: LookupTune, Enumerate, LookupVoiceRope, EnumerateInterests, ParseInterestEntry, AddInterest, DropInterest, LookupInterest, CRQuery, RCRQuery
Doug Terry, June 12, 1986 4:45:50 pm PDT
changes to: Open, ReadVoiceRope, EntryToTuneList, ~, WriteVoiceRope, PackHeader, ReplaceID, UnpackHeader, PackInterest, UnpackInterest, DeleteVoiceRope, VoiceRopeContainingTune, EnumerateVoiceRopes, AddInterest, DropInterest, ReplaceInterestID, ReadInterest, InterestForRef, InterestInVoiceRope, EnumerateInterestClass, BadUniqueID, ParseUniqueID, DIRECTORY
Doug Terry, June 17, 1986 12:02:00 pm PDT
changes to: UnpackHeader
Doug Terry, June 26, 1986 2:08:18 pm PDT
changes to: TuneListInterval
Doug Terry, June 26, 1986 5:03:38 pm PDT
changes to: Open, DIRECTORY, IMPORTS
Doug Terry, June 30, 1986 1:11:17 pm PDT
changes to: PackInterest
Doug Terry, June 30, 1986 2:36:30 pm PDT
changes to: UnpackHeader, Open, ReadVoiceRope, WriteVoiceRope, DeleteVoiceRope, VoiceRopeContainingTune, EnumerateVoiceRopes, AddInterest, DropInterest, InterestForRef, InterestInVoiceRope, EnumerateInterestClass, NextTuneOnList, EntryToTuneList, UnpackInterest
Doug Terry, August 18, 1986 4:53:00 pm PDT
Changes for server-side operation: now uses LoganBerry directly rather than LoganBerryStub.
changes to: DIRECTORY, IMPORTS, WriteVoiceRope, SimpleTuneList, NextTuneOnList, TuneListInterval, MarshalInterval, UnmarshalInterval
Doug Terry, October 8, 1986 11:21:42 am PDT
Changed back to using LoganBerryStub.
changes to: IMPORTS
Doug Terry, October 8, 1986 11:22:30 am PDT
changes to: DIRECTORY, IMPORTS
Swinehart, April 8, 1987 9:11:16 am PDT
Cedar 7. LoganBerryStub => LoganBerry
changes to: DIRECTORY, IMPORTS