summary refs log tree commit diff
path: root/crypto/src/asn1/tsp/Accuracy.cs
blob: f9cd8801497dc93f95cf1ec2bf0c1b75be6aada3 (plain) (blame)
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
using System;

using Org.BouncyCastle.Utilities;

namespace Org.BouncyCastle.Asn1.Tsp
{
	public class Accuracy
		: Asn1Encodable
	{
		private readonly DerInteger seconds;
		private readonly DerInteger millis;
		private readonly DerInteger micros;

		// constants
		protected const int MinMillis = 1;
		protected const int MaxMillis = 999;
		protected const int MinMicros = 1;
		protected const int MaxMicros = 999;

		public Accuracy(
			DerInteger seconds,
			DerInteger millis,
			DerInteger micros)
		{
            if (null != millis)
            {
                int millisValue = millis.IntValueExact;
                if (millisValue < MinMillis || millisValue > MaxMillis)
                    throw new ArgumentException("Invalid millis field : not in (1..999)");
            }
            if (null != micros)
            {
                int microsValue = micros.IntValueExact;
                if (microsValue < MinMicros || microsValue > MaxMicros)
                    throw new ArgumentException("Invalid micros field : not in (1..999)");
            }

            this.seconds = seconds;
            this.millis = millis;
            this.micros = micros;
		}

		private Accuracy(Asn1Sequence seq)
		{
			for (int i = 0; i < seq.Count; ++i)
			{
				// seconds
				if (seq[i] is DerInteger derInteger)
				{
					seconds = derInteger;
				}
                else if (seq[i] is Asn1TaggedObject extra)
				{
                    switch (extra.TagNo)
                    {
                    case 0:
                        millis = DerInteger.GetInstance(extra, false);
                        int millisValue = millis.IntValueExact;
                        if (millisValue < MinMillis || millisValue > MaxMillis)
                            throw new ArgumentException("Invalid millis field : not in (1..999)");
                        break;
                    case 1:
                        micros = DerInteger.GetInstance(extra, false);
                        int microsValue = micros.IntValueExact;
                        if (microsValue < MinMicros || microsValue > MaxMicros)
                            throw new ArgumentException("Invalid micros field : not in (1..999)");
                        break;
                    default:
                        throw new ArgumentException("Invalid tag number");
                    }
				}
			}
		}

        public static Accuracy GetInstance(object obj)
        {
            if (obj is Accuracy)
                return (Accuracy)obj;
            if (obj == null)
                return null;
            return new Accuracy(Asn1Sequence.GetInstance(obj));
        }

        public DerInteger Seconds
		{
			get { return seconds; }
		}

		public DerInteger Millis
		{
			get { return millis; }
		}

		public DerInteger Micros
		{
			get { return micros; }
		}

		/**
		 * <pre>
		 * Accuracy ::= SEQUENCE {
		 *             seconds        INTEGER              OPTIONAL,
		 *             millis     [0] INTEGER  (1..999)    OPTIONAL,
		 *             micros     [1] INTEGER  (1..999)    OPTIONAL
		 *             }
		 * </pre>
		 */
        public override Asn1Object ToAsn1Object()
        {
            Asn1EncodableVector v = new Asn1EncodableVector(3);
            v.AddOptional(seconds);
            v.AddOptionalTagged(false, 0, millis);
            v.AddOptionalTagged(false, 1, micros);
            return new DerSequence(v);
        }
	}
}