
<<PipalMosIOImpl.mesa    >>
    <<Copyright Ó 1986, 1987, 1988 by Xerox Corporation.  All rights reserved.>>
    <<Bertrand Serlet March 31, 1988 10:06:01 pm PST>>
    <<Barth, December 4, 1986 6:01:02 pm PST>>

DIRECTORY 
Core, CoreIO, 
Pipal, PipalInt, PipalMos, PipalIO, PipalMosIO;

PipalMosIOImpl: CEDAR PROGRAM 
IMPORTS CoreIO, Pipal, PipalInt, PipalIO, PipalMos =
BEGIN OPEN CoreIO, PipalIO;
<<Utility>>
    ReadObjects: PROC [h: Handle, size: NAT] RETURNS [objects: Pipal.Objects _ NIL] = {
        THROUGH [0 .. size) DO objects _ CONS [ReadObject[h], objects] ENDLOOP;
        RETURN [Pipal.Reverse[objects]];
        };
<<Overlay>>
    WriteOverlay: ClassWriteProc = {
        overlay: Pipal.Overlay _ NARROW [object];
        WriteInt[h, overlay.size];
        FOR i: NAT IN [0 .. overlay.size) DO WriteObject[h, overlay[i]] ENDLOOP;
        };

    ReadOverlay: ClassReadProc = {
        size: NAT = ReadInt[h];
        object _ Pipal.CreateOverlay[ReadObjects[h, size]];
        };
<<Icon>>
    WriteIcon: ClassWriteProc = {
        icon: Pipal.Icon _ NARROW [object];
        WriteObject[h, icon.reference]; WriteObject[h, icon.referent];
        };

    ReadIcon: ClassReadProc = {
        reference: Pipal.Object _ ReadObject[h];
        referent: Pipal.Object _ ReadObject[h];
        object _ Pipal.CreateIcon[reference, referent];
        };
<<Annotation>>
    WriteAnnotation: ClassWriteProc = {
        annotation: Pipal.Annotation _ NARROW [object];
        WriteAtom[h, annotation.key];
    IF annotation.value=NIL 
    THEN WriteAtom[h, $Nil] 
    ELSE WITH annotation.value SELECT FROM
    atom: ATOM    => {
    WriteAtom[h, $Atom];
    WriteAtom[h, atom];
    };
    rope: Pipal.ROPE    => {
    WriteAtom[h, $Rope];
    WriteRope[h, rope];
    };
    refRect: REF PipalInt.Rectangle => {
    WriteAtom[h, $Rectangle];
    WriteRectangle[h, refRect^];
    };
    ENDCASE    => ERROR;
        WriteObject[h, annotation.child];
        };

    ReadAnnotation: ClassReadProc = {
        key: ATOM _ ReadAtom[h];
        valueKey: ATOM _ ReadAtom[h];
        value: REF _ SELECT valueKey FROM
        $Nil            => NIL,
        $Atom        => ReadAtom[h],
        $Rope            => ReadRope[h],
        $Rectangle    => NEW [PipalInt.Rectangle _ ReadRectangle[h]],
        ENDCASE        => ERROR;
        object _ Pipal.CreateAnnotation[ReadObject[h], key, value];
        };
<<All Transformations>>
    WriteTransform: ClassWriteProc = {
    trans: PipalInt.Transformation;
    sub: Pipal.Object _ NIL;
    EachChild: PipalInt.EachChildProc = {
    IF sub#NIL THEN ERROR;
    sub _ child; trans _ transformation;
    };
    IF PipalInt.Enumerate[object, EachChild] THEN ERROR;
    IF sub=NIL THEN ERROR;
    WriteTransformation[h, trans];
        WriteObject[h, sub];
        };

    ReadTransform: ClassReadProc = {
        transformation: PipalInt.Transformation _ ReadTransformation[h];
        object _ PipalInt.TransformObject[transformation, ReadObject[h]];
        };
<<Abut>>
    WriteAbut: ClassWriteProc = {
        abut: PipalInt.Abut _ NARROW [object];
        WriteBool[h, abut.inX];
        WriteInt[h, abut.size];
        FOR i: NAT IN [0 .. abut.size) DO WriteObject[h, abut[i]] ENDLOOP;
        };

    ReadAbut: ClassReadProc = {
        inX: BOOL = ReadBool[h];
        size: NAT = ReadInt[h];
        object _ PipalInt.CreateAbut[inX, ReadObjects[h, size]];
        };
<<Box>>
    WriteBox: ClassWriteProc = {
        box: PipalMos.Box = NARROW [object];
        WriteVector[h, box.size];
        WriteAtom[h, box.layer];
        };

    ReadBox: ClassReadProc = {
        size: PipalInt.Size = ReadVector[h];
        layer: PipalMos.Layer = ReadAtom[h];
        RETURN [PipalMos.CreateBox[size, layer]]
        };
<<Star>>
    WriteStar: ClassWriteProc = {
        star: PipalMos.Star _ NARROW [object];
        WriteBool[h, star.overlayStar];
        WriteObject[h, star.master];
        WriteInt[h, star.size];
        FOR i: NAT IN [0 .. star.size) DO WriteObject[h, star[i]] ENDLOOP;
        };

    ReadStar: ClassReadProc = {
    overlayStar: BOOL _ ReadBool[h];
    master: Pipal.Object _ ReadObject[h];
        size: NAT = ReadInt[h];
        object _ PipalMos.CreateStar[master, ReadObjects[h, size], overlayStar];
        };
<<Routing>>
    WriteRouting: ClassWriteProc = {
        routing: PipalMos.Routing _ NARROW [object];
        WriteInt[h, routing.size];
        FOR i: NAT IN [0 .. routing.size) DO WriteObject[h, routing[i]] ENDLOOP;
        };

    ReadRouting: ClassReadProc = {
        size: NAT = ReadInt[h];
        object _ PipalMos.CreateRouting[ReadObjects[h, size]];
        };
<<Tiling>>
    WriteTiling: ClassWriteProc = {
        tiling: PipalMos.Tiling _ NARROW [object];
    WriteInt[h, tiling.sizeX];
    WriteInt[h, tiling.sizeY];
        FOR y: NAT IN [0 .. tiling.sizeY) DO
            FOR x: NAT IN [0 .. tiling.sizeX) DO WriteObject[h, tiling.xyTile[x, y, tiling.data]] ENDLOOP;
            ENDLOOP;
        };

    TileArrayRec: TYPE = RECORD [SEQUENCE sizeY: NAT OF REF TileLinesRec];
    TileLinesRec: TYPE = RECORD [SEQUENCE sizeX: NAT OF Pipal.Object];
    TileArrayXY: PipalMos.XYTileProc = {
        tileArray: REF TileArrayRec _ NARROW [data];
        RETURN [tileArray[y][x]];
        };

    ReadTiling: ClassReadProc = {
        sizeX: NAT _ NAT [ReadInt[h]];
        sizeY: NAT _ NAT [ReadInt[h]];
        tileArray: REF TileArrayRec _ NEW [TileArrayRec[sizeY]];
        FOR y: NAT IN [0 .. sizeY) DO
            tileArray[y] _ NEW [TileLinesRec[sizeX]];
            FOR x: NAT IN [0 .. sizeX) DO tileArray[y][x] _ ReadObject[h] ENDLOOP;
            ENDLOOP;
        object _ PipalMos.CreateTiling[sizeX, sizeY, TileArrayXY, tileArray];
        };
<<Marker>>
    WriteMarker: ClassWriteProc = {
        marker: PipalMos.Marker = NARROW [object];
        WriteVector[h, marker.size];
        WriteAtom[h, marker.layer];
        };

    ReadMarker: ClassReadProc = {
        size: PipalInt.Size = ReadVector[h];
        layer: PipalMos.Layer = ReadAtom[h];
        RETURN [PipalMos.CreateMarker[size, layer]]
        };
<<Text>>
    WriteText: ClassWriteProc = {
    ERROR;
        };

    ReadText: ClassReadProc = {
    ERROR;
        };
<<Picture>>
    WritePicture: ClassWriteProc = {
    ERROR;
        };

    ReadPicture: ClassReadProc = {
    ERROR;
        };
<<Initialization>>
    RegisterClass[Pipal.overlayClass, WriteOverlay, ReadOverlay];
    RegisterClass[Pipal.iconClass, WriteIcon, ReadIcon];
    RegisterClass[Pipal.annotationClass, WriteAnnotation, ReadAnnotation];

    RegisterClass[PipalInt.transformClass, WriteTransform, ReadTransform];
    RegisterClass[PipalInt.translationClass, WriteTransform, ReadTransform];
    RegisterClass[PipalInt.orientClass, WriteTransform, ReadTransform];
    RegisterClass[PipalInt.abutClass, WriteAbut, ReadAbut];

    RegisterClass[PipalMos.boxClass, WriteBox, ReadBox];
    RegisterClass[PipalMos.starClass, WriteStar, ReadStar];
    RegisterClass[PipalMos.routingClass, WriteRouting, ReadRouting];
    RegisterClass[PipalMos.tilingClass, WriteTiling, ReadTiling];
    RegisterClass[PipalMos.markerClass, WriteMarker, ReadMarker];
    RegisterClass[PipalMos.textClass, WriteText, ReadText];
    RegisterClass[PipalMos.textClass, WritePicture, ReadPicture];

END.