<<>>
<<WalnutRegistryImpl.mesa>>
<<Copyright Ó 1985, 1992 by Xerox Corporation.  All rights reserved.>>
<<Donahue, July 9, 1985 1:23:55 pm PDT>>
    <<Willie-Sue, December 29, 1986 5:57:23 pm PST>>
<<>>
<<Walnut Registry provides notification to outside clients of changes in Walnut databases.  Walnut RegistryImpl can be run without 
running Walnut -- WalnutKernel imports it, rather than the other way around.>>
<<>>
<<Procedures registered with Walnut Registry are placed on the queue, using MBQueue.QueueClientAction, given in the registration 
when the database changes; clients are guaranteed that the procedures will be queued in the order in which the database changes 
that caused their invocation occurred.>>

    DIRECTORY
        MBQueue,
        RefTab,
        Rope USING [ROPE],
        WalnutRegistry,
        WalnutRegistryInternal,
        WalnutRegistryPrivate;

    WalnutRegistryImpl: CEDAR MONITOR

        IMPORTS RefTab, WalnutRegistryInternal
        EXPORTS WalnutRegistry, WalnutRegistryPrivate

        = BEGIN

        RegistrationEntry: TYPE = REF RegistrationRecord;

        RegistrationRecord: TYPE = RECORD[queue: MBQueue.Queue, eventProc: EventProcEntry Ź NIL, msgProc: MsgProcEntry Ź NIL, msgGroupProc: 
        MsgGroupEntry Ź NIL, moveProc: MoveProcEntry Ź NIL, msgSetProc: MsgSetProcEntry Ź NIL];

        EventProcEntry: TYPE = REF EventProcRecord;

        EventProcRecord: TYPE = RECORD[clientData: REF ANY, proc: WalnutRegistry.EventProc, parent: RegistrationEntry, next, prev: 
        EventProcEntry];

        MsgProcEntry: TYPE = REF MsgProcRecord;

        MsgProcRecord: TYPE = RECORD[clientData: REF ANY, proc: WalnutRegistry.MsgProc, parent: RegistrationEntry, next, prev: 
        MsgProcEntry];

        MoveProcEntry: TYPE = REF MoveProcRecord;

        MoveProcRecord: TYPE = RECORD[clientData: REF ANY, proc: WalnutRegistry.MoveProc, parent: RegistrationEntry, next, prev: 
        MoveProcEntry];

        MsgGroupEntry: TYPE = REF MsgGroupRecord;

        MsgGroupRecord: TYPE = RECORD[clientData: REF ANY, proc: WalnutRegistry.MsgGroupProc, parent: RegistrationEntry, next, prev: 
        MsgGroupEntry];

        MsgSetProcEntry: TYPE = REF MsgSetProcRecord;

        MsgSetProcRecord: TYPE = RECORD[clientData: REF ANY, proc: WalnutRegistry.MsgSetProc, parent: RegistrationEntry, next, prev: 
        MsgSetProcEntry];

        nextRegistration: CARDINAL Ź 0;

        registrationTable: RefTab.Ref = RefTab.Create[];
    <<the values in the table are the registration entries; the keys are the Registrations returned (they are simply REF CARDINALS)>>

    <<the registrations are also linked into doubly-linked lists according to the type of procedures>>

        eventProcHead: EventProcEntry;
        msgProcHead: MsgProcEntry;
        moveProcHead: MoveProcEntry;
        msgSetProcHead: MsgSetProcEntry;
        msgGroupHead: MsgGroupEntry;

    <<we want to be able to notify new clients of the current state of Walnut>>
        stateIs: WalnutRegistry.Event Ź unknown;

        CurrentWalnutState: PUBLIC ENTRY PROC
                RETURNS[walnutState: WalnutRegistry.WalnutState] = {
            SELECT stateIs FROM
                unknown => RETURN[unknown];
                initializing => RETURN[initializing];
                stopped => RETURN[stopped];
                ENDCASE => RETURN[active];
            };

        Register: PUBLIC ENTRY PROC [procSet: WalnutRegistry.ProcSet, queue: MBQueue.Queue] RETURNS[registration: 
        WalnutRegistry.Registration] = {
            newEntry: RegistrationEntry = NEW[RegistrationRecord Ź [queue: queue]];
            registration Ź NEW[CARDINAL Ź nextRegistration];
            nextRegistration Ź nextRegistration+1;
            [] Ź RefTab.Store[registrationTable, registration, newEntry];
        <<stitch it into the appropriate lists>>
            IF procSet.eventProc # NIL THEN {
                newEntry.eventProc Ź NEW[EventProcRecord Ź [clientData: procSet.eventProcData, proc: procSet.eventProc, parent: newEntry]];
                newEntry.eventProc.next Ź eventProcHead;
                newEntry.eventProc.prev Ź eventProcHead.prev;
                eventProcHead.prev.next Ź newEntry.eventProc;
                eventProcHead.prev Ź newEntry.eventProc;
                IF stateIs # unknown THEN
                    WalnutRegistryInternal.QueueEvent[
                            stateIs, queue, procSet.eventProc, procSet.eventProcData];
                };
            IF procSet.msgProc # NIL THEN {
                newEntry.msgProc Ź NEW[MsgProcRecord Ź [clientData: procSet.msgProcData, proc: procSet.msgProc, parent: newEntry]];
                newEntry.msgProc.next Ź msgProcHead;
                newEntry.msgProc.prev Ź msgProcHead.prev;
                msgProcHead.prev.next Ź newEntry.msgProc;
                msgProcHead.prev Ź newEntry.msgProc };
            IF procSet.moveProc # NIL THEN {
                newEntry.moveProc Ź NEW[MoveProcRecord Ź [clientData: procSet.moveProcData, proc: procSet.moveProc, parent: newEntry]];
                newEntry.moveProc.next Ź moveProcHead;
                newEntry.moveProc.prev Ź moveProcHead.prev;
                moveProcHead.prev.next Ź newEntry.moveProc;
                moveProcHead.prev Ź newEntry.moveProc };
            IF procSet.msgGroupProc # NIL THEN {
                newEntry.msgGroupProc Ź NEW[MsgGroupRecord Ź [clientData: procSet.msgGroupData, proc: procSet.msgGroupProc, parent: newEntry]];
                newEntry.msgGroupProc.next Ź msgGroupHead;
                newEntry.msgGroupProc.prev Ź msgGroupHead.prev;
                msgGroupHead.prev.next Ź newEntry.msgGroupProc;
                msgGroupHead.prev Ź newEntry.msgGroupProc };
            IF procSet.msgSetProc # NIL THEN {
                newEntry.msgSetProc Ź NEW[MsgSetProcRecord Ź [clientData: procSet.msgSetData, proc: procSet.msgSetProc, parent: newEntry]];
                newEntry.msgSetProc.next Ź msgSetProcHead;
                newEntry.msgSetProc.prev Ź msgSetProcHead.prev;
                msgSetProcHead.prev.next Ź newEntry.msgSetProc;
                msgSetProcHead.prev Ź newEntry.msgSetProc };
            };

        InvalidRegistration: PUBLIC ERROR = CODE;

        UnRegister: PUBLIC ENTRY PROC [registration: WalnutRegistry.Registration] = {
            entry: RegistrationEntry = NARROW[RefTab.Fetch[registrationTable, registration].val];
            IF entry = NIL THEN ERROR InvalidRegistration;
            IF entry.eventProc # NIL THEN {
                entry.eventProc.prev.next Ź entry.eventProc.next;
                entry.eventProc.next.prev Ź entry.eventProc.prev;
                entry.eventProc.parent Ź NIL };
            IF entry.msgProc # NIL THEN {
                entry.msgProc.prev.next Ź entry.msgProc.next;
                entry.msgProc.next.prev Ź entry.msgProc.prev;
                entry.msgProc.parent Ź NIL };
            IF entry.moveProc # NIL THEN {
                entry.moveProc.prev.next Ź entry.moveProc.next;
                entry.moveProc.next.prev Ź entry.moveProc.prev;
                entry.moveProc.parent Ź NIL };
            IF entry.msgGroupProc # NIL THEN {
                entry.msgGroupProc.prev.next Ź entry.msgGroupProc.next;
                entry.msgGroupProc.next.prev Ź entry.msgGroupProc.prev;
                entry.msgGroupProc.parent Ź NIL };
            IF entry.msgSetProc # NIL THEN {
                entry.msgSetProc.prev.next Ź entry.msgSetProc.next;
                entry.msgSetProc.next.prev Ź entry.msgSetProc.prev;
                entry.msgSetProc.parent Ź NIL };
            [] Ź RefTab.Delete[registrationTable, registration] };

        GetProcs: PUBLIC ENTRY PROC[registration: WalnutRegistry.Registration] RETURNS[procSet: WalnutRegistry.ProcSet, queue: 
        MBQueue.Queue] = {
            entry: RegistrationEntry = NARROW[RefTab.Fetch[registrationTable, registration].val];
            IF entry = NIL THEN ERROR InvalidRegistration;
            queue Ź entry.queue;
            IF entry.eventProc # NIL THEN {
                procSet.eventProc Ź entry.eventProc.proc;
                procSet.eventProcData Ź entry.eventProc.clientData };
            IF entry.msgProc # NIL THEN {
                procSet.msgProc Ź entry.msgProc.proc;
                procSet.msgProcData Ź entry.msgProc.clientData};
            IF entry.moveProc # NIL THEN {
                procSet.moveProc Ź entry.moveProc.proc;
                procSet.moveProcData Ź entry.moveProc.clientData};
            IF entry.msgGroupProc # NIL THEN {
                procSet.msgGroupProc Ź entry.msgGroupProc.proc;
                procSet.msgGroupData Ź entry.msgGroupProc.clientData};
            IF entry.msgSetProc # NIL THEN {
                procSet.msgSetProc Ź entry.msgSetProc.proc;
                procSet.msgSetData Ź entry.msgSetProc.clientData}
            };

        CheckForMsgGroupRegistration: PUBLIC ENTRY PROC RETURNS[yes: BOOL] =
            { RETURN[msgGroupHead.next.proc # NIL] };

        NotifyForEvent: PUBLIC ENTRY PROC[event: WalnutRegistry.Event] = TRUSTED {
            stateIs Ź IF event = mailRead THEN started ELSE event;
            FOR e: EventProcEntry Ź eventProcHead.next, e.next UNTIL e.proc = NIL DO
                WalnutRegistryInternal.QueueEvent[event, e.parent.queue, e.proc, e.clientData];
                ENDLOOP };

        NotifyForMsgEvent: PUBLIC ENTRY PROC[msgEvent: WalnutRegistry.MsgEvent, msg: Rope.ROPE] = TRUSTED {
            FOR e: MsgProcEntry Ź msgProcHead.next, e.next UNTIL e.proc = NIL DO
                WalnutRegistryInternal.QueueMsgEvent[msgEvent, msg, e.parent.queue, e.proc, e.clientData];
                ENDLOOP};

        NotifyForMove: PUBLIC ENTRY PROC[msg: Rope.ROPE, to, from: Rope.ROPE] = TRUSTED {
            FOR e: MoveProcEntry Ź moveProcHead.next, e.next UNTIL e.proc = NIL DO
                WalnutRegistryInternal.QueueMoveEvent[msg, to, from, e.parent.queue, e.proc, e.clientData];
                ENDLOOP};

        NotifyForMsgGroup: PUBLIC ENTRY PROC[event: WalnutRegistry.MsgGroupEvent, group: WalnutRegistry.MsgGroup] = TRUSTED {
            msgGroupCopy: REF WalnutRegistry.MsgGroup = NEW[WalnutRegistry.MsgGroup];
            msgGroupCopy­ Ź group;
            FOR e: MsgGroupEntry Ź msgGroupHead.next, e.next UNTIL e.proc = NIL DO
                WalnutRegistryInternal.QueueMsgGroupEvent[event, msgGroupCopy, e.parent.queue, e.proc, e.clientData];
                ENDLOOP};

        NotifyForMsgSetEvent: PUBLIC ENTRY PROC[msgSetEvent: WalnutRegistry.MsgSetEvent, msgSet: Rope.ROPE] = TRUSTED {
            FOR e: MsgSetProcEntry Ź msgSetProcHead.next, e.next UNTIL e.proc = NIL DO
                WalnutRegistryInternal.QueueMsgSetEvent[msgSetEvent, msgSet, e.parent.queue, e.proc, e.clientData];
                ENDLOOP};

    <<The heads to be non-NIL to make the list manipulation easier and faster>>
        eventProcHead Ź NEW[EventProcRecord Ź [clientData: NIL, proc: NIL]];
        eventProcHead.prev Ź eventProcHead.next Ź eventProcHead;

        msgProcHead Ź NEW[MsgProcRecord Ź [clientData: NIL, proc: NIL]];
        msgProcHead.prev Ź msgProcHead.next Ź msgProcHead;

        moveProcHead Ź NEW[MoveProcRecord Ź [clientData: NIL, proc: NIL]];
        moveProcHead.prev Ź moveProcHead.next Ź moveProcHead;

        msgGroupHead Ź NEW[MsgGroupRecord Ź [clientData: NIL, proc: NIL]];
        msgGroupHead.prev Ź msgGroupHead.next Ź msgGroupHead;

        msgSetProcHead Ź NEW[MsgSetProcRecord Ź [clientData: NIL, proc: NIL]];
        msgSetProcHead.prev Ź msgSetProcHead.next Ź msgSetProcHead;

        END.