public override int encodeReal(object obj, System.IO.Stream stream, ElementInfo elementInfo)
{
int result = 0;
BitArrayOutputStream bitStream = (BitArrayOutputStream)stream;
Double value = (Double)obj;
//CoderUtils.checkConstraints(value,elementInfo);
long asLong = System.BitConverter.DoubleToInt64Bits(value);
if (value == Double.PositiveInfinity)
{ // positive infinity
result += encodeLengthDeterminant(1, bitStream);
doAlign(stream);
stream.WriteByte(0x40); // 01000000 Value is PLUS-INFINITY
result += 1;
}
else if (value == Double.NegativeInfinity)
{ // negative infinity
result += encodeLengthDeterminant(1, bitStream);
doAlign(stream);
stream.WriteByte(0x41); // 01000001 Value is MINUS-INFINITY
result += 1;
}
else if (asLong != 0)
{
long exponent = ((0x7ff0000000000000L & asLong) >> 52) - 1023 - 52;
long mantissa = 0x000fffffffffffffL & asLong;
mantissa |= 0x10000000000000L; // set virtual delimeter
// pack mantissa for base 2
while ((mantissa & 0xFFL) == 0)
{
mantissa >>= 8;
exponent += 8; //increment exponent to 8 (base 2)
}
while ((mantissa & 0x01L) == 0)
{
mantissa >>= 1;
exponent += 1; //increment exponent to 1
}
int szOfExp = CoderUtils.getIntegerLength(exponent);
encodeLengthDeterminant(CoderUtils.getIntegerLength(mantissa) + szOfExp + 1, bitStream);
doAlign(stream);
byte realPreamble = 0x80;
realPreamble |= (byte)(szOfExp - 1);
if ((((ulong)asLong) & 0x8000000000000000L) == 0x8000000000000000L)
{
realPreamble |= 0x40; // Sign
}
stream.WriteByte(realPreamble);
result += 1;
result += encodeIntegerValueAsBytes(exponent, stream);
result += encodeIntegerValueAsBytes(mantissa, stream);
}
return(result);
}
public override int encodeReal(object obj, Stream stream, ElementInfo elementInfo)
{
int resultSize = 0;
Double value = (Double)obj;
//CoderUtils.checkConstraints(value,elementInfo);
int szOfInt = 0;
#if PocketPC
byte[] dblValAsBytes = System.BitConverter.GetBytes(value);
long asLong = System.BitConverter.ToInt64(dblValAsBytes, 0);
#else
long asLong = BitConverter.DoubleToInt64Bits(value);
#endif
if (value == Double.PositiveInfinity)
{
// positive infinity
stream.WriteByte(0x40); // 01000000 Value is PLUS-INFINITY
}
else if (value == Double.NegativeInfinity)
{
// negative infinity
stream.WriteByte(0x41); // 01000001 Value is MINUS-INFINITY
}
else if (asLong != 0x0)
{
long exponent = ((0x7ff0000000000000L & asLong) >> 52) - 1023 - 52;
long mantissa = 0x000fffffffffffffL & asLong;
mantissa |= 0x10000000000000L; // set virtual delimiter
// pack mantissa for base 2
while ((mantissa & 0xFFL) == 0x0)
{
mantissa >>= 8;
exponent += 8; //increment exponent to 8 (base 2)
}
while ((mantissa & 0x01L) == 0x0)
{
mantissa >>= 1;
exponent += 1; //increment exponent to 1
}
szOfInt += encodeIntegerValue(mantissa, stream);
int szOfExp = CoderUtils.getIntegerLength(exponent);
szOfInt += encodeIntegerValue(exponent, stream);
byte realPreamble = 0x80;
realPreamble |= (byte)(szOfExp - 1);
if (((ulong)asLong & 0x8000000000000000L) == 1)
{
realPreamble |= 0x40; // Sign
}
stream.WriteByte(realPreamble);
szOfInt += 1;
}
resultSize += szOfInt;
resultSize += encodeLength(szOfInt, stream);
resultSize += encodeTag(BERCoderUtils.getTagValueForElement(elementInfo, TagClasses.Universal, ElementType.Primitive, UniversalTags.Real), stream);
return(resultSize);
}
/// <summary>
/// Encoding of a constrained whole number
/// ITU-T X.691. 10.5.
/// NOTE – (Tutorial) This subclause is referenced by other clauses,
/// and itself references earlier clauses for the production of
/// a nonnegative-binary-integer or a 2's-complement-binary-integer encoding.
/// </summary>
protected virtual int encodeConstraintNumber(long val, long min, long max, BitArrayOutputStream stream)
{
int result = 0;
long valueRange = max - min;
long narrowedVal = val - min;
int maxBitLen = PERCoderUtils.getMaxBitLength(valueRange);
if (valueRange == 0)
{
return(result);
}
// The rest of this Note addresses the ALIGNED variant.
if (valueRange > 0 && valueRange < 256)
{
/*
* 1. Where the range is less than or equal to 255, the value encodes
* into a bit-field of the minimum size for the range.
* 2. Where the range is exactly 256, the value encodes
* into a single octet octet-aligned bit-field.
*/
doAlign(stream);
for (int i = maxBitLen - 1; i >= 0; i--)
{
int bitValue = (int)((narrowedVal >> i) & 0x1);
stream.writeBit(bitValue);
}
result = 1;
}
else if (valueRange > 0 && valueRange < 65536)
{
/*
* 3. Where the range is 257 to 64K, the value encodes into
* a two octet octet-aligned bit-field.
*/
doAlign(stream);
stream.WriteByte((byte)(narrowedVal >> 8));
stream.WriteByte((byte)(narrowedVal & 0xFF));
result = 2;
}
else
{
/*
* 4. Where the range is greater than 64K, the range is ignored
* and the value encodes into an octet-aligned bit-field
* which is the minimum number of octets for the value.
* In this latter case, later procedures (see 10.9)
* also encode a length field (usually a single octet) to indicate
* the length of the encoding. For the other cases, the length
* of the encoding is independent of the value being encoded,
* and is not explicitly encoded.
*/
result = encodeConstraintLengthDeterminant(CoderUtils.getIntegerLength(narrowedVal), 1, CoderUtils.getPositiveIntegerLength(valueRange), stream);
doAlign(stream);
result += encodeIntegerValueAsBytes(narrowedVal, stream);
}
return(result);
}
/// <summary>
/// Encoding of a unconstrained whole number
/// ITU-T X.691. 10.8.
/// NOTE – (Tutorial) This case only arises in the encoding of the
/// value of an integer type with no lower bound. The procedure
/// encodes the value as a 2's-complement-binary-integer into
/// the minimum number of octets required to accommodate the encoding,
/// and requires an explicit length encoding (typically a single octet)
/// as specified in later procedures.
/// </summary>
protected virtual int encodeUnconstraintNumber(long val, BitArrayOutputStream stream)
{
int result = 0;
int intLen = CoderUtils.getIntegerLength(val);
result += encodeLengthDeterminant(intLen, stream);
doAlign(stream);
result += encodeIntegerValueAsBytes(val, stream);
return(result);
}
protected internal int encodeIntegerValue(long val, Stream stream)
{
int resultSize = CoderUtils.getIntegerLength(val);
for (int i = 0; i < resultSize; i++)
{
stream.WriteByte((byte)val);
val = val >> 8;
}
return(resultSize);
}
protected virtual int encodeIntegerValueAsBytes(long val, Stream stream)
{
int integerSize = CoderUtils.getIntegerLength(val);
for (int i = integerSize - 1; i >= 0; i--)
{
long valueTmp = val >> (8 * i);
stream.WriteByte((byte)valueTmp);
}
return(integerSize);
}
/// <summary>
/// Encoding of a semi-constrained whole number
/// ITU-T X.691. 10.7.
/// NOTE – (Tutorial) This procedure is used when a lower bound can be
/// identified but not an upper bound. The encoding procedure places
/// the offset from the lower bound into the minimum number of octets
/// as a non-negative-binary-integer, and requires an explicit length
/// encoding (typically a single octet) as specified in later procedures.
/// </summary>
protected virtual int encodeSemiConstraintNumber(int val, int min, BitArrayOutputStream stream)
{
int result = 0;
int narrowedVal = val - min;
int intLen = CoderUtils.getIntegerLength(narrowedVal);
result += encodeLengthDeterminant(intLen, stream);
doAlign(stream);
result += encodeIntegerValueAsBytes(narrowedVal, stream);
return(result);
}
