FilingAttributesP10V5AuxImpl:
CEDAR
PROGRAM
IMPORTS Convert, Rope, CHNameP2V0Aux
EXPORTS FilingAttributesP10V5Aux ~ {
OPEN FilingAttributesP10V5, FilingAttributesP10V5Aux;
ROPE: TYPE ~ Rope.ROPE;
ExposeSerializedFile:
PUBLIC
PROC [arg: SerializedFile, level:
NAT]
RETURNS [res:
ROPE] ~ {
res ¬ "[";
res ¬ Rope.Cat[res, "version~", Convert.RopeFromCard[arg.version], ", "];
res ¬ Rope.Cat[res, "file~", ExposeSerializedTree[arg.file, (level+1)], "]"];
};
ExposeAttributeValue:
PUBLIC
PROC [arg: AttributeValue, level:
NAT]
RETURNS [res:
ROPE] ~ {
res ¬ "[";
FOR i:
CARDINAL
IN [0..arg.length)
DO
res ¬ Rope.Cat[res, IF i>0 THEN ", " ELSE NIL, Convert.RopeFromCard[arg.body[i]]];
ENDLOOP;
res ¬ Rope.Concat[res, "]"];
};
ExposeAccessList:
PUBLIC
PROC [arg: AccessList, level:
NAT]
RETURNS [res:
ROPE] ~ {
res ¬ "[";
res ¬ Rope.Cat[res, "entries~", ExposeAccessEntrySequence[arg.entries, (level+1)], ", "];
res ¬ Rope.Cat[res, "defaulted~", Convert.RopeFromBool[arg.defaulted], "]"];
};
ExposeStreamOfUnspecified:
PUBLIC
PROC [arg: StreamOfUnspecified, level:
NAT]
RETURNS [res:
ROPE] ~ {
res ¬ "[";
FOR i:
CARDINAL
IN [0..arg.length)
DO
res ¬ Rope.Cat[res, IF i>0 THEN ", " ELSE NIL, Convert.RopeFromCard[arg.body[i]]];
ENDLOOP;
res ¬ Rope.Concat[res, "]"];
};
ExposeAttribute:
PUBLIC
PROC [arg: Attribute, level:
NAT]
RETURNS [res:
ROPE] ~ {
res ¬ "[";
res ¬ Rope.Cat[res, "type~", Convert.RopeFromCard[arg.type], ", "];
res ¬ Rope.Cat[res, "value~", ExposeAttributeValue[arg.value, (level+1)], "]"];
};
ExposeOrdering:
PUBLIC
PROC [arg: Ordering, level:
NAT]
RETURNS [res:
ROPE] ~ {
res ¬ "[";
res ¬ Rope.Cat[res, "key~", Convert.RopeFromCard[arg.key], ", "];
res ¬ Rope.Cat[res, "ascending~", Convert.RopeFromBool[arg.ascending], ", "];
res ¬ Rope.Cat[res, "interpretation~", ExposeInterpretation[arg.interpretation, (level+1)], "]"];
};
ExposeWellKnownType:
PUBLIC
PROC [arg: WellKnownType, level:
NAT]
RETURNS [res:
ROPE] ~ {
SELECT arg
FROM
tUnspecified => res ¬ "tUnspecified";
tDirectory => res ¬ "tDirectory";
tText => res ¬ "tText";
tSerialized => res ¬ "tSerialized";
tEmpty => res ¬ "tEmpty";
tAscii => res ¬ "tAscii";
tAsciiText => res ¬ "tAsciiText";
ENDCASE => ERROR
};
ExposeAccessEntry:
PUBLIC
PROC [arg: AccessEntry, level:
NAT]
RETURNS [res:
ROPE] ~ {
res ¬ "[";
res ¬ Rope.Cat[res, "key~", CHNameP2V0Aux.ExposeThreePartName[arg.key, (level+1)], ", "];
res ¬ Rope.Cat[res, "access~", ExposeAccessSequence[arg.access, (level+1)], "]"];
};
ExposeStreamOfAttributeSequence:
PUBLIC
PROC [arg: StreamOfAttributeSequence, level:
NAT]
RETURNS [res:
ROPE] ~ {
res ¬ Rope.Cat["StreamOfAttributeSequence(", ExposeStreamKind[arg.type, (level+1)], "): "];
WITH arg
SELECT
FROM
it:
REF StreamOfAttributeSequenceObject.nextSegment => {
res ¬ Rope.Concat[res, ExposeAttributeSequenceList[it.nextSegment, (level+1)]] };
it:
REF StreamOfAttributeSequenceObject.lastSegment => {
res ¬ Rope.Concat[res, ExposeAttributeSequenceSequence[it.lastSegment, (level+1)]] };
ENDCASE => ERROR
};
ExposeSerializedTree:
PUBLIC
PROC [arg: SerializedTree, level:
NAT]
RETURNS [res:
ROPE] ~ {
res ¬ "[";
res ¬ Rope.Cat[res, "attributes~", ExposeAttributeSequence[arg.attributes, (level+1)], ", "];
res ¬ Rope.Cat[res, "content~", ExposeSerializedContentBytes[arg.content, (level+1)], "]"];
};
ExposeInterpretation:
PUBLIC
PROC [arg: Interpretation, level:
NAT]
RETURNS [res:
ROPE] ~ {
SELECT arg
FROM
interpretationNone => res ¬ "interpretationNone";
boolean => res ¬ "boolean";
cardinal => res ¬ "cardinal";
longCardinal => res ¬ "longCardinal";
time => res ¬ "time";
integer => res ¬ "integer";
longInteger => res ¬ "longInteger";
string => res ¬ "string";
ENDCASE => ERROR
};
ExposeAttributeSequence:
PUBLIC
PROC [arg: AttributeSequence, level:
NAT]
RETURNS [res:
ROPE] ~ {
res ¬ "[";
FOR i:
CARDINAL
IN [0..arg.length)
DO
res ¬ Rope.Cat[res, IF i>0 THEN ", " ELSE NIL, ExposeAttribute[arg.body[i], (level+1)]];
ENDLOOP;
res ¬ Rope.Concat[res, "]"];
};
ExposeBytePairSequence:
PUBLIC
PROC [arg: BytePairSequence, level:
NAT]
RETURNS [res:
ROPE] ~ {
res ¬ "[";
FOR i:
CARDINAL
IN [0..arg.length)
DO
res ¬ Rope.Cat[res, IF i>0 THEN ", " ELSE NIL, Convert.RopeFromCard[arg.body[i]]];
ENDLOOP;
res ¬ Rope.Concat[res, "]"];
};
ExposeAttributeSequenceSequence:
PUBLIC
PROC [arg: AttributeSequenceSequence, level:
NAT]
RETURNS [res:
ROPE] ~ {
res ¬ "[";
FOR i:
CARDINAL
IN [0..arg.length)
DO
res ¬ Rope.Cat[res, IF i>0 THEN ", " ELSE NIL, ExposeAttributeSequence[arg.body[i], (level+1)]];
ENDLOOP;
res ¬ Rope.Concat[res, "]"];
};
ExposeAsciiString:
PUBLIC
PROC [arg: AsciiString, level:
NAT]
RETURNS [res:
ROPE] ~ {
res ¬ "[";
res ¬ Rope.Cat[res, "lastByteIsSignificant~", Convert.RopeFromBool[arg.lastByteIsSignificant], ", "];
res ¬ Rope.Cat[res, "data~", ExposeBytePairSequence[arg.data, (level+1)], "]"];
};
ExposeAttributeSequenceList:
PUBLIC
PROC [arg: AttributeSequenceList, level:
NAT]
RETURNS [res:
ROPE] ~ {
res ¬ "[";
res ¬ Rope.Cat[res, "segment~", ExposeAttributeSequenceSequence[arg.segment, (level+1)], "]"];
};
ExposeStreamKind:
PUBLIC
PROC [arg: StreamKind, level:
NAT]
RETURNS [res:
ROPE] ~ {
SELECT arg
FROM
nextSegment => res ¬ "nextSegment";
lastSegment => res ¬ "lastSegment";
ENDCASE => ERROR
};
ExposePosition:
PUBLIC
PROC [arg: Position, level:
NAT]
RETURNS [res:
ROPE] ~ {
res ¬ "[";
FOR i:
CARDINAL
IN [0..arg.length)
DO
res ¬ Rope.Cat[res, IF i>0 THEN ", " ELSE NIL, Convert.RopeFromCard[arg.body[i]]];
ENDLOOP;
res ¬ Rope.Concat[res, "]"];
};
ExposeSerializedContentBytes:
PUBLIC
PROC [arg: SerializedContentBytes, level:
NAT]
RETURNS [res:
ROPE] ~ {
res ¬ "[";
res ¬ Rope.Cat[res, "data~", ExposeStreamOfUnspecified[arg.data, (level+1)], ", "];
res ¬ Rope.Cat[res, "lastByteIsSignificant~", Convert.RopeFromBool[arg.lastByteIsSignificant], "]"];
};
ExposeInterpretedAttributeType:
PUBLIC
PROC [arg: InterpretedAttributeType, level:
NAT]
RETURNS [res:
ROPE] ~ {
SELECT arg
FROM
checksum => res ¬ "checksum";
childrenUniquelyNamed => res ¬ "childrenUniquelyNamed";
createdBy => res ¬ "createdBy";
createdOn => res ¬ "createdOn";
fileID => res ¬ "fileID";
isDirectory => res ¬ "isDirectory";
isTemporary => res ¬ "isTemporary";
modifiedBy => res ¬ "modifiedBy";
modifiedOn => res ¬ "modifiedOn";
name => res ¬ "name";
numberOfChildren => res ¬ "numberOfChildren";
ordering => res ¬ "ordering";
parentID => res ¬ "parentID";
position => res ¬ "position";
readBy => res ¬ "readBy";
readOn => res ¬ "readOn";
dataSize => res ¬ "dataSize";
type => res ¬ "type";
version => res ¬ "version";
accessList => res ¬ "accessList";
defaultAccessList => res ¬ "defaultAccessList";
pathname => res ¬ "pathname";
unused22 => res ¬ "unused22";
unused23 => res ¬ "unused23";
unused24 => res ¬ "unused24";
unused25 => res ¬ "unused25";
storedSize => res ¬ "storedSize";
subtreeSize => res ¬ "subtreeSize";
subtreeSizeLimit => res ¬ "subtreeSizeLimit";
ENDCASE => ERROR
};
ExposeStreamOfAsciiText:
PUBLIC
PROC [arg: StreamOfAsciiText, level:
NAT]
RETURNS [res:
ROPE] ~ {
res ¬ Rope.Cat["StreamOfAsciiText(", ExposeStringStreamKind[arg.type, (level+1)], "): "];
WITH arg
SELECT
FROM
it:
REF StreamOfAsciiTextObject.nextLine => {
res ¬ Rope.Concat[res, ExposeAsciiStringList[it.nextLine, (level+1)]] };
it:
REF StreamOfAsciiTextObject.lastLine => {
res ¬ Rope.Concat[res, ExposeAsciiString[it.lastLine, (level+1)]] };
ENDCASE => ERROR
};
ExposeSerializedTreeSequence:
PUBLIC
PROC [arg: SerializedTreeSequence, level:
NAT]
RETURNS [res:
ROPE] ~ {
res ¬ "[";
FOR i:
CARDINAL
IN [0..arg.length)
DO
res ¬ Rope.Cat[res, IF i>0 THEN ", " ELSE NIL, ExposeSerializedTree[arg.body[i], (level+1)]];
ENDLOOP;
res ¬ Rope.Concat[res, "]"];
};
ExposeFileID:
PUBLIC
PROC [arg: FileID, level:
NAT]
RETURNS [res:
ROPE] ~ {
res ¬ "[";
FOR i:
CARDINAL
IN [0..5)
DO
res ¬ Rope.Cat[res, IF i>0 THEN ", " ELSE NIL, Convert.RopeFromCard[arg[i]]];
ENDLOOP;
res ¬ Rope.Concat[res, "]"];
};
ExposeAsciiStringList:
PUBLIC
PROC [arg: AsciiStringList, level:
NAT]
RETURNS [res:
ROPE] ~ {
res ¬ "[";
res ¬ Rope.Cat[res, "line~", ExposeAsciiString[arg.line, (level+1)], "]"];
};
ExposeAccessEntrySequence:
PUBLIC
PROC [arg: AccessEntrySequence, level:
NAT]
RETURNS [res:
ROPE] ~ {
res ¬ "[";
FOR i:
CARDINAL
IN [0..arg.length)
DO
res ¬ Rope.Cat[res, IF i>0 THEN ", " ELSE NIL, ExposeAccessEntry[arg.body[i], (level+1)]];
ENDLOOP;
res ¬ Rope.Concat[res, "]"];
};
ExposeAccessSequence:
PUBLIC
PROC [arg: AccessSequence, level:
NAT]
RETURNS [res:
ROPE] ~ {
res ¬ "[";
FOR i:
CARDINAL
IN [0..arg.length)
DO
res ¬ Rope.Cat[res, IF i>0 THEN ", " ELSE NIL, ExposeAccessType[arg.body[i], (level+1)]];
ENDLOOP;
res ¬ Rope.Concat[res, "]"];
};
ExposeAccessType:
PUBLIC
PROC [arg: AccessType, level:
NAT]
RETURNS [res:
ROPE] ~ {
SELECT arg
FROM
read => res ¬ "read";
write => res ¬ "write";
owner => res ¬ "owner";
add => res ¬ "add";
remove => res ¬ "remove";
fullAccess => res ¬ "fullAccess";
ENDCASE => ERROR
};
ExposeStringStreamKind:
PUBLIC
PROC [arg: StringStreamKind, level:
NAT]
RETURNS [res:
ROPE] ~ {
SELECT arg
FROM
nextLine => res ¬ "nextLine";
lastLine => res ¬ "lastLine";
ENDCASE => ERROR
};
ExposeInterpretedAttribute:
PUBLIC
PROC [arg: InterpretedAttribute, level:
NAT]
RETURNS [res:
ROPE] ~ {
res ¬ Rope.Cat["InterpretedAttribute(", ExposeInterpretedAttributeType[arg.type, (level+1)], "): "];
WITH arg
SELECT
FROM
it:
REF InterpretedAttributeObject.checksum => {
res ¬ Rope.Concat[res, Convert.RopeFromCard[it.checksum]] };
it:
REF InterpretedAttributeObject.childrenUniquelyNamed => {
res ¬ Rope.Concat[res, Convert.RopeFromBool[it.childrenUniquelyNamed]] };
it:
REF InterpretedAttributeObject.createdBy => {
res ¬ Rope.Concat[res, CHNameP2V0Aux.ExposeThreePartName[it.createdBy, (level+1)]] };
it:
REF InterpretedAttributeObject.createdOn => {
res ¬ Rope.Concat[res, Convert.RopeFromCard[it.createdOn]] };
it:
REF InterpretedAttributeObject.fileID => {
res ¬ Rope.Concat[res, ExposeFileID[it.fileID, (level+1)]] };
it:
REF InterpretedAttributeObject.isDirectory => {
res ¬ Rope.Concat[res, Convert.RopeFromBool[it.isDirectory]] };
it:
REF InterpretedAttributeObject.isTemporary => {
res ¬ Rope.Concat[res, Convert.RopeFromBool[it.isTemporary]] };
it:
REF InterpretedAttributeObject.modifiedBy => {
res ¬ Rope.Concat[res, CHNameP2V0Aux.ExposeThreePartName[it.modifiedBy, (level+1)]] };
it:
REF InterpretedAttributeObject.modifiedOn => {
res ¬ Rope.Concat[res, Convert.RopeFromCard[it.modifiedOn]] };
it:
REF InterpretedAttributeObject.name => {
res ¬ Rope.Concat[res, it.name] };
it:
REF InterpretedAttributeObject.numberOfChildren => {
res ¬ Rope.Concat[res, Convert.RopeFromCard[it.numberOfChildren]] };
it:
REF InterpretedAttributeObject.ordering => {
res ¬ Rope.Concat[res, ExposeOrdering[it.ordering, (level+1)]] };
it:
REF InterpretedAttributeObject.parentID => {
res ¬ Rope.Concat[res, ExposeFileID[it.parentID, (level+1)]] };
it:
REF InterpretedAttributeObject.position => {
res ¬ Rope.Concat[res, ExposePosition[it.position, (level+1)]] };
it:
REF InterpretedAttributeObject.readBy => {
res ¬ Rope.Concat[res, CHNameP2V0Aux.ExposeThreePartName[it.readBy, (level+1)]] };
it:
REF InterpretedAttributeObject.readOn => {
res ¬ Rope.Concat[res, Convert.RopeFromCard[it.readOn]] };
it:
REF InterpretedAttributeObject.dataSize => {
res ¬ Rope.Concat[res, Convert.RopeFromCard[it.dataSize]] };
it:
REF InterpretedAttributeObject.type => {
res ¬ Rope.Concat[res, Convert.RopeFromCard[it.type]] };
it:
REF InterpretedAttributeObject.version => {
res ¬ Rope.Concat[res, Convert.RopeFromCard[it.version]] };
it:
REF InterpretedAttributeObject.accessList => {
res ¬ Rope.Concat[res, ExposeAccessList[it.accessList, (level+1)]] };
it:
REF InterpretedAttributeObject.defaultAccessList => {
res ¬ Rope.Concat[res, ExposeAccessList[it.defaultAccessList, (level+1)]] };
it:
REF InterpretedAttributeObject.pathname => {
res ¬ Rope.Concat[res, it.pathname] };
it:
REF InterpretedAttributeObject.unused22 => {
res ¬ Rope.Concat[res, Convert.RopeFromCard[it.unused22]] };
it:
REF InterpretedAttributeObject.unused23 => {
res ¬ Rope.Concat[res, Convert.RopeFromCard[it.unused23]] };
it:
REF InterpretedAttributeObject.unused24 => {
res ¬ Rope.Concat[res, Convert.RopeFromCard[it.unused24]] };
it:
REF InterpretedAttributeObject.unused25 => {
res ¬ Rope.Concat[res, Convert.RopeFromCard[it.unused25]] };
it:
REF InterpretedAttributeObject.storedSize => {
res ¬ Rope.Concat[res, Convert.RopeFromCard[it.storedSize]] };
it:
REF InterpretedAttributeObject.subtreeSize => {
res ¬ Rope.Concat[res, Convert.RopeFromCard[it.subtreeSize]] };
it:
REF InterpretedAttributeObject.subtreeSizeLimit => {
res ¬ Rope.Concat[res, Convert.RopeFromCard[it.subtreeSizeLimit]] };
ENDCASE => ERROR
};