-- File: WalnutDBLockImpl.mesa
-- Contents:
  -- procedures for locking access to Walnut's database & log
  -- this file contains ALL of (and only) the ENTRY PROCs

-- Created by: Willie-Sue  November 2, 1982
-- Last edited by:
  -- Rick Cattell on XXX
  -- Willie-Sue on April 13, 1983 12:27 pm

DIRECTORY
	GVBasics USING [Timestamp],
	GVRetrieve USING [Handle],
	IO USING [STREAM],
	DB,
	WalnutDB,
	WalnutDBAccess,
	WalnutDBLock,
	WalnutDBLog,
	WalnutWindow;
	
WalnutDBLockImpl: CEDAR MONITOR
  IMPORTS DB, WalnutDB, WalnutDBAccess, WalnutDBLog, WalnutWindow
  EXPORTS WalnutDB, WalnutDBLock =
		
BEGIN OPEN WalnutDB;

databaseIsBusy: BOOL_ FALSE;
databaseAvailable: CONDITION;
CheckForDatabaseBusy: INTERNAL PROC = INLINE
 { UNTIL ~databaseIsBusy DO WAIT databaseAvailable; ENDLOOP;};

-- ********************************************************
InitializeDBVars: PUBLIC ENTRY PROC =
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	WalnutDBAccess.DoInitializeDBVars[];
  END;

MsgRecToMsg: PUBLIC ENTRY PROC[mr: MsgRec] RETURNS[msg: Msg, existed: BOOL] =
  -- Converts msg from record to entity form
  BEGIN ENABLE UNWIND => NULL;
  CheckForDatabaseBusy[];
  [msg, existed]_ WalnutDBAccess.DoMsgRecToMsg[mr];
  END;

DeclareMsg: PUBLIC ENTRY PROC[mName: ROPE] RETURNS [msg: Msg, existed: BOOL] =
  -- Creates a new Msg entity, and sets its name to be mName.
  -- is called when messages have been read from the log or another file.
  -- If the Msg already exists, returns it and returns existed=TRUE.
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
   [msg, existed]_ WalnutDBAccess.DoDeclareMsg[mName];
  END;

DeclareMsgSet: PUBLIC ENTRY PROC[mName: ROPE] RETURNS[msgSet: MsgSet, existed: BOOL] =
  -- Creates a new MsgSet entity, and sets its name to be mName.
  -- is called when user creates a message set, or reads a log file
  -- If the MsgSet already exists, returns it.
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	[msgSet, existed]_ WalnutDBAccess.DoDeclareMsgSet[mName];
END;

-- ********************************************************
MGetPList: PUBLIC ENTRY PROC[m: Msg, prop: Attribute] RETURNS [LIST OF Value] =
  -- Finds all the values of prop for m and returns them.
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	RETURN[DB.GetPList[m, prop]]
  END;

MGetP: PUBLIC ENTRY PROC[m: Msg, prop: Attribute] RETURNS [Value] =
  -- Finds the one unique value for prop for m or NIL if none.
  -- SIGNALs NonUniquePropertyValue if more than one value.
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	RETURN[DB.GetP[m, prop]];
  END;

MSetPList: PUBLIC ENTRY PROC[m: Msg, prop: Attribute, vl: LIST OF Value] =
  -- Sets the values of prop for m to be those in vl.
  -- Erases any previous property values.
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	WalnutWindow.SetWalnutUpdatesPending[TRUE];
	DB.SetPList[m, prop, vl];
  END;

MSetP: PUBLIC ENTRY PROC[m: Msg, prop: Attribute, v: Value] RETURNS [Relship]=
  -- Sets the value of prop for m to be v.
  -- Erase any previous property values if this is 2nd attribute of reln
  -- (not on any attribute, so that props formed from N-aries will work).
  -- Returns the relship used by the prop.
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	WalnutWindow.SetWalnutUpdatesPending[TRUE];
	RETURN[DB.SetP[m, prop, v]];
  END;

--MEraseP: PUBLIC ENTRY PROC[m: Msg, prop: Attribute, v: Entity] =
-- BEGIN ENABLE UNWIND => NULL;
--	CheckForDatabaseBusy[];
--	WalnutDBAccess.DoEraseP[m, prop, v];
--  END;

--MErasePList: PUBLIC ENTRY PROC[m: Msg, first: Attribute] =
--  BEGIN ENABLE UNWIND => NULL;
--	CheckForDatabaseBusy[];
--	WalnutDBAccess.DoErasePList[m, first];
--  END;

DomainOf: PUBLIC ENTRY PROC[e: Entity] RETURNS[Domain] =
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	RETURN[DB.DomainOf[e]];
  END;

RelationOf: PUBLIC ENTRY PROC[rel: Relship] RETURNS[Relation] =
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	RETURN[DB.RelationOf[rel]];
  END;

Null: PUBLIC ENTRY PROC[e: Entity] RETURNS[BOOL] =
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	RETURN[DB.Null[e]];
  END;

GetName: PUBLIC ENTRY PROC[e: Entity] RETURNS [ROPE] =
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	RETURN[DB.GetName[e]];
  END;

GetFE: PUBLIC ENTRY PROC[rel: Relship, a: Attribute] RETURNS [Entity] =
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	RETURN[DB.V2E[DB.GetF[rel, a]]];
  END;

GetFS: PUBLIC ENTRY PROC[rel: Relship, a: Attribute] RETURNS [ROPE] =
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	RETURN[DB.GetFS[rel, a]];
  END;

CreateEntity: PUBLIC ENTRY PROC[d: Domain, name: ROPE_ NIL]
		RETURNS[Entity] =
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	RETURN[DB.DeclareEntity[d, name, NewOrOld]];
  END;

NameToEntity: PUBLIC ENTRY PROC[d: Domain, name: ROPE, oldOnly: BOOL]
		RETURNS[e: Entity] =
 BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	RETURN[WalnutDBAccess.DoNameToEntity[d, name, oldOnly]];
 END;

GetEntitiesInDomain: PUBLIC ENTRY PROC[d: Domain, alphaOrder: BOOL]
		RETURNS[eL: LIST OF Entity] =
  -- returns list of entities in given domain
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	RETURN[WalnutDBAccess.DoGetEntitiesInDomain[d, alphaOrder]];
  END;

NumInMsgSet: PUBLIC ENTRY PROC[msgSet: MsgSet] RETURNS[num: INT] =
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	RETURN[WalnutDBAccess.DoNumInMsgSet[msgSet]];
  END;

RelationSubsetList: PUBLIC ENTRY PROC[r: Relation, constraint: AttributeValueList_ NIL]
		RETURNS[relList: LIST OF Relship] =
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	RETURN[WalnutDBAccess.DoRelationSubsetList[r, constraint]];
  END;

-- ********************************************************
--  controlling access to the log file

InitializeLog: PUBLIC ENTRY PROC RETURNS [curLength: INT] =
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	RETURN[WalnutDBLog.DoInitializeLog[]];
  END;

CloseLogStream: PUBLIC ENTRY PROC =
  BEGIN ENABLE UNWIND => NULL;
    CheckForDatabaseBusy[];
    WalnutDBLog.DoCloseLogStream[];
  END;

OpenWalnutTransaction: PUBLIC ENTRY PROC[trans: DB.Transaction, noLog: BOOL] =
  BEGIN ENABLE UNWIND => NULL;
    CheckForDatabaseBusy[];
    WalnutDBLog.OpenWTransaction[trans, noLog];
  END;

CloseWalnutTransaction: PUBLIC ENTRY PROC =
  BEGIN ENABLE UNWIND => NULL;
    CheckForDatabaseBusy[];
    WalnutDBLog.CloseWTransaction[];
  END;

AbortWalnutTransaction: PUBLIC ENTRY PROC =
  BEGIN ENABLE UNWIND => NULL;
    CheckForDatabaseBusy[];
    WalnutDBLog.AbortWTransaction[];
  END;

MarkWalnutTransaction: PUBLIC ENTRY PROC =
  BEGIN ENABLE UNWIND => NULL;
    CheckForDatabaseBusy[];
    WalnutDBLog.MarkWTransaction[];
  END;

GetLogLength: PUBLIC ENTRY PROC[doFlush: BOOL_ FALSE] RETURNS[INT] =
  { ENABLE UNWIND => NULL; RETURN[WalnutDBLog.LogLength[doFlush]]};

AddMsgToMsgSet: PUBLIC ENTRY PROC[msg: Msg, msgSet: MsgSet] =
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	WalnutDBLog.DoAddMsgToMsgSet[msg, msgSet]
  END;

RemoveMsgFromMsgSet: PUBLIC ENTRY PROC[msg: Msg, msgSet: MsgSet, rel: Relship] =
  -- Removes msg from msgSet and makes entry in log for this update.
  --  adds msg to Deleted if necessary
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	WalnutDBLog.DoRemoveMsgFromMsgSet[msg, msgSet, rel, TRUE]
  END;

--  this is entirely inside the monitor so no one can change msgSet while it is being archived
ArchiveMsgSet: PUBLIC ENTRY PROC[msgSet: MsgSet, strm: IO.STREAM]
	RETURNS[num: INT] =
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	RETURN[WalnutDBLog.DoArchiveMsgSet[msgSet, strm]]
  END;

DestroyMsgSet: PUBLIC ENTRY PROC[msgSet: MsgSet] =
  -- Destroys the given msgSet, removing any messages from it first
  -- Makes an entry in the log that says this msgSet was destroyed.
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	WalnutDBLog.DoDestroyMsgSet[msgSet];
  END;

ReadGVMessageItems: PUBLIC ENTRY PROC
  [gvH: GVRetrieve.Handle, timeStamp: GVBasics.Timestamp, gvSender: RName]
  	RETURNS[BOOL] =
--  reads message items from Grapevine & makes a log entry for this message
  BEGIN ENABLE UNWIND => NULL;
    CheckForDatabaseBusy[];
    RETURN[WalnutDBLog.GVMessageToLog[gvH, timeStamp, gvSender]];
  END;

AddMessageToLog: PUBLIC ENTRY PROC [entryText, prefix: ROPE] =
--  makes a message LogEntryType on log (used by old mial file reader)
  BEGIN ENABLE UNWIND => NULL;
    CheckForDatabaseBusy[];
    WalnutDBLog.DoAddMessageToLog[entryText, prefix];
  END;

AddMsgReadEntryToLog: PUBLIC ENTRY PROC[msg: Msg] =
  BEGIN ENABLE UNWIND => NULL;
    CheckForDatabaseBusy[];
    WalnutDBLog.WriteMsgReadEntryToLog[msg];
  END;

DumpMsgs: PUBLIC ENTRY PROC[tempLog: IO.STREAM, doUpdates, tailRewrite: BOOL]
		RETURNS[ok: BOOL] =
  BEGIN ENABLE UNWIND => NULL;
    CheckForDatabaseBusy[];
    RETURN[WalnutDBLog.ExpungeMsgs[tempLog, doUpdates, tailRewrite]];
  END;

-- ********************************************************
--  operations that read the log

GetOneMessageFromLog: PUBLIC ENTRY PROC[startOfNextMessage: INT]
		RETURNS[endPos: INT, anymore: BOOL, msgRec: MsgRec, msgWasNew: BOOL] =
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	[endPos, anymore, msgRec, msgWasNew]_ WalnutDBLog.OneMsgFromLog[startOfNextMessage];
  END;

-- ********************************************************
-- EXPORTed to WalnutDBLock (private access)
 
GetWalnutInfo: PUBLIC ENTRY PROC[attr: Attribute] RETURNS[INT] =
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	RETURN[DB.V2I[DB.GetF[walnutInfoRelship, attr]]];
  END;

SetWalnutInfo: PUBLIC ENTRY PROC[attr: Attribute, i: INT] =
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	DB.SetF[walnutInfoRelship, attr, DB.I2V[i]];
	WalnutWindow.SetWalnutUpdatesPending[TRUE];
  END;

IsCopyInProgress: PUBLIC ENTRY PROC RETURNS[BOOL] =
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	RETURN[DB.V2B[DB.GetF[walnutInfoRelship, wCopyInProgress]]];
  END;

ReadLogFile: PUBLIC ENTRY PROC[startPos: INT] RETURNS[ok: BOOL] =
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	RETURN[WalnutDBLog.AddLogEntriesToDB[startPos]];
  END;

AcquireDBLock: PUBLIC ENTRY PROC[procToCall: PROC] =
  BEGIN ENABLE UNWIND => NULL;
	CheckForDatabaseBusy[];
	procToCall[];
  END;

END.
�Êc˜Jš Ïc,œ�<œ�8œ
�?œ�œ�)œ
Ïk	œžœžœžœ
žœžœdž
œžœ;žœžœ
žœžœžœž	œÏnœžœ
žœžœžœžœ
žœžœ�<Ÿœžœ
žœ
žœžœ
žœ
žœžœCžœŸœžœ
žœ
žœ
žœžœ�+œžœ
žœ
žœžœRžœŸ
œžœ
žœ
žœžœžœžœ�<œ�Hœ�Cœžœ
žœ
žœžœTžœŸ
œžœ
žœ
žœžœžœžœ�?œ�Bœ�-œžœ
žœ
žœžœVžœ�<Ÿ	œžœ
žœ
žœžœžœ
žœ�8œžœ
žœ
žœžœžœžœŸœžœ
žœ
žœžœ
�=œ�:œžœ
žœ
žœžœžœžœŸ	œžœ
žœ
žœžœ
žœ�4œ�(œžœ
žœ
žœžœAžœ žœŸœžœ
žœ
žœ$žœ�)œ�Gœ�Hœ�)œžœ
žœ
žœžœAžœžœžœŸ	œžœ
žœ
žœ*žœ
žœ
žœžœIžœŸ
œžœ
žœ
žœ!žœ
žœ
žœžœKžœŸœžœ
žœ
žœžœ
žœ
žœ
žœžœžœžœŸ
œžœ
žœ
žœžœžœ
žœ
žœžœžœžœŸœžœ
žœ
žœžœ
žœžœ
žœ
žœžœžœžœŸœžœ
žœ
žœžœžœžœ
žœ
žœžœžœžœŸœžœ
žœ
žœžœžœ
žœ
žœžœžœžœŸœžœ
žœ
žœžœžœžœ
žœ
žœžœžœžœŸœžœ
žœ
žœžœžœžœ
žœ
žœ
žœžœžœ)žœŸœžœ
žœ
žœžœžœžœžœ
žœ
žœžœžœ4žœŸœžœ
žœ
žœžœžœžœ
žœ
�,œžœ
žœ
žœžœžœ9žœŸœžœ
žœ
žœžœžœžœ
žœ
žœžœžœ*žœŸœžœ
žœ
žœ.žœžœ
žœ
žœžœ
žœ
žœžœžœ8žœ�cœ
Ÿ
œžœ
žœ
žœ
žœ
žœžœ
žœ
žœžœžœ#žœŸœžœ
žœ
žœžœ
žœ
žœžœDžœŸœžœ
žœ
žœžœžœ
žœ
žœžœPžœŸœžœ
žœ
žœžœ
žœ
žœžœEžœŸœžœ
žœ
žœžœ
žœ
žœžœEžœŸœžœ
žœ
žœžœ
žœ
žœžœDžœŸœžœ
žœ
žœ
žœžœžœ
žœžœ
žœžœžœ$Ÿœžœ
žœ
žœžœ
žœ
žœžœHžœŸœžœ
žœ
žœ-�Cœ�%œžœ
žœ
žœžœPžœžœ�_Ÿ
œžœ
žœ
žœžœ
žœžœžœžœ
žœ
žœžœžœ.žœŸ
œžœ
žœ
žœ�Bœ�Bœžœ
žœ
žœžœCžœŸœžœ
žœ
žœOžœ
žœ�Lœžœ
žœ
žœžœ"žœ:žœŸœžœ
žœ
žœžœ�Gœžœ
žœ
žœžœVžœŸœžœ
žœ
žœžœ
žœ
žœžœMžœŸœžœ
žœ
žœ
žœ
žœžœžœžœžœ
žœ
žœžœ"žœ>žœ�]Ÿœžœ
žœ
žœžœžœ	žœžœžœžœ
žœ
žœžœsžœ�iœŸ
œžœ
žœ
žœžœ
žœžœ
žœ
žœžœžœ.žœŸ
œžœ
žœ
žœžœžœ
žœ
žœžœožœžœŸœžœ
žœ
žœ
žœžœ
žœ
žœžœžœ9žœŸœžœ
žœ
žœžœžœžœžœ
žœ
žœžœžœ-žœŸ
œžœ
žœžœ
žœ
žœžœ,žœžœ
˜áP—…—(d0Í