Asn1Sequence
using Org.BouncyCastle.Utilities;
using Org.BouncyCastle.Utilities.Collections;
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
namespace Org.BouncyCastle.Asn1
{
public abstract class Asn1Sequence : Asn1Object, IEnumerable<Asn1Encodable>, IEnumerable
{
internal class Meta : Asn1UniversalType
{
internal static readonly Asn1UniversalType Instance = new Meta();
private Meta()
: base(typeof(Asn1Sequence), 16)
{
}
internal override Asn1Object FromImplicitConstructed(Asn1Sequence sequence)
{
return sequence;
}
}
private class Asn1SequenceParserImpl : Asn1SequenceParser, IAsn1Convertible
{
private readonly Asn1Sequence outer;
private readonly int max;
private int index;
public Asn1SequenceParserImpl(Asn1Sequence outer)
{
this.outer = outer;
max = outer.Count;
}
public IAsn1Convertible ReadObject()
{
if (index == max)
return null;
Asn1Encodable asn1Encodable = outer[index++];
if (asn1Encodable is Asn1Sequence)
return ((Asn1Sequence)asn1Encodable).Parser;
if (asn1Encodable is Asn1Set)
return ((Asn1Set)asn1Encodable).Parser;
return asn1Encodable;
}
public Asn1Object ToAsn1Object()
{
return outer;
}
}
internal readonly Asn1Encodable[] elements;
public virtual Asn1SequenceParser Parser => new Asn1SequenceParserImpl(this);
public virtual Asn1Encodable this[int index] {
get {
return elements[index];
}
}
public virtual int Count => elements.Length;
public static Asn1Sequence GetInstance(object obj)
{
if (obj == null)
return null;
Asn1Sequence asn1Sequence = obj as Asn1Sequence;
if (asn1Sequence != null)
return asn1Sequence;
IAsn1Convertible asn1Convertible = obj as IAsn1Convertible;
if (asn1Convertible != null) {
Asn1Sequence asn1Sequence2 = asn1Convertible.ToAsn1Object() as Asn1Sequence;
if (asn1Sequence2 != null)
return asn1Sequence2;
} else {
byte[] array = obj as byte[];
if (array != null)
try {
return (Asn1Sequence)Meta.Instance.FromByteArray(array);
} catch (IOException ex) {
throw new ArgumentException("failed to construct sequence from byte[]: " + ex.Message);
}
}
throw new ArgumentException("illegal object in GetInstance: " + Platform.GetTypeName(obj), "obj");
}
public static Asn1Sequence GetInstance(Asn1TaggedObject taggedObject, bool declaredExplicit)
{
return (Asn1Sequence)Meta.Instance.GetContextInstance(taggedObject, declaredExplicit);
}
protected internal Asn1Sequence()
{
elements = Asn1EncodableVector.EmptyElements;
}
protected internal Asn1Sequence(Asn1Encodable element)
{
if (element == null)
throw new ArgumentNullException("element");
elements = new Asn1Encodable[1] {
element
};
}
protected internal Asn1Sequence(Asn1Encodable element1, Asn1Encodable element2)
{
if (element1 == null)
throw new ArgumentNullException("element1");
if (element2 == null)
throw new ArgumentNullException("element2");
elements = new Asn1Encodable[2] {
element1,
element2
};
}
protected internal Asn1Sequence(params Asn1Encodable[] elements)
{
if (Arrays.IsNullOrContainsNull(elements))
throw new NullReferenceException("'elements' cannot be null, or contain null");
this.elements = Asn1EncodableVector.CloneElements(elements);
}
internal Asn1Sequence(Asn1Encodable[] elements, bool clone)
{
this.elements = (clone ? Asn1EncodableVector.CloneElements(elements) : elements);
}
protected internal Asn1Sequence(Asn1EncodableVector elementVector)
{
if (elementVector == null)
throw new ArgumentNullException("elementVector");
elements = elementVector.TakeElements();
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
public virtual IEnumerator<Asn1Encodable> GetEnumerator()
{
return ((IEnumerable<Asn1Encodable>)elements).GetEnumerator();
}
public virtual T[] MapElements<T>(Func<Asn1Encodable, T> func)
{
int count = Count;
T[] array = new T[count];
for (int i = 0; i < count; i++) {
array[i] = func(elements[i]);
}
return array;
}
public virtual Asn1Encodable[] ToArray()
{
return Asn1EncodableVector.CloneElements(elements);
}
protected override int Asn1GetHashCode()
{
int num = Count;
int num2 = num + 1;
while (--num >= 0) {
num2 *= 257;
num2 ^= elements[num].ToAsn1Object().CallAsn1GetHashCode();
}
return num2;
}
protected override bool Asn1Equals(Asn1Object asn1Object)
{
Asn1Sequence asn1Sequence = asn1Object as Asn1Sequence;
if (asn1Sequence == null)
return false;
int count = Count;
if (asn1Sequence.Count != count)
return false;
for (int i = 0; i < count; i++) {
Asn1Object asn1Object2 = elements[i].ToAsn1Object();
Asn1Object other = asn1Sequence.elements[i].ToAsn1Object();
if (!asn1Object2.Equals(other))
return false;
}
return true;
}
public override string ToString()
{
return CollectionUtilities.ToString(elements);
}
internal DerBitString[] GetConstructedBitStrings()
{
return MapElements(DerBitString.GetInstance);
}
internal Asn1OctetString[] GetConstructedOctetStrings()
{
return MapElements(Asn1OctetString.GetInstance);
}
internal abstract DerBitString ToAsn1BitString();
internal abstract DerExternal ToAsn1External();
internal abstract Asn1OctetString ToAsn1OctetString();
internal abstract Asn1Set ToAsn1Set();
}
}