DIRECTORY

AlpineEnvironment
USING[AccessRights, FileID, LockFailure, LockOption, NeededAccess,
OpenFileID, OperationFailure, OwnerName, PageCount, PageRun, PropertyValuePair,
RecoveryOption, ReferencePattern, TransID, nullTransID, UniversalFile, UnknownType, VolOrVolGroupID],
AlpFile
USING[Handle, Object, PropertySet, RESULTPageBuffer, VALUEPageBuffer, UserProperties, UserPropertyValuePairs, CachePageLockConversion, CachePageLockConversions],
AlpineFile
USING[AccessFailed, LockFailed, OperationFailed, PossiblyDamaged,
StaticallyInvalid, Unknown],
AlpPrivate
USING[NoticeUnboundInstance],
AlpTransaction
USING[Handle],
RPC
USING[CallFailed],
AlpineFileRpcControl;


AlpFileImpl: CEDAR PROGRAM 
IMPORTS AF: AlpineFile, AlpP: AlpPrivate, RPC, AlpineFileRpcControl
EXPORTS AlpFile =

BEGIN OPEN AlpF: AlpFile, AE: AlpineEnvironment, AlpT: AlpTransaction;



Open: PUBLIC PROCEDURE
[transHandle: AlpT.Handle, universalFile: AE.UniversalFile, access: AE.AccessRights, lock: AE.LockOption, recoveryOption: AE.RecoveryOption, referencePattern: AE.ReferencePattern] 
RETURNS[handle: AlpF.Handle, fileID: AE.FileID] 
= BEGIN
openFileID: AE.OpenFileID;
TRUSTED BEGIN [openFileID, fileID] _ transHandle.inst.file.Open[transHandle.inst.conversation,
transHandle.transID, universalFile, access, lock, recoveryOption, referencePattern
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpP.NoticeUnboundInstance[transHandle.inst]]; END;
handle _ NEW[AlpF.Object _ [trans: transHandle, openFileID: openFileID]];
END;

Create: PUBLIC PROCEDURE
[transHandle: AlpT.Handle, volumeID: AE.VolOrVolGroupID, owner: AE.OwnerName, initialSize: AE.PageCount, recoveryOption: AE.RecoveryOption, referencePattern: AE.ReferencePattern] 
RETURNS[handle: AlpF.Handle, refUniversalFile: REF AE.UniversalFile] 
= BEGIN
ENABLE RPC.CallFailed => IF why = unbound OR why = timeout
THEN AlpP.NoticeUnboundInstance[transHandle.inst];
openFileID: AE.OpenFileID;
universalFile: AE.UniversalFile;
TRUSTED BEGIN [openFileID, universalFile] _
transHandle.inst.file.Create[transHandle.inst.conversation, transHandle.transID, volumeID,
owner, initialSize, recoveryOption, referencePattern]; END;
handle _ NEW[AlpF.Object _ [trans: transHandle, openFileID: openFileID]];
refUniversalFile _ NEW[AE.UniversalFile _universalFile];
END;

Close: PUBLIC PROCEDURE[handle: AlpF.Handle] =
TRUSTED BEGIN 
handle.trans.inst.file.Close[handle.trans.inst.conversation, handle.openFileID
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpP.NoticeUnboundInstance[handle.trans.inst]];  
END;

Delete: PUBLIC PROCEDURE[handle: AlpF.Handle] =
TRUSTED BEGIN 
handle.trans.inst.file.Delete[handle.trans.inst.conversation, handle.openFileID
! RPC.CallFailed => IF why = unbound  OR why = timeout THEN
AlpP.NoticeUnboundInstance[handle.trans.inst]];  
END;

ReadPages: PUBLIC UNSAFE PROCEDURE
[handle: AlpF.Handle, pageRun: AE.PageRun, pageBuffer: AlpF.RESULTPageBuffer, lock: AE.LockOption, cacheTrans: AE.TransID _ AE.nullTransID] 
= TRUSTED BEGIN 
handle.trans.inst.file.ReadPages[handle.trans.inst.conversation,
handle.openFileID, pageRun, pageBuffer, lock
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpP.NoticeUnboundInstance[handle.trans.inst]];  
END;

WritePages: PUBLIC PROCEDURE[handle: AlpF.Handle, pageRun: AE.PageRun, pageBuffer:
AlpF.VALUEPageBuffer, lock: AE.LockOption] 
= TRUSTED BEGIN 
handle.trans.inst.file.WritePages[handle.trans.inst.conversation,
handle.openFileID, pageRun, pageBuffer, lock
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpP.NoticeUnboundInstance[handle.trans.inst]];  
END;

ReadProperties: PUBLIC PROCEDURE
[handle: AlpF.Handle, desiredProperties: AlpF.PropertySet, lock: AE.LockOption] 
RETURNS[properties: LIST OF AE.PropertyValuePair] 
= TRUSTED BEGIN 
RETURN[handle.trans.inst.file.ReadProperties[handle.trans.inst.conversation, handle.openFileID, desiredProperties, lock 
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpP.NoticeUnboundInstance[handle.trans.inst]]];  
END;

WriteProperties: PUBLIC PROCEDURE
[handle: AlpF.Handle, properties: LIST OF AE.PropertyValuePair, lock: AE.LockOption] 
= TRUSTED BEGIN 
handle.trans.inst.file.WriteProperties[handle.trans.inst.conversation, handle.openFileID, properties, lock 
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpP.NoticeUnboundInstance[handle.trans.inst]];  
END;

ReadUserProperties: PUBLIC PROCEDURE 
[handle: AlpF.Handle, desiredProperties: AlpF.UserProperties, lock: AE.LockOption _ [read, wait]] 
RETURNS [properties: AlpF.UserPropertyValuePairs] 
= TRUSTED BEGIN 
RETURN [handle.trans.inst.file.ReadUserProperties[handle.trans.inst.conversation, handle.openFileID, desiredProperties, lock 
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpP.NoticeUnboundInstance[handle.trans.inst]]];  
END;

WriteUserProperties: PUBLIC PROCEDURE 
[handle: AlpF.Handle, properties: AlpF.UserPropertyValuePairs, lock: AE.LockOption _ [write, wait]] 
= TRUSTED BEGIN
handle.trans.inst.file.WriteUserProperties[handle.trans.inst.conversation, handle.openFileID, properties, lock 
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpP.NoticeUnboundInstance[handle.trans.inst]];  
END;

LockPages: PUBLIC PROCEDURE
[handle: AlpF.Handle, pageRun: AE.PageRun, lock: AE.LockOption] 
= TRUSTED BEGIN 
handle.trans.inst.file.LockPages[handle.trans.inst.conversation, handle.openFileID, pageRun, lock 
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpP.NoticeUnboundInstance[handle.trans.inst]];  
END;

UnlockPages: PUBLIC PROCEDURE
[handle: AlpF.Handle, pageRun: AE.PageRun, retainCacheLocks: BOOLEAN _ FALSE] 
= TRUSTED BEGIN 
handle.trans.inst.file.UnlockPages[handle.trans.inst.conversation, handle.openFileID, pageRun, retainCacheLocks 
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpP.NoticeUnboundInstance[handle.trans.inst]];  
END;

ValidateCachePageLock: PUBLIC PROC [lock: AlpF.CachePageLockConversion] 
RETURNS [success: BOOLEAN]
= TRUSTED BEGIN
END;

ValidateCachePageLocks: PUBLIC PROC [locks: AlpF.CachePageLockConversions] 
RETURNS [locksGranted, locksNotGranted: AlpF.CachePageLockConversions]
= TRUSTED BEGIN
END;

GetAccessRights: PUBLIC PROCEDURE[handle: AlpF.Handle] RETURNS[access: AE.AccessRights] 
= TRUSTED BEGIN 
RETURN[handle.trans.inst.file.GetAccessRights[handle.trans.inst.conversation, handle.openFileID 
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpP.NoticeUnboundInstance[handle.trans.inst]]];  
END;

GetLockOption: PUBLIC PROCEDURE[handle: AlpF.Handle] RETURNS[lock: AE.LockOption] 
= TRUSTED BEGIN 
RETURN[handle.trans.inst.file.GetLockOption[handle.trans.inst.conversation, handle.openFileID
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpP.NoticeUnboundInstance[handle.trans.inst]]];  
END;

SetLockOption: PUBLIC PROCEDURE[handle: AlpF.Handle, lock: AE.LockOption] 
= TRUSTED BEGIN 
handle.trans.inst.file.SetLockOption[handle.trans.inst.conversation, handle.openFileID, lock
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpP.NoticeUnboundInstance[handle.trans.inst]];  
END;

GetRecoveryOption: PUBLIC PROCEDURE[handle: AlpF.Handle] 
RETURNS[recoveryOption: AE.RecoveryOption] 
= TRUSTED BEGIN
RETURN[handle.trans.inst.file.GetRecoveryOption[handle.trans.inst.conversation, handle.openFileID 
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpP.NoticeUnboundInstance[handle.trans.inst]]];  
END;

GetReferencePattern: PUBLIC PROCEDURE[handle: AlpF.Handle] RETURNS[referencePattern:
AE.ReferencePattern] = TRUSTED BEGIN
RETURN[handle.trans.inst.file.GetReferencePattern[handle.trans.inst.conversation,
handle.openFileID
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpP.NoticeUnboundInstance[handle.trans.inst]]];  
END;

SetReferencePattern: PUBLIC PROCEDURE[handle: AlpF.Handle, referencePattern:
AE.ReferencePattern] = TRUSTED BEGIN
 handle.trans.inst.file.SetReferencePattern[handle.trans.inst.conversation, handle.openFileID, referencePattern
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpP.NoticeUnboundInstance[handle.trans.inst]];  
END;

GetSize: PUBLIC PROCEDURE[handle: AlpF.Handle, lock: AE.LockOption] RETURNS[size:
AE.PageCount] = TRUSTED BEGIN 
RETURN[handle.trans.inst.file.GetSize[handle.trans.inst.conversation, handle.openFileID, lock
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpP.NoticeUnboundInstance[handle.trans.inst]]];  
END;

SetSize: PUBLIC PROCEDURE[handle: AlpF.Handle, size: AE.PageCount, lock: AE.LockOption] =
TRUSTED BEGIN 
handle.trans.inst.file.SetSize[handle.trans.inst.conversation, handle.openFileID, size, lock
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpP.NoticeUnboundInstance[handle.trans.inst]];  
END;

GetUniversalFile: PUBLIC PROCEDURE[handle: AlpF.Handle] RETURNS[universalFile:
AE.UniversalFile] = TRUSTED BEGIN 
universalFile _
handle.trans.inst.file.GetUniversalFile[handle.trans.inst.conversation, handle.openFileID
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpP.NoticeUnboundInstance[handle.trans.inst]];  
END;

UnlockVersion: PUBLIC PROCEDURE[handle: AlpF.Handle] = TRUSTED BEGIN 
handle.trans.inst.file.UnlockVersion[handle.trans.inst.conversation, handle.openFileID
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpP.NoticeUnboundInstance[handle.trans.inst]];  
END;

IncrementVersion: PUBLIC PROCEDURE[handle: AlpF.Handle, increment: INT] = TRUSTED BEGIN 
handle.trans.inst.file.IncrementVersion[handle.trans.inst.conversation, handle.openFileID, increment
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpP.NoticeUnboundInstance[handle.trans.inst]];  
END;

UnlockFile: PUBLIC PROCEDURE[handle: AlpF.Handle, retainCacheLocks: BOOLEAN _ FALSE] 
= TRUSTED BEGIN 
handle.trans.inst.file.UnlockFile[handle.trans.inst.conversation, handle.openFileID, retainCacheLocks 
! RPC.CallFailed => IF why = unbound OR why = timeout THEN
AlpP.NoticeUnboundInstance[handle.trans.inst]];  
END;

AccessFailed: PUBLIC ERROR [missingAccess: AE.NeededAccess] _ AF.AccessFailed;
LockFailed: PUBLIC ERROR [why: AE.LockFailure] _ AF.LockFailed;
OperationFailed: PUBLIC ERROR [why: AE.OperationFailure] _ AF.OperationFailed;
StaticallyInvalid: PUBLIC ERROR _ AF.StaticallyInvalid;
Unknown: PUBLIC ERROR [what: AE.UnknownType] _ AF.Unknown;
PossiblyDamaged: PUBLIC SIGNAL _ LOOPHOLE[AF.PossiblyDamaged];



END.
Edit Log

Initial: Kolling:  February 14, 1983 5:08 pm:  package to aid clients, in conjunction with AlpInstance and AlpTransaction.




˜AlpFileImpl.mesa
Copyright c 1986 by Xerox Corporation.  All rights reserved.
Last edited by
Kolling on October 20, 1983 6:24 am
MBrown on February 1, 1984 8:08:19 pm PST
Carl Hauser, June 18, 1986 11:00:36 am PDT
in addition to the errors documented for the corresponding Alpine procedures, all of the procedures defined in this interface can also error RPC.CallFailed[RPC.CallFailure].

Body

Body
�Ê9˜š
œ™Icodešœ
Ïm
œ1™<—š
œ™Jš
œ#™#Jš
œ)™)K™*—J˜J˜Jš
Ïk	˜	˜˜šžœ=˜BJ˜OJ˜e——˜Jšžœœ
˜¡
—˜
šžœ<˜AJ˜——˜
Jšžœ˜—˜Jšžœ	˜—š
ž˜Jšžœ
˜—J˜—J˜J˜šÏnœžœ
žœ
˜Jšžœ
žœ žœ˜CJšžœ
˜—J˜Jšžœ
žœžœ*˜FJ˜J˜Jš
œ­
™­
J˜šŸœžœ
ž	˜Jšœ*žœžœžœžœ#žœ˜´
Jšžœžœ	˜0šœ
ž˜Jšœžœ˜šžœ
žœQ˜^J˜Ršœžœžœžœž˜:Jšœ/žœ
˜3—Jšœ	žœ=˜I—Jšžœ
˜J˜——šŸœžœ
ž	˜Jšœ%žœžœžœžœ#žœ˜³
Jšžœ(žœ
žœ˜Ešœ
ž˜šžœ
žœžœžœ˜:Jšžœ.˜2Jšœžœ˜—Jšœžœ˜ šžœ
žœ˜+J˜ZJšœ7žœ
˜;—Jšœ	žœ=˜IJšœžœ
žœ˜8Jšžœ
˜——J˜šŸœžœ
ž	œ˜.šžœ
žœ
˜š
œN˜Nšœžœžœžœž˜:J˜1——Jšžœ
˜—J˜—šŸœžœ
ž	œ˜/šžœ
žœ
˜š
œO˜Ošœžœžœžœž˜;J˜1——Jšžœ
˜——J˜šŸ	œžœ
žœ
ž	˜"Jšœžœ3žœ6˜Œ
šœ
žœ
žœ
˜š
œ@˜@J˜,šœžœžœžœž˜:J˜1——Jšžœ
˜——J˜šŸ
œžœ
ž	œžœ˜RJšœžœ
˜+šœ
žœ
žœ
˜š
œA˜A˜,šœžœžœžœž˜:J˜1———Jšžœ
˜——J˜šŸœžœ
ž	˜ JšœAžœ
˜PJšžœ
žœ
žœ
žœ˜2šœ
žœ
žœ
˜šžœr˜xšœžœžœžœž˜:J˜2——Jšžœ
˜——J˜šŸœžœ
ž	˜!Jšœ"žœ
žœžœ
˜Ušœ
žœ
žœ
˜š
œk˜kšœžœžœžœž˜:J˜1——Jšžœ
˜——J˜šŸœžœ
˜%Kš
œb˜bKšžœ+˜2šœ
žœ
žœ
˜šžœw˜}šœžœžœžœž˜:J˜2——Kšžœ
˜——K˜šŸœžœ
˜&KšœEžœ˜dšœ
žœ
ž˜š
œo˜ošœžœžœžœž˜:J˜1——Kšžœ
˜——K˜šŸ	œžœ
ž	˜Jšœžœžœ
˜@šœ
žœ
žœ
˜š
œb˜bšœžœžœžœž˜:J˜1——Jšžœ
˜——J˜šŸœžœ
ž	˜Jšœžœžœžœ˜Nšœ
žœ
žœ
˜Kš
œp˜pšœžœžœžœž˜:J˜1——Jšžœ
˜—J˜šŸœžœ&˜HKšžœžœ
˜šœžœ
ž˜KšÏt
œ 
™Kšžœ
˜——K˜šŸœžœ(˜KKšžœ?˜Fšœžœ
ž˜Kš 
œ 
™Kšžœ
˜——K˜š
Ÿœžœ
ž	œžœžœ˜Xšœ
žœ
žœ
˜šžœZ˜`šœžœžœžœž˜:J˜2——Jšžœ
˜——J˜š
Ÿ
œžœ
ž	œžœžœ
˜Ršœ
žœ
žœ
˜šžœW˜]šœžœžœžœž˜:J˜2——Jšžœ
˜——J˜šŸ
œžœ
ž	œžœ
˜Jšœžœ
žœ
˜š
œ\˜\šœžœžœžœž˜:J˜1——Jšžœ
˜——J˜šŸœžœ
ž	œ˜9Jšžœžœ˜+šž	œ
ž˜šžœ\˜bšœžœžœžœž˜:J˜2——Jšžœ
˜——J˜šŸœžœ
ž	œžœ˜Tšžœžœ
ž˜$šžœK˜QJ˜šœžœžœžœž˜:J˜2——Jšžœ
˜——J˜šŸœžœ
ž	œ'˜Lšžœžœ
ž˜$š
œo˜ošœžœžœžœž˜:J˜1——Jšžœ
˜——J˜š
Ÿœžœ
ž	œžœ
žœ˜Qšžœžœ
žœ
˜šžœW˜]šœžœžœžœž˜:J˜2——Jšžœ
˜——J˜š
Ÿœžœ
ž	œžœžœ˜Yšžœ
žœ
˜š
œ\˜\šœžœžœžœž˜:J˜1——Jšžœ
˜——J˜šŸœžœ
ž	œžœ˜Nšžœžœ
žœ
˜"š
œ˜J˜Yšœžœžœžœž˜:J˜1——Jšžœ
˜——J˜š
Ÿ
œžœ
ž	œžœ
žœ
˜Eš
œV˜Všœžœžœžœž˜:J˜1——Jšžœ
˜—J˜šŸœžœ
ž	œ!žœžœ
žœ
˜Xš
œd˜dšœžœžœžœž˜:J˜1——Jšžœ
˜J˜—š
Ÿ
œžœ
ž	œ(žœžœ˜Ušœ
žœ
žœ
˜š
œf˜fšœžœžœžœž˜:J˜1——Jšžœ
˜——J˜Jš
Ÿœžœ
žœžœžœ˜NJš
Ÿ
œžœ
žœžœžœ˜?Jš
Ÿœžœ
žœžœžœ˜NJšŸœžœ
žœžœ˜7Jš
Ÿœžœ
žœžœžœ	˜:Jš
Ÿœžœ
žœžœ
žœ˜>J˜J˜J˜šžœ
˜J˜—J˜JšŸœs˜zJ˜J˜J˜—…—).5ÿ