← Back to branch summary

~ubuntu-branches/ubuntu/trusty/smuxi/trusty-proposed

« back to all changes in this revision

Viewing changes to lib/ServiceStack.Text/src/ServiceStack.Text/DateTimeExtensions.cs

  • Committer: Package Import Robot
  • Author(s): Mirco Bauer
  • Date: 2013-05-25 22:11:31 UTC
  • mfrom: (1.2.12)
  • Revision ID: package-import@ubuntu.com-20130525221131-nd2mc0kzubuwyx20
Tags: 0.8.11-1
* [22d13d5] Imported Upstream version 0.8.11
* [6d2b95a] Refreshed patches
* [89eb66e] Added ServiceStack libraries to smuxi-engine package
* [848ab10] Enable Campfire engine
* [c6dbdc7] Always build db4o for predictable build result
* [13ec489] Exclude OS X specific libraries from dh_clideps

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/ServiceStack.Text/src/ServiceStack.Text/DateTimeExtensions.cs
 
1
//
 
2
// http://code.google.com/p/servicestack/wiki/TypeSerializer
 
3
// ServiceStack.Text: .NET C# POCO Type Text Serializer.
 
4
//
 
5
// Authors:
 
6
//   Demis Bellot (demis.bellot@gmail.com)
 
7
//
 
8
// Copyright 2011 Liquidbit Ltd.
 
9
//
 
10
// Licensed under the same terms of ServiceStack: new BSD license.
 
11
//
 
12
 
 
13
using System;
 
14
using ServiceStack.Text.Common;
 
15
 
 
16
namespace ServiceStack.Text
 
17
{
 
18
        /// <summary>
 
19
        /// A fast, standards-based, serialization-issue free DateTime serailizer.
 
20
        /// </summary>
 
21
        public static class DateTimeExtensions
 
22
        {
 
23
                public const long UnixEpoch = 621355968000000000L;
 
24
                private static readonly DateTime UnixEpochDateTimeUtc = new DateTime(UnixEpoch, DateTimeKind.Utc);
 
25
                private static readonly DateTime UnixEpochDateTimeUnspecified = new DateTime(UnixEpoch, DateTimeKind.Unspecified);
 
26
 
 
27
                public static long ToUnixTime(this DateTime dateTime)
 
28
                {
 
29
                        return (dateTime.ToStableUniversalTime().Ticks - UnixEpoch) / TimeSpan.TicksPerSecond;
 
30
                }
 
31
 
 
32
                public static DateTime FromUnixTime(this double unixTime)
 
33
                {
 
34
                        return UnixEpochDateTimeUtc + TimeSpan.FromSeconds(unixTime);
 
35
                }
 
36
 
 
37
                public static long ToUnixTimeMs(this DateTime dateTime)
 
38
                {
 
39
                        return (dateTime.ToStableUniversalTime().Ticks - UnixEpoch) / TimeSpan.TicksPerMillisecond;
 
40
                }
 
41
 
 
42
                public static DateTime FromUnixTimeMs(this double msSince1970)
 
43
                {
 
44
                        return UnixEpochDateTimeUtc + TimeSpan.FromMilliseconds(msSince1970);
 
45
                }
 
46
 
 
47
                public static DateTime FromUnixTimeMs(this long msSince1970)
 
48
                {
 
49
                        return UnixEpochDateTimeUtc + TimeSpan.FromMilliseconds(msSince1970);
 
50
                }
 
51
 
 
52
                public static DateTime FromUnixTimeMs(this long msSince1970, TimeSpan offset)
 
53
                {
 
54
                        return UnixEpochDateTimeUnspecified + TimeSpan.FromMilliseconds(msSince1970) + offset;
 
55
                }
 
56
 
 
57
                public static DateTime FromUnixTimeMs(this double msSince1970, TimeSpan offset)
 
58
                {
 
59
                        return UnixEpochDateTimeUnspecified + TimeSpan.FromMilliseconds(msSince1970) + offset;
 
60
                }
 
61
 
 
62
                public static DateTime FromUnixTimeMs(string msSince1970)
 
63
                {
 
64
                        long ms;
 
65
                        if (long.TryParse(msSince1970, out ms)) return ms.FromUnixTimeMs();
 
66
 
 
67
                        // Do we really need to support fractional unix time ms time strings??
 
68
                        return double.Parse(msSince1970).FromUnixTimeMs();
 
69
                }
 
70
 
 
71
                public static DateTime FromUnixTimeMs(string msSince1970, TimeSpan offset)
 
72
                {
 
73
                        long ms;
 
74
                        if (long.TryParse(msSince1970, out ms)) return ms.FromUnixTimeMs(offset);
 
75
 
 
76
                        // Do we really need to support fractional unix time ms time strings??
 
77
                        return double.Parse(msSince1970).FromUnixTimeMs(offset);
 
78
                }
 
79
 
 
80
                public static DateTime RoundToMs(this DateTime dateTime)
 
81
                {
 
82
                        return new DateTime((dateTime.Ticks / TimeSpan.TicksPerMillisecond) * TimeSpan.TicksPerMillisecond);
 
83
                }
 
84
 
 
85
                public static DateTime RoundToSecond(this DateTime dateTime)
 
86
                {
 
87
                        return new DateTime((dateTime.Ticks / TimeSpan.TicksPerSecond) * TimeSpan.TicksPerSecond);
 
88
                }
 
89
 
 
90
                public static string ToShortestXsdDateTimeString(this DateTime dateTime)
 
91
                {
 
92
                        return DateTimeSerializer.ToShortestXsdDateTimeString(dateTime);
 
93
                }
 
94
 
 
95
                public static DateTime FromShortestXsdDateTimeString(this string xsdDateTime)
 
96
                {
 
97
                        return DateTimeSerializer.ParseShortestXsdDateTime(xsdDateTime);
 
98
                }
 
99
 
 
100
                public static bool IsEqualToTheSecond(this DateTime dateTime, DateTime otherDateTime)
 
101
                {
 
102
                        return dateTime.ToStableUniversalTime().RoundToSecond().Equals(otherDateTime.ToStableUniversalTime().RoundToSecond());
 
103
                }
 
104
 
 
105
                public static string ToTimeOffsetString(this TimeSpan offset, bool includeColon = false)
 
106
                {
 
107
                        var sign = offset < TimeSpan.Zero ? "-" : "+";
 
108
                        var hours = Math.Abs(offset.Hours);
 
109
                        var minutes = Math.Abs(offset.Minutes);
 
110
                        var separator = includeColon ? ":" : "";
 
111
                        return string.Format("{0}{1:00}{2}{3:00}", sign, hours, separator, minutes);
 
112
                }
 
113
 
 
114
                public static TimeSpan FromTimeOffsetString(this string offsetString)
 
115
                {
 
116
                        if (!offsetString.Contains(":"))
 
117
                                offsetString = offsetString.Insert(offsetString.Length - 2, ":");
 
118
 
 
119
                        offsetString = offsetString.TrimStart('+');
 
120
 
 
121
                        return TimeSpan.Parse(offsetString);
 
122
                }
 
123
 
 
124
                public static DateTime ToStableUniversalTime(this DateTime dateTime)
 
125
                {
 
126
#if SILVERLIGHT
 
127
                        // Silverlight 3, 4 and 5 all work ok with DateTime.ToUniversalTime, but have no TimeZoneInfo.ConverTimeToUtc implementation.
 
128
                        return dateTime.ToUniversalTime();
 
129
#else
 
130
                        // .Net 2.0 - 3.5 has an issue with DateTime.ToUniversalTime, but works ok with TimeZoneInfo.ConvertTimeToUtc.
 
131
                        // .Net 4.0+ does this under the hood anyway.
 
132
                        return TimeZoneInfo.ConvertTimeToUtc(dateTime);
 
133
#endif
 
134
                }
 
135
        }
 
136
}
 
 
b'\\ No newline at end of file'