
<<WalnutDBInfoImpl.mesa>>
<<Copyright © 1985 by Xerox Corporation.  All rights reserved.>>
<<Willie-Sue, August 1, 1985 9:57:19 am PDT>>
<<>>
<<Contents: procedures dealing with the Walnut message database>>
<<Initiated by Willie-Sue, January 29, 1985>>

DIRECTORY
BasicTime USING [GMT],
DB USING [
Attribute, AttributeValueList, Entity, EntitySet, GMT, Relship, Transaction, Value,
DeclareEntity, DeclareRelship, DomainSubset, FlushCache, GetF, GetSegmentInfo,
NameOf, NextEntity, ReleaseEntitySet, SetF,
V2B, V2I, V2T],
Rope,
WalnutDefs USING [Error, ServerInfo],
WalnutKernelDefs USING [LogExpungePhase],
WalnutDB,
WalnutDBInternal USING [CarefullyApply],
WalnutSchema;

WalnutDBInfoImpl: CEDAR PROGRAM
IMPORTS
DB,
WalnutDefs, WalnutDB, WalnutDBInternal, WalnutSchema

EXPORTS WalnutDB =

BEGIN OPEN WalnutSchema;
<<Types>>
ROPE: TYPE = Rope.ROPE;
GMT: TYPE = BasicTime.GMT;
Msg: TYPE = ROPE;
Entity: TYPE = DB.Entity;
Relship: TYPE = DB.Relship;
ServerInfo: TYPE = WalnutDefs.ServerInfo;
<<Variables>>
DBIntValue: REF INT _ NEW[INT];
DBBoolValue: REF BOOL _ NEW[BOOL];
DBGmtValue: REF DB.GMT _ NEW[DB.GMT];
<<Operations used during Expunge, NewMail and reading Archive files>>
GetExpungeInfo: PUBLIC PROC RETURNS[
firstDestroyedMsgPos, bytesInDestroyedMsgs: INT] = {
Gei: PROC = {
firstDestroyedMsgPos_ DB.V2I[DB.GetF[rLogInfo, gFirstDestroyedMsgPos]];
bytesInDestroyedMsgs_ DB.V2I[DB.GetF[rLogInfo, gBytesInDestroyedMsgs]]
};
WalnutDBInternal.CarefullyApply[Gei];
};

SetExpungeInfo: PUBLIC PROC[firstDestroyedMsgPos, bytesInDestroyedMsgs: INT] = {
Sei: PROC = {
DBIntValue^ _ firstDestroyedMsgPos;
DB.SetF[rLogInfo, gFirstDestroyedMsgPos, DBIntValue];
DBIntValue^ _ bytesInDestroyedMsgs;
DB.SetF[rLogInfo, gBytesInDestroyedMsgs, DBIntValue];
};
WalnutDBInternal.CarefullyApply[Sei];
};

GetLogExpungePhase: PUBLIC PROC RETURNS[exp: WalnutKernelDefs.LogExpungePhase] = {
Gep: PROC = {
ph: INT_ DB.V2I[DB.GetF[rExpungeInfo, gLogExpungePhase]];
SELECT ph FROM
0 => exp_ idle;
1 => exp_ initializingExpungeLog;
2 => exp_ writingExpungeLog;
3 => exp_ swappingLogs;
ENDCASE => {
SIGNAL WalnutDefs.Error[$db, $Bug, "Bad expungePhase value"];
exp_ idle
};
};
WalnutDBInternal.CarefullyApply[Gep];
};

SetLogExpungePhase: PUBLIC PROC[exp: WalnutKernelDefs.LogExpungePhase] = {
Sep: PROC = {
SELECT exp FROM
idle => DBIntValue^ _ 0;
initializingExpungeLog => DBIntValue^ _ 1;
writingExpungeLog => DBIntValue^ _ 2;
swappingLogs => DBIntValue^ _ 3;
ENDCASE => {
SIGNAL WalnutDefs.Error[$db, $Bug, "Bad expungePhase value"];
DBIntValue^ _ 0;
}; 
DB.SetF[rExpungeInfo, gLogExpungePhase, DBIntValue];
DB.FlushCache[DB.GetSegmentInfo[WalnutDB.walnutSegment].trans];
};
WalnutDBInternal.CarefullyApply[Sep];
};

GetExpungeProgressInfo: PUBLIC PROC RETURNS[currentLogPos, expungeLogPos: INT] = {
Gepi: PROC = {
currentLogPos_ DB.V2I[DB.GetF[rExpungeInfo, gCurrentLogPos]];
expungeLogPos_ DB.V2I[DB.GetF[rExpungeInfo, gExpungeLogPos]];
};
WalnutDBInternal.CarefullyApply[Gepi];
};

SetExpungeProgressInfo: PUBLIC PROC[currentLogPos, expungeLogPos: INT] = {
Sepi: PROC = {
DBIntValue^ _ currentLogPos;
DB.SetF[rExpungeInfo, gCurrentLogPos, DBIntValue];
DBIntValue^ _ expungeLogPos;
DB.SetF[rExpungeInfo, gExpungeLogPos, DBIntValue];
DB.FlushCache[DB.GetSegmentInfo[WalnutDB.walnutSegment].trans];
};
WalnutDBInternal.CarefullyApply[Sepi];
};

GetExpungeFileID: PUBLIC PROC RETURNS[expungeFileID: INT] = {
Gefi: PROC = { expungeFileID_ DB.V2I[DB.GetF[rExpungeInfo, gExpungeFileID]] };
WalnutDBInternal.CarefullyApply[Gefi];
};

SetExpungeFileID: PUBLIC PROC[expungeFileID: INT] = {
Sefi: PROC = {
DBIntValue^ _ expungeFileID;
DB.SetF[rExpungeInfo, gExpungeFileID, DBIntValue]
};
WalnutDBInternal.CarefullyApply[Sefi];
};

SetAcceptNewMailPos: PUBLIC PROC[pos: INT] = {
Sanmp: PROC = {
DBIntValue^ _ pos;
DB.SetF[rNewMailInfo, gAcceptNewMailLogPos, DBIntValue]
};
WalnutDBInternal.CarefullyApply[Sanmp];
};

GetAcceptNewMailPos: PUBLIC PROC RETURNS[pos: INT] = {
Ganmp: PROC =
{ pos _ DB.V2I[DB.GetF[rNewMailInfo, gAcceptNewMailLogPos]] };
WalnutDBInternal.CarefullyApply[Ganmp];
};

SetAddingServerMsgs: PUBLIC PROC[addingServerMsgs: BOOL] = {
Sasm: PROC = {
DBBoolValue^ _ addingServerMsgs;
DB.SetF[rNewMailInfo, gAddingServerMsgs, DBBoolValue]
};
WalnutDBInternal.CarefullyApply[Sasm];
};

GetAddingServerMsgs: PUBLIC PROC RETURNS[addingServerMsgs: BOOL] = {
Sasm: PROC =
{ addingServerMsgs_ DB.V2B[DB.GetF[rNewMailInfo, gAddingServerMsgs]] };
WalnutDBInternal.CarefullyApply[Sasm];
};

EnumerateServers: PUBLIC PROC RETURNS[serverList: LIST OF ServerInfo] = {
Gsi: PROC = {
enum: DB.EntitySet _ DB.DomainSubset[ServerDomain];
se: Entity;
FOR se_ DB.NextEntity[enum], DB.NextEntity[enum] UNTIL se = NIL DO
rel: Relship = DB.DeclareRelship[sBasicInfo, LIST[[sBIOf, se]]];
si: ServerInfo;
si.server _ DB.NameOf[se];
si.num _ DB.V2I[DB.GetF[rel, sBINum]];
serverList _ CONS[si, serverList];
ENDLOOP;
DB.ReleaseEntitySet[enum];
};
WalnutDBInternal.CarefullyApply[Gsi];
};

GetServerInfo: PUBLIC PROC[server: ROPE] RETURNS[num: INT] = {
Gsr: PROC = {
se: Entity = DB.DeclareEntity[ServerDomain, server, OldOnly];
IF se # NIL THEN {
rel: Relship = DB.DeclareRelship[sBasicInfo, LIST[[sBIOf, se]]];
num _ DB.V2I[DB.GetF[rel, sBINum]]
}
ELSE num _ 0;
};
WalnutDBInternal.CarefullyApply[Gsr];
};

SetNewMailInfo: PUBLIC PROC[logLen: INT, when: GMT, server: ROPE, num: INT] = {
Snmi: PROC = {
IF server # NIL THEN {
se: Entity = DB.DeclareEntity[ServerDomain, server];
rel: Relship = DB.DeclareRelship[sBasicInfo, LIST[[sBIOf, se]]];
DBIntValue^ _ num;
DB.SetF[rel, sBINum, DBIntValue];
};

DBIntValue^ _ logLen;
DB.SetF[rNewMailInfo, gNewMailLogLength, DBIntValue];
DBGmtValue^ _ [when];
DB.SetF[rNewMailInfo, gLastNewMailTimeStamp, DBGmtValue]
};
WalnutDBInternal.CarefullyApply[Snmi];
};

SetNewMailLogLength: PUBLIC PROC[logLen: INT] = {
Gnml: PROC = {
DBIntValue^ _ logLen;
DB.SetF[rNewMailInfo, gNewMailLogLength, DBIntValue];
};
WalnutDBInternal.CarefullyApply[Gnml];
};

GetNewMailLogLength: PUBLIC PROC RETURNS[logLen: INT] = {
Gnml: PROC =
{ logLen _ DB.V2I[DB.GetF[rNewMailInfo, gNewMailLogLength]] };
WalnutDBInternal.CarefullyApply[Gnml];
};

GetLastNewMailTimeStamp: PUBLIC PROC RETURNS[when: GMT] = {
Glnmts: PROC = { when _ DB.V2T[DB.GetF[rNewMailInfo, gLastNewMailTimeStamp]] };
WalnutDBInternal.CarefullyApply[Glnmts];
};

SetCopyMailLogPos: PUBLIC PROC[pos: INT] = {
Scml: PROC = {
DBIntValue^ _ pos;
DB.SetF[rNewMailInfo, gCopyNewMailLogPos, DBIntValue]
};
WalnutDBInternal.CarefullyApply[Scml];
};

GetCopyMailLogPos: PUBLIC PROC RETURNS[pos: INT] = {
Gcml: PROC = { pos _ DB.V2I[DB.GetF[rNewMailInfo, gCopyNewMailLogPos]] };
WalnutDBInternal.CarefullyApply[Gcml];
};

SetReadArchivePos: PUBLIC PROC[pos: INT] = {
Srap: PROC = {
DBIntValue^ _ pos;
DB.SetF[rReadArchiveInfo, gReadArchiveLogPos, DBIntValue]
};
WalnutDBInternal.CarefullyApply[Srap];
};

GetReadArchivePos: PUBLIC PROC RETURNS[pos: INT] = {
Grap: PROC = { pos _ DB.V2I[DB.GetF[rReadArchiveInfo, gReadArchiveLogPos]] };
WalnutDBInternal.CarefullyApply[Grap];
};

SetCopyReadArchivePos: PUBLIC PROC[pos: INT] = {
Scra: PROC = {
DBIntValue^ _ pos;
DB.SetF[rReadArchiveInfo, gCopyReadArchiveLogPos, DBIntValue]
};
WalnutDBInternal.CarefullyApply[Scra];
};

GetCopyReadArchivePos: PUBLIC PROC RETURNS[pos: INT] = {
Gcra: PROC = { pos _ DB.V2I[DB.GetF[rReadArchiveInfo, gCopyReadArchiveLogPos]] };
WalnutDBInternal.CarefullyApply[Gcra];
};

END.