AttributeTable
using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
namespace Org.BouncyCastle.Asn1.Cms
{
public class AttributeTable : IReadOnlyCollection<Attribute>, IEnumerable<Attribute>, IEnumerable
{
private readonly Dictionary<DerObjectIdentifier, object> m_attributes;
private readonly int m_count;
public Attribute this[DerObjectIdentifier oid] {
get {
if (!m_attributes.TryGetValue(oid, out object value))
return null;
List<Attribute> list = value as List<Attribute>;
if (list != null)
return list[0];
Attribute attribute = value as Attribute;
if (attribute != null)
return attribute;
throw new InvalidOperationException();
}
}
public int Count => m_count;
public AttributeTable(IDictionary<DerObjectIdentifier, object> attrs)
{
m_attributes = BuildAttributes(attrs, out m_count);
}
public AttributeTable(Asn1EncodableVector v)
{
m_attributes = BuildAttributes(v, out m_count);
}
public AttributeTable(IReadOnlyCollection<Attribute> attributes)
{
m_attributes = BuildAttributes(attributes, out m_count);
}
public AttributeTable(Asn1Set s)
{
m_attributes = BuildAttributes(s, out m_count);
}
public AttributeTable(Attributes attrs)
: this(Asn1Set.GetInstance(attrs.ToAsn1Object()))
{
}
private AttributeTable(Dictionary<DerObjectIdentifier, object> attributes, int count)
{
m_attributes = attributes;
m_count = count;
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
public virtual IEnumerator<Attribute> GetEnumerator()
{
return EnumerateAttributes(m_attributes).GetEnumerator();
}
public Asn1EncodableVector GetAll(DerObjectIdentifier oid)
{
if (!m_attributes.TryGetValue(oid, out object value))
return new Asn1EncodableVector(0);
List<Attribute> list = value as List<Attribute>;
if (list != null)
return Asn1EncodableVector.FromCollection(list);
Attribute attribute = value as Attribute;
if (attribute != null)
return Asn1EncodableVector.FromElement(attribute);
throw new InvalidOperationException();
}
public IDictionary<DerObjectIdentifier, object> ToDictionary()
{
int count;
return BuildAttributes(m_attributes, out count);
}
public Asn1EncodableVector ToAsn1EncodableVector()
{
return Asn1EncodableVector.FromCollection(this);
}
public Attributes ToAttributes()
{
return new Attributes(this);
}
public AttributeTable Add(params Attribute[] attributes)
{
if (attributes == null || attributes.Length < 1)
return this;
int count;
Dictionary<DerObjectIdentifier, object> attributes2 = BuildAttributes(m_attributes, out count);
foreach (Attribute a in attributes) {
AddAttribute(attributes2, a);
}
count += attributes.Length;
return new AttributeTable(attributes2, count);
}
public AttributeTable Add(DerObjectIdentifier attrType, Asn1Encodable attrValue)
{
return Add(new Attribute(attrType, new DerSet(attrValue)));
}
public AttributeTable Remove(DerObjectIdentifier attrType)
{
int num = CountAttributesOfType(m_attributes, attrType);
if (num < 1)
return this;
int count;
Dictionary<DerObjectIdentifier, object> dictionary = BuildAttributes(m_attributes, out count);
if (!dictionary.Remove(attrType))
throw new InvalidOperationException();
int count2 = count - num;
return new AttributeTable(dictionary, count2);
}
private static void AddAttribute(Dictionary<DerObjectIdentifier, object> attributes, Attribute a)
{
DerObjectIdentifier attrType = a.AttrType;
if (!attributes.TryGetValue(attrType, out object value))
attributes.Add(attrType, a);
else {
List<Attribute> list = value as List<Attribute>;
if (list != null)
list.Add(a);
else {
Attribute attribute = value as Attribute;
if (attribute == null)
throw new InvalidOperationException();
attributes[attrType] = new List<Attribute> {
attribute,
a
};
}
}
}
private static Dictionary<DerObjectIdentifier, object> BuildAttributes(IDictionary<DerObjectIdentifier, object> d, out int count)
{
Dictionary<DerObjectIdentifier, object> dictionary = new Dictionary<DerObjectIdentifier, object>();
count = 0;
foreach (KeyValuePair<DerObjectIdentifier, object> item in d) {
List<Attribute> list = item.Value as List<Attribute>;
if (list != null) {
List<Attribute> list2 = new List<Attribute>(list);
dictionary.Add(item.Key, list2);
count += list2.Count;
} else {
Attribute attribute = item.Value as Attribute;
if (attribute == null)
throw new InvalidOperationException();
dictionary.Add(item.Key, attribute);
count++;
}
}
return dictionary;
}
private static Dictionary<DerObjectIdentifier, object> BuildAttributes(IReadOnlyCollection<Asn1Encodable> c, out int count)
{
count = c.Count;
Dictionary<DerObjectIdentifier, object> dictionary = new Dictionary<DerObjectIdentifier, object>();
foreach (Asn1Encodable item in c) {
AddAttribute(dictionary, Attribute.GetInstance(item));
}
return dictionary;
}
private static int CountAttributesOfType(Dictionary<DerObjectIdentifier, object> attributes, DerObjectIdentifier attrType)
{
if (!attributes.TryGetValue(attrType, out object value))
return 0;
List<Attribute> list = value as List<Attribute>;
if (list != null)
return list.Count;
if (value is Attribute)
return 1;
throw new InvalidOperationException();
}
[IteratorStateMachine(typeof(<EnumerateAttributes>d__25))]
private static IEnumerable<Attribute> EnumerateAttributes(Dictionary<DerObjectIdentifier, object> attributes)
{
<EnumerateAttributes>d__25 <EnumerateAttributes>d__ = new <EnumerateAttributes>d__25(-2);
<EnumerateAttributes>d__.<>3__attributes = attributes;
return <EnumerateAttributes>d__;
}
}
}