public void initWithDefaults()
{
BitString param_AttrBitStrDef =
new BitString(CoderUtils.defStringToOctetString("'011'B"));
AttrBitStrDef = param_AttrBitStrDef;
}
public virtual int encodeSet(object obj, Stream stream, ElementInfo elementInfo)
{
int resultSize = 0;
PropertyInfo[] fields = null;
if (elementInfo.hasPreparedInfo())
{
fields = elementInfo.getProperties(obj.GetType());
}
else
{
SortedList <int, PropertyInfo> fieldOrder = CoderUtils.getSetOrder(obj.GetType());
//TO DO Performance optimization need (unnecessary copy)
fields = new PropertyInfo[fieldOrder.Count];
fieldOrder.Values.CopyTo(fields, 0);
}
resultSize += encodeSequencePreamble(obj, fields, stream, elementInfo);
int fieldIdx = 0;
foreach (PropertyInfo field in fields)
{
resultSize += encodeSequenceField(obj, fieldIdx++, field, stream, elementInfo);
}
return(resultSize);
}
public override int encodeBitString(Object obj, System.IO.Stream stream, ElementInfo elementInfo)
{
int resultSize = 0;
BitString str = (BitString)obj;
CoderUtils.checkConstraints(str.getLengthInBits(), elementInfo);
byte[] buffer = str.Value;
string s = "";
if (elementInfo.hasPreparedInfo() && elementInfo.hasPreparedASN1ElementInfo())
{
s = elementInfo.PreparedASN1ElementInfo.Name;
}
if (s == "")
{
s = "unnamedBitString" + unknown.ToString("D3");
unknown++;
}
System.Text.StringBuilder sb = new System.Text.StringBuilder();
for (int i = 0; i < buffer.Length; i++)
{
for (int j = 0; j < 8; j++)
{
sb.Append((buffer[i] >> j & 1).ToString());
}
if (i < buffer.Length - 1)
{
sb.Append(',');
}
}
resultSize += printString(stream, "<" + s + " type=\"BitString\">" + sb.ToString() + "</" + s + ">\r\n");
return(resultSize);
}
public override int encode(IASN1TypesEncoder encoder, object obj, Stream stream, ElementInfo elementInfo)
{
Object result = null;
ASN1ElementMetadata saveInfo = elementInfo.PreparedASN1ElementInfo;
elementInfo.PreparedInfo = (valueFieldMeta);
if (!CoderUtils.isNullField(valueField, elementInfo))
{
result = encoder.invokeGetterMethodForField(valueField, obj, elementInfo);
}
if (saveInfo != null)
{
if (!saveInfo.HasTag &&
elementInfo.hasPreparedASN1ElementInfo() &&
elementInfo.PreparedASN1ElementInfo.HasTag)
{
ASN1ElementMetadata elData = new ASN1ElementMetadata(
saveInfo.Name,
saveInfo.IsOptional,
elementInfo.PreparedASN1ElementInfo.HasTag,
elementInfo.PreparedASN1ElementInfo.IsImplicitTag,
elementInfo.PreparedASN1ElementInfo.TagClass,
elementInfo.PreparedASN1ElementInfo.Tag,
saveInfo.HasDefaultValue
);
elementInfo.PreparedASN1ElementInfo = elData;
}
else
{
elementInfo.PreparedASN1ElementInfo = (saveInfo);
}
}
return(valueFieldMeta.TypeMetadata.encode(encoder, result, stream, elementInfo));
}
public override int encodeAny(object obj, System.IO.Stream stream, ElementInfo elementInfo)
{
int resultSize = 0, sizeOfString = 0;
byte[] buffer = (byte[])obj;
CoderUtils.checkConstraints(sizeOfString, elementInfo);
System.Text.StringBuilder sb = new System.Text.StringBuilder();
for (int i = 0; i < buffer.Length; i++)
{
sb.Append(buffer[i]);
sb.Append(',');
}
string s = "";
if (elementInfo.hasPreparedInfo() && elementInfo.hasPreparedASN1ElementInfo())
{
s = elementInfo.PreparedASN1ElementInfo.Name;
}
if (s == "")
{
s = "unnamedAny" + unknown.ToString("D3");
unknown++;
}
resultSize += printString(stream, "<" + s + " type=\"Any\">" + sb.ToString() + "</" + s + ">\r\n");
return(resultSize);
}
public override int encodeSequence(object obj, Stream stream, ElementInfo elementInfo)
{
int resultSize = 0;
PropertyInfo[] fields = elementInfo.getProperties(obj.GetType());
for (int i = 0; i < fields.Length; i++)
{
PropertyInfo field = fields[fields.Length - 1 - i];
resultSize += encodeSequenceField(obj, fields.Length - 1 - i, field, stream, elementInfo);
}
if (!CoderUtils.isSequenceSet(elementInfo))
{
resultSize += encodeHeader(
BERCoderUtils.getTagValueForElement(
elementInfo,
TagClasses.Universal,
ElementType.Constructed,
UniversalTags.Sequence)
, resultSize, stream);
}
else
{
resultSize += encodeHeader(
BERCoderUtils.getTagValueForElement(
elementInfo,
TagClasses.Universal,
ElementType.Constructed,
UniversalTags.Set)
, resultSize, stream);
}
return(resultSize);
}
public override int encodeEnumItem(object enumConstant, Type enumClass, Stream stream, ElementInfo elementInfo)
{
ASN1EnumItem enumObj = elementInfo.getAttribute <ASN1EnumItem>();
//int min = 0, max = enumClass.GetFields().Length, val = 0;
int min = 0, max = 0, val = 0;
foreach (FieldInfo enumItem in enumClass.GetFields())
{
if (CoderUtils.isAttributePresent <ASN1EnumItem>(enumItem))
{
ASN1EnumItem enumItemObj = CoderUtils.getAttribute <ASN1EnumItem>(enumItem);
if (enumItemObj.Tag == enumObj.Tag)
{
val = max;
}
max++; //val++;
}
}
if (max > 0)
{
return(encodeConstraintNumber(val, min, max, (BitArrayOutputStream)stream));
}
else
{
throw new Exception("Unable to present any enum item!");
}
}
public void initWithDefaults()
{
ExtendedStatus param_ExtendedStatusMask =
new ExtendedStatus(CoderUtils.defStringToOctetString("'1111'B"));
ExtendedStatusMask = param_ExtendedStatusMask;
}
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);
}
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);
}
/// <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>
/// Decode of the 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 long decodeConstraintNumber(long min, long max, BitArrayInputStream stream)
{
long result = 0;
long valueRange = max - min;
//!!!! int narrowedVal = value - min; !!!
int maxBitLen = PERCoderUtils.getMaxBitLength(valueRange);
if (valueRange == 0)
{
return(max);
}
// 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.
*/
skipAlignedBits(stream);
result = stream.readBits(maxBitLen);
result += min;
}
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.
*/
skipAlignedBits(stream);
result = stream.ReadByte() << 8;
result = (int)result | stream.ReadByte();
result += min;
}
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.
*/
int intLen = decodeConstraintLengthDeterminant(1, CoderUtils.getPositiveIntegerLength(valueRange), stream);
skipAlignedBits(stream);
result = (int)decodeIntegerValueAsBytes(intLen, stream);
result += min;
}
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 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);
}
public override void setParentAnnotated(ICustomAttributeProvider parent)
{
if (parent != null)
{
if (CoderUtils.isAttributePresent <ASN1String>(parent))
{
ASN1String value = CoderUtils.getAttribute <ASN1String>(parent);
stringType = value.StringType;
}
}
}
public override DecodedObject <object> decodeSequenceOf(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
if (!CoderUtils.isSequenceSetOf(elementInfo))
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Constructed, UniversalTags.Sequence, elementInfo))
{
return(null);
}
}
else
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Constructed, UniversalTags.Set, elementInfo))
{
return(null);
}
}
Type paramType = (System.Type)objectClass.GetGenericArguments()[0];
Type collectionType = typeof(List <>);
Type genCollectionType = collectionType.MakeGenericType(paramType);
Object param = Activator.CreateInstance(genCollectionType);
DecodedObject <int> len = decodeLength(stream);
if (len.Value != 0)
{
int lenOfItems = 0;
int itemsCnt = 0;
do
{
ElementInfo info = new ElementInfo();
info.ParentAnnotatedClass = elementInfo.AnnotatedClass;
info.AnnotatedClass = paramType;
if (elementInfo.hasPreparedInfo())
{
ASN1SequenceOfMetadata seqOfMeta = (ASN1SequenceOfMetadata)elementInfo.PreparedInfo.TypeMetadata;
info.PreparedInfo = (seqOfMeta.getItemClassMetadata());
}
DecodedObject <object> itemTag = decodeTag(stream);
DecodedObject <object> item = decodeClassType(itemTag, paramType, info, stream);
MethodInfo method = param.GetType().GetMethod("Add");
if (item != null)
{
lenOfItems += item.Size + itemTag.Size;
method.Invoke(param, new object[] { item.Value });
itemsCnt++;
}
}while (lenOfItems < len.Value);
CoderUtils.checkConstraints(itemsCnt, elementInfo);
}
return(new DecodedObject <object>(param, len.Value + len.Size));
}
public override int encodeAny(object obj, Stream stream, ElementInfo elementInfo)
{
int resultSize = 0, sizeOfString = 0;
byte[] buffer = (byte[])obj;
sizeOfString = buffer.Length;
CoderUtils.checkConstraints(sizeOfString, elementInfo);
stream.Write(buffer, 0, buffer.Length);
resultSize += sizeOfString;
return(resultSize);
}
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);
}
/// <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);
}
public static bool is7BitEncodedString(ElementInfo info)
{
bool is7Bit = false;
int stringType = CoderUtils.getStringTagForElement(info);
is7Bit = (
stringType == org.bn.coders.UniversalTags.PrintableString ||
stringType == org.bn.coders.UniversalTags.VisibleString
);
return(is7Bit);
}
public override DecodedObject <object> decode(IASN1TypesDecoder decoder, DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream)
{
IASN1PreparedElementData saveInfo = elementInfo.PreparedInfo;
IASN1PreparedElement instance = (IASN1PreparedElement)elementInfo.PreparedInstance;
ASN1ElementMetadata saveElemInfo = elementInfo.PreparedASN1ElementInfo;
elementInfo.PreparedInfo = (valueFieldMeta);
if (saveElemInfo != null)
{
if (!saveElemInfo.HasTag &&
elementInfo.hasPreparedASN1ElementInfo() &&
elementInfo.PreparedASN1ElementInfo.HasTag)
{
ASN1ElementMetadata elData = new ASN1ElementMetadata(
saveElemInfo.Name,
saveElemInfo.IsOptional,
elementInfo.PreparedASN1ElementInfo.HasTag,
elementInfo.PreparedASN1ElementInfo.IsImplicitTag,
elementInfo.PreparedASN1ElementInfo.TagClass,
elementInfo.PreparedASN1ElementInfo.Tag,
saveElemInfo.HasDefaultValue
);
elementInfo.PreparedASN1ElementInfo = elData;
}
else
{
elementInfo.PreparedASN1ElementInfo = (saveElemInfo);
}
}
DecodedObject <object> decodedResult =
valueFieldMeta.TypeMetadata.decode(decoder, decodedTag, valueField.PropertyType, elementInfo, stream);
if (decodedResult != null)
{
if (!CoderUtils.isNullField(valueField, elementInfo))
{
decoder.invokeSetterMethodForField(valueField, instance, decodedResult.Value, elementInfo);
}
}
elementInfo.PreparedInfo = (saveInfo);
elementInfo.PreparedInstance = (instance);
elementInfo.PreparedASN1ElementInfo = (saveElemInfo);
if (decodedResult != null)
{
return(new DecodedObject <object>(instance, decodedResult.Size));
}
else
{
return(decodedResult);
}
}
public override DecodedObject <object> decodeSequence(DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream)
{
BitArrayInputStream bitStream = (BitArrayInputStream)stream;
int preambleLen = getSequencePreambleBitLen(objectClass, elementInfo);
int preamble = bitStream.readBits(preambleLen);
int preambleCurrentBit = 32 - preambleLen;
skipAlignedBits(stream);
object sequence = createInstanceForElement(objectClass, elementInfo);
initDefaultValues(sequence);
ElementInfo info = new ElementInfo();
int idx = 0;
PropertyInfo[] fields = null;
if (!CoderUtils.isSequenceSet(elementInfo) || elementInfo.hasPreparedInfo())
{
fields = elementInfo.getProperties(objectClass);
}
else
{
SortedList <int, PropertyInfo> fieldOrder = CoderUtils.getSetOrder(sequence.GetType());
fields = new PropertyInfo[fieldOrder.Values.Count];
fieldOrder.Values.CopyTo(fields, 0);
}
foreach (PropertyInfo field in fields)
{
if (elementInfo.hasPreparedInfo())
{
info.PreparedInfo = elementInfo.PreparedInfo.getPropertyMetadata(idx);
}
if (CoderUtils.isOptionalField(field, info))
{
if ((preamble & (0x80000000 >> preambleCurrentBit)) != 0)
{
decodeSequenceField(null, sequence, idx, field, stream, elementInfo, true);
}
preambleCurrentBit++;
}
else
{
decodeSequenceField(null, sequence, idx, field, stream, elementInfo, true);
}
idx++;
}
return(new DecodedObject <object>(sequence));
/* }
* else
* return decodeSet(decodedTag, objectClass, elementInfo, stream);*/
}
public override DecodedObject <object> decodeOctetString(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.OctetString, elementInfo))
{
return(null);
}
DecodedObject <int> len = decodeLength(stream);
CoderUtils.checkConstraints(len.Value, elementInfo);
byte[] byteBuf = new byte[len.Value];
stream.Read(byteBuf, 0, byteBuf.Length);
return(new DecodedObject <object>(byteBuf, len.Value + len.Size));
}
public override int encodeString(object obj, Stream stream, ElementInfo elementInfo)
{
int resultSize = 0;
byte[] val = CoderUtils.ASN1StringToBuffer(obj, elementInfo);
resultSize = encodeLength(val.Length, elementInfo, stream);
doAlign(stream);
resultSize += val.Length;
if (val.Length > 0)
{
stream.Write(val, 0, val.Length);
}
return(resultSize);
}
public override DecodedObject <object> decodeBitString(DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream)
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Bitstring, elementInfo))
{
return(null);
}
DecodedObject <int> len = decodeLength(stream);
int trailBitCnt = stream.ReadByte();
CoderUtils.checkConstraints(len.Value * 8 - trailBitCnt, elementInfo);
byte[] byteBuf = new byte[len.Value - 1];
stream.Read(byteBuf, 0, byteBuf.Length);
return(new DecodedObject <object>(new BitString(byteBuf, trailBitCnt), len.Value + len.Size));
}
protected int encodeLength(int val, ElementInfo elementInfo, System.IO.Stream stream)
{
CoderUtils.checkConstraints(val, elementInfo);
int resultSize = 0;
BitArrayOutputStream bitStream = (BitArrayOutputStream)stream;
if (elementInfo.hasPreparedInfo())
{
if (elementInfo.PreparedInfo.hasConstraint())
{
IASN1ConstraintMetadata constraint = elementInfo.PreparedInfo.Constraint;
if (constraint is ASN1ValueRangeConstraintMetadata)
{
resultSize += encodeConstraintLengthDeterminant(
val,
(int)((ASN1ValueRangeConstraintMetadata)constraint).Min,
(int)((ASN1ValueRangeConstraintMetadata)constraint).Max,
bitStream
);
}
else
if (constraint is ASN1SizeConstraintMetadata)
{
}
}
else
{
resultSize += encodeLengthDeterminant(val, bitStream);
}
}
else
{
if (elementInfo.isAttributePresent <ASN1ValueRangeConstraint>())
{
ASN1ValueRangeConstraint constraint = elementInfo.getAttribute <ASN1ValueRangeConstraint>();
resultSize += encodeConstraintLengthDeterminant(val, (int)constraint.Min, (int)constraint.Max, bitStream);
}
else
if (elementInfo.isAttributePresent <ASN1SizeConstraint>())
{
ASN1SizeConstraint constraint = elementInfo.getAttribute <ASN1SizeConstraint>();
}
else
{
resultSize += encodeLengthDeterminant(val, bitStream);
}
}
return(resultSize);
}
public override int encodeString(object obj, Stream stream, ElementInfo elementInfo)
{
int resultSize = 0, sizeOfString = 0;
byte[] buffer = CoderUtils.ASN1StringToBuffer(obj, elementInfo);
sizeOfString = buffer.Length;
CoderUtils.checkConstraints(sizeOfString, elementInfo);
stream.Write(buffer, 0, buffer.Length);
resultSize += sizeOfString;
resultSize += encodeLength(sizeOfString, stream);
resultSize += encodeTag(BERCoderUtils.getTagValueForElement(elementInfo, TagClasses.Universal, ElementType.Primitive, CoderUtils.getStringTagForElement(elementInfo)), stream);
return(resultSize);
}
/**
* @see CoderUtils#defStringToOctetString(String)
*/
public void testDefStringToOctetString()
{
BitString result = CoderUtils.defStringToOctetString("'FFAABBEE'H");
ByteTools.checkBuffers(result.Value, new byte[] { (byte)0xFF, (byte)0xAA, (byte)0xBB, (byte)0xEE });
result = CoderUtils.defStringToOctetString("'FFAABBEEC'H");
ByteTools.checkBuffers(result.Value, new byte[] { (byte)0xFF, (byte)0xAA, (byte)0xBB, (byte)0xEE, (byte)0xC0 });
result = CoderUtils.defStringToOctetString("'111100001111000010011001'B");
ByteTools.checkBuffers(result.Value, new byte[] { (byte)0xF0, (byte)0xF0, (byte)0x99 });
result = CoderUtils.defStringToOctetString("'1111000011110000100110011'B");
ByteTools.checkBuffers(result.Value, new byte[] { (byte)0xF0, (byte)0xF0, (byte)0x99, (byte)0x80 });
}
public override int encodeSequence(object obj, Stream stream, ElementInfo elementInfo)
{
int resultSize = 0;
if (!CoderUtils.isSequenceSet(elementInfo))
{
resultSize += encodeSequencePreamble(obj, elementInfo.getProperties(obj.GetType()), stream, elementInfo);
resultSize += base.encodeSequence(obj, stream, elementInfo);
}
else
{
resultSize += encodeSet(obj, stream, elementInfo);
}
return(resultSize);
}
public override DecodedObject <object> decodeString(DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream)
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, CoderUtils.getStringTagForElement(elementInfo), elementInfo))
{
return(null);
}
DecodedObject <int> len = decodeLength(stream);
CoderUtils.checkConstraints(len.Value, elementInfo);
byte[] byteBuf = new byte[len.Value];
stream.Read(byteBuf, 0, byteBuf.Length);
string result = CoderUtils.bufferToASN1String(byteBuf, elementInfo);
return(new DecodedObject <object>(result, len.Value + len.Size));
}
