DIRECTORY
Rope,
SunRPC,
UT,
UTGetPut,
LB,
LBGetPut;

LBGetPutImpl: CEDAR PROGRAM
IMPORTS SunRPC, UTGetPut  EXPORTS LB, LBGetPut =
BEGIN
Handle: TYPE = SunRPC.Handle;

ROPE: TYPE = Rope.ROPE;

ReturnCodesNames: PUBLIC ARRAY LB.ReturnCodes OF ROPE _ [
"iluSuccess",
"iluECantExportService",
"EError"
];

GetReturnCodes: PUBLIC PROC[h: Handle] RETURNS [res: LB.ReturnCodes] = {
res _ VAL[SunRPC.GetInt32[h]];
};

PutReturnCodes: PUBLIC PROC[h: Handle, in: LB.ReturnCodes] = {
SunRPC.PutInt32[h, ORD[in]];
};

GetLocRoom: PUBLIC PROC[h: Handle] RETURNS [res: LB.LocRoom] = {
res _ SunRPC.GetRope[h];
};

PutLocRoom: PUBLIC PROC[h: Handle, in: LB.LocRoom] = {
SunRPC.PutRope[h, in];
};

GetLocXYZ: PUBLIC PROC[h: Handle] RETURNS [res: LB.LocXYZ] = {
res.x _ SunRPC.GetDReal[h];
res.y _ SunRPC.GetDReal[h];
res.z _ SunRPC.GetDReal[h];
};

PutLocXYZ: PUBLIC PROC[h: Handle, in: LB.LocXYZ] = {
SunRPC.PutDReal[h, in.x];
SunRPC.PutDReal[h, in.y];
SunRPC.PutDReal[h, in.z];
};

LocationDescriminationValuesNames: PUBLIC ARRAY LB.LocationDescriminationValues OF ROPE _ [
"LocationVLocRoom",
"LocationVLocXYZ"
];

GetLocationDescriminationValues: PUBLIC PROC[h: Handle] RETURNS [res: LB.LocationDescriminationValues] = {
res _ VAL[SunRPC.GetInt32[h]];
};

PutLocationDescriminationValues: PUBLIC PROC[h: Handle, in: LB.LocationDescriminationValues] = {
SunRPC.PutInt32[h, ORD[in]];
};

GetLocation: PUBLIC PROC[h: Handle] RETURNS [res: LB.Location] = {
tag: LB.LocationDescriminationValues;
tag _ GetLocationDescriminationValues[h];
SELECT tag FROM
LocationVLocRoom => {
v: REF LocationVLocRoom LB.LocationObject _ NEW[LocationVLocRoom LB.LocationObject];
v.vLocRoom _ SunRPC.GetRope[h];
res _ v;
};
LocationVLocXYZ => {
v: REF LocationVLocXYZ LB.LocationObject _ NEW[LocationVLocXYZ LB.LocationObject];
v.vLocXYZ _ GetLocXYZ[h];
res _ v;
};
ENDCASE => NULL;
};

PutLocation: PUBLIC PROC[h: Handle, in: LB.Location] = {
PutLocationDescriminationValues[h, in.descriminator];
SELECT in.descriminator FROM
LocationVLocRoom => {
v: REF LocationVLocRoom LB.LocationObject _ NARROW[in];
SunRPC.PutRope[h, v.vLocRoom];
};
LocationVLocXYZ => {
v: REF LocationVLocXYZ LB.LocationObject _ NARROW[in];
PutLocXYZ[h, v.vLocXYZ];
};
ENDCASE => NULL;
};

GetSphere: PUBLIC PROC[h: Handle] RETURNS [res: LB.Sphere] = {
res.center _ GetLocXYZ[h];
res.radius _ SunRPC.GetDReal[h];
};

PutSphere: PUBLIC PROC[h: Handle, in: LB.Sphere] = {
PutLocXYZ[h, in.center];
SunRPC.PutDReal[h, in.radius];
};

BasicVolumeDescriminationValuesNames: PUBLIC ARRAY LB.BasicVolumeDescriminationValues OF ROPE _ [
"BasicVolumeVLocRoom",
"BasicVolumeVSphere"
];

GetBasicVolumeDescriminationValues: PUBLIC PROC[h: Handle] RETURNS [res: LB.BasicVolumeDescriminationValues] = {
res _ VAL[SunRPC.GetInt32[h]];
};

PutBasicVolumeDescriminationValues: PUBLIC PROC[h: Handle, in: LB.BasicVolumeDescriminationValues] = {
SunRPC.PutInt32[h, ORD[in]];
};

GetBasicVolume: PUBLIC PROC[h: Handle] RETURNS [res: LB.BasicVolume] = {
tag: LB.BasicVolumeDescriminationValues;
tag _ GetBasicVolumeDescriminationValues[h];
SELECT tag FROM
BasicVolumeVLocRoom => {
v: REF BasicVolumeVLocRoom LB.BasicVolumeObject _ NEW[BasicVolumeVLocRoom LB.BasicVolumeObject];
v.vLocRoom _ SunRPC.GetRope[h];
res _ v;
};
BasicVolumeVSphere => {
v: REF BasicVolumeVSphere LB.BasicVolumeObject _ NEW[BasicVolumeVSphere LB.BasicVolumeObject];
v.vSphere _ GetSphere[h];
res _ v;
};
ENDCASE => NULL;
};

PutBasicVolume: PUBLIC PROC[h: Handle, in: LB.BasicVolume] = {
PutBasicVolumeDescriminationValues[h, in.descriminator];
SELECT in.descriminator FROM
BasicVolumeVLocRoom => {
v: REF BasicVolumeVLocRoom LB.BasicVolumeObject _ NARROW[in];
SunRPC.PutRope[h, v.vLocRoom];
};
BasicVolumeVSphere => {
v: REF BasicVolumeVSphere LB.BasicVolumeObject _ NARROW[in];
PutSphere[h, v.vSphere];
};
ENDCASE => NULL;
};

GetVolume: PUBLIC PROC[h: Handle] RETURNS [res: LB.Volume] = {
{
len: INT _ SunRPC.GetInt32[h];
res _ NEW[LB.SeqType0Object[len]];
FOR i: INT IN [0..len) DO
res[i] _ GetBasicVolume[h];
ENDLOOP;
};
};

PutVolume: PUBLIC PROC[h: Handle, in: LB.Volume] = {
SunRPC.PutInt32[h, in.size];
FOR i: INT IN [0..in.size) DO
PutBasicVolume[h, in[i]];
ENDLOOP;
};

GetLocatedObject: PUBLIC PROC[h: Handle] RETURNS [res: LB.LocatedObject] = {
res.o _ UTGetPut.GetObjct[h];
res.l _ GetLocation[h];
};

PutLocatedObject: PUBLIC PROC[h: Handle, in: LB.LocatedObject] = {
UTGetPut.PutObjct[h, in.o];
PutLocation[h, in.l];
};

GetLocatedObjectSet: PUBLIC PROC[h: Handle] RETURNS [res: LB.LocatedObjectSet] = {
{
len: INT _ SunRPC.GetInt32[h];
res _ NEW[LB.SeqType1Object[len]];
FOR i: INT IN [0..len) DO
res[i] _ GetLocatedObject[h];
ENDLOOP;
};
};

PutLocatedObjectSet: PUBLIC PROC[h: Handle, in: LB.LocatedObjectSet] = {
SunRPC.PutInt32[h, in.size];
FOR i: INT IN [0..in.size) DO
PutLocatedObject[h, in[i]];
ENDLOOP;
};

ChangeOperationNames: PUBLIC ARRAY LB.ChangeOperation OF ROPE _ [
"Add",
"Delete"
];

GetChangeOperation: PUBLIC PROC[h: Handle] RETURNS [res: LB.ChangeOperation] = {
res _ VAL[SunRPC.GetInt32[h]];
};

PutChangeOperation: PUBLIC PROC[h: Handle, in: LB.ChangeOperation] = {
SunRPC.PutInt32[h, ORD[in]];
};

ErrorTypeNames: PUBLIC ARRAY LB.ErrorType OF ROPE _ [
"BadLoc",
"BadObject",
"BadCallback",
"BadRoom",
"BadRock",
"NotDescendantLoc",
"NotCompositeLoc"
];

GetErrorType: PUBLIC PROC[h: Handle] RETURNS [res: LB.ErrorType] = {
res _ VAL[SunRPC.GetInt32[h]];
};

PutErrorType: PUBLIC PROC[h: Handle, in: LB.ErrorType] = {
SunRPC.PutInt32[h, ORD[in]];
};

GetSimple: PUBLIC PROC[h: Handle] RETURNS [res: LB.Simple] = {
res _ SunRPC.GetRope[h];
};

PutSimple: PUBLIC PROC[h: Handle, in: LB.Simple] = {
SunRPC.PutRope[h, in];
};

GetString: PUBLIC PROC[h: Handle] RETURNS [res: LB.String] = {
res _ SunRPC.GetRope[h];
};

PutString: PUBLIC PROC[h: Handle, in: LB.String] = {
SunRPC.PutRope[h, in];
};

GetT: PUBLIC PROC[h: Handle] RETURNS [res: LB.T] = {
{
len: INT _ SunRPC.GetInt32[h];
res _ NEW[LB.SeqType2Object[len]];
FOR i: INT IN [0..len) DO
res[i] _ GetString[h];
ENDLOOP;
};
};

PutT: PUBLIC PROC[h: Handle, in: LB.T] = {
SunRPC.PutInt32[h, in.size];
FOR i: INT IN [0..in.size) DO
PutString[h, in[i]];
ENDLOOP;
};

GetSet: PUBLIC PROC[h: Handle] RETURNS [res: LB.Set] = {
{
len: INT _ SunRPC.GetInt32[h];
res _ NEW[LB.SeqType3Object[len]];
FOR i: INT IN [0..len) DO
res[i] _ GetT[h];
ENDLOOP;
};
};

PutSet: PUBLIC PROC[h: Handle, in: LB.Set] = {
SunRPC.PutInt32[h, in.size];
FOR i: INT IN [0..in.size) DO
PutT[h, in[i]];
ENDLOOP;
};

GetAtomic: PUBLIC PROC[h: Handle] RETURNS [res: LB.Atomic] = {
res _ SunRPC.GetRope[h];
};

PutAtomic: PUBLIC PROC[h: Handle, in: LB.Atomic] = {
SunRPC.PutRope[h, in];
};

GetDistance: PUBLIC PROC[h: Handle] RETURNS [res: LB.Distance] = {
res _ SunRPC.GetDReal[h];
};

PutDistance: PUBLIC PROC[h: Handle, in: LB.Distance] = {
SunRPC.PutDReal[h, in];
};

GetStep: PUBLIC PROC[h: Handle] RETURNS [res: LB.Step] = {
res.d _ GetDistance[h];
res.to _ SunRPC.GetRope[h];
};

PutStep: PUBLIC PROC[h: Handle, in: LB.Step] = {
PutDistance[h, in.d];
SunRPC.PutRope[h, in.to];
};

GetStepSeq: PUBLIC PROC[h: Handle] RETURNS [res: LB.StepSeq] = {
{
len: INT _ SunRPC.GetInt32[h];
res _ NEW[LB.SeqType4Object[len]];
FOR i: INT IN [0..len) DO
res[i] _ GetStep[h];
ENDLOOP;
};
};

PutStepSeq: PUBLIC PROC[h: Handle, in: LB.StepSeq] = {
SunRPC.PutInt32[h, in.size];
FOR i: INT IN [0..in.size) DO
PutStep[h, in[i]];
ENDLOOP;
};

GetPath: PUBLIC PROC[h: Handle] RETURNS [res: LB.Path] = {
res.frm _ SunRPC.GetRope[h];
res.d _ GetDistance[h];
res.steps _ GetStepSeq[h];
};

PutPath: PUBLIC PROC[h: Handle, in: LB.Path] = {
SunRPC.PutRope[h, in.frm];
PutDistance[h, in.d];
PutStepSeq[h, in.steps];
};

GetPathSet: PUBLIC PROC[h: Handle] RETURNS [res: LB.PathSet] = {
{
len: INT _ SunRPC.GetInt32[h];
res _ NEW[LB.SeqType5Object[len]];
FOR i: INT IN [0..len) DO
res[i] _ GetPath[h];
ENDLOOP;
};
};

PutPathSet: PUBLIC PROC[h: Handle, in: LB.PathSet] = {
SunRPC.PutInt32[h, in.size];
FOR i: INT IN [0..in.size) DO
PutPath[h, in[i]];
ENDLOOP;
};

GetPathSolution: PUBLIC PROC[h: Handle] RETURNS [res: LB.PathSolution] = {
res.dmin _ GetDistance[h];
res.dmax _ GetDistance[h];
res.ps _ GetPathSet[h];
};

PutPathSolution: PUBLIC PROC[h: Handle, in: LB.PathSolution] = {
PutDistance[h, in.dmin];
PutDistance[h, in.dmax];
PutPathSet[h, in.ps];
};

GetNearest: PUBLIC PROC[h: Handle] RETURNS [res: LB.Nearest] = {
res.to _ GetT[h];
res.paths _ GetPathSolution[h];
};

PutNearest: PUBLIC PROC[h: Handle, in: LB.Nearest] = {
PutT[h, in.to];
PutPathSolution[h, in.paths];
};

GetNearests: PUBLIC PROC[h: Handle] RETURNS [res: LB.Nearests] = {
{
len: INT _ SunRPC.GetInt32[h];
res _ NEW[LB.SeqType6Object[len]];
FOR i: INT IN [0..len) DO
res[i] _ GetNearest[h];
ENDLOOP;
};
};

PutNearests: PUBLIC PROC[h: Handle, in: LB.Nearests] = {
SunRPC.PutInt32[h, in.size];
FOR i: INT IN [0..in.size) DO
PutNearest[h, in[i]];
ENDLOOP;
};

GetAtLocargs: PUBLIC PROC[h: Handle] RETURNS [res: LB.AtLocargs] = {
res.o _ UTGetPut.GetObjct[h];
res.loc _ GetLocation[h];
};

PutAtLocargs: PUBLIC PROC[h: Handle, in: LB.AtLocargs] = {
UTGetPut.PutObjct[h, in.o];
PutLocation[h, in.loc];
};

GetAtLocreturn: PUBLIC PROC[h: Handle] RETURNS [res: LB.AtLocreturn] = {
tag: LB.ReturnCodes;
tag _ GetReturnCodes[h];
SELECT tag FROM
EError => {
v: REF EError LB.AtLocreturnObject _ NEW[EError LB.AtLocreturnObject];
v.EErrorValue _ GetErrorType[h];
res _ v;
};
iluSuccess => {
v: REF iluSuccess LB.AtLocreturnObject _ NEW[iluSuccess LB.AtLocreturnObject];
res _ v;
};
ENDCASE => NULL;
};

PutAtLocreturn: PUBLIC PROC[h: Handle, in: LB.AtLocreturn] = {
PutReturnCodes[h, in.returnCode];
SELECT in.returnCode FROM
EError => {
v: REF EError LB.AtLocreturnObject _ NARROW[in];
PutErrorType[h, v.EErrorValue];
};
iluSuccess => {
v: REF iluSuccess LB.AtLocreturnObject _ NARROW[in];
};
ENDCASE => NULL;
};

GetRemoveObjectargs: PUBLIC PROC[h: Handle] RETURNS [res: LB.RemoveObjectargs] = {
res.o _ UTGetPut.GetObjct[h];
};

PutRemoveObjectargs: PUBLIC PROC[h: Handle, in: LB.RemoveObjectargs] = {
UTGetPut.PutObjct[h, in.o];
};

GetRemoveObjectreturn: PUBLIC PROC[h: Handle] RETURNS [res: LB.RemoveObjectreturn] = {
tag: LB.ReturnCodes;
tag _ GetReturnCodes[h];
SELECT tag FROM
EError => {
v: REF EError LB.RemoveObjectreturnObject _ NEW[EError LB.RemoveObjectreturnObject];
v.EErrorValue _ GetErrorType[h];
res _ v;
};
iluSuccess => {
v: REF iluSuccess LB.RemoveObjectreturnObject _ NEW[iluSuccess LB.RemoveObjectreturnObject];
v.returnValue _ SunRPC.GetCard32[h];
res _ v;
};
ENDCASE => NULL;
};

PutRemoveObjectreturn: PUBLIC PROC[h: Handle, in: LB.RemoveObjectreturn] = {
PutReturnCodes[h, in.returnCode];
SELECT in.returnCode FROM
EError => {
v: REF EError LB.RemoveObjectreturnObject _ NARROW[in];
PutErrorType[h, v.EErrorValue];
};
iluSuccess => {
v: REF iluSuccess LB.RemoveObjectreturnObject _ NARROW[in];
SunRPC.PutCard32[h, v.returnValue];
};
ENDCASE => NULL;
};

GetFindObjectsargs: PUBLIC PROC[h: Handle] RETURNS [res: LB.FindObjectsargs] = {
res.locs _ GetVolume[h];
res.types _ UTGetPut.GetObjectTypeSet[h];
};

PutFindObjectsargs: PUBLIC PROC[h: Handle, in: LB.FindObjectsargs] = {
PutVolume[h, in.locs];
UTGetPut.PutObjectTypeSet[h, in.types];
};

GetFindObjectsreturn: PUBLIC PROC[h: Handle] RETURNS [res: LB.FindObjectsreturn] = {
tag: LB.ReturnCodes;
tag _ GetReturnCodes[h];
SELECT tag FROM
EError => {
v: REF EError LB.FindObjectsreturnObject _ NEW[EError LB.FindObjectsreturnObject];
v.EErrorValue _ GetErrorType[h];
res _ v;
};
iluSuccess => {
v: REF iluSuccess LB.FindObjectsreturnObject _ NEW[iluSuccess LB.FindObjectsreturnObject];
v.returnValue _ GetLocatedObjectSet[h];
res _ v;
};
ENDCASE => NULL;
};

PutFindObjectsreturn: PUBLIC PROC[h: Handle, in: LB.FindObjectsreturn] = {
PutReturnCodes[h, in.returnCode];
SELECT in.returnCode FROM
EError => {
v: REF EError LB.FindObjectsreturnObject _ NARROW[in];
PutErrorType[h, v.EErrorValue];
};
iluSuccess => {
v: REF iluSuccess LB.FindObjectsreturnObject _ NARROW[in];
PutLocatedObjectSet[h, v.returnValue];
};
ENDCASE => NULL;
};

GetNotifyOfObjectsargs: PUBLIC PROC[h: Handle] RETURNS [res: LB.NotifyOfObjectsargs] = {
res.locs _ GetVolume[h];
res.types _ UTGetPut.GetObjectTypeSet[h];
res.who _ SunRPC.GetRope[h];
res.rock _ UTGetPut.GetOPAQUE[h];
};

PutNotifyOfObjectsargs: PUBLIC PROC[h: Handle, in: LB.NotifyOfObjectsargs] = {
PutVolume[h, in.locs];
UTGetPut.PutObjectTypeSet[h, in.types];
SunRPC.PutRope[h, in.who];
UTGetPut.PutOPAQUE[h, in.rock];
};

GetNotifyOfObjectsreturn: PUBLIC PROC[h: Handle] RETURNS [res: LB.NotifyOfObjectsreturn] = {
tag: LB.ReturnCodes;
tag _ GetReturnCodes[h];
SELECT tag FROM
EError => {
v: REF EError LB.NotifyOfObjectsreturnObject _ NEW[EError LB.NotifyOfObjectsreturnObject];
v.EErrorValue _ GetErrorType[h];
res _ v;
};
iluSuccess => {
v: REF iluSuccess LB.NotifyOfObjectsreturnObject _ NEW[iluSuccess LB.NotifyOfObjectsreturnObject];
res _ v;
};
ENDCASE => NULL;
};

PutNotifyOfObjectsreturn: PUBLIC PROC[h: Handle, in: LB.NotifyOfObjectsreturn] = {
PutReturnCodes[h, in.returnCode];
SELECT in.returnCode FROM
EError => {
v: REF EError LB.NotifyOfObjectsreturnObject _ NARROW[in];
PutErrorType[h, v.EErrorValue];
};
iluSuccess => {
v: REF iluSuccess LB.NotifyOfObjectsreturnObject _ NARROW[in];
};
ENDCASE => NULL;
};

GetRemoveObjectCallbackargs: PUBLIC PROC[h: Handle] RETURNS [res: LB.RemoveObjectCallbackargs] = {
res.who _ SunRPC.GetRope[h];
res.rock _ UTGetPut.GetOPAQUE[h];
};

PutRemoveObjectCallbackargs: PUBLIC PROC[h: Handle, in: LB.RemoveObjectCallbackargs] = {
SunRPC.PutRope[h, in.who];
UTGetPut.PutOPAQUE[h, in.rock];
};

GetRemoveObjectCallbackreturn: PUBLIC PROC[h: Handle] RETURNS [res: LB.RemoveObjectCallbackreturn] = {
tag: LB.ReturnCodes;
tag _ GetReturnCodes[h];
SELECT tag FROM
EError => {
v: REF EError LB.RemoveObjectCallbackreturnObject _ NEW[EError LB.RemoveObjectCallbackreturnObject];
v.EErrorValue _ GetErrorType[h];
res _ v;
};
iluSuccess => {
v: REF iluSuccess LB.RemoveObjectCallbackreturnObject _ NEW[iluSuccess LB.RemoveObjectCallbackreturnObject];
res _ v;
};
ENDCASE => NULL;
};

PutRemoveObjectCallbackreturn: PUBLIC PROC[h: Handle, in: LB.RemoveObjectCallbackreturn] = {
PutReturnCodes[h, in.returnCode];
SELECT in.returnCode FROM
EError => {
v: REF EError LB.RemoveObjectCallbackreturnObject _ NARROW[in];
PutErrorType[h, v.EErrorValue];
};
iluSuccess => {
v: REF iluSuccess LB.RemoveObjectCallbackreturnObject _ NARROW[in];
};
ENDCASE => NULL;
};

GetParentargs: PUBLIC PROC[h: Handle] RETURNS [res: LB.Parentargs] = {
res.l _ SunRPC.GetRope[h];
};

PutParentargs: PUBLIC PROC[h: Handle, in: LB.Parentargs] = {
SunRPC.PutRope[h, in.l];
};

GetParentreturn: PUBLIC PROC[h: Handle] RETURNS [res: LB.Parentreturn] = {
tag: LB.ReturnCodes;
tag _ GetReturnCodes[h];
SELECT tag FROM
EError => {
v: REF EError LB.ParentreturnObject _ NEW[EError LB.ParentreturnObject];
v.EErrorValue _ GetErrorType[h];
res _ v;
};
iluSuccess => {
v: REF iluSuccess LB.ParentreturnObject _ NEW[iluSuccess LB.ParentreturnObject];
v.returnValue _ SunRPC.GetRope[h];
res _ v;
};
ENDCASE => NULL;
};

PutParentreturn: PUBLIC PROC[h: Handle, in: LB.Parentreturn] = {
PutReturnCodes[h, in.returnCode];
SELECT in.returnCode FROM
EError => {
v: REF EError LB.ParentreturnObject _ NARROW[in];
PutErrorType[h, v.EErrorValue];
};
iluSuccess => {
v: REF iluSuccess LB.ParentreturnObject _ NARROW[in];
SunRPC.PutRope[h, v.returnValue];
};
ENDCASE => NULL;
};

GetChildrenargs: PUBLIC PROC[h: Handle] RETURNS [res: LB.Childrenargs] = {
res.l _ SunRPC.GetRope[h];
};

PutChildrenargs: PUBLIC PROC[h: Handle, in: LB.Childrenargs] = {
SunRPC.PutRope[h, in.l];
};

GetChildrenreturn: PUBLIC PROC[h: Handle] RETURNS [res: LB.Childrenreturn] = {
tag: LB.ReturnCodes;
tag _ GetReturnCodes[h];
SELECT tag FROM
EError => {
v: REF EError LB.ChildrenreturnObject _ NEW[EError LB.ChildrenreturnObject];
v.EErrorValue _ GetErrorType[h];
res _ v;
};
iluSuccess => {
v: REF iluSuccess LB.ChildrenreturnObject _ NEW[iluSuccess LB.ChildrenreturnObject];
v.returnValue _ GetSet[h];
res _ v;
};
ENDCASE => NULL;
};

PutChildrenreturn: PUBLIC PROC[h: Handle, in: LB.Childrenreturn] = {
PutReturnCodes[h, in.returnCode];
SELECT in.returnCode FROM
EError => {
v: REF EError LB.ChildrenreturnObject _ NARROW[in];
PutErrorType[h, v.EErrorValue];
};
iluSuccess => {
v: REF iluSuccess LB.ChildrenreturnObject _ NARROW[in];
PutSet[h, v.returnValue];
};
ENDCASE => NULL;
};

GetShortestPathsargs: PUBLIC PROC[h: Handle] RETURNS [res: LB.ShortestPathsargs] = {
res.frm _ GetT[h];
res.to _ GetT[h];
res.wantPaths _ SunRPC.GetCard32[h];
};

PutShortestPathsargs: PUBLIC PROC[h: Handle, in: LB.ShortestPathsargs] = {
PutT[h, in.frm];
PutT[h, in.to];
SunRPC.PutCard32[h, in.wantPaths];
};

GetShortestPathsreturn: PUBLIC PROC[h: Handle] RETURNS [res: LB.ShortestPathsreturn] = {
tag: LB.ReturnCodes;
tag _ GetReturnCodes[h];
SELECT tag FROM
EError => {
v: REF EError LB.ShortestPathsreturnObject _ NEW[EError LB.ShortestPathsreturnObject];
v.EErrorValue _ GetErrorType[h];
res _ v;
};
iluSuccess => {
v: REF iluSuccess LB.ShortestPathsreturnObject _ NEW[iluSuccess LB.ShortestPathsreturnObject];
v.returnValue _ GetPathSolution[h];
res _ v;
};
ENDCASE => NULL;
};

PutShortestPathsreturn: PUBLIC PROC[h: Handle, in: LB.ShortestPathsreturn] = {
PutReturnCodes[h, in.returnCode];
SELECT in.returnCode FROM
EError => {
v: REF EError LB.ShortestPathsreturnObject _ NARROW[in];
PutErrorType[h, v.EErrorValue];
};
iluSuccess => {
v: REF iluSuccess LB.ShortestPathsreturnObject _ NARROW[in];
PutPathSolution[h, v.returnValue];
};
ENDCASE => NULL;
};

GetFindNearestsargs: PUBLIC PROC[h: Handle] RETURNS [res: LB.FindNearestsargs] = {
res.frm _ GetT[h];
res.to _ GetSet[h];
res.wantPaths _ SunRPC.GetCard32[h];
};

PutFindNearestsargs: PUBLIC PROC[h: Handle, in: LB.FindNearestsargs] = {
PutT[h, in.frm];
PutSet[h, in.to];
SunRPC.PutCard32[h, in.wantPaths];
};

GetFindNearestsreturn: PUBLIC PROC[h: Handle] RETURNS [res: LB.FindNearestsreturn] = {
tag: LB.ReturnCodes;
tag _ GetReturnCodes[h];
SELECT tag FROM
EError => {
v: REF EError LB.FindNearestsreturnObject _ NEW[EError LB.FindNearestsreturnObject];
v.EErrorValue _ GetErrorType[h];
res _ v;
};
iluSuccess => {
v: REF iluSuccess LB.FindNearestsreturnObject _ NEW[iluSuccess LB.FindNearestsreturnObject];
v.returnValue _ GetNearests[h];
res _ v;
};
ENDCASE => NULL;
};

PutFindNearestsreturn: PUBLIC PROC[h: Handle, in: LB.FindNearestsreturn] = {
PutReturnCodes[h, in.returnCode];
SELECT in.returnCode FROM
EError => {
v: REF EError LB.FindNearestsreturnObject _ NARROW[in];
PutErrorType[h, v.EErrorValue];
};
iluSuccess => {
v: REF iluSuccess LB.FindNearestsreturnObject _ NARROW[in];
PutNearests[h, v.returnValue];
};
ENDCASE => NULL;
};

GetFindNearestsOfKindargs: PUBLIC PROC[h: Handle] RETURNS [res: LB.FindNearestsOfKindargs] = {
res.frm _ GetT[h];
res.kind _ SunRPC.GetRope[h];
res.description _ UTGetPut.GetObjectDescription[h];
res.wantPaths _ SunRPC.GetCard32[h];
};

PutFindNearestsOfKindargs: PUBLIC PROC[h: Handle, in: LB.FindNearestsOfKindargs] = {
PutT[h, in.frm];
SunRPC.PutRope[h, in.kind];
UTGetPut.PutObjectDescription[h, in.description];
SunRPC.PutCard32[h, in.wantPaths];
};

GetFindNearestsOfKindreturn: PUBLIC PROC[h: Handle] RETURNS [res: LB.FindNearestsOfKindreturn] = {
tag: LB.ReturnCodes;
tag _ GetReturnCodes[h];
SELECT tag FROM
EError => {
v: REF EError LB.FindNearestsOfKindreturnObject _ NEW[EError LB.FindNearestsOfKindreturnObject];
v.EErrorValue _ GetErrorType[h];
res _ v;
};
iluSuccess => {
v: REF iluSuccess LB.FindNearestsOfKindreturnObject _ NEW[iluSuccess LB.FindNearestsOfKindreturnObject];
v.returnValue _ GetNearests[h];
res _ v;
};
ENDCASE => NULL;
};

PutFindNearestsOfKindreturn: PUBLIC PROC[h: Handle, in: LB.FindNearestsOfKindreturn] = {
PutReturnCodes[h, in.returnCode];
SELECT in.returnCode FROM
EError => {
v: REF EError LB.FindNearestsOfKindreturnObject _ NARROW[in];
PutErrorType[h, v.EErrorValue];
};
iluSuccess => {
v: REF iluSuccess LB.FindNearestsOfKindreturnObject _ NARROW[in];
PutNearests[h, v.returnValue];
};
ENDCASE => NULL;
};

GetNotifyObjectsCallbackargs: PUBLIC PROC[h: Handle] RETURNS [res: LB.NotifyObjectsCallbackargs] = {
res.rock _ UTGetPut.GetOPAQUE[h];
res.os _ GetLocatedObjectSet[h];
res.change _ GetChangeOperation[h];
};

PutNotifyObjectsCallbackargs: PUBLIC PROC[h: Handle, in: LB.NotifyObjectsCallbackargs] = {
UTGetPut.PutOPAQUE[h, in.rock];
PutLocatedObjectSet[h, in.os];
PutChangeOperation[h, in.change];
};

GetNotifyObjectsCallbackreturn: PUBLIC PROC[h: Handle] RETURNS [res: LB.NotifyObjectsCallbackreturn] = {
tag: LB.ReturnCodes;
tag _ GetReturnCodes[h];
SELECT tag FROM
EError => {
v: REF EError LB.NotifyObjectsCallbackreturnObject _ NEW[EError LB.NotifyObjectsCallbackreturnObject];
v.EErrorValue _ GetErrorType[h];
res _ v;
};
iluSuccess => {
v: REF iluSuccess LB.NotifyObjectsCallbackreturnObject _ NEW[iluSuccess LB.NotifyObjectsCallbackreturnObject];
res _ v;
};
ENDCASE => NULL;
};

PutNotifyObjectsCallbackreturn: PUBLIC PROC[h: Handle, in: LB.NotifyObjectsCallbackreturn] = {
PutReturnCodes[h, in.returnCode];
SELECT in.returnCode FROM
EError => {
v: REF EError LB.NotifyObjectsCallbackreturnObject _ NARROW[in];
PutErrorType[h, v.EErrorValue];
};
iluSuccess => {
v: REF iluSuccess LB.NotifyObjectsCallbackreturnObject _ NARROW[in];
};
ENDCASE => NULL;
};

END.
\
LBGetPutImpl.mesa
Please do not edit this file.
It was generated using CedarRPCGen.
�ʕNewlineDelimiter

™J™J™J™#J˜š
Ïk	˜	J˜J˜Jš�œ
˜J˜	Jš�œ
˜J˜	J˜—šÏnœ�œ
�˜Jš�œ�œ
�œ˜0—Jš
�˜Jšœ�œ˜J˜Jš�œ�œ�œ
˜J˜šžœ�œ
�œ
�œ
�œ
�œ˜9J˜
J˜J˜J˜J˜—š
žœ�œ
�œ�œ�œ˜HJšœ�œ˜J˜J˜—šžœ�œ
�œ�œ˜>Jšœ�œ˜J˜J˜—š
ž
œ�œ
�œ�œ�œ
˜@J˜J˜J˜—šž
œ�œ
�œ�œ
˜6J˜J˜J˜—š
ž	œ�œ
�œ�œ�œ˜>J˜J˜J˜J˜J˜—šž	œ�œ
�œ�œ˜4J˜J˜J˜J˜J˜—šž!œ�œ
�œ
�œ�œ
�œ˜[J˜J˜J˜J˜—š
žœ�œ
�œ�œ�œ"˜jJšœ�œ˜J˜J˜—šžœ�œ
�œ�œ"˜`Jšœ�œ˜J˜J˜—š
žœ�œ
�œ�œ�œ˜BJšœ�œ˜%J˜)š�œ�˜˜Jš	œ�œ�œ�œ�œ˜TJ˜J˜J˜—˜Jš	œ�œ�œ�œ�œ˜RJ˜J˜J˜—Jš�œ�œ
˜—J˜J˜—šžœ�œ
�œ�œ˜8J˜5š�œ�˜˜Jšœ�œ�œ�œ˜7J˜J˜—˜Jšœ�œ�œ�œ˜6J˜J˜—Jš�œ�œ
˜—J˜J˜—š
ž	œ�œ
�œ�œ�œ˜>J˜J˜ J˜J˜—šž	œ�œ
�œ�œ˜4J˜J˜J˜J˜—šž$œ�œ
�œ
�œ!�œ
�œ˜aJ˜J˜J˜J˜—š
ž"œ�œ
�œ�œ�œ%˜pJšœ�œ˜J˜J˜—šž"œ�œ
�œ�œ%˜fJšœ�œ˜J˜J˜—š
žœ�œ
�œ�œ�œ˜HJšœ�œ!˜(J˜,š�œ�˜˜Jš	œ�œ�œ�œ�œ˜`J˜J˜J˜—˜Jš	œ�œ�œ�œ�œ˜^J˜J˜J˜—Jš�œ�œ
˜—J˜J˜—šžœ�œ
�œ�œ˜>J˜8š�œ�˜˜Jšœ�œ�œ�œ˜=J˜J˜—˜Jšœ�œ�œ�œ˜<J˜J˜—Jš�œ�œ
˜—J˜J˜—š
ž	œ�œ
�œ�œ�œ˜>J˜
Jšœ�œ˜Jšœ�œ
�œ˜"š�œ�œ
�œ
�˜J˜Jš�œ
˜—J˜J˜J˜—šž	œ�œ
�œ�œ˜4J˜š�œ�œ
�œ�˜J˜Jš�œ
˜—J˜J˜—š
žœ�œ
�œ�œ�œ˜LJ˜J˜J˜J˜—šžœ�œ
�œ�œ˜BJ˜J˜J˜J˜—š
žœ�œ
�œ�œ�œ˜RJ˜
Jšœ�œ˜Jšœ�œ
�œ˜"š�œ�œ
�œ
�˜J˜Jš�œ
˜—J˜J˜J˜—šžœ�œ
�œ�œ˜HJ˜š�œ�œ
�œ�˜J˜Jš�œ
˜—J˜J˜—šžœ�œ
�œ
�œ�œ
�œ˜AJ˜J˜J˜J˜—š
žœ�œ
�œ�œ�œ˜PJšœ�œ˜J˜J˜—šžœ�œ
�œ�œ˜FJšœ�œ˜J˜J˜—šžœ�œ
�œ
�œ�œ
�œ˜5J˜	J˜J˜J˜
J˜
J˜J˜J˜J˜—š
žœ�œ
�œ�œ�œ˜DJšœ�œ˜J˜J˜—šžœ�œ
�œ�œ˜:Jšœ�œ˜J˜J˜—š
ž	œ�œ
�œ�œ�œ˜>J˜J˜J˜—šž	œ�œ
�œ�œ˜4J˜J˜J˜—š
ž	œ�œ
�œ�œ�œ˜>J˜J˜J˜—šž	œ�œ
�œ�œ˜4J˜J˜J˜—š
žœ�œ
�œ�œ�œ˜4J˜
Jšœ�œ˜Jšœ�œ
�œ˜"š�œ�œ
�œ
�˜J˜Jš�œ
˜—J˜J˜J˜—šžœ�œ
�œ�œ˜*J˜š�œ�œ
�œ�˜J˜Jš�œ
˜—J˜J˜—š
žœ�œ
�œ�œ�œ	˜8J˜
Jšœ�œ˜Jšœ�œ
�œ˜"š�œ�œ
�œ
�˜J˜Jš�œ
˜—J˜J˜J˜—šžœ�œ
�œ�œ	˜.J˜š�œ�œ
�œ�˜J˜Jš�œ
˜—J˜J˜—š
ž	œ�œ
�œ�œ�œ˜>J˜J˜J˜—šž	œ�œ
�œ�œ˜4J˜J˜J˜—š
žœ�œ
�œ�œ�œ˜BJ˜J˜J˜—šžœ�œ
�œ�œ˜8J˜J˜J˜—š
žœ�œ
�œ�œ�œ
˜:J˜J˜J˜J˜—šžœ�œ
�œ�œ
˜0J˜J˜J˜J˜—š
ž
œ�œ
�œ�œ�œ
˜@J˜
Jšœ�œ˜Jšœ�œ
�œ˜"š�œ�œ
�œ
�˜J˜Jš�œ
˜—J˜J˜J˜—šž
œ�œ
�œ�œ
˜6J˜š�œ�œ
�œ�˜J˜Jš�œ
˜—J˜J˜—š
žœ�œ
�œ�œ�œ
˜:J˜J˜J˜J˜J˜—šžœ�œ
�œ�œ
˜0J˜J˜J˜J˜J˜—š
ž
œ�œ
�œ�œ�œ
˜@J˜
Jšœ�œ˜Jšœ�œ
�œ˜"š�œ�œ
�œ
�˜J˜Jš�œ
˜—J˜J˜J˜—šž
œ�œ
�œ�œ
˜6J˜š�œ�œ
�œ�˜J˜Jš�œ
˜—J˜J˜—š
žœ�œ
�œ�œ�œ˜JJ˜J˜J˜J˜J˜—šžœ�œ
�œ�œ˜@J˜J˜J˜J˜J˜—š
ž
œ�œ
�œ�œ�œ
˜@J˜J˜J˜J˜—šž
œ�œ
�œ�œ
˜6J˜J˜J˜J˜—š
žœ�œ
�œ�œ�œ˜BJ˜
Jšœ�œ˜Jšœ�œ
�œ˜"š�œ�œ
�œ
�˜J˜Jš�œ
˜—J˜J˜J˜—šžœ�œ
�œ�œ˜8J˜š�œ�œ
�œ�˜J˜Jš�œ
˜—J˜J˜—š
žœ�œ
�œ�œ�œ˜DJ˜J˜J˜J˜—šžœ�œ
�œ�œ˜:J˜J˜J˜J˜—š
žœ�œ
�œ�œ�œ˜HJšœ�œ
˜J˜š�œ�˜˜Jš	œ�œ�œ�œ�œ˜FJ˜ J˜J˜—˜Jš	œ�œ�œ�œ�œ˜NJ˜J˜—Jš�œ�œ
˜—J˜J˜—šžœ�œ
�œ�œ˜>J˜!š�œ�˜˜Jšœ�œ�œ�œ˜0J˜J˜—˜Jšœ�œ�œ�œ˜4J˜—Jš�œ�œ
˜—J˜J˜—š
žœ�œ
�œ�œ�œ˜RJ˜J˜J˜—šžœ�œ
�œ�œ˜HJ˜J˜J˜—š
žœ�œ
�œ�œ�œ˜VJšœ�œ
˜J˜š�œ�˜˜Jš	œ�œ�œ�œ�œ˜TJ˜ J˜J˜—˜Jš	œ�œ�œ�œ�œ˜\J˜$J˜J˜—Jš�œ�œ
˜—J˜J˜—šžœ�œ
�œ�œ˜LJ˜!š�œ�˜˜Jšœ�œ�œ�œ˜7J˜J˜—˜Jšœ�œ�œ�œ˜;J˜#J˜—Jš�œ�œ
˜—J˜J˜—š
žœ�œ
�œ�œ�œ˜PJ˜J˜)J˜J˜—šžœ�œ
�œ�œ˜FJ˜J˜'J˜J˜—š
žœ�œ
�œ�œ�œ˜TJšœ�œ
˜J˜š�œ�˜˜Jš	œ�œ�œ�œ�œ˜RJ˜ J˜J˜—˜Jš	œ�œ�œ�œ�œ˜ZJ˜'J˜J˜—Jš�œ�œ
˜—J˜J˜—šžœ�œ
�œ�œ˜JJ˜!š�œ�˜˜Jšœ�œ�œ�œ˜6J˜J˜—˜Jšœ�œ�œ�œ˜:J˜&J˜—Jš�œ�œ
˜—J˜J˜—š
žœ�œ
�œ�œ�œ˜XJ˜J˜)J˜J˜!J˜J˜—šžœ�œ
�œ�œ˜NJ˜J˜'J˜J˜J˜J˜—š
žœ�œ
�œ�œ�œ˜\Jšœ�œ
˜J˜š�œ�˜˜Jš	œ�œ�œ�œ�œ˜ZJ˜ J˜J˜—˜Jš	œ�œ�œ�œ�œ˜bJ˜J˜—Jš�œ�œ
˜—J˜J˜—šžœ�œ
�œ�œ˜RJ˜!š�œ�˜˜Jšœ�œ�œ�œ˜:J˜J˜—˜Jšœ�œ�œ�œ˜>J˜—Jš�œ�œ
˜—J˜J˜—š
žœ�œ
�œ�œ�œ˜bJ˜J˜!J˜J˜—šžœ�œ
�œ�œ˜XJ˜J˜J˜J˜—š
žœ�œ
�œ�œ�œ ˜fJšœ�œ
˜J˜š�œ�˜˜Jš	œ�œ�œ$�œ�œ#˜dJ˜ J˜J˜—˜Jš	œ�œ�œ$�œ�œ#˜lJ˜J˜—Jš�œ�œ
˜—J˜J˜—šžœ�œ
�œ�œ ˜\J˜!š�œ�˜˜Jšœ�œ�œ$�œ˜?J˜J˜—˜Jšœ�œ�œ$�œ˜CJ˜—Jš�œ�œ
˜—J˜J˜—š
ž
œ�œ
�œ�œ�œ˜FJ˜J˜J˜—šž
œ�œ
�œ�œ˜<J˜J˜J˜—š
žœ�œ
�œ�œ�œ˜JJšœ�œ
˜J˜š�œ�˜˜Jš	œ�œ�œ�œ�œ˜HJ˜ J˜J˜—˜Jš	œ�œ�œ�œ�œ˜PJ˜"J˜J˜—Jš�œ�œ
˜—J˜J˜—šžœ�œ
�œ�œ˜@J˜!š�œ�˜˜Jšœ�œ�œ�œ˜1J˜J˜—˜Jšœ�œ�œ�œ˜5J˜!J˜—Jš�œ�œ
˜—J˜J˜—š
žœ�œ
�œ�œ�œ˜JJ˜J˜J˜—šžœ�œ
�œ�œ˜@J˜J˜J˜—š
žœ�œ
�œ�œ�œ˜NJšœ�œ
˜J˜š�œ�˜˜Jš	œ�œ�œ�œ�œ˜LJ˜ J˜J˜—˜Jš	œ�œ�œ�œ�œ˜TJ˜J˜J˜—Jš�œ�œ
˜—J˜J˜—šžœ�œ
�œ�œ˜DJ˜!š�œ�˜˜Jšœ�œ�œ�œ˜3J˜J˜—˜Jšœ�œ�œ�œ˜7J˜J˜—Jš�œ�œ
˜—J˜J˜—š
žœ�œ
�œ�œ�œ˜TJ˜J˜J˜$J˜J˜—šžœ�œ
�œ�œ˜JJ˜J˜J˜"J˜J˜—š
žœ�œ
�œ�œ�œ˜XJšœ�œ
˜J˜š�œ�˜˜Jš	œ�œ�œ�œ�œ˜VJ˜ J˜J˜—˜Jš	œ�œ�œ�œ�œ˜^J˜#J˜J˜—Jš�œ�œ
˜—J˜J˜—šžœ�œ
�œ�œ˜NJ˜!š�œ�˜˜Jšœ�œ�œ�œ˜8J˜J˜—˜Jšœ�œ�œ�œ˜<J˜"J˜—Jš�œ�œ
˜—J˜J˜—š
žœ�œ
�œ�œ�œ˜RJ˜J˜J˜$J˜J˜—šžœ�œ
�œ�œ˜HJ˜J˜J˜"J˜J˜—š
žœ�œ
�œ�œ�œ˜VJšœ�œ
˜J˜š�œ�˜˜Jš	œ�œ�œ�œ�œ˜TJ˜ J˜J˜—˜Jš	œ�œ�œ�œ�œ˜\J˜J˜J˜—Jš�œ�œ
˜—J˜J˜—šžœ�œ
�œ�œ˜LJ˜!š�œ�˜˜Jšœ�œ�œ�œ˜7J˜J˜—˜Jšœ�œ�œ�œ˜;J˜J˜—Jš�œ�œ
˜—J˜J˜—š
žœ�œ
�œ�œ�œ˜^J˜J˜J˜3J˜$J˜J˜—šžœ�œ
�œ�œ˜TJ˜J˜J˜1J˜"J˜J˜—š
žœ�œ
�œ�œ�œ˜bJšœ�œ
˜J˜š�œ�˜˜Jš	œ�œ�œ"�œ�œ!˜`J˜ J˜J˜—˜Jš	œ�œ�œ"�œ�œ!˜hJ˜J˜J˜—Jš�œ�œ
˜—J˜J˜—šžœ�œ
�œ�œ˜XJ˜!š�œ�˜˜Jšœ�œ�œ"�œ˜=J˜J˜—˜Jšœ�œ�œ"�œ˜AJ˜J˜—Jš�œ�œ
˜—J˜J˜—š
žœ�œ
�œ�œ�œ˜dJ˜!J˜ J˜#J˜J˜—šžœ�œ
�œ�œ˜ZJ˜J˜J˜!J˜J˜—š
žœ�œ
�œ�œ�œ!˜hJšœ�œ
˜J˜š�œ�˜˜Jš	œ�œ�œ%�œ�œ$˜fJ˜ J˜J˜—˜Jš	œ�œ�œ%�œ�œ$˜nJ˜J˜—Jš�œ�œ
˜—J˜J˜—šžœ�œ
�œ�œ!˜^J˜!š�œ�˜˜Jšœ�œ�œ%�œ˜@J˜J˜—˜Jšœ�œ�œ%�œ˜DJ˜—Jš�œ�œ
˜—J˜J˜—Jš�œ
˜—…—S<nŸ