Asn1EncodableVector
public class Asn1EncodableVector : IReadOnlyCollection<Asn1Encodable>, IEnumerable<Asn1Encodable>, IEnumerable
using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
namespace Org.BouncyCastle.Asn1
{
public class Asn1EncodableVector : IReadOnlyCollection<Asn1Encodable>, IEnumerable<Asn1Encodable>, IEnumerable
{
internal static readonly Asn1Encodable[] EmptyElements = Array.Empty<Asn1Encodable>();
private const int DefaultCapacity = 10;
private Asn1Encodable[] m_elements;
private int m_elementCount;
private bool m_copyOnWrite;
public Asn1Encodable this[int index] {
get {
if (index >= m_elementCount)
throw new IndexOutOfRangeException(index.ToString() + " >= " + m_elementCount.ToString());
return m_elements[index];
}
}
public int Count => m_elementCount;
public static Asn1EncodableVector FromCollection(IReadOnlyCollection<Asn1Encodable> c)
{
Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector(c.Count);
asn1EncodableVector.AddAll((IEnumerable<Asn1Encodable>)c);
return asn1EncodableVector;
}
public static Asn1EncodableVector FromElement(Asn1Encodable element)
{
return new Asn1EncodableVector(1) {
element
};
}
public static Asn1EncodableVector FromEnumerable(IEnumerable<Asn1Encodable> e)
{
Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector();
asn1EncodableVector.AddAll(e);
return asn1EncodableVector;
}
public Asn1EncodableVector()
: this(10)
{
}
public Asn1EncodableVector(int initialCapacity)
{
if (initialCapacity < 0)
throw new ArgumentException("must not be negative", "initialCapacity");
m_elements = ((initialCapacity == 0) ? EmptyElements : new Asn1Encodable[initialCapacity]);
m_elementCount = 0;
m_copyOnWrite = false;
}
public Asn1EncodableVector(Asn1Encodable element)
: this()
{
Add(element);
}
public Asn1EncodableVector(Asn1Encodable element1, Asn1Encodable element2)
: this()
{
Add(element1);
Add(element2);
}
public Asn1EncodableVector(params Asn1Encodable[] v)
: this()
{
Add(v);
}
public void Add(Asn1Encodable element)
{
if (element == null)
throw new ArgumentNullException("element");
PrepareCapacity(1);
m_elements[m_elementCount++] = element;
}
public void Add(Asn1Encodable element1, Asn1Encodable element2)
{
Add(element1);
Add(element2);
}
public void Add(params Asn1Encodable[] objs)
{
foreach (Asn1Encodable element in objs) {
Add(element);
}
}
public void AddOptional(Asn1Encodable element)
{
if (element != null)
Add(element);
}
public void AddOptional(Asn1Encodable element1, Asn1Encodable element2)
{
AddOptional(element1);
AddOptional(element2);
}
public void AddOptional(params Asn1Encodable[] elements)
{
if (elements != null) {
foreach (Asn1Encodable element in elements) {
AddOptional(element);
}
}
}
public void AddOptionalTagged(bool isExplicit, int tagNo, Asn1Encodable obj)
{
if (obj != null)
Add(new DerTaggedObject(isExplicit, tagNo, obj));
}
public void AddOptionalTagged(bool isExplicit, int tagClass, int tagNo, Asn1Encodable obj)
{
if (obj != null)
Add(new DerTaggedObject(isExplicit, tagClass, tagNo, obj));
}
public void AddAll(IEnumerable<Asn1Encodable> e)
{
if (e == null)
throw new ArgumentNullException("e");
foreach (Asn1Encodable item in e) {
Add(item);
}
}
public void AddAll(IReadOnlyCollection<Asn1Encodable> c)
{
if (c == null)
throw new ArgumentNullException("c");
int count = c.Count;
if (count >= 1) {
PrepareCapacity(count);
AddAll((IEnumerable<Asn1Encodable>)c);
}
}
public void AddAll(Asn1EncodableVector other)
{
if (other == null)
throw new ArgumentNullException("other");
int count = other.Count;
if (count >= 1) {
PrepareCapacity(count);
Array.Copy(other.m_elements, 0, m_elements, m_elementCount, count);
m_elementCount += count;
}
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
public IEnumerator<Asn1Encodable> GetEnumerator()
{
return EnumerateElements(m_elements, m_elementCount).GetEnumerator();
}
internal Asn1Encodable[] CopyElements()
{
return CopyElements(m_elements, m_elementCount);
}
internal Asn1Encodable[] TakeElements()
{
if (m_elementCount == 0)
return EmptyElements;
if (m_elements.Length == m_elementCount) {
m_copyOnWrite = true;
return m_elements;
}
Asn1Encodable[] array = new Asn1Encodable[m_elementCount];
Array.Copy(m_elements, 0, array, 0, m_elementCount);
return array;
}
private int PrepareCapacity(int requiredCapacity)
{
int num = m_elements.Length;
int num2 = m_elementCount + requiredCapacity;
if ((num2 > num) | m_copyOnWrite)
Reallocate(num2);
return num2;
}
private void Reallocate(int minCapacity)
{
Asn1Encodable[] array = new Asn1Encodable[System.Math.Max(m_elements.Length, minCapacity + (minCapacity >> 1))];
Array.Copy(m_elements, 0, array, 0, m_elementCount);
m_elements = array;
m_copyOnWrite = false;
}
internal static Asn1Encodable[] CloneElements(Asn1Encodable[] elements)
{
return CopyElements(elements, elements.Length);
}
private static Asn1Encodable[] CopyElements(Asn1Encodable[] elements, int elementCount)
{
if (elementCount < 1)
return EmptyElements;
Asn1Encodable[] array = new Asn1Encodable[elementCount];
Array.Copy(elements, 0, array, 0, elementCount);
return array;
}
[IteratorStateMachine(typeof(<EnumerateElements>d__36))]
private static IEnumerable<Asn1Encodable> EnumerateElements(Asn1Encodable[] elements, int elementCount)
{
<EnumerateElements>d__36 <EnumerateElements>d__ = new <EnumerateElements>d__36(-2);
<EnumerateElements>d__.<>3__elements = elements;
<EnumerateElements>d__.<>3__elementCount = elementCount;
return <EnumerateElements>d__;
}
}
}