<<>>
    <<WalnutDBMsgSetsImpl.mesa>>
        <<Copyright Ó 1984, 1988, 1989, 1992 by Xerox Corporation.  All rights reserved. >>
        <<Willie-Sue, March 29, 1989 6:04:55 pm PST>>
        <<Donahue, May 12, 1986 2:13:42 pm PDT  >>
        <<Jack Kent, June 23, 1987 6:57:27 pm PDT >>
        <<Doug Terry, August 28, 1990 5:35:08 pm PDT>>
        <<TerryTest, November 15, 1990 12:40 pm PST>>
        <<>>
        <<Contents: types and procedures dealing with the Walnut message database>>
        <<Initiated by Willie-Sue, September 24, 1984>>
        <<Swinehar, February 25, 1991 9:50 am PST>>

    DIRECTORY
        Ascii USING [Lower], 
        Atom USING [MakeAtomFromRefText, GetPName], 
        IO,
        LoganBerry,
        LoganBerryEntry,
        RefTab USING [Ref, Val, Create, Delete, Fetch, Store],
        RefText USING [line, InlineAppendChar],
        Rope,
        WalnutDefs USING [dontCareDomainVersion, dontCareMsgSetVersion, Error, MsgSet, VersionMismatch, WalnutOpsHandle],
        WalnutDB,
        WalnutRegistry USING [MsgGroup, MsgGroupSize],
        WalnutRegistryPrivate USING [ CheckForMsgGroupRegistration,  NotifyForEvent, NotifyForMove, NotifyForMsgEvent, NotifyForMsgGroup],
        WalnutRoot USING [CommitAndContinue, RootHandle],
        WalnutSchema;

    WalnutDBMsgSetsImpl: CEDAR PROGRAM
        IMPORTS
            Ascii, Atom, IO, LoganBerry, LoganBerryEntry, RefTab, RefText, Rope,
            WalnutDefs, WalnutDB,
            WalnutRegistryPrivate,
            WalnutRoot

        EXPORTS WalnutDB, WalnutDefs =

    BEGIN OPEN WalnutDB, WalnutSchema;
    <<>>
    <<Types>>
        ROPE: TYPE = Rope.ROPE;
        Relship: TYPE = LoganBerry.Entry;

        WalnutOpsHandle: TYPE = WalnutDefs.WalnutOpsHandle;
        RootHandle: TYPE = WalnutRoot.RootHandle;
        SchemaHandle: TYPE = WalnutSchema.SchemaHandle;
        SchemaHandleRec: PUBLIC TYPE = WalnutSchema.SchemaHandleRec;
        MsgSet: TYPE = WalnutDefs.MsgSet;

        dontCareDomainVersion: INT = WalnutDefs.dontCareDomainVersion;
        dontCareMsgSetVersion: INT = WalnutDefs.dontCareMsgSetVersion;
        CheckReportProc: TYPE = WalnutDB.CheckReportProc;
    <<>>
    <<Internal Types and Variables>>

        Value: TYPE = LoganBerry.AttributeValue;
        DBMinusOneInt: Value Ź LoganBerryEntry.I2V[-1];
        DBZeroInt: Value Ź LoganBerryEntry.I2V[0];
        DBTrueBool: Value Ź LoganBerryEntry.B2V[TRUE];
        DBFalseBool: Value Ź LoganBerryEntry.B2V[FALSE];
        nullValue: Value = NIL;
        ActiveMsgSetName: ROPE = "Active";
        DeletedMsgSetName: ROPE = "Deleted";
        timeToDelete: CARD16 Ź 40;

        IsEntity: TYPE = RECORD [entity: LoganBerry.Entry, exists: BOOL];
        <<>>
        <<MSInfo's are stored in the msgSetsTable>>
        MSInfo: TYPE = REF MSInfoObject;
        MSInfoObject: TYPE = RECORD [canonicalName: ROPE, entity: ROPE, versionRel: Relship];
        nameText: REF TEXT = NEW[TEXT[RefText.line]]; 

        LazyEnumerator: TYPE = REF LazyEnumeratorRec;
        LazyEnumeratorRec: PUBLIC TYPE = RECORD[
            opsH: WalnutOpsHandle,
            msgSet: MsgSet,
            pos: INT,
            set: LoganBerry.Cursor,
            valid: BOOL,
            checkShow: BOOL
            ];
    <<>>
    <<Operations on Message Sets>>

        MsgSetExists: PUBLIC PROC[opsH: WalnutOpsHandle, name: ROPE, msDomainVersion: INT] RETURNS[existed: BOOL, msVersion: INT] = {
            <<Does this message set already exist in the database.>>
            msI: MSInfo;
            CheckDomainVersion[opsH, msDomainVersion];
            [msI, msVersion] Ź GetMsgSetAndVersion[opsH, name];
            existed Ź msI # NIL;
            };

        CreateMsgSet: PUBLIC PROC[opsH: WalnutOpsHandle, name: ROPE, msDomainVersion: INT] RETURNS [existed: BOOL, msVersion: INT] = {
            <<Create this message set if it doesn't already exist in the database.>>
            msI: MSInfo;
            mse: ROPE;
            cName: ROPE;
            aName: ATOM;
            sH: SchemaHandle = opsH.schemaHandle;
            CheckDomainVersion[opsH, msDomainVersion];
            [msI, msVersion] Ź GetMsgSetAndVersion[opsH, name];
            IF existed Ź (msI # NIL) THEN RETURN;
            cName Ź Atom.GetPName[aName Ź CanonicalName[name]];
            mse Ź cName;
            msI Ź NEW[MSInfoObject Ź [canonicalName: cName, entity: mse, versionRel: NIL] ];
            msI.versionRel Ź LIST [ 
                [$Key, Rope.Concat[sH.msBasicInfo, mse]],
                [sH.msPrintNameIs, name],
                [sH.msBICount, "0"],
                [sH.msBIVersion, "1"]
                ];
            LoganBerry.WriteEntry[db: opsH.db, entry: msI.versionRel];
            ChangeGlobalMsgSetInfo[opsH, 1];
            [] Ź RefTab.Store[sH.msgSetsTable, aName, msI];
            };

        NumInMsgSet: PUBLIC PROC[opsH: WalnutOpsHandle, name: ROPE]
                RETURNS[num: INT, msVersion: INT] = {
            sH: WalnutSchema.SchemaHandle = opsH.schemaHandle;
            msI: MSInfo;
            CountOne: PROC[msg, tocEntry: ROPE, hasBeenRead: BOOL, startOfSubject: INT]
                RETURNS[continue: BOOLŹTRUE] ~ { num Ź num+1; };
            num Ź 0;
            [msI, msVersion] Ź GetMsgSetAndVersion[opsH, name];
            <<IF msI = NIL THEN num_ 0>>
                <<ELSE num _ LoganBerryEntry.V2I[LoganBerryEntry.GetAttr[msI.versionRel, sH.msBICount]];>>
            <<Replaced by:>>
            IF msI # NIL THEN []ŹEnumerateMsgsInSet[opsH, name, TRUE, CountOne];
            <<Could now update msI.versionRel entry.>>
            };

        EmptyMsgSet: PUBLIC PROC[opsH: WalnutOpsHandle, msgSet: MsgSet, report: CheckReportProc]
                RETURNS[someInDeleted: BOOL Ź FALSE] = {
            <<Removes any messages from msgSet - long running op>>
            sH: WalnutSchema.SchemaHandle = opsH.schemaHandle;
            numIn: INT;
            msI: MSInfo;
            IF WalnutDB.EqMsgSets[msgSet.name, DeletedMsgSetName] THEN {
                WalnutDB.SetOpInProgressPos[opsH, -1];
                ERROR WalnutDefs.Error[$db, $InvalidOperation, "Can't empty the Deleted MsgSet"];
                };

            msI Ź CheckMsgSetEntity[opsH, msgSet];
            IF msI = NIL THEN RETURN;
            numIn Ź LoganBerryEntry.V2I[LoganBerryEntry.GetAttr[msI.versionRel, sH.msBICount]];
            someInDeleted Ź EmptyThisMsgSet[opsH, msI.entity, msgSet.name, report];
            IF numIn # 0 THEN WalnutDB.ChangeCountInMsgSet[opsH, msI.entity, -numIn];
            };

        DestroyMsgSet: PUBLIC PROC[opsH: WalnutOpsHandle, msgSet: MsgSet, msDomainVersion: INT, report: CheckReportProc]
                RETURNS[someInDeleted: BOOL Ź FALSE] = {
            <<Destroys the given msgSet, removing any messages from it first (uses equivalent of RemoveMsgFromMsgSet below).  If the message 
            set is "Deleted" then WalnutDefs.IError[$db, $InvalidMsgSet] - long running op>>
            msI: MSInfo;
            sH: SchemaHandle = opsH.schemaHandle;
            IF WalnutDB.EqMsgSets[msgSet.name, DeletedMsgSetName] THEN {
                WalnutDB.SetOpInProgressPos[opsH, -1];
                ERROR WalnutDefs.Error[$db, $InvalidOperation, "Can't destroy the Deleted MsgSet"];
                };
            CheckDomainVersion[opsH, msDomainVersion];
            msI Ź CheckMsgSetEntity[opsH, msgSet];
            IF msI = NIL THEN RETURN;
            someInDeleted Ź EmptyThisMsgSet[opsH, msI.entity, msgSet.name, report];
            LoganBerry.DeleteEntry[db: opsH.db, key: $Key, value: Rope.Concat[sH.msBasicInfo, msI.entity]];
            msI.versionRel Ź NIL;
            ChangeGlobalMsgSetInfo[opsH, -1];
            };

        VerifyMsgSet: PUBLIC PROC[opsH: WalnutOpsHandle, msgSet: MsgSet]
                RETURNS[exists: BOOL] = {
            msI: MSInfo Ź CheckMsgSetEntity[opsH, msgSet];
            exists Ź msI # NIL;
            };

        VerifyDomainVersion: PUBLIC PROC[opsH: WalnutOpsHandle, msDomainVersion: INT] =
            { CheckDomainVersion[opsH, msDomainVersion] };

        ExpungeMsgs: PUBLIC PROC[opsH: WalnutOpsHandle, deletedVersion: INT, report: CheckReportProc] = {
            <<Destroys the Deleted message set - long running op>>
            OPEN WalnutDB;
            sH: SchemaHandle = opsH.schemaHandle;
            msI: MSInfo = CheckMsgSetEntity[opsH, [DeletedMsgSetName, deletedVersion]];
            BEGIN
            deletedCount: INT = LoganBerryEntry.V2I[LoganBerryEntry.GetAttr[msI.versionRel, sH.msBICount]];
            rs: LoganBerry.Cursor Ź LoganBerry.GenerateEntries[db: opsH.db, key: sH.cdMsgSet, start: sH.deletedEntity, end: sH.deletedEntity];
            sinceLastCommit: INT Ź 0;
            commitFrequency: CARDINAL = WalnutRegistry.MsgGroupSize;
            delArray: WalnutRegistry.MsgGroup;
            numDel: CARDINAL Ź 0;
            count: INT Ź 0;
            doMsgGroup: BOOL Ź WalnutRegistryPrivate.CheckForMsgGroupRegistration[];
            IF doMsgGroup THEN delArray Ź ALL[NIL];
            <<>>
            <<If the counts are wrong, change them.  They may already have been changed if you're restarting an Expunge>>
            IF deletedCount # 0 THEN {
                ChangeCountInMsgSet[opsH, sH.deletedEntity, -deletedCount];
                ChangeCountOfMsgs[opsH, -deletedCount];
                <<This counts as one operation>>
                sinceLastCommit Ź sinceLastCommit + 1
                };

            BEGIN ENABLE UNWIND => NULL;
                rel: Relship;
                rLogInfo: Relship = LoganBerry.ReadEntry[db: opsH.db, key: $Key, value: sH.gLogInfo].entry;
                bytesDestroyed: INT Ź LoganBerryEntry.V2I[LoganBerryEntry.GetAttr[rLogInfo, sH.gBytesInDestroyedMsgs]];
                firstDestroyedPos: INT Ź LoganBerryEntry.V2I[LoganBerryEntry.GetAttr[rLogInfo, sH.gFirstDestroyedMsgPos]];
                UNTIL (rel Ź LoganBerry.NextEntry[cursor: rs]) = NIL DO
                    me: ROPE = LoganBerryEntry.GetAttr[rel, sH.cdMsg];
                    textRel: Relship = LoganBerry.ReadEntry[db: opsH.db, key: $Key, value: Rope.Concat[sH.mMsgInfo, me]].entry;
                    startPos: INT Ź LoganBerryEntry.V2I[LoganBerryEntry.GetAttr[textRel, sH.mMIEntryStart]];
                    thisLen: INT Ź LoganBerryEntry.V2I[LoganBerryEntry.GetAttr[textRel, sH.mMITextOffset]] +
                        LoganBerryEntry.V2I[LoganBerryEntry.GetAttr[textRel, sH.mMITextLen]] + LoganBerryEntry.V2I[LoganBerryEntry.GetAttr[textRel, 
                        sH.mMIFormatLen]];
                    bytesDestroyed Ź bytesDestroyed + thisLen;
                    IF firstDestroyedPos = 0 OR startPos < firstDestroyedPos THEN
                        firstDestroyedPos Ź startPos;
                    IF doMsgGroup THEN {
                        delArray[numDel] Ź me;
                        numDel Ź numDel + 1;
                        };
                    <<Destroy all information about message>>
                    LoganBerry.DeleteEntry[db: opsH.db, key: $Key, value: Rope.Concat[sH.mMsgInfo, me]];
                    LoganBerry.DeleteEntry[db: opsH.db, key: $Key, value: Rope.Concat[sH.mDisplayInfo, me]];
                    LoganBerry.DeleteEntry[db: opsH.db, key: $Key, value: Rope.Concat[sH.mInfo, me]];
                    LoganBerry.DeleteEntry[db: opsH.db, key: $Key, value: Rope.Concat[sH.cdRelation, me]];
                    LoganBerry.DeleteEntry[db: opsH.db, key: $Key, value: Rope.Concat[sH.toRelation, me]];
                    LoganBerry.DeleteEntry[db: opsH.db, key: $Key, value: Rope.Concat[sH.ccRelation, me]];
                    LoganBerry.DeleteEntry[db: opsH.db, key: $Key, value: Rope.Concat[sH.fromRelation, me]];
                    IF (sinceLastCommit Ź sinceLastCommit + 1) >= commitFrequency THEN {
                        LoganBerryEntry.SetAttr[rLogInfo, sH.gBytesInDestroyedMsgs, LoganBerryEntry.I2V[bytesDestroyed]];
                        LoganBerryEntry.SetAttr[rLogInfo, sH.gFirstDestroyedMsgPos, LoganBerryEntry.I2V[firstDestroyedPos]];
                        LoganBerry.WriteEntry[db: opsH.db, entry: rLogInfo, replace: TRUE];
                        WalnutRoot.CommitAndContinue[opsH];
                        sinceLastCommit Ź 0;
                        IF doMsgGroup THEN {
                            WalnutRegistryPrivate.NotifyForMsgGroup[destroyed, delArray];
                            delArray Ź ALL[NIL];        -- clear out the Array
                            numDel Ź 0;
                            };
                        };
                    IF report # NIL THEN count Ź CheckCount[opsH, count, report];
                    ENDLOOP;
                LoganBerry.EndGenerate[cursor: rs];
                IF sinceLastCommit # 0 THEN {
                    LoganBerryEntry.SetAttr[rLogInfo, sH.gBytesInDestroyedMsgs, LoganBerryEntry.I2V[bytesDestroyed]];
                    LoganBerryEntry.SetAttr[rLogInfo, sH.gFirstDestroyedMsgPos, LoganBerryEntry.I2V[firstDestroyedPos]];
                    LoganBerry.WriteEntry[db: opsH.db, entry: rLogInfo, replace: TRUE];
                    };
                BEGIN        -- change the version number of Deleted
                    delRel: Relship = LoganBerry.ReadEntry[db: opsH.db, key: $Key, value: Rope.Concat[sH.msBasicInfo, sH.deletedEntity]].entry;
                    LoganBerryEntry.SetAttr[delRel, sH.msBIVersion, LoganBerryEntry.I2V[LoganBerryEntry.V2I[LoganBerryEntry.GetAttr[delRel, 
                    sH.msBIVersion]] + 1]];
                    LoganBerry.WriteEntry[db: opsH.db, entry: delRel, replace: TRUE];
                    <<now change the length of the last log back to -1>>
                    WalnutRoot.CommitAndContinue[opsH];
                    IF doMsgGroup AND (numDel # 0) THEN
                        WalnutRegistryPrivate.NotifyForMsgGroup[destroyed, delArray];
                    WalnutRegistryPrivate.NotifyForEvent[expungeComplete];
                    END;
                DestroyOrphanAddrsAndSubjs[opsH, report];
                END;
            END;
            };
        <<>>
        MsgSetsInfo: PUBLIC PROC[opsH: WalnutOpsHandle] RETURNS[version, num: INT] = {
            sH: WalnutSchema.SchemaHandle = opsH.schemaHandle;
            rVersionInfo: Relship = LoganBerry.ReadEntry[db: opsH.db, key: $Key, value: sH.gVersionInfo].entry;
            version Ź LoganBerryEntry.V2I[LoganBerryEntry.GetAttr[rVersionInfo, sH.gMsgSetsVersion]];
            num Ź LoganBerryEntry.V2I[LoganBerryEntry.GetAttr[rVersionInfo, sH.gMsgSetCount]];
            };
    <<>>
    <<Operations to Move Messages Among Message Sets>>

        AddMsg: PUBLIC PROC[opsH: WalnutOpsHandle, msg: ROPE, from, to: MsgSet]
                RETURNS[exists: BOOL] = {
            <<Adds Msg to MsgSet, if it's not already in it.  IF msgSet=deletedMsgSet, does nothing and returns exists=FALSE>>
            m: IsEntity;
            msI: MSInfo;
            sH: SchemaHandle = opsH.schemaHandle;
            exists Ź FALSE;
            IF WalnutDB.EqMsgSets[to.name, DeletedMsgSetName] THEN RETURN;
            m Ź GetMsgEntity[opsH, msg];
            IF ~m.exists THEN RETURN;
            [] Ź CheckMsgSetEntity[opsH, from];
            msI Ź CheckMsgSetEntity[opsH, to];
            IF msI = NIL THEN RETURN;        -- can't create msgset here
            { rel: Relship Ź LoganBerry.ReadEntry[db: opsH.db, key: $Key, value: Rope.Concat[sH.cdRelation, msg]].entry;
                wasInDeleted: BOOL Ź FALSE;
                FOR msL: LIST OF ROPE Ź LoganBerryEntry.GetAllAttrs[rel, sH.cdMsgSet], msL.rest WHILE msL # NIL DO
                    msgSet: ROPE Ź msL.first;
                    IF Rope.Equal[msI.entity, msgSet, FALSE] THEN { exists Ź TRUE; EXIT };
                    IF Rope.Equal[msgSet, sH.deletedEntity, FALSE] THEN {
                        rel Ź LoganBerryEntry.RemoveAttr[rel, sH.cdMsgSet, msgSet];
                        LoganBerry.WriteEntry[db: opsH.db, entry: rel, replace: TRUE];
                        WalnutDB.ChangeCountInMsgSet[opsH, sH.deletedEntity, -1]
                        }
                    ENDLOOP;
                };
            IF NOT exists THEN AddMsgTo[opsH, msg, to.name];
            };

        RemoveMsg: PUBLIC PROC[opsH: WalnutOpsHandle, msg: ROPE, from: MsgSet, deletedVersion: INT] RETURNS[deleted: BOOL] = {
            <<IF removing msg from msgSet would leave it in no MsgSet, then msg gets added to the distinguished MsgSet Deleted, and returns 
            deleted = TRUE>>
            m: IsEntity;
            msI: MSInfo;
            rel, thisCDRel: Relship;
            sH: SchemaHandle = opsH.schemaHandle;
            deleted Ź FALSE;

            IF NOT (mŹ GetMsgEntity[opsH, msg]).exists THEN RETURN;
            IF (msIŹ CheckMsgSetEntity[opsH, from]) = NIL THEN RETURN;

            deleted Ź TRUE;  -- We're committed to deleting the message unless we find it in another message set
            rel Ź LoganBerry.ReadEntry[db: opsH.db, key: $Key, value: Rope.Concat[sH.cdRelation, msg]].entry;
            FOR msL: LIST OF ROPE Ź LoganBerryEntry.GetAllAttrs[rel, sH.cdMsgSet], msL.rest WHILE msL # NIL DO
                IF Rope.Equal[msI.entity, msL.first, FALSE] THEN thisCDRel Ź rel
                ELSE deleted Ź FALSE
                ENDLOOP;
            IF thisCDRel = NIL THEN { deleted Ź FALSE; RETURN };  -- Something strange here
            WalnutDB.ChangeCountInMsgSet[opsH, msI.entity, -1];
            IF NOT deleted 
                THEN {
                    thisCDRel Ź LoganBerryEntry.RemoveAttr[thisCDRel, sH.cdMsgSet, msI.entity];
                    LoganBerry.WriteEntry[db: opsH.db, entry: thisCDRel, replace: TRUE];
                    WalnutDB.ChangeCountInMsgSet[opsH, msI.entity, -1];
                    }
                ELSE {
                    LoganBerryEntry.SetAttr[thisCDRel, sH.cdMsgSet, sH.deletedEntity];
                    LoganBerry.WriteEntry[db: opsH.db, entry: thisCDRel, replace: TRUE];
                    };
            };

        MoveMsg: PUBLIC PROC[opsH: WalnutOpsHandle, msg: ROPE, from: MsgSet, to: MsgSet]
                RETURNS [exists: BOOL Ź FALSE] = {
            <<Move the message.  Note that the result of a move may be that a message becomes deleted (if to was the Deleted message set) or 
            undeleted (if from is the Deleted message set)>>
            m: IsEntity;
            fromMsI, toMsI: MSInfo;
            sH: SchemaHandle = opsH.schemaHandle;
            rel, fromCDRelship, toCDRelship: Relship;
            IF WalnutDB.EqMsgSets[from.name, to.name] THEN RETURN[TRUE]; -- don't do anything

            IF NOT (m Ź GetMsgEntity[opsH, msg]).exists THEN RETURN;
            IF (fromMsI Ź CheckMsgSetEntity[opsH, from]) = NIL THEN RETURN;
            IF (toMsI Ź CheckMsgSetEntity[opsH, to]) = NIL THEN RETURN;
            rel Ź LoganBerry.ReadEntry[db: opsH.db, key: $Key, value: Rope.Concat[sH.cdRelation, msg]].entry;
            FOR msL: LIST OF ROPE Ź LoganBerryEntry.GetAllAttrs[rel, sH.cdMsgSet], msL.rest WHILE msL # NIL DO
                IF Rope.Equal[fromMsI.entity, msL.first, FALSE] THEN
                    fromCDRelship Ź rel
                ELSE IF Rope.Equal[toMsI.entity, msL.first, FALSE] THEN
                    toCDRelship Ź rel;
                ENDLOOP;
            IF fromCDRelship = NIL THEN {exists Ź FALSE; RETURN};
            exists Ź toCDRelship # NIL;
            rel Ź LoganBerryEntry.RemoveAttr[rel, sH.cdMsgSet, fromMsI.entity];
            IF NOT exists THEN {
                rel Ź LoganBerryEntry.AddAttr[rel, sH.cdMsgSet, toMsI.entity];
                };
            LoganBerry.WriteEntry[db: opsH.db, entry: rel, replace: TRUE];
            WalnutDB.ChangeCountInMsgSet[opsH, fromMsI.entity, -1];
            IF NOT exists THEN WalnutDB.ChangeCountInMsgSet[opsH, toMsI.entity, 1];
            };
    <<>>
    <<Enumerations>>

        MsgsEnumeration: PUBLIC PROC [opsH: WalnutOpsHandle, alphaOrder: BOOL]
                RETURNS [mL: LIST OF ROPE] = {
            ok: BOOL Ź FALSE;
            sH: WalnutSchema.SchemaHandle = opsH.schemaHandle;

            MEnum: PROC = {
                last: LIST OF ROPE;
                enum: LoganBerry.Cursor Ź
                    IF alphaOrder 
                        THEN LoganBerry.GenerateEntries[db: opsH.db, key: $Key, start: Rope.Concat[sH.mMsgInfo, "\000"], end: Rope.Concat[sH.mMsgInfo, 
                        "\177"]] 
                        ELSE LoganBerry.GenerateEntries[db: opsH.db, key: $Key, start: sH.mMsgInfo, end: Rope.Concat[sH.mMsgInfo, "\255"]];
                mL Ź NIL;
                BEGIN ENABLE UNWIND => GOTO end;
                    e: LoganBerry.Entry;
                    msg: ROPE;
                    count: INT Ź 0;
                    FOR e Ź LoganBerry.NextEntry[cursor: enum], LoganBerry.NextEntry[cursor: enum] UNTIL e = NIL DO
                        msg Ź LoganBerryEntry.GetAttr[e, sH.mMIOf];
                        IF mL = NIL THEN mL Ź last Ź CONS[msg, NIL] ELSE
                            { last.rest Ź CONS[msg, NIL]; last Ź last.rest};
                        count Ź CheckForCommit[opsH, count];
                        ENDLOOP;
                    ok Ź TRUE;
                    EXITS end => NULL;
                END;
                LoganBerry.EndGenerate[cursor: enum ! LoganBerry.Error => CONTINUE];
                };
            MEnum[];
            IF ok THEN RETURN
                ELSE WalnutDefs.Error[$db, $DatabaseInaccessible, "During Msgs enumeration"];
            };

        MsgsInSetEnumeration: PUBLIC PROC[opsH: WalnutOpsHandle, name: ROPE, fromStart: BOOL] RETURNS [mL: LIST OF ROPE, msVersion: INT Ź 
        -1] = {
            <<Note: fromStart is ignored.>>
            ok: BOOL Ź FALSE;
            sH: SchemaHandle = opsH.schemaHandle;

            MEnum: PROC = {
                msI: MSInfo;
                enum: LoganBerry.Cursor;
                checkShow: BOOL;
                count: INT Ź 0;
                lastInList: LIST OF ROPE Ź NIL;
                mL Ź NIL;

                [msI, msVersion] Ź GetMsgSetAndVersion[opsH, name];
                IF msI = NIL THEN {ok Ź TRUE; RETURN};
                checkShow Ź  name.Equal["Active", FALSE];

                enum Ź
                    LoganBerry.GenerateEntries[db: opsH.db, key: sH.cdMsgSet, start: msI.entity, end: msI.entity];
                BEGIN ENABLE UNWIND => GOTO end;
                    DO
                        rel: Relship = LoganBerry.NextEntry[cursor: enum];
                        me: ROPE;
                        IF rel = NIL THEN EXIT;
                        me Ź LoganBerryEntry.GetAttr[rel, sH.cdMsg];
                        IF checkShow THEN {
                            sRel: Relship = LoganBerry.ReadEntry[db: opsH.db, key: $Key, value: Rope.Concat[sH.mInfo, me]].entry;
                            IF NOT Rope.Equal[LoganBerryEntry.GetAttr[sRel, sH.mShowIs], "NULL"] THEN LOOP; -- mShowIs is unaccepted
                            };  
                        IF fromStart THEN {
                            thisL: LIST OF ROPE = CONS[me, NIL];
                            IF mL = NIL THEN mL Ź lastInList Ź thisL
                                ELSE {
                                    lastInList.rest Ź thisL;
                                    lastInList Ź lastInList.rest;
                                    };
                                }
                            ELSE mL Ź CONS[me, mL];
                        count Ź CheckForCommit[opsH, count];
                        ENDLOOP;
                    ok Ź TRUE;
                    EXITS end => NULL;
                    END;
                LoganBerry.EndGenerate[cursor: enum ! LoganBerry.Error => CONTINUE]
                };
            MEnum[];
            IF ok THEN RETURN
                ELSE WalnutDefs.Error[$db, $DatabaseInaccessible, "During MsgSets enumeration"];
            };

        MsgSetsNames: PUBLIC PROC[opsH: WalnutOpsHandle, alphaOrder: BOOL]
                RETURNS[msL: LIST OF ROPE, msDomainVersion: INT Ź -1] = {
            ok: BOOL Ź FALSE;
            sH: SchemaHandle = opsH.schemaHandle;

            MSEnum: PROC = {
                last: LIST OF ROPE;
                rVersionInfo: Relship = LoganBerry.ReadEntry[db: opsH.db, key: $Key, value: sH.gVersionInfo].entry;
                enum: LoganBerry.Cursor Ź
                    IF alphaOrder 
                        THEN LoganBerry.GenerateEntries[db: opsH.db, key: $Key, start: Rope.Concat[sH.msBasicInfo, "\000"], end: 
                        Rope.Concat[sH.msBasicInfo, "\177"]] 
                        ELSE LoganBerry.GenerateEntries[db: opsH.db, key: $Key, start: sH.msBasicInfo, end: Rope.Concat[sH.msBasicInfo, "\255"]];
                msDomainVersion Ź LoganBerryEntry.V2I[LoganBerryEntry.GetAttr[rVersionInfo, sH.gMsgSetsVersion]];
                msL Ź NIL;
                BEGIN ENABLE UNWIND => GOTO end;
                    FOR e: LoganBerry.Entry Ź LoganBerry.NextEntry[cursor: enum], LoganBerry.NextEntry[cursor: enum] UNTIL e = NIL DO
                        thisName: ROPE =
                            LoganBerryEntry.GetAttr[e, sH.msPrintNameIs];
                        IF msL = NIL THEN msL Ź last Ź CONS[thisName, NIL] ELSE
                            { last.rest Ź CONS[thisName, NIL]; last Ź last.rest};
                        ENDLOOP;
                    ok Ź TRUE;
                    EXITS end => NULL;
                END;
                LoganBerry.EndGenerate[cursor: enum ! LoganBerry.Error => CONTINUE]
                };
            MSEnum[];
            IF ok THEN RETURN
                ELSE WalnutDefs.Error[$db, $DatabaseInaccessible, "During MsgSets enumeration"];
            };

        EnumerateMsgSets: PUBLIC PROC[opsH: WalnutOpsHandle, alphaOrder: BOOL, proc: PROC[msgSet: MsgSet] RETURNS[continue: BOOL] ]
        RETURNS[msDomainVersion: INT Ź -1] = {
            ok: BOOL Ź FALSE;
            sH: SchemaHandle = opsH.schemaHandle;

            MSEnum: PROC = {
                enum: LoganBerry.Cursor Ź
                    IF alphaOrder 
                        THEN LoganBerry.GenerateEntries[db: opsH.db, key: $Key, start: Rope.Concat[sH.msBasicInfo, "\000"], end: 
                        Rope.Concat[sH.msBasicInfo, "\177"]] 
                        ELSE LoganBerry.GenerateEntries[db: opsH.db, key: $Key, start: sH.msBasicInfo, end: Rope.Concat[sH.msBasicInfo, "\255"]];
                rVersionInfo: Relship = LoganBerry.ReadEntry[db: opsH.db, key: $Key, value: sH.gVersionInfo].entry;
                msDomainVersion Ź LoganBerryEntry.V2I[LoganBerryEntry.GetAttr[rVersionInfo, sH.gMsgSetsVersion]];
                BEGIN ENABLE UNWIND => GOTO end;
                    FOR e: LoganBerry.Entry Ź LoganBerry.NextEntry[cursor: enum], LoganBerry.NextEntry[cursor: enum] UNTIL e = NIL DO
                        msgSet: MsgSet Ź
                            [LoganBerryEntry.GetAttr[e, sH.msPrintNameIs], LoganBerryEntry.V2I[LoganBerryEntry.GetAttr[e, sH.msBIVersion]]];
                        IF NOT proc[msgSet] THEN EXIT;
                        ENDLOOP;
                    ok Ź TRUE;
                    EXITS end => NULL;
                END;
                LoganBerry.EndGenerate[cursor: enum ! LoganBerry.Error => CONTINUE]
                };
            MSEnum[];
            IF ok THEN RETURN
                ELSE ERROR WalnutDefs.Error[$db, $DatabaseInaccessible, "During MsgSets enumeration"]
            };

        EnumerateMsgsInSet: PUBLIC PROC [
        opsH: WalnutOpsHandle,
        name: ROPE,
        fromStart: BOOL Ź TRUE,
        proc: PROC[msg, tocEntry: ROPE, hasBeenRead: BOOL, startOfSubject: INT] RETURNS[continue: BOOL] ]
            RETURNS [msVersion: INT Ź -1] = {
            <<Note: fromStart is ignored.>>
            ok: BOOL Ź FALSE;
            sH: SchemaHandle = opsH.schemaHandle;
            MEnum: PROC = {
                msI: MSInfo;
                enum: LoganBerry.Cursor;
                checkShow: BOOL;
                count: INT Ź 0;

                [msI, msVersion] Ź GetMsgSetAndVersion[opsH, name];
                IF msI = NIL THEN {okŹ TRUE; RETURN};
                checkShow Ź name.Equal["Active", FALSE];

                enum Ź
                    LoganBerry.GenerateEntries[db: opsH.db, key: sH.cdMsgSet, start: msI.entity, end: msI.entity];
                BEGIN ENABLE UNWIND => GOTO end;
                    DO
                        rel: Relship = LoganBerry.NextEntry[cursor: enum];
                        msg, tocEntry: ROPE;
                        hasBeenRead: BOOL;
                        startOfSubject: INT;
                        IF rel = NIL THEN EXIT;
                        msg Ź LoganBerryEntry.GetAttr[rel, sH.cdMsg];
                        IF checkShow THEN {
                            sRel: Relship = LoganBerry.ReadEntry[db: opsH.db, key: $Key, value: Rope.Concat[sH.mInfo, msg]].entry;
                            IF NOT Rope.Equal[LoganBerryEntry.GetAttr[sRel, sH.mShowIs], "NULL"] THEN LOOP; -- mShowIs is unaccepted
                            };
                        [hasBeenRead, tocEntry, startOfSubject] Ź WalnutDB.GetMsgDisplayInfo[opsH, msg];
                        IF NOT proc[msg, tocEntry, hasBeenRead, startOfSubject] THEN EXIT;
                        count Ź CheckForCommit[opsH, count];
                        ENDLOOP;
                    okŹ TRUE;
                    EXITS end => NULL;
                    END;
                LoganBerry.EndGenerate[cursor: enum ! LoganBerry.Error => CONTINUE]
                };
            MEnum[];
            IF ok THEN RETURN
                ELSE ERROR WalnutDefs.Error[$db, $DatabaseInaccessible, "During MsgSets enumeration"]
            };

        EnumerateMsgsInMsgSet: PUBLIC PROC[opsH: WalnutOpsHandle, msgSet: MsgSet]
                RETURNS[lazyEnum: WalnutDB.LazyEnumerator] = {
            sH: SchemaHandle = opsH.schemaHandle;
            lazyEnum Ź NEW[LazyEnumeratorRec];
            lazyEnum.opsH Ź opsH;
            lazyEnum.msgSet Ź msgSet;
            lazyEnum.pos Ź 0;
            lazyEnum.checkShow Ź Rope.Equal[msgSet.name, ActiveMsgSetName];
            lazyEnum.set Ź
                LoganBerry.GenerateEntries[db: opsH.db, key: sH.cdMsgSet, start: msgSet.name, end: msgSet.name];
            lazyEnum.valid Ź TRUE;
            };

        NextMsgInMsgSet: PUBLIC PROC[lazyEnum: WalnutDB.LazyEnumerator]
                RETURNS[msgID: ROPE, valid: BOOL Ź FALSE] = {
            howManyIterations: INT Ź 0;
            sH: SchemaHandle = lazyEnum.opsH.schemaHandle;
            GetNextMsg: PROC = {
                me: ROPE;
                IF lazyEnum.valid = FALSE THEN { valid Ź FALSE; RETURN };
                DO
                    rel: Relship = LoganBerry.NextEntry[cursor: lazyEnum.set];
                    howManyIterations Ź howManyIterations+1;
                    IF rel = NIL THEN { LoganBerry.EndGenerate[cursor: lazyEnum.set]; lazyEnum.valid Ź FALSE; EXIT };
                    me Ź LoganBerryEntry.GetAttr[rel, sH.cdMsg];
                    IF lazyEnum.checkShow THEN {
                        sRel: Relship = LoganBerry.ReadEntry[db: lazyEnum.opsH.db, key: $Key, value: Rope.Concat[sH.mInfo, me]].entry;
                        IF NOT Rope.Equal[LoganBerryEntry.GetAttr[sRel, sH.mShowIs], "NULL"] THEN LOOP ELSE EXIT }
                    ELSE EXIT
                    ENDLOOP;
                IF me # NIL THEN msgID Ź me;
                valid Ź TRUE
                };
            ResetToStart: PROC = {
                lazyEnum.set Ź LoganBerry.GenerateEntries[db: lazyEnum.opsH.db, key: sH.cdMsgSet, start: lazyEnum.msgSet.name, end: 
                lazyEnum.msgSet.name];
                FOR i: INT IN [0..lazyEnum.pos) DO [] Ź LoganBerry.NextEntry[cursor: lazyEnum.set] ENDLOOP;
                howManyIterations Ź 0 };

            IF NOT VerifyMsgSet[lazyEnum.opsH, lazyEnum.msgSet] THEN RETURN[NIL, FALSE];
            FOR tryRestart: BOOL Ź TRUE, FALSE WHILE tryRestart DO
                failed: BOOL Ź FALSE;
                GetNextMsg[ ! LoganBerry.Error => { failed Ź TRUE; CONTINUE } ];
                IF NOT failed THEN { lazyEnum.pos Ź lazyEnum.pos+howManyIterations; RETURN };
                ResetToStart[]
                ENDLOOP
            };

        EnumerateUnacceptedMsgs: PUBLIC PROC[opsH: WalnutOpsHandle, activeVersion: INT, proc: PROC[msg, tocEntry: ROPE, startOfSubject: 
        INT] ] = {
            ok: BOOL Ź FALSE;
            sH: SchemaHandle = opsH.schemaHandle;

            Eum: PROC = {
                enum: LoganBerry.Cursor;
                count: INT Ź 0;
                [] Ź CheckMsgSetEntity[opsH, [ActiveMsgSetName, activeVersion]];
                enum Ź LoganBerry.GenerateEntries[db: opsH.db, key: sH.mShowIs, start: sH.unacceptedEntity, end: sH.unacceptedEntity];

                BEGIN ENABLE UNWIND => GOTO end;
                    showRel: Relship;
                    msg: ROPE;
                    UNTIL (showRel Ź LoganBerry.NextEntry[cursor: enum]) = NIL DO
                        tocEntry: ROPE;
                        startOfSubject: INT;
                        me: ROPE = LoganBerryEntry.GetAttr[showRel, sH.mInfoOf];
                        msg Ź me;
                        [ , tocEntry, startOfSubject] Ź WalnutDB.GetMsgDisplayInfo[opsH, me];
                        proc[msg, tocEntry, startOfSubject];
                        count Ź CheckForCommit[opsH, count];
                        ENDLOOP;
                    okŹ TRUE;
                    EXITS end => NULL;
                    END;
                LoganBerry.EndGenerate[cursor: enum ! LoganBerry.Error => CONTINUE]
                };

            Eum[];
            IF ok THEN RETURN;
            ERROR WalnutDefs.Error[$db, $DatabaseInaccessable, "During Get New Mail"];
            };

        AcceptNewMail: PUBLIC PROC[opsH: WalnutOpsHandle, pos, activeVersion: INT] = {
            <<long running op>>
            rs: LoganBerry.Cursor;
            es: LoganBerry.Cursor;
            commitFrequency: CARDINAL = WalnutRegistry.MsgGroupSize;
            accArray: WalnutRegistry.MsgGroup;
            numAcc: CARDINAL Ź 0;
            sinceLastCommit: INT Ź 0;
            sH: SchemaHandle = opsH.schemaHandle;
            rNewMailInfo, rLogInfo: Relship;
            activeRel: Relship = LoganBerry.ReadEntry[db: opsH.db, key: $Key, value: Rope.Concat[sH.msBasicInfo, sH.activeEntity]].entry;
            doMsgGroup: BOOL Ź WalnutRegistryPrivate.CheckForMsgGroupRegistration[];

            [] Ź CheckMsgSetEntity[opsH, [ActiveMsgSetName, activeVersion]];
            IF doMsgGroup THEN accArray Ź ALL[NIL];

            BEGIN ENABLE UNWIND => NULL;
                showRel: Relship;
                rs Ź LoganBerry.GenerateEntries[db: opsH.db, key: sH.mShowIs, start: sH.unacceptedEntity, end: sH.unacceptedEntity];
                UNTIL (showRel Ź LoganBerry.NextEntry[cursor: rs]) = NIL DO
                    me: ROPE = LoganBerryEntry.GetAttr[showRel, sH.mInfoOf];
                    LoganBerryEntry.SetAttr[showRel, sH.mShowIs, "NULL"];
                    LoganBerry.WriteEntry[db: opsH.db, entry: showRel, replace: TRUE];
                    IF doMsgGroup THEN {
                        accArray[numAcc] Ź me;
                        numAcc Ź numAcc + 1;
                        };
                    IF (sinceLastCommit Ź sinceLastCommit + 1) >= commitFrequency THEN {
                        newCount: INT = LoganBerryEntry.V2I[LoganBerryEntry.GetAttr[activeRel, sH.msBICount]] + sinceLastCommit;
                        LoganBerryEntry.SetAttr[activeRel, sH.msBICount, LoganBerryEntry.I2V[newCount]];
                        LoganBerry.WriteEntry[db: opsH.db, entry: activeRel, replace: TRUE];
                        WalnutRoot.CommitAndContinue[opsH];
                        sinceLastCommit Ź 0;
                        IF doMsgGroup THEN {
                            WalnutRegistryPrivate.NotifyForMsgGroup[added, accArray];
                            accArray Ź ALL[NIL];
                            numAcc Ź 0;
                            };
                        };
                    ENDLOOP;
                LoganBerry.EndGenerate[cursor: rs];
                END;
            BEGIN ENABLE UNWIND => NULL;
                es Ź LoganBerry.GenerateEntries[db: opsH.db, key: $Key, start: Rope.Concat[sH.sBasicInfo, "\000"], end: Rope.Concat[sH.sBasicInfo, 
                "\177"]];
                FOR se: LoganBerry.Entry Ź LoganBerry.NextEntry[cursor: es], LoganBerry.NextEntry[cursor: es] UNTIL se = NIL DO
                    rel: Relship = se;
                    LoganBerryEntry.SetAttr[rel, sH.sBINum, DBZeroInt];
                    LoganBerry.WriteEntry[db: opsH.db, entry: rel, replace: TRUE];
                    ENDLOOP;
                LoganBerry.EndGenerate[cursor: es];
            END;

            IF sinceLastCommit # 0 THEN
                LoganBerryEntry.SetAttr[activeRel, sH.msBICount, LoganBerryEntry.I2V[LoganBerryEntry.V2I[LoganBerryEntry.GetAttr[activeRel, 
                sH.msBICount]] + sinceLastCommit]];

            LoganBerryEntry.SetAttr[activeRel, sH.msBIVersion, LoganBerryEntry.I2V[LoganBerryEntry.V2I[LoganBerryEntry.GetAttr[activeRel, 
            sH.msBIVersion]] + 1]];
            LoganBerry.WriteEntry[db: opsH.db, entry: activeRel, replace: TRUE];
            rNewMailInfo Ź LoganBerry.ReadEntry[db: opsH.db, key: $Key, value: sH.gNewMailInfo].entry;
            LoganBerryEntry.SetAttr[rNewMailInfo, sH.gAcceptNewMailLogPos, LoganBerryEntry.I2V[pos]];
            LoganBerry.WriteEntry[db: opsH.db, entry: rNewMailInfo, replace: TRUE];
            rLogInfo Ź LoganBerry.ReadEntry[db: opsH.db, key: $Key, value: sH.gLogInfo].entry;
            LoganBerryEntry.SetAttr[rLogInfo, sH.gOpInProgressPos, DBMinusOneInt];
            LoganBerry.WriteEntry[db: opsH.db, entry: rLogInfo, replace: TRUE];
            WalnutRoot.CommitAndContinue[opsH];
            IF doMsgGroup AND (numAcc # 0) THEN
                WalnutRegistryPrivate.NotifyForMsgGroup[added, accArray];
            };
    <<>>
    <<Internal procedures>>

        mismatchReport: ROPE = "Msgset: %g: version is %g, version expected is: %g";

        GetMsgSetBasicInfoRel: PROC[opsH: WalnutOpsHandle, ms: ROPE] RETURNS[rel: Relship] =
            { RETURN[LoganBerry.ReadEntry[db: opsH.db, key: $Key, value: Rope.Concat[opsH.schemaHandle.msBasicInfo, ms]].entry] };

        GetMsgEntity: PROC[opsH: WalnutOpsHandle, msg: ROPE] RETURNS[e: IsEntity] = {
            sH: WalnutSchema.SchemaHandle = opsH.schemaHandle;
            e.entity Ź LoganBerry.ReadEntry[db: opsH.db, key: $Key, value: Rope.Concat[sH.mMsgInfo, msg]].entry;
            e.exists Ź (e.entity # NIL);
            };

        GetMsgSetAndVersion: PROC[opsH: WalnutOpsHandle, name: ROPE]
                RETURNS[msI: MSInfo, version: INT] = {
            sH: WalnutSchema.SchemaHandle = opsH.schemaHandle;
            msI Ź GetMsgSetEntity[opsH, name];
            IF msI # NIL THEN version Ź LoganBerryEntry.V2I[LoganBerryEntry.GetAttr[msI.versionRel, sH.msBIVersion]]
                ELSE versionŹ -1;
            };

        GetMsgSetEntity: PROC[opsH: WalnutOpsHandle, name: ROPE] RETURNS[msInfo: MSInfo] = {
            sH: WalnutSchema.SchemaHandle = opsH.schemaHandle;
            aName: ATOM = CanonicalName[name];        -- all lower case
            cName: ROPE;
            found: BOOL;
            val: RefTab.Val;
            mse: ROPE;
            IF opsH.schemaHandle.msgSetsTable = NIL THEN {
                rVersionInfo: Relship = LoganBerry.ReadEntry[db: opsH.db, key: $Key, value: sH.gVersionInfo].entry;
                numMsgSets: INT Ź LoganBerryEntry.V2I[LoganBerryEntry.GetAttr[rVersionInfo, sH.gMsgSetCount]];
                opsH.schemaHandle.msgSetsTable Ź RefTab.Create[MAX[numMsgSets*2+1, 16]];
                };

            [found, val] Ź RefTab.Fetch[opsH.schemaHandle.msgSetsTable, aName];
            IF found THEN {
                msInfo Ź NARROW[val];
                IF msInfo.versionRel # NIL THEN RETURN;
                msInfo.versionRel Ź GetMsgSetBasicInfoRel[opsH, msInfo.entity];
                IF msInfo.versionRel = NIL THEN {        -- no longer exists
                    [] Ź RefTab.Delete[opsH.schemaHandle.msgSetsTable, aName];
                    RETURN[NIL]
                    };
                RETURN;
                };
            mse Ź cName Ź Atom.GetPName[aName];
            msInfo Ź NEW[MSInfoObject Ź [canonicalName: cName, entity: mse]];
            msInfo.versionRel Ź GetMsgSetBasicInfoRel[opsH, mse];
            IF msInfo.versionRel = NIL THEN RETURN[NIL];        -- return NIL IF msgSet doesn't exist
            [] Ź RefTab.Store[opsH.schemaHandle.msgSetsTable, aName, msInfo];
            };

        <<changes name to all lower case, to get canonical names>>
        CanonicalName: PUBLIC PROC[name: ROPE] RETURNS[aName: ATOM] = {
            nameText.length Ź 0;
            FOR i: INT IN [0 .. name.Length[]) DO
                [] Ź RefText.InlineAppendChar[nameText, Ascii.Lower[name.Fetch[i]]];
                ENDLOOP;
            aName Ź Atom.MakeAtomFromRefText[nameText];
            };

        CheckDomainVersion: PROC[opsH: WalnutOpsHandle, version: INT] = {
            sH: WalnutSchema.SchemaHandle = opsH.schemaHandle;
            is: INT;
            rVersionInfo: Relship;
            IF version = dontCareDomainVersion THEN RETURN;
            rVersionInfo Ź LoganBerry.ReadEntry[db: opsH.db, key: $Key, value: sH.gVersionInfo].entry;
            IF version # (is Ź LoganBerryEntry.V2I[LoganBerryEntry.GetAttr[rVersionInfo, sH.gMsgSetsVersion]]) THEN {
                rLogInfo: Relship Ź LoganBerry.ReadEntry[db: opsH.db, key: $Key, value: sH.gLogInfo].entry;
                LoganBerryEntry.SetAttr[rLogInfo, sH.gOpInProgressPos, DBMinusOneInt];
                LoganBerry.WriteEntry[db: opsH.db, entry: rLogInfo, replace: TRUE];
                ERROR WalnutDefs.VersionMismatch[
                    IO.PutFR["Domain version is %g, version expected is: %g", [integer[is]], [integer[version]]] ];
                };
            };

        CheckMsgSetVersion: PROC[opsH: WalnutOpsHandle, msgSet: MsgSet]
                RETURNS[msI: MSInfo, version: INT] = {
            sH: WalnutSchema.SchemaHandle = opsH.schemaHandle;
            [msI, version] Ź GetMsgSetAndVersion[opsH, msgSet.name];
            <<Commented out since I don't know why we need message set versions.  ... DBT>>
            <<BEGIN>>
                <<rLogInfo: Relship;>>
                <<IF msI = NIL THEN RETURN;>>
                <<IF msgSet.version = dontCareMsgSetVersion THEN RETURN;>>
                <<IF msgSet.version = version THEN RETURN;>>
                <<rLogInfo _ LoganBerry.ReadEntry[db: opsH.db, key: $Key, value: sH.gLogInfo].entry;>>
                <<LoganBerryEntry.SetAttr[rLogInfo, sH.gOpInProgressPos, DBMinusOneInt];>>
                <<LoganBerry.WriteEntry[db: opsH.db, entry: rLogInfo, replace: TRUE];>>
                <<ERROR WalnutDefs.VersionMismatch[IO.PutFR[mismatchReport,>>
                    <<[rope[msgSet.name]], [integer[version]], [integer[msgSet.version]]] ];>>
                <<END;>>
            <<End of commented out code.  ... DBT>>
            };

        CheckMsgSetEntity: PROC[opsH: WalnutOpsHandle, msgSet: MsgSet] RETURNS[msI: MSInfo] = {
            sH: WalnutSchema.SchemaHandle = opsH.schemaHandle;
            msI Ź GetMsgSetEntity[opsH, msgSet.name];
            <<Commented out since I don't know why we need message set versions.  ... DBT>>
            <<BEGIN>>
                <<is: INT;>>
                <<rLogInfo: Relship;>>
                <<IF msI = NIL THEN RETURN;>>
                <<IF msgSet.version = dontCareMsgSetVersion THEN RETURN;>>
                <<IF msgSet.version = (is _ LoganBerryEntry.V2I[LoganBerryEntry.GetAttr[msI.versionRel, sH.msBIVersion]]) THEN RETURN;>>
                <<rLogInfo _ LoganBerry.ReadEntry[db: opsH.db, key: $Key, value: sH.gLogInfo].entry;>>
                <<LoganBerryEntry.SetAttr[rLogInfo, sH.gOpInProgressPos, DBMinusOneInt];>>
                <<LoganBerry.WriteEntry[db: opsH.db, entry: rLogInfo, replace: TRUE];>>
                <<ERROR WalnutDefs.VersionMismatch[IO.PutFR[mismatchReport,>>
                    <<[rope[msgSet.name]], [integer[is]], [integer[msgSet.version]]] ];>>
                <<END;>>
            <<End of commented out code.  ... DBT>>
            };

        commitFreq: INT Ź 500;

        CheckForCommit: PROC[opsH: WalnutOpsHandle, count: INT] RETURNS[new: INT] = {
            IF ( (new Ź count + 1) MOD commitFreq ) = 0 THEN WalnutRoot.CommitAndContinue[opsH];
            };

        EmptyThisMsgSet: PROC[opsH: WalnutOpsHandle, mse: ROPE, name: ROPE, report: CheckReportProc]
                RETURNS[someInDeleted: BOOL] = {
            sH: SchemaHandle = opsH.schemaHandle;
            rs: LoganBerry.Cursor = LoganBerry.GenerateEntries[db: opsH.db, key: sH.cdMsgSet, start: mse, end: mse];
            BEGIN ENABLE UNWIND => NULL;
                rel: Relship;
                de: ROPE = sH.deletedEntity;
                commitFrequency: CARDINAL = WalnutRegistry.MsgGroupSize;
                delArray: WalnutRegistry.MsgGroup;
                remArray: WalnutRegistry.MsgGroup;
                numDel: CARDINAL Ź 0;
                numRem: CARDINAL Ź 0;
                sinceLastCommit: INT Ź 0;
                count: INT Ź 0;
                someInDeleted Ź FALSE;
                UNTIL (rel Ź LoganBerry.NextEntry[cursor: rs]) = NIL DO
                    me: ROPE = LoganBerryEntry.GetAttr[rel, sH.cdMsg];
                    deleted: BOOL;
                    rel Ź LoganBerryEntry.RemoveAttr[rel, sH.cdMsgSet, mse];
                    deleted Ź LoganBerryEntry.GetAttr[rel, sH.cdMsgSet] = NIL;
                    IF deleted THEN {
                        rel Ź LoganBerryEntry.AddAttr[rel, sH.cdMsgSet, sH.deletedEntity];
                        delArray[numDel] Ź me;
                        numDel Ź numDel + 1;
                        }
                        ELSE {
                            remArray[numRem] Ź me;
                            numRem Ź numRem + 1;
                            };
                    LoganBerry.WriteEntry[db: opsH.db, entry: rel, replace: TRUE];

                    someInDeletedŹ someInDeleted OR deleted;
                    IF (sinceLastCommit Ź sinceLastCommit + 1) >= commitFrequency THEN {
                        WalnutRoot.CommitAndContinue[opsH];
                        sinceLastCommit Ź 0;
                        FOR i: CARDINAL IN [0 .. numDel) DO
                            WalnutRegistryPrivate.NotifyForMsgEvent[deleted, delArray[i]]; ENDLOOP;
                        FOR i: CARDINAL IN [0 .. numRem) DO
                            WalnutRegistryPrivate.NotifyForMove[msg: remArray[i], to: NIL, from: name];
                                ENDLOOP;
                        numDel Ź numRem Ź 0;
                        };
                    IF report # NIL THEN count Ź CheckCount[opsH, count, report];
                    ENDLOOP;
                LoganBerry.EndGenerate[cursor: rs];
                IF sinceLastCommit # 0 THEN {
                    WalnutRoot.CommitAndContinue[opsH];
                    FOR i: CARDINAL IN [0 .. numDel) DO
                        WalnutRegistryPrivate.NotifyForMsgEvent[deleted, delArray[i]]; ENDLOOP;
                    FOR i: CARDINAL IN [0 .. numRem) DO
                        WalnutRegistryPrivate.NotifyForMove[msg: remArray[i], to: NIL, from: name];
                        ENDLOOP;
                    };
            END;
            };

        ChangeGlobalMsgSetInfo: PROC[opsH: WalnutOpsHandle, delta: INT] = {
            sH: WalnutSchema.SchemaHandle = opsH.schemaHandle;
            rVersionInfo: Relship = LoganBerry.ReadEntry[db: opsH.db, key: $Key, value: sH.gVersionInfo].entry;
            numNow: INT Ź LoganBerryEntry.V2I[LoganBerryEntry.GetAttr[rVersionInfo, sH.gMsgSetCount]];
            newV: INT = LoganBerryEntry.V2I[LoganBerryEntry.GetAttr[rVersionInfo, sH.gMsgSetsVersion]] + 1;
            LoganBerryEntry.SetAttr[rVersionInfo, sH.gMsgSetsVersion, LoganBerryEntry.I2V[newV]];
            LoganBerryEntry.SetAttr[rVersionInfo, sH.gMsgSetCount, LoganBerryEntry.I2V[numNow + delta]];
            LoganBerry.WriteEntry[db: opsH.db, entry: rVersionInfo, replace: TRUE];
            };

        AddMsgTo: PROC[opsH: WalnutOpsHandle, me: ROPE, mse: ROPE] = {
            sH: WalnutSchema.SchemaHandle = opsH.schemaHandle;
            rel: Relship Ź LoganBerry.ReadEntry[db: opsH.db, key: $Key, value: Rope.Concat[sH.cdRelation, me]].entry;
            rel Ź LoganBerryEntry.AddAttr[rel, sH.cdMsgSet, mse];
            LoganBerry.WriteEntry[db: opsH.db, entry: rel, replace: TRUE];
            WalnutDB.ChangeCountInMsgSet[opsH, mse, 1]
            };

        CheckCount: PROC[opsH: WalnutOpsHandle, count: INT, report: CheckReportProc]
                RETURNS[c: INT] = {
            IF count = 0 THEN report[opsH, "  "];        -- put out spaces first
            IF (c Ź count + 1) MOD 10 # 0 THEN RETURN;
            IF c MOD 100 = 0 THEN report[opsH, "! "] ELSE report[opsH, "&"];
            };

        DestroyOrphanAddrsAndSubjs: PROC[opsH: WalnutOpsHandle, report: CheckReportProc] = {
            <<Now a no-op.>>
            };

    END.
    <<>>