1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
using System;
namespace Org.BouncyCastle.Asn1
{
public class BerSequence
: DLSequence
{
public static new readonly BerSequence Empty = new BerSequence();
public static new BerSequence Concatenate(params Asn1Sequence[] sequences)
{
if (sequences == null)
return Empty;
switch (sequences.Length)
{
case 0:
return Empty;
case 1:
return FromSequence(sequences[0]);
default:
return WithElements(ConcatenateElements(sequences));
}
}
public static new BerSequence FromElements(Asn1Encodable[] elements)
{
if (elements == null)
throw new ArgumentNullException(nameof(elements));
return elements.Length < 1 ? Empty : new BerSequence(elements);
}
public static new BerSequence FromElementsOptional(Asn1Encodable[] elements)
{
if (elements == null)
return null;
return elements.Length < 1 ? Empty : new BerSequence(elements);
}
public static new BerSequence FromSequence(Asn1Sequence sequence)
{
if (sequence is BerSequence berSequence)
return berSequence;
return WithElements(sequence.m_elements);
}
public static new BerSequence FromVector(Asn1EncodableVector elementVector)
{
return elementVector.Count < 1 ? Empty : new BerSequence(elementVector);
}
public static new BerSequence Map(Asn1Sequence sequence, Func<Asn1Encodable, Asn1Encodable> func)
{
return sequence.Count < 1 ? Empty : new BerSequence(sequence.MapElements(func), clone: false);
}
internal static new BerSequence WithElements(Asn1Encodable[] elements)
{
return elements.Length < 1 ? Empty : new BerSequence(elements, clone: false);
}
/**
* create an empty sequence
*/
public BerSequence()
: base()
{
}
/**
* create a sequence containing one object
*/
public BerSequence(Asn1Encodable element)
: base(element)
{
}
/**
* create a sequence containing two objects
*/
public BerSequence(Asn1Encodable element1, Asn1Encodable element2)
: base(element1, element2)
{
}
public BerSequence(params Asn1Encodable[] elements)
: base(elements)
{
}
/**
* create a sequence containing a vector of objects.
*/
public BerSequence(Asn1EncodableVector elementVector)
: base(elementVector)
{
}
internal BerSequence(Asn1Encodable[] elements, bool clone)
: base(elements, clone)
{
}
internal override IAsn1Encoding GetEncoding(int encoding)
{
if (Asn1OutputStream.EncodingBer != encoding)
return base.GetEncoding(encoding);
return new ConstructedILEncoding(Asn1Tags.Universal, Asn1Tags.Sequence,
Asn1OutputStream.GetContentsEncodings(encoding, m_elements));
}
internal override IAsn1Encoding GetEncodingImplicit(int encoding, int tagClass, int tagNo)
{
if (Asn1OutputStream.EncodingBer != encoding)
return base.GetEncodingImplicit(encoding, tagClass, tagNo);
return new ConstructedILEncoding(tagClass, tagNo,
Asn1OutputStream.GetContentsEncodings(encoding, m_elements));
}
internal override DerBitString ToAsn1BitString()
{
return new BerBitString(GetConstructedBitStrings());
}
internal override DerExternal ToAsn1External()
{
// TODO[asn1] There is currently no BerExternal (or Asn1External)
return new DLExternal(this);
}
internal override Asn1OctetString ToAsn1OctetString()
{
return new BerOctetString(GetConstructedOctetStrings());
}
internal override Asn1Set ToAsn1Set()
{
return new BerSet(false, m_elements);
}
}
}
|
