//----
protected override int MakeVariableLengthHeader(byte[] buf, int offset,
ElementTypeDescriptor etd, out HeaderWriteState headerState)
{
bool seqOrAltToStore = false;
if (!this.aboveBase)
{
Debug.Assert(etd == ElementTypeDescriptor.ElementSequence,
"Outer element is a SEQ! Or are we called elsewhere!?");
this.aboveBase = true;
}
else if (this.isInSeqOrAlt)
{
// Child of a SEQ/ALT, will be written from byte buffer.
}
else if (etd == ElementTypeDescriptor.ElementSequence ||
etd == ElementTypeDescriptor.ElementAlternative)
{
seqOrAltToStore = true;
}
//
int ret = base.MakeVariableLengthHeader(buf, offset, etd, out headerState);
//
if (seqOrAltToStore)
{
this.isInSeqOrAlt = true; // Ignore individual elements
headerState.widcommNeedsStoring = true;
}
return(ret);
}
protected virtual int MakeVariableLengthHeader(byte[] buf, int offset, ElementTypeDescriptor elementTypeDescriptor, out HeaderWriteState headerState)
{
HackFxCopHintNonStaticMethod();
// We only support one-byte length fields (currently?).
headerState = new HeaderWriteState(elementTypeDescriptor, buf, offset, SizeIndex.AdditionalUInt8, 2);
return(headerState.HeaderLength);
}
private int WriteHeaderFixedLength_(ElementTypeDescriptor elementTypeDescriptor, int contentLength, SizeIndex sizeIndex,
byte[] buf, int offset,
out int totalLength)
{
System.Diagnostics.Debug.Assert(
sizeIndex == SizeIndex.LengthOneByteOrNil ||
sizeIndex == SizeIndex.LengthTwoBytes ||
sizeIndex == SizeIndex.LengthFourBytes ||
sizeIndex == SizeIndex.LengthEightBytes ||
sizeIndex == SizeIndex.LengthSixteenBytes);
ServiceRecordParser.VerifyAllowedSizeIndex(elementTypeDescriptor, sizeIndex, false);
HeaderWriteState headerState = new HeaderWriteState(elementTypeDescriptor, buf, offset, sizeIndex, 1);
CompleteHeaderWrite(headerState, buf, offset + contentLength + headerState.HeaderLength, out totalLength);
return(headerState.HeaderLength);
}
protected override void CompleteHeaderWrite(HeaderWriteState headerState,
byte[] buf, int offsetAtEndOfWritten, out int totalLength)
{
base.CompleteHeaderWrite(headerState, buf, offsetAtEndOfWritten, out totalLength);
//
if (headerState.widcommNeedsStoring)
{
Debug.Assert(!this.needWrite, "overwrite");
Debug.Assert(this.isInSeqOrAlt);
this.isInSeqOrAlt = false;
int startOffset = headerState.HeaderOffset + headerState.HeaderLength;
byte[] val = new byte[offsetAtEndOfWritten - startOffset];
Array.Copy(buf, startOffset, val, 0, val.Length);
this.value = val;
this.dt = ToDESC_TYPE(headerState.Etd);
this.needWrite = true;
}
}
protected virtual void CompleteHeaderWrite(HeaderWriteState headerState, byte[] buf, int offsetAtEndOfWritten, out int totalLength)
{
HackFxCopHintNonStaticMethod();
byte headerByte = CreateHeaderByte(headerState.Etd, headerState.SizeIndex);
buf[headerState.HeaderOffset] = headerByte;
//
if (headerState.SizeIndex == SizeIndex.LengthOneByteOrNil ||
headerState.SizeIndex == SizeIndex.LengthTwoBytes ||
headerState.SizeIndex == SizeIndex.LengthFourBytes ||
headerState.SizeIndex == SizeIndex.LengthEightBytes ||
headerState.SizeIndex == SizeIndex.LengthSixteenBytes)
{
// Nothing to write-out here.
totalLength = offsetAtEndOfWritten - headerState.HeaderOffset;
}
else
{
System.Diagnostics.Debug.Assert(
headerState.SizeIndex == SizeIndex.AdditionalUInt8 ||
headerState.SizeIndex == SizeIndex.AdditionalUInt16 ||
headerState.SizeIndex == SizeIndex.AdditionalUInt32);
int contentLength = offsetAtEndOfWritten - headerState.HeaderOffset - headerState.HeaderLength;
System.Diagnostics.Debug.Assert(headerState.SizeIndex == SizeIndex.AdditionalUInt8,
"WriteHeader not AdditionalUInt8 but that's all that MakeHeaderSpace supports...");
if (headerState.SizeIndex == SizeIndex.AdditionalUInt8)
{
if (contentLength > Byte.MaxValue)
{
throw new NotSupportedException(ErrorMsgSupportOnlyLength255);
}
buf[headerState.HeaderOffset + 1] = checked ((byte)contentLength);
}
totalLength = offsetAtEndOfWritten - headerState.HeaderOffset;
}
}
private void CompleteHeaderWrite(HeaderWriteState headerState, byte[] buf, int offsetAtEndOfWritten, out int totalLength)
{
HackFxCopHintNonStaticMethod();
byte headerByte = CreateHeaderByte(headerState.Etd, headerState.SizeIndex);
buf[headerState.HeaderOffset] = headerByte;
//
if (headerState.SizeIndex == SizeIndex.LengthOneByteOrNil
|| headerState.SizeIndex == SizeIndex.LengthTwoBytes
|| headerState.SizeIndex == SizeIndex.LengthFourBytes
|| headerState.SizeIndex == SizeIndex.LengthEightBytes
|| headerState.SizeIndex == SizeIndex.LengthSixteenBytes) {
// Nothing to write-out here.
totalLength = offsetAtEndOfWritten - headerState.HeaderOffset;
} else {
System.Diagnostics.Debug.Assert(
headerState.SizeIndex == SizeIndex.AdditionalUInt8
|| headerState.SizeIndex == SizeIndex.AdditionalUInt16
|| headerState.SizeIndex == SizeIndex.AdditionalUInt32);
int contentLength = offsetAtEndOfWritten - headerState.HeaderOffset - headerState.HeaderLength;
System.Diagnostics.Debug.Assert(headerState.SizeIndex == SizeIndex.AdditionalUInt8,
"WriteHeader not AdditionalUInt8 but that's all that MakeHeaderSpace supports...");
if (headerState.SizeIndex == SizeIndex.AdditionalUInt8) {
if (contentLength > Byte.MaxValue) {
throw new NotSupportedException(ErrorMsgSupportOnlyLength255);
}
buf[headerState.HeaderOffset + 1] = checked((byte)contentLength);
}
totalLength = offsetAtEndOfWritten - headerState.HeaderOffset;
}
}
private int MakeVariableLengthHeader(byte[] buf, int offset, ElementTypeDescriptor elementTypeDescriptor, out HeaderWriteState headerState)
{
HackFxCopHintNonStaticMethod();
// We only support one-byte length fields (currently?).
headerState = new HeaderWriteState(elementTypeDescriptor, buf, offset, SizeIndex.AdditionalUInt8, 2);
return headerState.HeaderLength;
}
private int WriteHeaderFixedLength_(ElementTypeDescriptor elementTypeDescriptor, int contentLength, SizeIndex sizeIndex,
byte[] buf, int offset,
out int totalLength)
{
System.Diagnostics.Debug.Assert(
sizeIndex == SizeIndex.LengthOneByteOrNil
|| sizeIndex == SizeIndex.LengthTwoBytes
|| sizeIndex == SizeIndex.LengthFourBytes
|| sizeIndex == SizeIndex.LengthEightBytes
|| sizeIndex == SizeIndex.LengthSixteenBytes);
ServiceRecordParser.VerifyAllowedSizeIndex(elementTypeDescriptor, sizeIndex, false);
HeaderWriteState headerState = new HeaderWriteState(elementTypeDescriptor, buf, offset, sizeIndex, 1);
CompleteHeaderWrite(headerState, buf, offset + contentLength + headerState.HeaderLength, out totalLength);
return headerState.HeaderLength;
}
