public override DecodedObject<object> decodeAny(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
int bufSize = elementInfo.MaxAvailableLen;
if (bufSize == 0)
return null;
System.IO.MemoryStream anyStream = new System.IO.MemoryStream(1024);
/*int tagValue = (int)decodedTag.Value;
for (int i = 0; i < decodedTag.Size; i++)
{
anyStream.WriteByte((byte)tagValue);
tagValue = tagValue >> 8;
}*/
if(bufSize<0)
bufSize = 1024;
int len = 0;
if (bufSize > 0)
{
byte[] buffer = new byte[bufSize];
int readed = stream.Read(buffer, 0, buffer.Length);
while (readed > 0)
{
anyStream.Write(buffer, 0, readed);
len += readed;
if (elementInfo.MaxAvailableLen > 0)
break;
readed = stream.Read(buffer, 0, buffer.Length);
}
}
CoderUtils.checkConstraints(len, elementInfo);
return new DecodedObject<object>(anyStream.ToArray(), len);
}
public override DecodedObject <object> decodeReal(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Real, elementInfo))
{
return(null);
}
DecodedObject <int> len = decodeLength(stream);
int realPreamble = stream.ReadByte();
Double result = 0.0D;
int szResult = len.Value;
if ((realPreamble & 0x40) == 1)
{
// 01000000 Value is PLUS-INFINITY
result = Double.PositiveInfinity;
}
if ((realPreamble & 0x41) == 1)
{
// 01000001 Value is MINUS-INFINITY
result = Double.NegativeInfinity;
szResult += 1;
}
else
if (len.Value > 0)
{
int szOfExp = 1 + (realPreamble & 0x3);
int sign = realPreamble & 0x40;
int ff = (realPreamble & 0x0C) >> 2;
DecodedObject <object> exponentEncFrm = decodeLongValue(stream, new DecodedObject <int>(szOfExp));
long exponent = (long)exponentEncFrm.Value;
DecodedObject <object> mantissaEncFrm = decodeLongValue(stream, new DecodedObject <int>(szResult - szOfExp - 1));
// Unpack mantissa & decrement exponent for base 2
long mantissa = (long)mantissaEncFrm.Value << ff;
while ((mantissa & 0x000ff00000000000L) == 0x0)
{
exponent -= 8;
mantissa <<= 8;
}
while ((mantissa & 0x0010000000000000L) == 0x0)
{
exponent -= 1;
mantissa <<= 1;
}
mantissa &= 0x0FFFFFFFFFFFFFL;
long lValue = (exponent + 1023 + 52) << 52;
lValue |= mantissa;
if (sign == 1)
{
lValue = (long)((ulong)lValue | 0x8000000000000000L);
}
#if PocketPC
byte[] dblValAsBytes = System.BitConverter.GetBytes(lValue);
result = System.BitConverter.ToDouble(dblValAsBytes, 0);
#else
result = System.BitConverter.Int64BitsToDouble(lValue);
#endif
}
return(new DecodedObject <object>(result, len.Value + len.Size));
}
public override DecodedObject <object> decodeBitString(DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream)
{
DecodedObject <object> result = new DecodedObject <object>();
skipAlignedBits(stream);
int sizeOfString = decodeLength(elementInfo, stream);
BitArrayInputStream bitStream = (BitArrayInputStream)stream;
skipAlignedBits(stream);
int trailBits = 8 - sizeOfString % 8;
sizeOfString = sizeOfString / 8;
if (sizeOfString > 0 || (sizeOfString == 0 && trailBits > 0))
{
byte[] value = new byte[trailBits > 0 ? sizeOfString + 1 : sizeOfString];
if (sizeOfString > 0)
{
stream.Read(value, 0, sizeOfString);
}
if (trailBits > 0)
{
value[sizeOfString] = (byte)(bitStream.readBits(trailBits) << (8 - trailBits));
}
result.Value = (new BitString(value, trailBits));
}
else
{
result.Value = (new BitString(new byte[0]));
}
return(result);
}
protected internal int encodeHeader(DecodedObject <int> tagValue, int contentLen, Stream stream)
{
int resultSize = encodeLength(contentLen, stream);
resultSize += encodeTag(tagValue, stream);
return(resultSize);
}
public override DecodedObject<object> decodeString(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
if (!PERCoderUtils.is7BitEncodedString(elementInfo))
return base.decodeString(decodedTag, objectClass, elementInfo, stream);
else
{
DecodedObject<object> result = new DecodedObject<object>();
int strLen = decodeLength(elementInfo, stream);
if (strLen <= 0)
{
result.Value = ("");
return result;
}
BitArrayInputStream bitStream = (BitArrayInputStream) stream;
byte[] buffer = new byte[strLen];
// 7-bit decoding of string
for (int i = 0; i < strLen; i++)
buffer[i] = (byte)bitStream.readBits(7);
result.Value = new string(
System.Text.ASCIIEncoding.ASCII.GetChars(buffer)
);
return result;
}
}
public override DecodedObject <object> decodeSequenceOf(DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream)
{
Type paramType = (Type)objectClass.GetGenericArguments()[0];
Type collectionType = typeof(List <>);
Type genCollectionType = collectionType.MakeGenericType(paramType);
Object param = Activator.CreateInstance(genCollectionType);
int countOfElements = decodeLength(elementInfo, stream);
MethodInfo method = param.GetType().GetMethod("Add");
for (int i = 0; i < countOfElements; i++)
{
ElementInfo elementItemInfo = new ElementInfo();
elementItemInfo.ParentAnnotatedClass = elementInfo.AnnotatedClass;
elementItemInfo.AnnotatedClass = paramType;
if (elementInfo.hasPreparedInfo())
{
ASN1SequenceOfMetadata seqOfMeta = (ASN1SequenceOfMetadata)elementInfo.PreparedInfo.TypeMetadata;
elementItemInfo.PreparedInfo = seqOfMeta.getItemClassMetadata();
}
else
{
elementItemInfo.ASN1ElementInfo = null;
}
DecodedObject <object> item = decodeClassType(null, paramType, elementItemInfo, stream);
if (item != null)
{
method.Invoke(param, new[] { item.Value });
}
}
return(new DecodedObject <object>(param));
}
public override DecodedObject <object> decodeString(DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream)
{
if (!PERCoderUtils.is7BitEncodedString(elementInfo))
{
return(base.decodeString(decodedTag, objectClass, elementInfo, stream));
}
else
{
DecodedObject <object> result = new DecodedObject <object>();
int strLen = decodeLength(elementInfo, stream);
if (strLen <= 0)
{
result.Value = "";
}
else
{
BitArrayInputStream bitStream = (BitArrayInputStream)stream;
// 7-bit decoding of string
byte[] buffer = new byte[strLen];
for (int i = 0; i < strLen; i++)
{
buffer[i] = (byte)bitStream.readBits(7);
}
result.Value = new string(ASCIIEncoding.ASCII.GetChars(buffer));
}
return(result);
}
}
public override DecodedObject <object> decodeBoolean(DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream)
{
DecodedObject <object> result = new DecodedObject <object>();
BitArrayInputStream bitStream = (BitArrayInputStream)stream;
result.Value = (bitStream.readBit() == 1);
return(result);
}
public override DecodedObject <object> decodeEnumItem(DecodedObject <object> decodedTag, System.Type objectClass, System.Type enumClass, ElementInfo elementInfo, System.IO.Stream stream)
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Enumerated, elementInfo))
{
return(null);
}
return(decodeIntegerValue(stream));
}
public override DecodedObject <object> decodeReal(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
BitArrayInputStream bitStream = (BitArrayInputStream)stream;
int len = decodeLengthDeterminant(bitStream);
int realPreamble = stream.ReadByte();
skipAlignedBits(stream);
Double result = 0.0D;
int szResult = len;
if ((realPreamble & 0x40) == 1)
{
// 01000000 Value is PLUS-INFINITY
result = Double.PositiveInfinity;
}
if ((realPreamble & 0x41) == 1)
{
// 01000001 Value is MINUS-INFINITY
result = Double.NegativeInfinity;
szResult += 1;
}
else
if (len > 0)
{
int szOfExp = 1 + (realPreamble & 0x3);
int sign = realPreamble & 0x40;
int ff = (realPreamble & 0x0C) >> 2;
long exponent = decodeIntegerValueAsBytes(szOfExp, stream);
long mantissaEncFrm = decodeIntegerValueAsBytes(szResult - szOfExp - 1, stream);
// Unpack mantissa & decrement exponent for base 2
long mantissa = mantissaEncFrm << ff;
while ((mantissa & 0x000ff00000000000L) == 0x0)
{
exponent -= 8;
mantissa <<= 8;
}
while ((mantissa & 0x0010000000000000L) == 0x0)
{
exponent -= 1;
mantissa <<= 1;
}
mantissa &= 0x0FFFFFFFFFFFFFL;
long lValue = (exponent + 1023 + 52) << 52;
lValue |= mantissa;
if (sign == 1)
{
lValue = (long)((ulong)lValue | 0x8000000000000000L);
}
#if PocketPC
byte[] dblValAsBytes = System.BitConverter.GetBytes(lValue);
result = System.BitConverter.ToDouble(dblValAsBytes, 0);
#else
result = System.BitConverter.Int64BitsToDouble(lValue);
#endif
}
return(new DecodedObject <object>(result, szResult));
}
protected bool checkTagForObject(DecodedObject <object> decodedTag, int tagClass, int elementType, int universalTag, ElementInfo elementInfo)
{
if (decodedTag == null)
{
return(false);
}
int definedTag = BERCoderUtils.getTagValueForElement(elementInfo, tagClass, elementType, universalTag).Value;
return(definedTag == (int)decodedTag.Value);
}
public override DecodedObject <object> decodeObjectIdentifier(DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream)
{
DecodedObject <int> len = BERCoderUtils.decodeLength(stream);
byte[] byteBuf = new byte[len.value];
stream.Read(byteBuf, 0, byteBuf.Length);
string dottedDecimal = BERObjectIdentifier.Decode(byteBuf);
return(new DecodedObject <object>(new ObjectIdentifier(dottedDecimal)));
}
public override DecodedObject<object> decodeBitString(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.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);
}
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 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> decodeBoolean(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Boolean, elementInfo))
return null;
DecodedObject<object> result = decodeIntegerValue(stream);
int val = (int) result.Value;
if (val != 0)
result.Value = true;
else
result.Value = false;
return result;
}
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> decodeNull(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Null, elementInfo))
{
return(null);
}
stream.ReadByte(); // ignore null length
object obj = createInstanceForElement(objectClass, elementInfo);
DecodedObject <object> result = new DecodedObject <object>(obj, 1);
return(result);
}
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 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));
}
public override DecodedObject <object> decodeObjectIdentifier(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.ObjectIdentifier, elementInfo))
{
return(null);
}
DecodedObject <int> len = decodeLength(stream);
byte[] byteBuf = new byte[len.Value];
stream.Read(byteBuf, 0, byteBuf.Length);
string dottedDecimal = BERObjectIdentifier.Decode(byteBuf);
return(new DecodedObject <object>(new ObjectIdentifier(dottedDecimal)));
}
public static DecodedObject <int> getTagValueForElement(ElementInfo info, int tagClass, int elemenType, int universalTag)
{
DecodedObject <int> result = new DecodedObject <int>();
// result.Value = tagClass | elemenType | universalTag;
if (universalTag < UniversalTags.LastUniversal)
{
result.Value = tagClass | elemenType | universalTag;
}
else
{
result = getTagValue(tagClass, elemenType, universalTag, universalTag, tagClass);
}
result.Size = 1;
if (info.hasPreparedInfo())
{
ASN1ElementMetadata meta = info.PreparedASN1ElementInfo;
if (meta != null && meta.HasTag)
{
result = getTagValue(tagClass, elemenType, universalTag,
meta.Tag,
meta.TagClass
);
}
}
else
{
ASN1Element elementInfo = null;
if (info.ASN1ElementInfo != null)
{
elementInfo = info.ASN1ElementInfo;
}
else
if (info.isAttributePresent <ASN1Element>())
{
elementInfo = info.getAttribute <ASN1Element>();
}
if (elementInfo != null)
{
if (elementInfo.HasTag)
{
result = getTagValue(tagClass, elemenType, universalTag, elementInfo.Tag, elementInfo.TagClass);
}
}
}
return(result);
}
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));
}
public static DecodedObject<int> getTagValueForElement(ElementInfo info, int tagClass, int elemenType, int universalTag)
{
DecodedObject<int> result = new DecodedObject<int>();
// result.Value = tagClass | elemenType | universalTag;
if (universalTag < UniversalTags.LastUniversal)
{
result.Value = tagClass | elemenType | universalTag;
}
else
result = getTagValue(tagClass, elemenType, universalTag, universalTag, tagClass);
result.Size = 1;
if (info.hasPreparedInfo())
{
ASN1ElementMetadata meta = info.PreparedASN1ElementInfo;
if (meta != null && meta.HasTag)
{
result = getTagValue(tagClass, elemenType, universalTag,
meta.Tag,
meta.TagClass
);
}
}
else
{
ASN1Element elementInfo = null;
if (info.ASN1ElementInfo != null)
{
elementInfo = info.ASN1ElementInfo;
}
else if (info.isAttributePresent<ASN1Element>())
{
elementInfo = info.getAttribute<ASN1Element>();
}
if (elementInfo != null)
{
if (elementInfo.HasTag)
{
result = getTagValue(tagClass, elemenType, universalTag, elementInfo.Tag, elementInfo.TagClass);
}
}
}
return result;
}
public override DecodedObject <object> decodeSequence(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
bool isSet = false;
if (!CoderUtils.isSequenceSet(elementInfo))
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Constructed, UniversalTags.Sequence, elementInfo))
{
return(null);
}
}
else
{
if (checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Constructed, UniversalTags.Set, elementInfo))
{
isSet = true;
}
else
{
return(null);
}
}
DecodedObject <int> len = decodeLength(stream);
int saveMaxAvailableLen = elementInfo.MaxAvailableLen;
elementInfo.MaxAvailableLen = (len.Value);
DecodedObject <object> result = null;
if (!isSet)
{
result = base.decodeSequence(decodedTag, objectClass, elementInfo, stream);
}
else
{
result = decodeSet(decodedTag, objectClass, elementInfo, len.Value, stream);
}
if (result.Size != len.Value)
{
throw new System.ArgumentException("Sequence '" + objectClass.ToString() + "' size is incorrect!");
}
result.Size = result.Size + len.Size;
elementInfo.MaxAvailableLen = (saveMaxAvailableLen);
return(result);
}
public override DecodedObject <object> decodeOctetString(DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream)
{
DecodedObject <object> result = new DecodedObject <object>();
int sizeOfString = decodeLength(elementInfo, stream);
skipAlignedBits(stream);
if (sizeOfString > 0)
{
byte[] val = new byte[sizeOfString];
stream.Read(val, 0, val.Length);
result.Value = val;
}
else
{
result.Value = (new byte[0]);
}
return(result);
}
public override DecodedObject <object> decodeString(DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream)
{
DecodedObject <object> result = new DecodedObject <object>();
int strLen = decodeLength(elementInfo, stream);
skipAlignedBits(stream);
if (strLen > 0)
{
byte[] val = new byte[strLen];
stream.Read(val, 0, val.Length);
result.Value = CoderUtils.bufferToASN1String(val, elementInfo);
}
else
{
result.Value = ("");
}
return(result);
}
public override DecodedObject <object> decodeInteger(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Integer, elementInfo))
{
return(null);
}
if (objectClass.Equals(typeof(int)))
{
DecodedObject <object> result = decodeIntegerValue(stream);
CoderUtils.checkConstraints((int)result.Value, elementInfo);
return(result);
}
else
{
DecodedObject <object> result = decodeLongValue(stream);
CoderUtils.checkConstraints((long)result.Value, elementInfo);
return(result);
}
}
public override DecodedObject <object> decodeBoolean(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Boolean, elementInfo))
{
return(null);
}
DecodedObject <object> result = decodeIntegerValue(stream);
int val = (int)result.Value;
if (val != 0)
{
result.Value = true;
}
else
{
result.Value = false;
}
return(result);
}
public override DecodedObject <object> decodeChoice(DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream)
{
object choice = createInstanceForElement(objectClass, elementInfo);
skipAlignedBits(stream);
PropertyInfo[] fields = elementInfo.getProperties(objectClass);
int elementIndex = (int)decodeConstraintNumber(1, fields.Length, (BitArrayInputStream)stream);
DecodedObject <object> val = null;
for (int i = 0; i < elementIndex && i < fields.Length; i++)
{
if (i + 1 == elementIndex)
{
PropertyInfo field = fields[i];
ElementInfo info = new ElementInfo();
info.AnnotatedClass = field;
if (elementInfo.hasPreparedInfo())
{
info.PreparedInfo = elementInfo.PreparedInfo.getPropertyMetadata(i);
}
else
{
info.ASN1ElementInfo = CoderUtils.getAttribute <ASN1Element>(field);
}
val = decodeClassType(decodedTag, field.PropertyType, info, stream);
if (val != null)
{
invokeSelectMethodForField(field, choice, val.Value, info);
}
break;
}
;
}
if (val == null && !CoderUtils.isOptional(elementInfo))
{
throw new ArgumentException("The choice '" + objectClass + "' does not have a selected item!");
}
else
{
return(new DecodedObject <object>(choice));
}
}
public override DecodedObject <object> decodeChoice(DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
if ((elementInfo.hasPreparedInfo() && elementInfo.hasPreparedASN1ElementInfo() && elementInfo.PreparedASN1ElementInfo.HasTag) ||
(elementInfo.ASN1ElementInfo != null && elementInfo.ASN1ElementInfo.HasTag))
{
if (!checkTagForObject(decodedTag, TagClasses.ContextSpecific, ElementType.Constructed, UniversalTags.LastUniversal, elementInfo))
{
return(null);
}
DecodedObject <int> len = decodeLength(stream);
DecodedObject <object> childDecodedTag = decodeTag(stream);
DecodedObject <object> result = base.decodeChoice(childDecodedTag, objectClass, elementInfo, stream);
result.Size += len.Size + childDecodedTag.Size;
return(result);
}
else
{
return(base.decodeChoice(decodedTag, objectClass, elementInfo, stream));
}
}
public static DecodedObject <int> getTagValue(int tagClass, int elemenType, int universalTag, int userTag, int userTagClass)
{
DecodedObject <int> resultObj = new DecodedObject <int>();
int result = tagClass | elemenType | universalTag;
tagClass = userTagClass;
if (userTag < 31)
{
result = tagClass | elemenType | userTag;
resultObj.Size = 1;
}
else
{
result = tagClass | elemenType | 0x1F;
if (userTag < 0x80)
{
result <<= 8;
result |= userTag & 0x7F;
resultObj.Size = 2;
}
else
if (userTag < 0x3FFF)
{
result <<= 16;
result |= (((userTag & 0x3FFF) >> 7) | 0x80) << 8;
result |= ((userTag & 0x3FFF) & 0x7f);
resultObj.Size = 3;
}
else
if (userTag < 0x3FFFF)
{
result <<= 24;
result |= (((userTag & 0x3FFFF) >> 15) | 0x80) << 16;
result |= (((userTag & 0x3FFFF) >> 7) | 0x80) << 8;
result |= ((userTag & 0x3FFFF) & 0x3f);
resultObj.Size = 4;
}
}
resultObj.Value = result;
return(resultObj);
}
public override DecodedObject <object> decodeInteger(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
bool hasConstraint = false;
long min = 0, max = 0;
if (elementInfo.hasPreparedInfo())
{
if (elementInfo.PreparedInfo.hasConstraint() &&
elementInfo.PreparedInfo.Constraint is ASN1ValueRangeConstraintMetadata)
{
IASN1ConstraintMetadata constraint = elementInfo.PreparedInfo.Constraint;
hasConstraint = true;
min = ((ASN1ValueRangeConstraintMetadata)constraint).Min;
max = ((ASN1ValueRangeConstraintMetadata)constraint).Max;
}
}
else
if (elementInfo.isAttributePresent <ASN1ValueRangeConstraint>())
{
hasConstraint = true;
ASN1ValueRangeConstraint constraint = elementInfo.getAttribute <ASN1ValueRangeConstraint>();
min = constraint.Min;
max = constraint.Max;
}
DecodedObject <object> result = new DecodedObject <object>();
BitArrayInputStream bitStream = (BitArrayInputStream)stream;
int val = 0;
if (hasConstraint)
{
ASN1ValueRangeConstraint constraint = elementInfo.getAttribute <ASN1ValueRangeConstraint>();
val = (int)decodeConstraintNumber(min, max, bitStream);
}
else
{
val = decodeUnconstraintNumber(bitStream);
}
result.Value = val;
return(result);
}
public override DecodedObject <object> decodeAny(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
int bufSize = elementInfo.MaxAvailableLen;
if (bufSize == 0)
{
return(null);
}
System.IO.MemoryStream anyStream = new System.IO.MemoryStream(1024);
/*int tagValue = (int)decodedTag.Value;
* for (int i = 0; i < decodedTag.Size; i++)
* {
* anyStream.WriteByte((byte)tagValue);
* tagValue = tagValue >> 8;
* }*/
if (bufSize < 0)
{
bufSize = 1024;
}
int len = 0;
if (bufSize > 0)
{
byte[] buffer = new byte[bufSize];
int readed = stream.Read(buffer, 0, buffer.Length);
while (readed > 0)
{
anyStream.Write(buffer, 0, readed);
len += readed;
if (elementInfo.MaxAvailableLen > 0)
{
break;
}
readed = stream.Read(buffer, 0, buffer.Length);
}
}
CoderUtils.checkConstraints(len, elementInfo);
return(new DecodedObject <object>(anyStream.ToArray(), len));
}
protected internal int encodeTag(DecodedObject <int> tagValue, Stream stream)
{
int resultSize = tagValue.Size;
int value = tagValue.Value;
for (int i = 0; i < tagValue.Size; i++)
{
stream.WriteByte((byte)value);
value = value >> 8;
}
return(resultSize);
/*int resultSize = 0;
* if (tagValue.Size == 1)
* {
* stream.WriteByte((byte)tagValue.Value);
* resultSize++;
* }
* else
* resultSize += encodeIntegerValue(tagValue.Value, stream);
* return resultSize;*/
}
public abstract DecodedObject<object> decode(IASN1TypesDecoder decoder, DecodedObject<object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream);
public override DecodedObject<object> decodeString(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.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);
}
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> decodeInteger(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Integer, elementInfo))
return null;
if (objectClass.Equals(typeof(int)))
{
DecodedObject<object> result = decodeIntegerValue(stream);
CoderUtils.checkConstraints((int)result.Value, elementInfo);
return result;
}
else
{
DecodedObject<object> result = decodeLongValue(stream);
CoderUtils.checkConstraints((long)result.Value, elementInfo);
return result;
}
}
protected internal virtual DecodedObject<object> decodeLongValue(System.IO.Stream stream, DecodedObject<int> len)
{
DecodedObject<object> result = new DecodedObject<object>();
long val = 0;
for (int i = 0; i < len.Value; i++)
{
long bt = stream.ReadByte();
if (bt == -1)
{
throw new System.ArgumentException("Unexpected EOF when encoding!");
}
if (i == 0 && (bt & (byte)0x80) != 0)
{
bt = bt - 256;
}
val = (val << 8) | bt;
}
result.Value = val;
result.Size = len.Value + len.Size;
return result;
}
public override DecodedObject<object> decodeObjectIdentifier(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.ObjectIdentifier, elementInfo))
return null;
DecodedObject<int> len = decodeLength(stream);
byte[] byteBuf = new byte[len.Value];
stream.Read(byteBuf, 0, byteBuf.Length);
string dottedDecimal = BERObjectIdentifier.Decode(byteBuf);
return new DecodedObject<object>(new ObjectIdentifier(dottedDecimal));
}
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);
}
protected bool checkTagForObject(DecodedObject<object> decodedTag, int tagClass, int elementType, int universalTag, ElementInfo elementInfo)
{
if (decodedTag == null)
return false;
int definedTag = BERCoderUtils.getTagValueForElement(elementInfo, tagClass, elementType, universalTag).Value;
return definedTag == (int)decodedTag.Value;
}
public override DecodedObject<object> decodeEnumItem(DecodedObject<object> decodedTag, System.Type objectClass, System.Type enumClass, ElementInfo elementInfo, System.IO.Stream stream)
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Enumerated, elementInfo))
return null;
return decodeIntegerValue(stream);
}
protected virtual DecodedObject<object> decodeSet(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, int len, System.IO.Stream stream)
{
object sequence = createInstanceForElement(objectClass,elementInfo);
initDefaultValues(sequence);
DecodedObject<object> fieldTag = null;
int sizeOfSequence = 0;
int maxSeqLen = elementInfo.MaxAvailableLen;
if (maxSeqLen == -1 || maxSeqLen > 0)
{
fieldTag = decodeTag(stream);
if (fieldTag != null)
sizeOfSequence += fieldTag.Size;
}
PropertyInfo[] fields =
elementInfo.getProperties(objectClass);
bool fieldEncoded = false;
do
{
for (int i = 0; i < fields.Length; i++)
{
PropertyInfo field = fields[i];
DecodedObject<object> obj = decodeSequenceField(
fieldTag, sequence, i, field, stream, elementInfo, false
);
if (obj != null)
{
fieldEncoded = true;
sizeOfSequence += obj.Size;
bool isAny = false;
if (i + 1 == fields.Length - 1)
{
ElementInfo info = new ElementInfo();
info.AnnotatedClass = (fields[i + 1]);
info.MaxAvailableLen = (elementInfo.MaxAvailableLen);
if (elementInfo.hasPreparedInfo())
{
info.PreparedInfo = (elementInfo.PreparedInfo.getPropertyMetadata(i + 1));
}
else
info.ASN1ElementInfo = CoderUtils.getAttribute<ASN1Element>(fields[i + 1]);
isAny = CoderUtils.isAnyField(fields[i + 1], info);
}
if (maxSeqLen != -1)
{
elementInfo.MaxAvailableLen = (maxSeqLen - sizeOfSequence);
}
if (!isAny)
{
if (i < fields.Length - 1)
{
if (maxSeqLen == -1 || elementInfo.MaxAvailableLen > 0)
{
fieldTag = decodeTag(stream);
if (fieldTag != null)
sizeOfSequence += fieldTag.Size;
else
{
break;
}
}
else
fieldTag = null;
}
else
break;
}
}
;
}
}
while (sizeOfSequence < len && fieldEncoded);
return new DecodedObject<object>(sequence, sizeOfSequence);
}
protected DecodedObject<object> decodeIntegerValue(System.IO.Stream stream)
{
DecodedObject<object> result = new DecodedObject<object>();
DecodedObject<int> len = decodeLength(stream);
int val = 0;
for (int i = 0; i < len.Value; i++)
{
int bt = stream.ReadByte();
if (bt == -1)
{
throw new System.ArgumentException("Unexpected EOF when encoding!");
}
if (i == 0 && (bt & (byte)0x80) != 0)
{
bt = bt - 256;
}
val = (val << 8) | bt;
}
result.Value = val;
result.Size = len.Value + len.Size;
return result;
}
public override DecodedObject<object> decode(IASN1TypesDecoder decoder, DecodedObject<object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream)
{
elementInfo.PreparedInstance = null;
return decoder.decodeElement(decodedTag, objectClass, elementInfo, stream);
}
public static DecodedObject<int> getTagValue(int tagClass, int elemenType, int universalTag, int userTag, int userTagClass)
{
DecodedObject<int> resultObj = new DecodedObject<int>();
int result = tagClass | elemenType | universalTag;
tagClass = userTagClass;
if (userTag < 31)
{
result = tagClass | elemenType | userTag;
resultObj.Size = 1;
}
else
{
result = tagClass | elemenType | 0x1F;
if (userTag < 0x80)
{
result <<= 8;
result |= userTag & 0x7F;
resultObj.Size = 2;
}
else
if (userTag < 0x3FFF)
{
result <<= 16;
result |= (((userTag & 0x3FFF) >> 7) | 0x80) << 8;
result |= ((userTag & 0x3FFF) & 0x7f);
resultObj.Size = 3;
}
else
if (userTag < 0x3FFFF)
{
result <<= 24;
result |= (((userTag & 0x3FFFF) >> 15) | 0x80) << 16;
result |= (((userTag & 0x3FFFF) >> 7) | 0x80) << 8;
result |= ((userTag & 0x3FFFF) & 0x3f);
resultObj.Size = 4;
}
}
resultObj.Value = result;
return resultObj;
}
public override DecodedObject<object> decodeOctetString(DecodedObject<object> decodedTag, Type objectClass, ElementInfo elementInfo, 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 DecodedObject<object> decodeChoice(DecodedObject<object> decodedTag, Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
if ( (elementInfo.hasPreparedInfo() && elementInfo.hasPreparedASN1ElementInfo() && elementInfo.PreparedASN1ElementInfo.HasTag)
|| (elementInfo.ASN1ElementInfo != null && elementInfo.ASN1ElementInfo.HasTag))
{
if (!checkTagForObject(decodedTag, TagClasses.ContextSpecific, ElementType.Constructed, UniversalTags.LastUniversal, elementInfo))
return null;
DecodedObject<int> len = decodeLength(stream);
DecodedObject<object> childDecodedTag = decodeTag(stream);
DecodedObject<object> result = base.decodeChoice(childDecodedTag, objectClass, elementInfo, stream);
result.Size += len.Size + childDecodedTag.Size;
return result;
}
else
return base.decodeChoice(decodedTag, objectClass, elementInfo, stream);
}
public override DecodedObject<object> decodeReal(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Real, elementInfo))
return null;
DecodedObject<int> len = decodeLength(stream);
int realPreamble = stream.ReadByte();
Double result = 0.0D;
int szResult = len.Value;
if ((realPreamble & 0x40) == 1)
{
// 01000000 Value is PLUS-INFINITY
result = Double.PositiveInfinity;
}
if ((realPreamble & 0x41) == 1)
{
// 01000001 Value is MINUS-INFINITY
result = Double.NegativeInfinity;
szResult += 1;
}
else
if (len.Value > 0)
{
int szOfExp = 1 + (realPreamble & 0x3);
int sign = realPreamble & 0x40;
int ff = (realPreamble & 0x0C) >> 2;
DecodedObject<object> exponentEncFrm = decodeLongValue(stream, new DecodedObject<int>(szOfExp));
long exponent = (long)exponentEncFrm.Value;
DecodedObject<object> mantissaEncFrm = decodeLongValue(stream, new DecodedObject<int>(szResult - szOfExp - 1));
// Unpack mantissa & decrement exponent for base 2
long mantissa = (long)mantissaEncFrm.Value << ff;
while ((mantissa & 0x000ff00000000000L) == 0x0)
{
exponent -= 8;
mantissa <<= 8;
}
while ((mantissa & 0x0010000000000000L) == 0x0)
{
exponent -= 1;
mantissa <<= 1;
}
mantissa &= 0x0FFFFFFFFFFFFFL;
long lValue = (exponent + 1023 + 52) << 52;
lValue |= mantissa;
if (sign == 1)
{
lValue = (long)((ulong)lValue | 0x8000000000000000L);
}
#if PocketPC
byte[] dblValAsBytes = System.BitConverter.GetBytes(lValue);
result = System.BitConverter.ToDouble(dblValAsBytes, 0);
#else
result = System.BitConverter.Int64BitsToDouble(lValue);
#endif
}
return new DecodedObject<object>(result, len.Value + len.Size);
}
public override DecodedObject<object> decodeNull(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Null, elementInfo))
return null;
stream.ReadByte(); // ignore null length
object obj = createInstanceForElement(objectClass, elementInfo);
DecodedObject<object> result = new DecodedObject<object>(obj, 1);
return result;
}
public override DecodedObject<object> decode(IASN1TypesDecoder decoder, DecodedObject<object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream)
{
return decoder.decodeSequence(decodedTag,objectClass,elementInfo,stream);
}
public override DecodedObject<object> decodeSequence(DecodedObject<object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
bool isSet = false;
if (!CoderUtils.isSequenceSet(elementInfo))
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Constructed, UniversalTags.Sequence, elementInfo))
{
return null;
}
}
else
{
if (checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Constructed, UniversalTags.Set, elementInfo))
{
isSet = true;
}
else
return null;
}
DecodedObject<int> len = decodeLength(stream);
int saveMaxAvailableLen = elementInfo.MaxAvailableLen;
elementInfo.MaxAvailableLen = (len.Value);
DecodedObject<object> result = null;
if(!isSet)
result =base.decodeSequence(decodedTag, objectClass, elementInfo, stream);
else
result = decodeSet(decodedTag, objectClass, elementInfo, len.Value, stream);
if (result.Size != len.Value)
throw new System.ArgumentException("Sequence '" + objectClass.ToString() + "' size is incorrect!");
result.Size = result.Size + len.Size;
elementInfo.MaxAvailableLen = (saveMaxAvailableLen);
return result;
}
