DateTools.cs
上传用户:zhangkuixh
上传日期:2013-09-30
资源大小:5473k
文件大小:12k
源码类别:

搜索引擎

开发平台:

C#

  1. /*
  2.  * Copyright 2004 The Apache Software Foundation
  3.  * 
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  * 
  8.  * http://www.apache.org/licenses/LICENSE-2.0
  9.  * 
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  */
  16. using System;
  17. namespace Lucene.Net.Documents
  18. {
  19. /// <summary> Provides support for converting dates to strings and vice-versa.
  20. /// The strings are structured so that lexicographic sorting orders 
  21. /// them by date, which makes them suitable for use as field values 
  22. /// and search terms.
  23. /// 
  24. /// <P>This class also helps you to limit the resolution of your dates. Do not
  25. /// save dates with a finer resolution than you really need, as then
  26. /// RangeQuery and PrefixQuery will require more memory and become slower.
  27. /// 
  28. /// <P>Compared to {@link DateField} the strings generated by the methods
  29. /// in this class take slightly more space, unless your selected resolution
  30. /// is set to <code>Resolution.DAY</code> or lower.
  31. /// </summary>
  32. public class DateTools
  33. {
  34. private DateTools()
  35. {
  36. }
  37. /// <summary> Converts a Date to a string suitable for indexing.
  38. /// 
  39. /// </summary>
  40. /// <param name="date">the date to be converted
  41. /// </param>
  42. /// <param name="resolution">the desired resolution, see
  43. /// {@link #Round(Date, DateTools.Resolution)}
  44. /// </param>
  45. /// <returns> a string in format <code>yyyyMMddHHmmssSSS</code> or shorter,
  46. /// depeding on <code>resolution</code>
  47. /// </returns>
  48. public static System.String DateToString(System.DateTime date, Resolution resolution)
  49. {
  50. return TimeToString(date.Ticks, resolution);
  51. }
  52. /// <summary> Converts a millisecond time to a string suitable for indexing.
  53. /// 
  54. /// </summary>
  55. /// <param name="time">the date expressed as milliseconds since January 1, 1970, 00:00:00 GMT
  56. /// </param>
  57. /// <param name="resolution">the desired resolution, see
  58. /// {@link #Round(long, DateTools.Resolution)}
  59. /// </param>
  60. /// <returns> a string in format <code>yyyyMMddHHmmssSSS</code> or shorter,
  61. /// depeding on <code>resolution</code>
  62. /// </returns>
  63. public static System.String TimeToString(long time, Resolution resolution)
  64. {
  65. System.Globalization.Calendar cal = new System.Globalization.GregorianCalendar();
  66. //protected in JDK's prior to 1.4
  67. //cal.setTimeInMillis(round(time, resolution));
  68. System.DateTime dt = new System.DateTime(Round(time, resolution));
  69. System.String t = "";
  70.             if (resolution == Resolution.YEAR)
  71.             {
  72.                 t = dt.ToString("yyyy");
  73.             }
  74.             else if (resolution == Resolution.MONTH)
  75.             {
  76.                 t = dt.ToString("yyyyMM");
  77.             }
  78.             else if (resolution == Resolution.DAY)
  79.             {
  80.                 t = dt.ToString("yyyyMMdd");
  81.             }
  82.             else if (resolution == Resolution.HOUR)
  83.             {
  84.                 t = dt.ToString("yyyyMMddHH");
  85.             }
  86.             else if (resolution == Resolution.MINUTE)
  87.             {
  88.                 t = dt.ToString("yyyyMMddHHmm");
  89.             }
  90.             else if (resolution == Resolution.SECOND)
  91.             {
  92.                 t = dt.ToString("yyyyMMddHHmmss");
  93.             }
  94.             else if (resolution == Resolution.MILLISECOND)
  95.             {
  96.                 t = dt.ToString("yyyyMMddHHmmssfff");
  97.             }
  98.             else
  99.             {
  100.                 throw new System.ArgumentException("unknown resolution " + resolution);
  101.             }
  102.             return t;
  103. }
  104. /// <summary> Converts a string produced by <code>timeToString</code> or
  105. /// <code>DateToString</code> back to a time, represented as the
  106. /// number of milliseconds since January 1, 1970, 00:00:00 GMT.
  107. /// 
  108. /// </summary>
  109. /// <param name="dateString">the date string to be converted
  110. /// </param>
  111. /// <returns> the number of milliseconds since January 1, 1970, 00:00:00 GMT
  112. /// </returns>
  113. /// <throws>  ParseException if <code>dateString</code> is not in the  </throws>
  114. /// <summary>  expected format 
  115. /// </summary>
  116. public static long StringToTime(System.String dateString)
  117. {
  118. return StringToDate(dateString).Ticks;
  119. }
  120. /// <summary> Converts a string produced by <code>timeToString</code> or
  121. /// <code>DateToString</code> back to a time, represented as a
  122. /// Date object.
  123. /// 
  124. /// </summary>
  125. /// <param name="dateString">the date string to be converted
  126. /// </param>
  127. /// <returns> the parsed time as a Date object 
  128. /// </returns>
  129. /// <throws>  ParseException if <code>dateString</code> is not in the  </throws>
  130. /// <summary>  expected format 
  131. /// </summary>
  132. public static System.DateTime StringToDate(System.String dateString)
  133. {
  134.             System.String yyyy = null;
  135.             System.String MM = null;
  136.             System.String dd = null;
  137.             System.String HH = null;
  138.             System.String mm = null;
  139.             System.String ss = null;
  140.             System.String SSS = null;
  141.             if (dateString.Length == 4)     // "yyyy"
  142.             {
  143.                 yyyy = dateString.Substring(0, 4);
  144.             }
  145.             else if (dateString.Length == 6)     // "yyyyMM";
  146.             {
  147.                 yyyy = dateString.Substring(0, 4);
  148.                 MM = dateString.Substring(4, 2);
  149.             }
  150.             else if (dateString.Length == 8)     // "yyyyMMdd"
  151.             {
  152.                 yyyy = dateString.Substring(0, 4);
  153.                 MM = dateString.Substring(4, 2);
  154.                 dd = dateString.Substring(6, 2);
  155.             }
  156.             else if (dateString.Length == 10)    // "yyyyMMddHH"
  157.             {
  158.                 yyyy = dateString.Substring(0, 4);
  159.                 MM = dateString.Substring(4, 2);
  160.                 dd = dateString.Substring(6, 2);
  161.                 HH = dateString.Substring(8, 2);
  162.             }
  163.             else if (dateString.Length == 12)    // "yyyyMMddHHmm";
  164.             {
  165.                 yyyy = dateString.Substring(0, 4);
  166.                 MM = dateString.Substring(4, 2);
  167.                 dd = dateString.Substring(6, 2);
  168.                 HH = dateString.Substring(8, 2);
  169.                 mm = dateString.Substring(10, 2);
  170.             }
  171.             else if (dateString.Length == 14)    // "yyyyMMddHHmmss";
  172.             {
  173.                 yyyy = dateString.Substring(0, 4);
  174.                 MM = dateString.Substring(4, 2);
  175.                 dd = dateString.Substring(6, 2);
  176.                 HH = dateString.Substring(8, 2);
  177.                 mm = dateString.Substring(10, 2);
  178.                 ss = dateString.Substring(12, 2);
  179.             }
  180.             else if (dateString.Length == 17)    // "yyyyMMddHHmmssSSS";
  181.             {
  182.                 yyyy = dateString.Substring(0, 4);
  183.                 MM = dateString.Substring(4, 2);
  184.                 dd = dateString.Substring(6, 2);
  185.                 HH = dateString.Substring(8, 2);
  186.                 mm = dateString.Substring(10, 2);
  187.                 ss = dateString.Substring(12, 2);
  188.                 SSS = dateString.Substring(14, 3);
  189.             }
  190.             else
  191.             {
  192.                 throw new System.FormatException("Input is not valid date string: " + dateString);
  193.             }
  194.             return new System.DateTime(Convert.ToInt16(yyyy), 
  195.                 Convert.ToInt16(MM), Convert.ToInt16(dd), Convert.ToInt16(HH), 
  196.                 Convert.ToInt16(mm), Convert.ToInt16(ss), Convert.ToInt16(SSS));
  197.         }
  198. /// <summary> Limit a date's resolution. For example, the date <code>2004-09-21 13:50:11</code>
  199. /// will be changed to <code>2004-09-01 00:00:00</code> when using
  200. /// <code>Resolution.MONTH</code>. 
  201. /// 
  202. /// </summary>
  203. /// <param name="resolution">The desired resolution of the date to be returned
  204. /// </param>
  205. /// <returns> the date with all values more precise than <code>resolution</code>
  206. /// set to 0 or 1
  207. /// </returns>
  208.         public static System.DateTime Round(System.DateTime date, Resolution resolution)
  209.         {
  210.             return new System.DateTime(Round(date.Ticks, resolution));
  211.         }
  212. /// <summary> Limit a date's resolution. For example, the date <code>1095767411000</code>
  213. /// (which represents 2004-09-21 13:50:11) will be changed to 
  214. /// <code>1093989600000</code> (2004-09-01 00:00:00) when using
  215. /// <code>Resolution.MONTH</code>.
  216. /// 
  217. /// </summary>
  218. /// <param name="resolution">The desired resolution of the date to be returned
  219. /// </param>
  220. /// <returns> the date with all values more precise than <code>resolution</code>
  221. /// set to 0 or 1, expressed as milliseconds since January 1, 1970, 00:00:00 GMT
  222. /// </returns>
  223.         public static long Round(long time, Resolution resolution)
  224.         {
  225.             System.Globalization.Calendar cal = new System.Globalization.GregorianCalendar();
  226.             // protected in JDK's prior to 1.4
  227.             //cal.setTimeInMillis(time);
  228.             System.DateTime dt = new System.DateTime(time);
  229.             if (resolution == Resolution.YEAR)
  230.             {
  231.                 dt = dt.AddMonths(1 - dt.Month);
  232.                 dt = dt.AddDays(1 - dt.Day);
  233.                 dt = dt.AddHours(0 - dt.Hour);
  234.                 dt = dt.AddMinutes(0 - dt.Minute);
  235.                 dt = dt.AddSeconds(0 - dt.Second);
  236.                 dt = dt.AddMilliseconds(0 - dt.Millisecond);
  237.             }
  238.             else if (resolution == Resolution.MONTH)
  239.             {
  240.                 dt = dt.AddDays(1 - dt.Day);
  241.                 dt = dt.AddHours(0 - dt.Hour);
  242.                 dt = dt.AddMinutes(0 - dt.Minute);
  243.                 dt = dt.AddSeconds(0 - dt.Second);
  244.                 dt = dt.AddMilliseconds(0 - dt.Millisecond);
  245.             }
  246.             else if (resolution == Resolution.DAY)
  247.             {
  248.                 dt = dt.AddHours(0 - dt.Hour);
  249.                 dt = dt.AddMinutes(0 - dt.Minute);
  250.                 dt = dt.AddSeconds(0 - dt.Second);
  251.                 dt = dt.AddMilliseconds(0 - dt.Millisecond);
  252.             }
  253.             else if (resolution == Resolution.HOUR)
  254.             {
  255.                 dt = dt.AddMinutes(0 - dt.Minute);
  256.                 dt = dt.AddSeconds(0 - dt.Second);
  257.                 dt = dt.AddMilliseconds(0 - dt.Millisecond);
  258.             }
  259.             else if (resolution == Resolution.MINUTE)
  260.             {
  261.                 dt = dt.AddSeconds(0 - dt.Second);
  262.                 dt = dt.AddMilliseconds(0 - dt.Millisecond);
  263.             }
  264.             else if (resolution == Resolution.SECOND)
  265.             {
  266.                 dt = dt.AddMilliseconds(0 - dt.Millisecond);
  267.             }
  268.             else if (resolution == Resolution.MILLISECOND)
  269.             {
  270.                 // don't cut off anything
  271.             }
  272.             else
  273.             {
  274.                 throw new System.ArgumentException("unknown resolution " + resolution);
  275.             }
  276.             return dt.Ticks;
  277.         }
  278. public class Resolution
  279. {
  280. public static readonly Resolution YEAR = new Resolution("year");
  281. public static readonly Resolution MONTH = new Resolution("month");
  282. public static readonly Resolution DAY = new Resolution("day");
  283. public static readonly Resolution HOUR = new Resolution("hour");
  284. public static readonly Resolution MINUTE = new Resolution("minute");
  285. public static readonly Resolution SECOND = new Resolution("second");
  286. public static readonly Resolution MILLISECOND = new Resolution("millisecond");
  287. private System.String resolution;
  288. internal Resolution()
  289. {
  290. }
  291. internal Resolution(System.String resolution)
  292. {
  293. this.resolution = resolution;
  294. }
  295. public override System.String ToString()
  296. {
  297. return resolution;
  298. }
  299. }
  300. }
  301. }