<<>>
    <<LoganBerrySunRPCToLoganBerry.mesa>>
        <<Copyright Ó 1987, 1992 by Xerox Corporation.  All rights reserved.>>
        <<Doug Terry, August 22, 1989 6:08:14 pm PDT>>
        <<Adapted from LoganBerryCrServerImpl.mesa>>
        <<>>
        <<Exports LoganBerrySunRPCServer, which is called by LoganBerrySunRPCServerStub, and calls the real LoganBerry routines.>>
        <<>>
    DIRECTORY
        Atom USING [GetPName, MakeAtom],
        LoganBerry,
        LoganBerrySunRPC,
        LoganBerrySunRPCServer,
        Rope USING [Equal];

    LoganBerrySunRPCToLoganBerry: CEDAR PROGRAM
    IMPORTS Atom, LoganBerry, Rope 
    EXPORTS LoganBerrySunRPCServer
    ~ BEGIN
        OPEN LoganBerrySunRPC, LoganBerrySunRPCServer;

<<LoganBerry operations>>
Error: PUBLIC ERROR [ec: ErrorCode, explanation: ROPE Ź NIL] = CODE;

    Null: PUBLIC NullType ~ {
        NULL;
        };

    Open: PUBLIC OpenType ~ {
        ENABLE LoganBerry.Error => ERROR Error[Atom.GetPName[ec], explanation];
        db Ź LoganBerry.Open[NIL, dbName];
        };

    ReadEntry: PUBLIC ReadEntryType ~ {
        ENABLE LoganBerry.Error => ERROR Error[Atom.GetPName[ec], explanation];
        lbentry: LoganBerry.Entry;
        [lbentry, others] Ź LoganBerry.ReadEntry[NIL, db, Atom.MakeAtom[key], value];
        entry Ź EntryToSr[lbentry];
        };

    GenerateEntries: PUBLIC GenerateEntriesType ~ {
        ENABLE LoganBerry.Error => ERROR Error[Atom.GetPName[ec], explanation];
        cursor Ź LoganBerry.GenerateEntries[NIL, db, Atom.MakeAtom[key], IF Rope.Equal[start, ""] THEN NIL ELSE start, IF Rope.Equal[end, 
        ""] THEN NIL ELSE end];
        };

    NextEntry: PUBLIC NextEntryType ~ {
        ENABLE LoganBerry.Error => ERROR Error[Atom.GetPName[ec], explanation];
        lbentry: LoganBerry.Entry;
        lbentry Ź LoganBerry.NextEntry[NIL, cursor, IF dir=increasing THEN increasing ELSE decreasing];
        entry Ź EntryToSr[lbentry];
        };

    EndGenerate: PUBLIC EndGenerateType ~ {
        ENABLE LoganBerry.Error => ERROR Error[Atom.GetPName[ec], explanation];
        LoganBerry.EndGenerate[NIL, cursor];
        };

    WriteEntry: PUBLIC WriteEntryType ~ {
        ENABLE LoganBerry.Error => ERROR Error[Atom.GetPName[ec], explanation];
        LoganBerry.WriteEntry[NIL, db, SrToEntry[entry], log, replace];
        };

    DeleteEntry: PUBLIC DeleteEntryType ~ {
        ENABLE LoganBerry.Error => ERROR Error[Atom.GetPName[ec], explanation];
        LoganBerry.DeleteEntry[NIL, db, Atom.MakeAtom[key], value];
        };

    Close: PUBLIC CloseType ~ {
        ENABLE LoganBerry.Error => ERROR Error[Atom.GetPName[ec], explanation];
        LoganBerry.Close[NIL, db];
        };

    BuildIndices: PUBLIC BuildIndicesType ~ {
        ENABLE LoganBerry.Error => ERROR Error[Atom.GetPName[ec], explanation];
        LoganBerry.BuildIndices[NIL, db];
        };

    CompactLogs: PUBLIC CompactLogsType ~ {
        ENABLE LoganBerry.Error => ERROR Error[Atom.GetPName[ec], explanation];
        LoganBerry.CompactLogs[NIL, db];
        };

    Describe: PUBLIC DescribeType ~ {
        ENABLE LoganBerry.Error => ERROR Error[Atom.GetPName[ec], explanation];
        lbinfo: LoganBerry.SchemaInfo;
        lbinfo Ź LoganBerry.Describe[NIL, db];
        info Ź SchemaInfoToSr[lbinfo];
        };
<<Data conversion>>
    SrToEntry: PROC [srEntry: LoganBerrySunRPC.Entry] RETURNS [entry: LoganBerry.Entry] ~ {
        entry Ź NIL;
        FOR i: CARDINAL DECREASING IN [0..srEntry.length) DO
            attr: LoganBerry.Attribute Ź [Atom.MakeAtom[srEntry[i].type], srEntry[i].value];
            entry Ź CONS[attr, entry];
            ENDLOOP;
        };

    EntryToSr: PROC [entry: LoganBerry.Entry] RETURNS [crEntry: LoganBerrySunRPC.Entry] ~ {
        count: CARDINAL Ź 0;
        FOR e: LoganBerry.Entry Ź entry, e.rest WHILE e # NIL DO
            count Ź count + 1;
            ENDLOOP;
        crEntry Ź NEW[LoganBerrySunRPC.EntryObject[count]];
        count Ź 0;
        FOR e: LoganBerry.Entry Ź entry, e.rest WHILE e # NIL DO
            crEntry[count].type Ź Atom.GetPName[e.first.type];
            crEntry[count].value Ź e.first.value;
            count Ź count + 1;
            ENDLOOP;
        };

    SrToSchemaInfo: PROC [crInfo: LoganBerrySunRPC.SchemaInfo] RETURNS [info: LoganBerry.SchemaInfo] ~ {
        SrToLogList: PROC [crLogs: LoganBerrySunRPC.LogList] RETURNS [logs: LIST OF LoganBerry.LogInfo] ~ {
            logs Ź NIL;
            FOR i: CARDINAL DECREASING IN [0..crLogs.length) DO
                loginfo: LoganBerry.LogInfo Ź NEW[LoganBerry.LogInfoRec Ź [crLogs[i].id, crLogs[i].file]];
                logs Ź CONS[loginfo, logs];
                ENDLOOP;
            };
        SrToIndexList: PROC [crIndices: LoganBerrySunRPC.IndexList] RETURNS [indices: LIST OF LoganBerry.IndexInfo] ~ {
            indices Ź NIL;
            FOR i: CARDINAL DECREASING IN [0..crIndices.length) DO
                indexinfo: LoganBerry.IndexInfo Ź NEW[LoganBerry.IndexInfoRec Ź [Atom.MakeAtom[crIndices[i].key], crIndices[i].file, 
                Atom.MakeAtom[crIndices[i].order]]];
                indices Ź CONS[indexinfo, indices];
                ENDLOOP;
            };
        info Ź NEW[LoganBerry.SchemaInfoRec Ź [crInfo.dbName, SrToLogList[crInfo.logs], SrToIndexList[crInfo.indices]]];
        };

    SchemaInfoToSr: PROC [info: LoganBerry.SchemaInfo] RETURNS [crInfo: LoganBerrySunRPC.SchemaInfo] ~ {
        LogListToSr: PROC [logs: LIST OF LoganBerry.LogInfo] RETURNS [crLogs: LoganBerrySunRPC.LogList] ~ {
            count: CARDINAL Ź 0;
            FOR i: LIST OF LoganBerry.LogInfo Ź logs, i.rest WHILE i # NIL DO
                count Ź count + 1;
                ENDLOOP;
            crLogs Ź NEW[LoganBerrySunRPC.LogListObject[count]];
            count Ź 0;
            FOR i: LIST OF LoganBerry.LogInfo Ź logs, i.rest WHILE i # NIL DO
                crLogs[count].id Ź i.first.id;
                crLogs[count].file Ź i.first.file;
                count Ź count + 1;
                ENDLOOP;
            };
        IndexListToSr: PROC [indices: LIST OF LoganBerry.IndexInfo] RETURNS [crIndices: LoganBerrySunRPC.IndexList] ~ {
            count: CARDINAL Ź 0;
            FOR i: LIST OF LoganBerry.IndexInfo Ź indices, i.rest WHILE i # NIL DO
                count Ź count + 1;
                ENDLOOP;
            crIndices Ź NEW[LoganBerrySunRPC.IndexListObject[count]];
            count Ź 0;
            FOR i: LIST OF LoganBerry.IndexInfo Ź indices, i.rest WHILE i # NIL DO
                crIndices[count].key Ź Atom.GetPName[i.first.key];
                crIndices[count].file Ź i.first.file;
                crIndices[count].order Ź Atom.GetPName[i.first.order];
                count Ź count + 1;
                ENDLOOP;
            };
        crInfo.dbName Ź info.dbName;
        crInfo.logs Ź LogListToSr[info.logs];
        crInfo.indices Ź IndexListToSr[info.indices];
        };


    END.