Skip to content
Projects
Groups
Snippets
Help
Loading...
Sign in / Register
Toggle navigation
P
protobuf
Project
Project
Details
Activity
Cycle Analytics
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Charts
Issues
0
Issues
0
List
Board
Labels
Milestones
Merge Requests
0
Merge Requests
0
CI / CD
CI / CD
Pipelines
Jobs
Schedules
Charts
Packages
Packages
Wiki
Wiki
Snippets
Snippets
Members
Members
Collapse sidebar
Close sidebar
Activity
Graph
Charts
Create a new issue
Jobs
Commits
Issue Boards
Open sidebar
submodule
protobuf
Commits
c20f67fd
Commit
c20f67fd
authored
Jul 31, 2015
by
Jon Skeet
Browse files
Options
Browse Files
Download
Plain Diff
Merge pull request #666 from jskeet/wkt-times
Well-known type operations for Timestamp and Duration
parents
5bdb1fb3
96297973
Hide whitespace changes
Inline
Side-by-side
Showing
7 changed files
with
563 additions
and
0 deletions
+563
-0
Google.Protobuf.Test.csproj
csharp/src/Google.Protobuf.Test/Google.Protobuf.Test.csproj
+2
-0
DurationTest.cs
...p/src/Google.Protobuf.Test/WellKnownTypes/DurationTest.cs
+104
-0
TimestampTest.cs
.../src/Google.Protobuf.Test/WellKnownTypes/TimestampTest.cs
+84
-0
Google.Protobuf.csproj
csharp/src/Google.Protobuf/Google.Protobuf.csproj
+3
-0
DurationPartial.cs
csharp/src/Google.Protobuf/WellKnownTypes/DurationPartial.cs
+145
-0
TimeExtensions.cs
csharp/src/Google.Protobuf/WellKnownTypes/TimeExtensions.cs
+61
-0
TimestampPartial.cs
...rp/src/Google.Protobuf/WellKnownTypes/TimestampPartial.cs
+164
-0
No files found.
csharp/src/Google.Protobuf.Test/Google.Protobuf.Test.csproj
View file @
c20f67fd
...
...
@@ -97,6 +97,8 @@
<Compile
Include=
"Properties\AssemblyInfo.cs"
/>
<Compile
Include=
"TestCornerCases.cs"
/>
<Compile
Include=
"TestProtos\UnittestWellKnownTypes.cs"
/>
<Compile
Include=
"WellKnownTypes\DurationTest.cs"
/>
<Compile
Include=
"WellKnownTypes\TimestampTest.cs"
/>
<Compile
Include=
"WellKnownTypes\WrappersTest.cs"
/>
</ItemGroup>
<ItemGroup>
...
...
csharp/src/Google.Protobuf.Test/WellKnownTypes/DurationTest.cs
0 → 100644
View file @
c20f67fd
#
region
Copyright
notice
and
license
// Protocol Buffers - Google's data interchange format
// Copyright 2015 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#endregion
using
NUnit.Framework
;
using
System
;
namespace
Google.Protobuf.WellKnownTypes
{
public
class
DurationTest
{
[
Test
]
public
void
ToTimeSpan
()
{
Assert
.
AreEqual
(
TimeSpan
.
FromSeconds
(
1
),
new
Duration
{
Seconds
=
1
}.
ToTimeSpan
());
Assert
.
AreEqual
(
TimeSpan
.
FromSeconds
(-
1
),
new
Duration
{
Seconds
=
-
1
}.
ToTimeSpan
());
Assert
.
AreEqual
(
TimeSpan
.
FromMilliseconds
(
1
),
new
Duration
{
Nanos
=
1000000
}.
ToTimeSpan
());
Assert
.
AreEqual
(
TimeSpan
.
FromMilliseconds
(-
1
),
new
Duration
{
Nanos
=
-
1000000
}.
ToTimeSpan
());
Assert
.
AreEqual
(
TimeSpan
.
FromTicks
(
1
),
new
Duration
{
Nanos
=
100
}.
ToTimeSpan
());
Assert
.
AreEqual
(
TimeSpan
.
FromTicks
(-
1
),
new
Duration
{
Nanos
=
-
100
}.
ToTimeSpan
());
// Rounding is towards 0
Assert
.
AreEqual
(
TimeSpan
.
FromTicks
(
2
),
new
Duration
{
Nanos
=
250
}.
ToTimeSpan
());
Assert
.
AreEqual
(
TimeSpan
.
FromTicks
(-
2
),
new
Duration
{
Nanos
=
-
250
}.
ToTimeSpan
());
// Non-normalized durations
Assert
.
AreEqual
(
TimeSpan
.
FromSeconds
(
3
),
new
Duration
{
Seconds
=
1
,
Nanos
=
2
*
Duration
.
NanosecondsPerSecond
}.
ToTimeSpan
());
Assert
.
AreEqual
(
TimeSpan
.
FromSeconds
(
1
),
new
Duration
{
Seconds
=
3
,
Nanos
=
-
2
*
Duration
.
NanosecondsPerSecond
}.
ToTimeSpan
());
Assert
.
AreEqual
(
TimeSpan
.
FromSeconds
(-
1
),
new
Duration
{
Seconds
=
1
,
Nanos
=
-
2
*
Duration
.
NanosecondsPerSecond
}.
ToTimeSpan
());
}
[
Test
]
public
void
Addition
()
{
Assert
.
AreEqual
(
new
Duration
{
Seconds
=
2
,
Nanos
=
100000000
},
new
Duration
{
Seconds
=
1
,
Nanos
=
600000000
}
+
new
Duration
{
Nanos
=
500000000
});
Assert
.
AreEqual
(
new
Duration
{
Seconds
=
-
2
,
Nanos
=
-
100000000
},
new
Duration
{
Seconds
=
-
1
,
Nanos
=
-
600000000
}
+
new
Duration
{
Nanos
=
-
500000000
});
Assert
.
AreEqual
(
new
Duration
{
Seconds
=
1
,
Nanos
=
100000000
},
new
Duration
{
Seconds
=
1
,
Nanos
=
600000000
}
+
new
Duration
{
Nanos
=
-
500000000
});
// Non-normalized durations, or non-normalized intermediate results
Assert
.
AreEqual
(
new
Duration
{
Seconds
=
1
},
new
Duration
{
Seconds
=
1
,
Nanos
=
-
500000000
}
+
new
Duration
{
Nanos
=
500000000
});
Assert
.
AreEqual
(
new
Duration
{
Nanos
=
-
900000000
},
new
Duration
{
Seconds
=
-
1
,
Nanos
=
-
100000000
}
+
new
Duration
{
Nanos
=
200000000
});
Assert
.
AreEqual
(
new
Duration
{
Nanos
=
900000000
},
new
Duration
{
Seconds
=
1
,
Nanos
=
100000000
}
+
new
Duration
{
Nanos
=
-
200000000
});
}
[
Test
]
public
void
Subtraction
()
{
Assert
.
AreEqual
(
new
Duration
{
Seconds
=
1
,
Nanos
=
100000000
},
new
Duration
{
Seconds
=
1
,
Nanos
=
600000000
}
-
new
Duration
{
Nanos
=
500000000
});
Assert
.
AreEqual
(
new
Duration
{
Seconds
=
-
1
,
Nanos
=
-
100000000
},
new
Duration
{
Seconds
=
-
1
,
Nanos
=
-
600000000
}
-
new
Duration
{
Nanos
=
-
500000000
});
Assert
.
AreEqual
(
new
Duration
{
Seconds
=
2
,
Nanos
=
100000000
},
new
Duration
{
Seconds
=
1
,
Nanos
=
600000000
}
-
new
Duration
{
Nanos
=
-
500000000
});
// Non-normalized durations
Assert
.
AreEqual
(
new
Duration
(),
new
Duration
{
Seconds
=
1
,
Nanos
=
-
500000000
}
-
new
Duration
{
Nanos
=
500000000
});
Assert
.
AreEqual
(
new
Duration
{
Seconds
=
1
},
new
Duration
{
Nanos
=
2000000000
}
-
new
Duration
{
Nanos
=
1000000000
});
}
[
Test
]
public
void
FromTimeSpan
()
{
Assert
.
AreEqual
(
new
Duration
{
Seconds
=
1
},
Duration
.
FromTimeSpan
(
TimeSpan
.
FromSeconds
(
1
)));
Assert
.
AreEqual
(
new
Duration
{
Nanos
=
Duration
.
NanosecondsPerTick
},
Duration
.
FromTimeSpan
(
TimeSpan
.
FromTicks
(
1
)));
}
}
}
csharp/src/Google.Protobuf.Test/WellKnownTypes/TimestampTest.cs
0 → 100644
View file @
c20f67fd
#
region
Copyright
notice
and
license
// Protocol Buffers - Google's data interchange format
// Copyright 2015 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#endregion
using
NUnit.Framework
;
using
System
;
namespace
Google.Protobuf.WellKnownTypes
{
public
class
TimestampTest
{
[
Test
]
public
void
FromAndToDateTime
()
{
DateTime
utcMin
=
DateTime
.
SpecifyKind
(
DateTime
.
MinValue
,
DateTimeKind
.
Utc
);
DateTime
utcMax
=
DateTime
.
SpecifyKind
(
DateTime
.
MaxValue
,
DateTimeKind
.
Utc
);
AssertRoundtrip
(
new
Timestamp
{
Seconds
=
-
62135596800
},
utcMin
);
AssertRoundtrip
(
new
Timestamp
{
Seconds
=
253402300799
,
Nanos
=
999999900
},
utcMax
);
AssertRoundtrip
(
new
Timestamp
(),
new
DateTime
(
1970
,
1
,
1
,
0
,
0
,
0
,
DateTimeKind
.
Utc
));
AssertRoundtrip
(
new
Timestamp
{
Nanos
=
1000000
},
new
DateTime
(
1970
,
1
,
1
,
0
,
0
,
0
,
1
,
DateTimeKind
.
Utc
));
AssertRoundtrip
(
new
Timestamp
{
Seconds
=
-
1
,
Nanos
=
999000000
},
new
DateTime
(
1969
,
12
,
31
,
23
,
59
,
59
,
999
,
DateTimeKind
.
Utc
));
AssertRoundtrip
(
new
Timestamp
{
Seconds
=
3600
},
new
DateTime
(
1970
,
1
,
1
,
1
,
0
,
0
,
DateTimeKind
.
Utc
));
AssertRoundtrip
(
new
Timestamp
{
Seconds
=
-
3600
},
new
DateTime
(
1969
,
12
,
31
,
23
,
0
,
0
,
DateTimeKind
.
Utc
));
}
[
Test
]
public
void
ToDateTimeTruncation
()
{
var
t1
=
new
Timestamp
{
Seconds
=
1
,
Nanos
=
1000000
+
Duration
.
NanosecondsPerTick
-
1
};
Assert
.
AreEqual
(
new
DateTime
(
1970
,
1
,
1
,
0
,
0
,
1
,
DateTimeKind
.
Utc
).
AddMilliseconds
(
1
),
t1
.
ToDateTime
());
var
t2
=
new
Timestamp
{
Seconds
=
-
1
,
Nanos
=
1000000
+
Duration
.
NanosecondsPerTick
-
1
};
Assert
.
AreEqual
(
new
DateTime
(
1969
,
12
,
31
,
23
,
59
,
59
).
AddMilliseconds
(
1
),
t2
.
ToDateTime
());
}
private
static
void
AssertRoundtrip
(
Timestamp
timestamp
,
DateTime
dateTime
)
{
Assert
.
AreEqual
(
timestamp
,
Timestamp
.
FromDateTime
(
dateTime
));
Assert
.
AreEqual
(
dateTime
,
timestamp
.
ToDateTime
());
Assert
.
AreEqual
(
DateTimeKind
.
Utc
,
timestamp
.
ToDateTime
().
Kind
);
}
[
Test
]
public
void
Arithmetic
()
{
Timestamp
t1
=
new
Timestamp
{
Seconds
=
10000
,
Nanos
=
5000
};
Timestamp
t2
=
new
Timestamp
{
Seconds
=
8000
,
Nanos
=
10000
};
Duration
difference
=
new
Duration
{
Seconds
=
1999
,
Nanos
=
Duration
.
NanosecondsPerSecond
-
5000
};
Assert
.
AreEqual
(
difference
,
t1
-
t2
);
Assert
.
AreEqual
(-
difference
,
t2
-
t1
);
Assert
.
AreEqual
(
t1
,
t2
+
difference
);
Assert
.
AreEqual
(
t2
,
t1
-
difference
);
}
}
}
csharp/src/Google.Protobuf/Google.Protobuf.csproj
View file @
c20f67fd
...
...
@@ -100,11 +100,14 @@
<Compile
Include=
"WellKnownTypes\Any.cs"
/>
<Compile
Include=
"WellKnownTypes\Api.cs"
/>
<Compile
Include=
"WellKnownTypes\Duration.cs"
/>
<Compile
Include=
"WellKnownTypes\DurationPartial.cs"
/>
<Compile
Include=
"WellKnownTypes\Empty.cs"
/>
<Compile
Include=
"WellKnownTypes\FieldMask.cs"
/>
<Compile
Include=
"WellKnownTypes\SourceContext.cs"
/>
<Compile
Include=
"WellKnownTypes\Struct.cs"
/>
<Compile
Include=
"WellKnownTypes\TimeExtensions.cs"
/>
<Compile
Include=
"WellKnownTypes\Timestamp.cs"
/>
<Compile
Include=
"WellKnownTypes\TimestampPartial.cs"
/>
<Compile
Include=
"WellKnownTypes\Type.cs"
/>
<Compile
Include=
"WellKnownTypes\Wrappers.cs"
/>
<Compile
Include=
"WireFormat.cs"
/>
...
...
csharp/src/Google.Protobuf/WellKnownTypes/DurationPartial.cs
0 → 100644
View file @
c20f67fd
#
region
Copyright
notice
and
license
// Protocol Buffers - Google's data interchange format
// Copyright 2015 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#endregion
using
System
;
namespace
Google.Protobuf.WellKnownTypes
{
// Manually-written partial class for the Duration well-known type,
// providing a conversion to TimeSpan and convenience operators.
public
partial
class
Duration
{
public
const
int
NanosecondsPerSecond
=
1000000000
;
public
const
int
NanosecondsPerTick
=
100
;
/// <summary>
/// Converts this <see cref="Duration"/> to a <see cref="TimeSpan"/>.
/// </summary>
/// <remarks>If the duration is not a precise number of ticks, it is truncated towards 0.</remarks>
/// <returns>The value of this duration, as a <c>TimeSpan</c>.</returns>
public
TimeSpan
ToTimeSpan
()
{
checked
{
long
ticks
=
Seconds
*
TimeSpan
.
TicksPerSecond
+
Nanos
/
NanosecondsPerTick
;
return
TimeSpan
.
FromTicks
(
ticks
);
}
}
/// <summary>
/// Converts the given <see cref="TimeSpan"/> to a <see cref="Duration"/>.
/// </summary>
/// <param name="timeSpan">The <c>TimeSpan</c> to convert.</param>
/// <returns>The value of the given <c>TimeSpan</c>, as a <c>Duration</c>.</returns>
public
static
Duration
FromTimeSpan
(
TimeSpan
timeSpan
)
{
checked
{
long
ticks
=
timeSpan
.
Ticks
;
long
seconds
=
ticks
/
TimeSpan
.
TicksPerSecond
;
int
nanos
=
(
int
)
(
ticks
%
TimeSpan
.
TicksPerSecond
)
*
NanosecondsPerTick
;
return
new
Duration
{
Seconds
=
seconds
,
Nanos
=
nanos
};
}
}
/// <summary>
/// Returns the result of negating the duration. For example, the negation of 5 minutes is -5 minutes.
/// </summary>
/// <param name="value">The duration to negate. Must not be null.</param>
/// <returns>The negated value of this duration.</returns>
public
static
Duration
operator
-(
Duration
value
)
{
Preconditions
.
CheckNotNull
(
value
,
"value"
);
checked
{
return
Normalize
(-
value
.
Seconds
,
-
value
.
Nanos
);
}
}
/// <summary>
/// Adds the two specified <see cref="Duration"/> values together.
/// </summary>
/// <param name="lhs">The first value to add. Must not be null.</param>
/// <param name="rhs">The second value to add. Must not be null.</param>
/// <returns></returns>
public
static
Duration
operator
+(
Duration
lhs
,
Duration
rhs
)
{
Preconditions
.
CheckNotNull
(
lhs
,
"lhs"
);
Preconditions
.
CheckNotNull
(
rhs
,
"rhs"
);
checked
{
return
Normalize
(
lhs
.
Seconds
+
rhs
.
Seconds
,
lhs
.
Nanos
+
rhs
.
Nanos
);
}
}
/// <summary>
/// Subtracts one <see cref="Duration"/> from another.
/// </summary>
/// <param name="lhs">The duration to subtract from. Must not be null.</param>
/// <param name="rhs">The duration to subtract. Must not be null.</param>
/// <returns>The difference between the two specified durations.</returns>
public
static
Duration
operator
-(
Duration
lhs
,
Duration
rhs
)
{
Preconditions
.
CheckNotNull
(
lhs
,
"lhs"
);
Preconditions
.
CheckNotNull
(
rhs
,
"rhs"
);
checked
{
return
Normalize
(
lhs
.
Seconds
-
rhs
.
Seconds
,
lhs
.
Nanos
-
rhs
.
Nanos
);
}
}
/// <summary>
/// Creates a duration with the normalized values from the given number of seconds and
/// nanoseconds, conforming with the description in the proto file.
/// </summary>
internal
static
Duration
Normalize
(
long
seconds
,
int
nanoseconds
)
{
// Ensure that nanoseconds is in the range (-1,000,000,000, +1,000,000,000)
int
extraSeconds
=
nanoseconds
/
NanosecondsPerSecond
;
seconds
+=
extraSeconds
;
nanoseconds
-=
extraSeconds
*
NanosecondsPerSecond
;
// Now make sure that Sign(seconds) == Sign(nanoseconds) if Sign(seconds) != 0.
if
(
seconds
<
0
&&
nanoseconds
>
0
)
{
seconds
+=
1
;
nanoseconds
-=
NanosecondsPerSecond
;
}
else
if
(
seconds
>
0
&&
nanoseconds
<
0
)
{
seconds
-=
1
;
nanoseconds
+=
NanosecondsPerSecond
;
}
return
new
Duration
{
Seconds
=
seconds
,
Nanos
=
nanoseconds
};
}
}
}
csharp/src/Google.Protobuf/WellKnownTypes/TimeExtensions.cs
0 → 100644
View file @
c20f67fd
#
region
Copyright
notice
and
license
// Protocol Buffers - Google's data interchange format
// Copyright 2015 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#endregion
using
System
;
using
System.Collections.Generic
;
using
System.Linq
;
using
System.Text
;
using
System.Threading.Tasks
;
namespace
Google.Protobuf.WellKnownTypes
{
/// <summary>
/// Extension methods on BCL time-related types, converting to protobuf types.
/// </summary>
public
static
class
TimeExtensions
{
public
static
Timestamp
ToTimestamp
(
this
DateTime
dateTime
)
{
return
Timestamp
.
FromDateTime
(
dateTime
);
}
public
static
Timestamp
ToTimestamp
(
this
DateTimeOffset
dateTimeOffset
)
{
return
Timestamp
.
FromDateTimeOffset
(
dateTimeOffset
);
}
public
static
Duration
ToDuration
(
this
TimeSpan
timeSpan
)
{
return
Duration
.
FromTimeSpan
(
timeSpan
);
}
}
}
csharp/src/Google.Protobuf/WellKnownTypes/TimestampPartial.cs
0 → 100644
View file @
c20f67fd
#
region
Copyright
notice
and
license
// Protocol Buffers - Google's data interchange format
// Copyright 2015 Google Inc. All rights reserved.
// https://developers.google.com/protocol-buffers/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#endregion
using
System
;
namespace
Google.Protobuf.WellKnownTypes
{
public
partial
class
Timestamp
{
private
static
readonly
DateTime
UnixEpoch
=
new
DateTime
(
1970
,
1
,
1
,
0
,
0
,
0
,
DateTimeKind
.
Utc
);
private
static
readonly
long
BclSecondsAtUnixEpoch
=
UnixEpoch
.
Ticks
/
TimeSpan
.
TicksPerSecond
;
/// <summary>
/// Returns the difference between one <see cref="Timestamp"/> and another, as a <see cref="Duration"/>.
/// </summary>
/// <param name="lhs">The timestamp to subtract from. Must not be null.</param>
/// <param name="rhs">The timestamp to subtract. Must not be null.</param>
/// <returns>The difference between the two specified timestamps.</returns>
public
static
Duration
operator
-(
Timestamp
lhs
,
Timestamp
rhs
)
{
Preconditions
.
CheckNotNull
(
lhs
,
"lhs"
);
Preconditions
.
CheckNotNull
(
rhs
,
"rhs"
);
checked
{
return
Duration
.
Normalize
(
lhs
.
Seconds
-
rhs
.
Seconds
,
lhs
.
Nanos
-
rhs
.
Nanos
);
}
}
/// <summary>
/// Adds a <see cref="Duration"/> to a <see cref="Timestamp"/>, to obtain another <c>Timestamp</c>.
/// </summary>
/// <param name="lhs">The timestamp to add the duration to. Must not be null.</param>
/// <param name="rhs">The duration to add. Must not be null.</param>
/// <returns>The result of adding the duration to the timestamp.</returns>
public
static
Timestamp
operator
+(
Timestamp
lhs
,
Duration
rhs
)
{
Preconditions
.
CheckNotNull
(
lhs
,
"lhs"
);
Preconditions
.
CheckNotNull
(
rhs
,
"rhs"
);
checked
{
return
Normalize
(
lhs
.
Seconds
+
rhs
.
Seconds
,
lhs
.
Nanos
+
rhs
.
Nanos
);
}
}
/// <summary>
/// Subtracts a <see cref="Duration"/> from a <see cref="Timestamp"/>, to obtain another <c>Timestamp</c>.
/// </summary>
/// <param name="lhs">The timestamp to subtract the duration from. Must not be null.</param>
/// <param name="rhs">The duration to subtract.</param>
/// <returns>The result of subtracting the duration from the timestamp.</returns>
public
static
Timestamp
operator
-(
Timestamp
lhs
,
Duration
rhs
)
{
Preconditions
.
CheckNotNull
(
lhs
,
"lhs"
);
Preconditions
.
CheckNotNull
(
rhs
,
"rhs"
);
checked
{
return
Normalize
(
lhs
.
Seconds
-
rhs
.
Seconds
,
lhs
.
Nanos
-
rhs
.
Nanos
);
}
}
/// <summary>
/// Converts this timestamp into a <see cref="DateTime"/>.
/// </summary>
/// <remarks>
/// The resulting <c>DateTime</c> will always have a <c>Kind</c> of <c>Utc</c>.
/// If the timestamp is not a precise number of ticks, it will be truncated towards the start
/// of time. For example, a timestamp with a <see cref="Nanos"/> value of 99 will result in a
/// <see cref="DateTime"/> value precisely on a second.
/// </remarks>
/// <returns>This timestamp as a <c>DateTime</c>.</returns>
public
DateTime
ToDateTime
()
{
return
UnixEpoch
.
AddSeconds
(
Seconds
).
AddTicks
(
Nanos
/
Duration
.
NanosecondsPerTick
);
}
/// <summary>
/// Converts this timestamp into a <see cref="DateTimeOffset"/>.
/// </summary>
/// <remarks>
/// The resulting <c>DateTimeOffset</c> will always have an <c>Offset</c> of zero.
/// If the timestamp is not a precise number of ticks, it will be truncated towards the start
/// of time. For example, a timestamp with a <see cref="Nanos"/> value of 99 will result in a
/// <see cref="DateTimeOffset"/> value precisely on a second.
/// </remarks>
/// <returns>This timestamp as a <c>DateTimeOffset</c>.</returns>
public
DateTimeOffset
ToDateTimeOffset
()
{
return
new
DateTimeOffset
(
ToDateTime
(),
TimeSpan
.
Zero
);
}
/// <summary>
/// Converts the specified <see cref="DateTime"/> to a <see cref="Timestamp"/>.
/// </summary>
/// <param name="dateTime"></param>
/// <exception cref="ArgumentException">The <c>Kind</c> of <paramref name="dateTime"/> is not <c>DateTimeKind.Utc</c>.</exception>
/// <returns>The converted timestamp.</returns>
public
static
Timestamp
FromDateTime
(
DateTime
dateTime
)
{
if
(
dateTime
.
Kind
!=
DateTimeKind
.
Utc
)
{
throw
new
ArgumentException
(
"Conversion from DateTime to Timestamp requires the DateTime kind to be Utc"
,
"dateTime"
);
}
// Do the arithmetic using DateTime.Ticks, which is always non-negative, making things simpler.
long
secondsSinceBclEpoch
=
dateTime
.
Ticks
/
TimeSpan
.
TicksPerSecond
;
int
nanoseconds
=
(
int
)
(
dateTime
.
Ticks
%
TimeSpan
.
TicksPerSecond
)
*
Duration
.
NanosecondsPerTick
;
return
new
Timestamp
{
Seconds
=
secondsSinceBclEpoch
-
BclSecondsAtUnixEpoch
,
Nanos
=
nanoseconds
};
}
/// <summary>
/// Converts the specified <see cref="DateTimeOffset"/> to a <see cref="Timestamp"/>.
/// </summary>
/// <param name="dateTime"></param>
/// <returns>The converted timestamp.</returns>
public
static
Timestamp
FromDateTimeOffset
(
DateTimeOffset
dateTimeOffset
)
{
// We don't need to worry about this having negative ticks: DateTimeOffset is constrained to handle
// values whose *UTC* value is in the range of DateTime.
return
FromDateTime
(
dateTimeOffset
.
UtcDateTime
);
}
private
static
Timestamp
Normalize
(
long
seconds
,
int
nanoseconds
)
{
int
extraSeconds
=
nanoseconds
/
Duration
.
NanosecondsPerSecond
;
seconds
+=
extraSeconds
;
nanoseconds
-=
extraSeconds
*
Duration
.
NanosecondsPerSecond
;
if
(
nanoseconds
<
0
)
{
nanoseconds
+=
Duration
.
NanosecondsPerSecond
;
seconds
--;
}
return
new
Timestamp
{
Seconds
=
seconds
,
Nanos
=
nanoseconds
};
}
}
}
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment