niko
372 lines
9.5 KiB
C#
372 lines
9.5 KiB
C#
using System;
|
|
using System.Diagnostics;
|
|
using System.Globalization;
|
|
using System.Text;
|
|
using Google.Protobuf.Reflection;
|
|
|
|
namespace Google.Protobuf.WellKnownTypes
|
|
{
|
|
// Token: 0x02000020 RID: 32
|
|
public sealed class Duration : IMessage<Duration>, IMessage, IEquatable<Duration>, IDeepCloneable<Duration>, ICustomDiagnosticMessage
|
|
{
|
|
// Token: 0x1700004A RID: 74
|
|
// (get) Token: 0x060001B9 RID: 441 RVA: 0x00008F1D File Offset: 0x0000711D
|
|
[DebuggerNonUserCode]
|
|
public static MessageParser<Duration> Parser
|
|
{
|
|
get
|
|
{
|
|
return Duration._parser;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700004B RID: 75
|
|
// (get) Token: 0x060001BA RID: 442 RVA: 0x00008F24 File Offset: 0x00007124
|
|
[DebuggerNonUserCode]
|
|
public static MessageDescriptor Descriptor
|
|
{
|
|
get
|
|
{
|
|
return DurationReflection.Descriptor.MessageTypes[0];
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700004C RID: 76
|
|
// (get) Token: 0x060001BB RID: 443 RVA: 0x00008F36 File Offset: 0x00007136
|
|
[DebuggerNonUserCode]
|
|
MessageDescriptor IMessage.Descriptor
|
|
{
|
|
get
|
|
{
|
|
return Duration.Descriptor;
|
|
}
|
|
}
|
|
|
|
// Token: 0x060001BC RID: 444 RVA: 0x00007601 File Offset: 0x00005801
|
|
[DebuggerNonUserCode]
|
|
public Duration()
|
|
{
|
|
}
|
|
|
|
// Token: 0x060001BD RID: 445 RVA: 0x00008F3D File Offset: 0x0000713D
|
|
[DebuggerNonUserCode]
|
|
public Duration(Duration other)
|
|
: this()
|
|
{
|
|
this.seconds_ = other.seconds_;
|
|
this.nanos_ = other.nanos_;
|
|
}
|
|
|
|
// Token: 0x060001BE RID: 446 RVA: 0x00008F5D File Offset: 0x0000715D
|
|
[DebuggerNonUserCode]
|
|
public Duration Clone()
|
|
{
|
|
return new Duration(this);
|
|
}
|
|
|
|
// Token: 0x1700004D RID: 77
|
|
// (get) Token: 0x060001BF RID: 447 RVA: 0x00008F65 File Offset: 0x00007165
|
|
// (set) Token: 0x060001C0 RID: 448 RVA: 0x00008F6D File Offset: 0x0000716D
|
|
[DebuggerNonUserCode]
|
|
public long Seconds
|
|
{
|
|
get
|
|
{
|
|
return this.seconds_;
|
|
}
|
|
set
|
|
{
|
|
this.seconds_ = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x1700004E RID: 78
|
|
// (get) Token: 0x060001C1 RID: 449 RVA: 0x00008F76 File Offset: 0x00007176
|
|
// (set) Token: 0x060001C2 RID: 450 RVA: 0x00008F7E File Offset: 0x0000717E
|
|
[DebuggerNonUserCode]
|
|
public int Nanos
|
|
{
|
|
get
|
|
{
|
|
return this.nanos_;
|
|
}
|
|
set
|
|
{
|
|
this.nanos_ = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x060001C3 RID: 451 RVA: 0x00008F87 File Offset: 0x00007187
|
|
[DebuggerNonUserCode]
|
|
public override bool Equals(object other)
|
|
{
|
|
return this.Equals(other as Duration);
|
|
}
|
|
|
|
// Token: 0x060001C4 RID: 452 RVA: 0x00008F95 File Offset: 0x00007195
|
|
[DebuggerNonUserCode]
|
|
public bool Equals(Duration other)
|
|
{
|
|
return other != null && (other == this || (this.Seconds == other.Seconds && this.Nanos == other.Nanos));
|
|
}
|
|
|
|
// Token: 0x060001C5 RID: 453 RVA: 0x00008FC4 File Offset: 0x000071C4
|
|
[DebuggerNonUserCode]
|
|
public override int GetHashCode()
|
|
{
|
|
int num = 1;
|
|
if (this.Seconds != 0L)
|
|
{
|
|
num ^= this.Seconds.GetHashCode();
|
|
}
|
|
if (this.Nanos != 0)
|
|
{
|
|
num ^= this.Nanos.GetHashCode();
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x060001C6 RID: 454 RVA: 0x00007C02 File Offset: 0x00005E02
|
|
[DebuggerNonUserCode]
|
|
public override string ToString()
|
|
{
|
|
return JsonFormatter.ToDiagnosticString(this);
|
|
}
|
|
|
|
// Token: 0x060001C7 RID: 455 RVA: 0x00009006 File Offset: 0x00007206
|
|
[DebuggerNonUserCode]
|
|
public void WriteTo(CodedOutputStream output)
|
|
{
|
|
if (this.Seconds != 0L)
|
|
{
|
|
output.WriteRawTag(8);
|
|
output.WriteInt64(this.Seconds);
|
|
}
|
|
if (this.Nanos != 0)
|
|
{
|
|
output.WriteRawTag(16);
|
|
output.WriteInt32(this.Nanos);
|
|
}
|
|
}
|
|
|
|
// Token: 0x060001C8 RID: 456 RVA: 0x00009040 File Offset: 0x00007240
|
|
[DebuggerNonUserCode]
|
|
public int CalculateSize()
|
|
{
|
|
int num = 0;
|
|
if (this.Seconds != 0L)
|
|
{
|
|
num += 1 + CodedOutputStream.ComputeInt64Size(this.Seconds);
|
|
}
|
|
if (this.Nanos != 0)
|
|
{
|
|
num += 1 + CodedOutputStream.ComputeInt32Size(this.Nanos);
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x060001C9 RID: 457 RVA: 0x00009080 File Offset: 0x00007280
|
|
[DebuggerNonUserCode]
|
|
public void MergeFrom(Duration other)
|
|
{
|
|
if (other == null)
|
|
{
|
|
return;
|
|
}
|
|
if (other.Seconds != 0L)
|
|
{
|
|
this.Seconds = other.Seconds;
|
|
}
|
|
if (other.Nanos != 0)
|
|
{
|
|
this.Nanos = other.Nanos;
|
|
}
|
|
}
|
|
|
|
// Token: 0x060001CA RID: 458 RVA: 0x000090B0 File Offset: 0x000072B0
|
|
[DebuggerNonUserCode]
|
|
public void MergeFrom(CodedInputStream input)
|
|
{
|
|
uint num;
|
|
while ((num = input.ReadTag()) != 0U)
|
|
{
|
|
if (num != 8U)
|
|
{
|
|
if (num != 16U)
|
|
{
|
|
input.SkipLastField();
|
|
}
|
|
else
|
|
{
|
|
this.Nanos = input.ReadInt32();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.Seconds = input.ReadInt64();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x060001CB RID: 459 RVA: 0x000090F4 File Offset: 0x000072F4
|
|
internal static bool IsNormalized(long seconds, int nanoseconds)
|
|
{
|
|
return seconds >= -315576000000L && seconds <= 315576000000L && nanoseconds >= -999999999 && nanoseconds <= 999999999 && Math.Sign(seconds) * Math.Sign(nanoseconds) != -1;
|
|
}
|
|
|
|
// Token: 0x060001CC RID: 460 RVA: 0x00009133 File Offset: 0x00007333
|
|
public TimeSpan ToTimeSpan()
|
|
{
|
|
if (!Duration.IsNormalized(this.Seconds, this.Nanos))
|
|
{
|
|
throw new InvalidOperationException("Duration was not a valid normalized duration");
|
|
}
|
|
checked
|
|
{
|
|
return TimeSpan.FromTicks(this.Seconds * 10000000L + unchecked((long)(this.Nanos / 100)));
|
|
}
|
|
}
|
|
|
|
// Token: 0x060001CD RID: 461 RVA: 0x00009170 File Offset: 0x00007370
|
|
public static Duration FromTimeSpan(TimeSpan timeSpan)
|
|
{
|
|
long ticks = timeSpan.Ticks;
|
|
long num = ticks / 10000000L;
|
|
int num2 = checked((int)(ticks % 10000000L) * 100);
|
|
return new Duration
|
|
{
|
|
Seconds = num,
|
|
Nanos = num2
|
|
};
|
|
}
|
|
|
|
// Token: 0x060001CE RID: 462 RVA: 0x000091AC File Offset: 0x000073AC
|
|
public static Duration operator -(Duration value)
|
|
{
|
|
ProtoPreconditions.CheckNotNull<Duration>(value, "value");
|
|
return checked(Duration.Normalize(0L - value.Seconds, 0 - value.Nanos));
|
|
}
|
|
|
|
// Token: 0x060001CF RID: 463 RVA: 0x000091D0 File Offset: 0x000073D0
|
|
public static Duration operator +(Duration lhs, Duration rhs)
|
|
{
|
|
ProtoPreconditions.CheckNotNull<Duration>(lhs, "lhs");
|
|
ProtoPreconditions.CheckNotNull<Duration>(rhs, "rhs");
|
|
return checked(Duration.Normalize(lhs.Seconds + rhs.Seconds, lhs.Nanos + rhs.Nanos));
|
|
}
|
|
|
|
// Token: 0x060001D0 RID: 464 RVA: 0x00009209 File Offset: 0x00007409
|
|
public static Duration operator -(Duration lhs, Duration rhs)
|
|
{
|
|
ProtoPreconditions.CheckNotNull<Duration>(lhs, "lhs");
|
|
ProtoPreconditions.CheckNotNull<Duration>(rhs, "rhs");
|
|
return checked(Duration.Normalize(lhs.Seconds - rhs.Seconds, lhs.Nanos - rhs.Nanos));
|
|
}
|
|
|
|
// Token: 0x060001D1 RID: 465 RVA: 0x00009244 File Offset: 0x00007444
|
|
internal static Duration Normalize(long seconds, int nanoseconds)
|
|
{
|
|
int num = nanoseconds / 1000000000;
|
|
seconds += (long)num;
|
|
nanoseconds -= num * 1000000000;
|
|
if (seconds < 0L && nanoseconds > 0)
|
|
{
|
|
seconds += 1L;
|
|
nanoseconds -= 1000000000;
|
|
}
|
|
else if (seconds > 0L && nanoseconds < 0)
|
|
{
|
|
seconds -= 1L;
|
|
nanoseconds += 1000000000;
|
|
}
|
|
return new Duration
|
|
{
|
|
Seconds = seconds,
|
|
Nanos = nanoseconds
|
|
};
|
|
}
|
|
|
|
// Token: 0x060001D2 RID: 466 RVA: 0x000092B0 File Offset: 0x000074B0
|
|
internal static string ToJson(long seconds, int nanoseconds, bool diagnosticOnly)
|
|
{
|
|
if (Duration.IsNormalized(seconds, nanoseconds))
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
stringBuilder.Append('"');
|
|
if (seconds == 0L && nanoseconds < 0)
|
|
{
|
|
stringBuilder.Append('-');
|
|
}
|
|
stringBuilder.Append(seconds.ToString("d", CultureInfo.InvariantCulture));
|
|
Duration.AppendNanoseconds(stringBuilder, Math.Abs(nanoseconds));
|
|
stringBuilder.Append("s\"");
|
|
return stringBuilder.ToString();
|
|
}
|
|
if (diagnosticOnly)
|
|
{
|
|
return string.Format(CultureInfo.InvariantCulture, "{{ \"@warning\": \"Invalid Duration\", \"seconds\": \"{0}\", \"nanos\": {1} }}", new object[] { seconds, nanoseconds });
|
|
}
|
|
throw new InvalidOperationException("Non-normalized duration value");
|
|
}
|
|
|
|
// Token: 0x060001D3 RID: 467 RVA: 0x00009351 File Offset: 0x00007551
|
|
public string ToDiagnosticString()
|
|
{
|
|
return Duration.ToJson(this.Seconds, this.Nanos, true);
|
|
}
|
|
|
|
// Token: 0x060001D4 RID: 468 RVA: 0x00009368 File Offset: 0x00007568
|
|
internal static void AppendNanoseconds(StringBuilder builder, int nanos)
|
|
{
|
|
if (nanos != 0)
|
|
{
|
|
builder.Append('.');
|
|
if (nanos % 1000000 == 0)
|
|
{
|
|
builder.Append((nanos / 1000000).ToString("d3", CultureInfo.InvariantCulture));
|
|
return;
|
|
}
|
|
if (nanos % 1000 == 0)
|
|
{
|
|
builder.Append((nanos / 1000).ToString("d6", CultureInfo.InvariantCulture));
|
|
return;
|
|
}
|
|
builder.Append(nanos.ToString("d9", CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
|
|
// Token: 0x0400007E RID: 126
|
|
private static readonly MessageParser<Duration> _parser = new MessageParser<Duration>(() => new Duration());
|
|
|
|
// Token: 0x0400007F RID: 127
|
|
public const int SecondsFieldNumber = 1;
|
|
|
|
// Token: 0x04000080 RID: 128
|
|
private long seconds_;
|
|
|
|
// Token: 0x04000081 RID: 129
|
|
public const int NanosFieldNumber = 2;
|
|
|
|
// Token: 0x04000082 RID: 130
|
|
private int nanos_;
|
|
|
|
// Token: 0x04000083 RID: 131
|
|
public const int NanosecondsPerSecond = 1000000000;
|
|
|
|
// Token: 0x04000084 RID: 132
|
|
public const int NanosecondsPerTick = 100;
|
|
|
|
// Token: 0x04000085 RID: 133
|
|
public const long MaxSeconds = 315576000000L;
|
|
|
|
// Token: 0x04000086 RID: 134
|
|
public const long MinSeconds = -315576000000L;
|
|
|
|
// Token: 0x04000087 RID: 135
|
|
internal const int MaxNanoseconds = 999999999;
|
|
|
|
// Token: 0x04000088 RID: 136
|
|
internal const int MinNanoseconds = -999999999;
|
|
}
|
|
}
|