
<<AlpFileImpl.mesa>>
    <<Copyright © 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>>


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;


<<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].>>

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
            <<Body>>
            END;

    ValidateCachePageLocks: PUBLIC PROC [locks: AlpF.CachePageLockConversions] 
        RETURNS [locksGranted, locksNotGranted: AlpF.CachePageLockConversions]
        = TRUSTED BEGIN
            <<Body>>
            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.