We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Globalization \ MonthNameStyles

SSCLI
  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  16. namespace System.Globalization
  17. {
  18.     using System;
  19.     using System.Security;
  20.     using System.Threading;
  21.     using System.Collections;
  22.     using System.Runtime.Serialization;
  23.     using System.Security.Permissions;
  24.     using System.Runtime.InteropServices;
  25.     using System.Text;
  26.    
  27.     //
  28.     // Flags used to indicate different styles of month names.
  29.     // This is an internal flag used by internalGetMonthName().
  30.     // Use flag here in case that we need to provide a combination of these styles
  31.     // (such as month name of a leap year in genitive form. Not likely for now,
  32.     // but would like to keep the option open).
  33.     //
  34.    
  35.     [Flags()]
  36.     internal enum MonthNameStyles
  37.     {
  38.         Regular = 0,
  39.         Genitive = 1,
  40.         LeapYear = 2
  41.     }
  42.    
  43.     //
  44.     // Flags used to indicate special rule used in parsing/formatting
  45.     // for a specific DateTimeFormatInfo instance.
  46.     // This is an internal flag.
  47.     //
  48.     // This flag is different from MonthNameStyles because this flag
  49.     // can be expanded to accomodate parsing behaviors like CJK month names
  50.     // or alternative month names, etc.
  51.    
  52.     [Flags()]
  53.     internal enum DateTimeFormatFlags
  54.     {
  55.         None = 0,
  56.         UseGenitiveMonth = 1,
  57.         UseLeapYearMonth = 2,
  58.         UseSpacesInMonthNames = 4,
  59.         // Has spaces or non-breaking space in the month names.
  60.         UseHebrewRule = 8,
  61.         // Format/Parse using the Hebrew calendar rule.
  62.         UseSpacesInDayNames = 16,
  63.         // Has spaces or non-breaking space in the day names.
  64.         UseDigitPrefixInTokens = 32,
  65.         // Has token starting with numbers.
  66.         NotInitialized = -1
  67.     }
  68.    
  69.    
  70.     [Serializable()]
  71.     [System.Runtime.InteropServices.ComVisible(true)]
  72.     public sealed class DateTimeFormatInfo : ICloneable, IFormatProvider
  73.     {
  74.        
  75.         // cache for the invarinat culture.
  76.         // invariantInfo is constant irrespective of your current culture.
  77.         private static DateTimeFormatInfo invariantInfo;
  78.        
  79.         // an index which points to a record in Culture Data Table.
  80.         [NonSerialized()]
  81.         internal CultureTableRecord m_cultureTableRecord;
  82.        
  83.         // The culture name used to create this DTFI.
  84.         [OptionalField(VersionAdded = 2)]
  85.         internal string m_name = null;
  86.        
  87.         // The language name of the culture used to create this DTFI.
  88.         [NonSerialized()]
  89.         internal string m_langName = null;
  90.        
  91.         // CompareInfo usually used by the parser.
  92.         [NonSerialized()]
  93.         internal CompareInfo m_compareInfo = null;
  94.        
  95.         // Flag to indicate if the specified calendar for this DTFI is the
  96.         // default calendar stored in the culture.nlp.
  97.         internal bool m_isDefaultCalendar;
  98.        
  99.         internal int CultureId {
  100.             get { return this.m_cultureTableRecord.CultureID; }
  101.         }
  102.        
  103.         //
  104.         //
  105.         //
  106.         //
  107.         //
  108.         internal bool bUseCalendarInfo = false;
  109.        
  110.         //
  111.         // Caches for various properties.
  112.         //
  113.         internal string amDesignator = null;
  114.         internal string pmDesignator = null;
  115.         internal string dateSeparator = null;
  116.         internal string longTimePattern = null;
  117.         internal string shortTimePattern = null;
  118.         internal string generalShortTimePattern = null;
  119.         internal string generalLongTimePattern = null;
  120.         internal string timeSeparator = null;
  121.         internal string monthDayPattern = null;
  122.        
  123.         // In case default time/date pattern included in the all patterns array then we always set it as first item.
  124.         // that is to be easy to know if we need to add the default pattern to the array when the array is requested.
  125.         // look at SetDefaultPatternAsFirstItem to see how we do that.
  126.         internal string[] allShortTimePatterns = null;
  127.         internal string[] allLongTimePatterns = null;
  128.        
  129.         //
  130.         // The following are constant values.
  131.         //
  132.         internal const string rfc1123Pattern = "ddd, dd MMM yyyy HH':'mm':'ss 'GMT'";
  133.         // The sortable pattern is based on ISO 8601.
  134.         internal const string sortableDateTimePattern = "yyyy'-'MM'-'dd'T'HH':'mm':'ss";
  135.         internal const string universalSortableDateTimePattern = "yyyy'-'MM'-'dd HH':'mm':'ss'Z'";
  136.        
  137.         //
  138.         // The following are affected by calendar settings.
  139.         //
  140.         internal Calendar calendar = null;
  141.        
  142.         internal int firstDayOfWeek = -1;
  143.         internal int calendarWeekRule = -1;
  144.        
  145.         internal string fullDateTimePattern = null;
  146.        
  147.         internal string longDatePattern = null;
  148.        
  149.         internal string shortDatePattern = null;
  150.        
  151.         internal string yearMonthPattern = null;
  152.        
  153.         internal string[] abbreviatedDayNames = null;
  154.        
  155.         [OptionalField(VersionAdded = 2)]
  156.         internal string[] m_superShortDayNames = null;
  157.        
  158.         internal string[] dayNames = null;
  159.         internal string[] abbreviatedMonthNames = null;
  160.         internal string[] monthNames = null;
  161.         // Cache the genitive month names that we retrieve from the data table.
  162.         [OptionalField(VersionAdded = 2)]
  163.         internal string[] genitiveMonthNames = null;
  164.        
  165.         // Cache the abbreviated genitive month names that we retrieve from the data table.
  166.         [OptionalField(VersionAdded = 2)]
  167.         internal string[] m_genitiveAbbreviatedMonthNames = null;
  168.        
  169.         // Cache the month names of a leap year that we retrieve from the data table.
  170.         [OptionalField(VersionAdded = 2)]
  171.         internal string[] leapYearMonthNames = null;
  172.        
  173.         // In case default time/date pattern included in the all patterns array then we always set it as first item.
  174.         // that is to be easy to know if we need to add the default pattern to the array when the array is requested.
  175.         // look at SetDefaultPatternAsFirstItem to see how we do that.
  176.        
  177.         [NonSerialized()]
  178.         // this is lazy intialized so no need to serialize it.
  179.         internal string[] allYearMonthPatterns = null;
  180.         internal string[] allShortDatePatterns = null;
  181.         internal string[] allLongDatePatterns = null;
  182.        
  183.        
  184.        
  185.         // Cache the era names for this DateTimeFormatInfo instance.
  186.         internal string[] m_eraNames = null;
  187.         internal string[] m_abbrevEraNames = null;
  188.         internal string[] m_abbrevEnglishEraNames = null;
  189.        
  190.         internal string[] m_dateWords = null;
  191.        
  192.         internal int[] optionalCalendars = null;
  193.        
  194.         private const int DEFAULT_ALL_DATETIMES_SIZE = 132;
  195.        
  196.         internal bool m_isReadOnly = false;
  197.         // This flag gives hints about if formatting/parsing should perform special code path for things like
  198.         // genitive form or leap year month names.
  199.         [OptionalField(VersionAdded = 2)]
  200.         internal DateTimeFormatFlags formatFlags = DateTimeFormatFlags.NotInitialized;
  201.        
  202.         private static Hashtable m_calendarNativeNames;
  203.         // Maps from calendar Id to calendar native name.
  204.         private static object s_InternalSyncObject;
  205.        
  206.         private static object InternalSyncObject {
  207.             get {
  208.                 if (s_InternalSyncObject == null) {
  209.                     object o = new object();
  210.                     Interlocked.CompareExchange(ref s_InternalSyncObject, o, null);
  211.                 }
  212.                 return s_InternalSyncObject;
  213.             }
  214.         }
  215.        
  216.         internal string CultureName {
  217.             get {
  218.                 if (m_name == null) {
  219.                     m_name = this.m_cultureTableRecord.SNAME;
  220.                 }
  221.                 return (m_name);
  222.             }
  223.         }
  224.        
  225.         internal string LanguageName {
  226.             get {
  227.                 if (m_langName == null) {
  228.                     m_langName = this.m_cultureTableRecord.SISO639LANGNAME;
  229.                 }
  230.                 return (m_langName);
  231.             }
  232.         }
  233.        
  234.         ////////////////////////////////////////////////////////////////////////////
  235.         //
  236.         // Create an array of string which contains the abbreviated day names.
  237.         //
  238.         ////////////////////////////////////////////////////////////////////////////
  239.        
  240.         private string[] GetAbbreviatedDayOfWeekNames()
  241.         {
  242.             if (abbreviatedDayNames == null) {
  243.                 if (abbreviatedDayNames == null) {
  244.                     string[] temp = null;
  245.                     if (!m_isDefaultCalendar) {
  246.                         BCLDebug.Assert(Calendar.ID > 0, "[DateTimeFormatInfo.GetAbbreviatedDayOfWeekNames] Expected Calendar.ID > 0");
  247.                         temp = CalendarTable.Default.SABBREVDAYNAMES(Calendar.ID);
  248.                     }
  249.                     if (temp == null || temp.Length == 0 || temp[0].Length == 0)
  250.                         temp = this.m_cultureTableRecord.SABBREVDAYNAMES;
  251.                     System.Threading.Thread.MemoryBarrier();
  252.                     abbreviatedDayNames = temp;
  253.                     BCLDebug.Assert(abbreviatedDayNames.Length == 7, "[DateTimeFormatInfo.GetAbbreviatedDayOfWeekNames] Expected 7 day names in a week");
  254.                 }
  255.             }
  256.             return (abbreviatedDayNames);
  257.         }
  258.        
  259.         ////////////////////////////////////////////////////////////////////////
  260.         //
  261.         // Action: Returns the string array of the one-letter day of week names.
  262.         // Returns:
  263.         // an array of one-letter day of week names
  264.         // Arguments:
  265.         // None
  266.         // Exceptions:
  267.         // None
  268.         //
  269.         ////////////////////////////////////////////////////////////////////////
  270.        
  271.         private string[] internalGetSuperShortDayNames()
  272.         {
  273.             if (this.m_superShortDayNames == null) {
  274.                 if (this.m_superShortDayNames == null) {
  275.                     string[] temp = null;
  276.                     if (!m_isDefaultCalendar) {
  277.                         BCLDebug.Assert(Calendar.ID > 0, "[DateTimeFormatInfo.internalGetSuperShortDayNames] Expected Calendar.ID > 0");
  278.                         temp = CalendarTable.Default.SSUPERSHORTDAYNAMES(Calendar.ID);
  279.                     }
  280.                     if (temp == null || temp.Length == 0 || temp[0].Length == 0)
  281.                         temp = this.m_cultureTableRecord.SSUPERSHORTDAYNAMES;
  282.                     System.Threading.Thread.MemoryBarrier();
  283.                     this.m_superShortDayNames = temp;
  284.                     BCLDebug.Assert(this.m_superShortDayNames.Length == 7, "[DateTimeFormatInfo.internalGetSuperShortDayNames] Expected 7 day names in a week");
  285.                 }
  286.             }
  287.             return (this.m_superShortDayNames);
  288.         }
  289.        
  290.         ////////////////////////////////////////////////////////////////////////////
  291.         //
  292.         // Create an array of string which contains the day names.
  293.         //
  294.         ////////////////////////////////////////////////////////////////////////////
  295.        
  296.         private string[] GetDayOfWeekNames()
  297.         {
  298.             if (dayNames == null) {
  299.                 if (dayNames == null) {
  300.                     string[] temp = null;
  301.                     if (!m_isDefaultCalendar) {
  302.                         BCLDebug.Assert(Calendar.ID > 0, "[DateTimeFormatInfo.GetDayOfWeekNames] Expected Calendar.ID > 0");
  303.                         temp = CalendarTable.Default.SDAYNAMES(Calendar.ID);
  304.                     }
  305.                     if (temp == null || temp.Length == 0 || temp[0].Length == 0)
  306.                         temp = this.m_cultureTableRecord.SDAYNAMES;
  307.                     System.Threading.Thread.MemoryBarrier();
  308.                     dayNames = temp;
  309.                     BCLDebug.Assert(dayNames.Length == 7, "[DateTimeFormatInfo.GetDayOfWeekNames] Expected 7 day names in a week");
  310.                 }
  311.             }
  312.             return (dayNames);
  313.         }
  314.        
  315.         ////////////////////////////////////////////////////////////////////////////
  316.         //
  317.         // Create an array of string which contains the abbreviated month names.
  318.         //
  319.         ////////////////////////////////////////////////////////////////////////////
  320.        
  321.         private string[] GetAbbreviatedMonthNames()
  322.         {
  323.             if (abbreviatedMonthNames == null) {
  324.                 if (abbreviatedMonthNames == null) {
  325.                     string[] temp = null;
  326.                     if (!m_isDefaultCalendar) {
  327.                         BCLDebug.Assert(Calendar.ID > 0, "[DateTimeFormatInfo.GetAbbreviatedMonthNames] Expected Calendar.ID > 0");
  328.                         temp = CalendarTable.Default.SABBREVMONTHNAMES(Calendar.ID);
  329.                     }
  330.                     if (temp == null || temp.Length == 0 || temp[0].Length == 0)
  331.                         temp = this.m_cultureTableRecord.SABBREVMONTHNAMES;
  332.                     System.Threading.Thread.MemoryBarrier();
  333.                     abbreviatedMonthNames = temp;
  334.                     BCLDebug.Assert(abbreviatedMonthNames.Length == 12 || abbreviatedMonthNames.Length == 13, "[DateTimeFormatInfo.GetAbbreviatedMonthNames] Expected 12 or 13 month names in a year");
  335.                 }
  336.             }
  337.             return (abbreviatedMonthNames);
  338.         }
  339.        
  340.        
  341.         ////////////////////////////////////////////////////////////////////////////
  342.         //
  343.         // Create an array of string which contains the month names.
  344.         //
  345.         ////////////////////////////////////////////////////////////////////////////
  346.        
  347.         private string[] GetMonthNames()
  348.         {
  349.             if (monthNames == null) {
  350.                 string[] temp = null;
  351.                 if (!m_isDefaultCalendar) {
  352.                     BCLDebug.Assert(Calendar.ID > 0, "[DateTimeFormatInfo.GetMonthNames] Expected Calendar.ID > 0");
  353.                     temp = CalendarTable.Default.SMONTHNAMES(Calendar.ID);
  354.                 }
  355.                 if (temp == null || temp.Length == 0 || temp[0].Length == 0)
  356.                     temp = this.m_cultureTableRecord.SMONTHNAMES;
  357.                 System.Threading.Thread.MemoryBarrier();
  358.                 monthNames = temp;
  359.                 BCLDebug.Assert(MonthNames.Length == 12 || MonthNames.Length == 13, "[DateTimeFormatInfo.GetMonthNames] Expected 12 or 13 month names in a year");
  360.             }
  361.            
  362.             return (monthNames);
  363.         }
  364.        
  365.        
  366.         public DateTimeFormatInfo()
  367.         {
  368.             //
  369.             // Invariant DateTimeFormatInfo doesn't have user-overriden values, so we pass false in useUserOverride.
  370.             //
  371.             this.m_cultureTableRecord = CultureInfo.InvariantCulture.m_cultureTableRecord;
  372.             // In Invariant culture, the default calendar store in culture.nlp is Gregorian localized.
  373.             // And the date/time pattern for invariant culture stored in
  374.             this.m_isDefaultCalendar = true;
  375.             this.calendar = GregorianCalendar.GetDefaultInstance();
  376.            
  377.             // We don't have to call the setter of Calendar property here because the Calendar getter
  378.             // will return Gregorian localized calendar by default.
  379.             InitializeOverridableProperties();
  380.         }
  381.        
  382.         internal DateTimeFormatInfo(CultureTableRecord cultureTable, int cultureID, Calendar cal)
  383.         {
  384.             this.m_cultureTableRecord = cultureTable;
  385.             // m_isDefaultCalendar is set in the setter of Calendar below.
  386.             this.Calendar = cal;
  387.         }
  388.        
  389.         #region Serialization
  390.         // The following fields are defined to keep the serialization compatibility with .NET V1.0/V1.1.
  391.         private int CultureID;
  392.         private bool m_useUserOverride;
  393.         private int nDataItem;
  394.        
  395.         [OnDeserialized()]
  396.         private void OnDeserialized(StreamingContext ctx)
  397.         {
  398.             BCLDebug.Assert(CultureID >= 0, "[DateTimeFormatInfo.OnDeserialized] clulture ID < 0");
  399.            
  400.             if (CultureTableRecord.IsCustomCultureId(CultureID))
  401.                 m_cultureTableRecord = CultureTableRecord.GetCultureTableRecord(m_name, m_useUserOverride);
  402.             else
  403.                 m_cultureTableRecord = CultureTableRecord.GetCultureTableRecord(CultureID, m_useUserOverride);
  404.            
  405.             if (calendar == null) {
  406.                 calendar = (Calendar)GregorianCalendar.GetDefaultInstance().Clone();
  407.                 calendar.SetReadOnlyState(m_isReadOnly);
  408.             }
  409.             else {
  410.                 CultureInfo.CheckDomainSafetyObject(calendar, this);
  411.             }
  412.            
  413.             InitializeOverridableProperties();
  414.         }
  415.        
  416.         [OnSerializing()]
  417.         private void OnSerializing(StreamingContext ctx)
  418.         {
  419.             CultureID = m_cultureTableRecord.CultureID;
  420.             m_useUserOverride = m_cultureTableRecord.UseUserOverride;
  421.             nDataItem = m_cultureTableRecord.EverettDataItem();
  422.            
  423.             //
  424.             // If we have custom culture then we serialize a valid name so it can be used
  425.             // during the deserialization as we cannot use the CultureID at that time.
  426.             //
  427.            
  428.             if (CultureTableRecord.IsCustomCultureId(CultureID)) {
  429.                 // make sure the m_name is initialized.
  430.                 m_name = this.CultureName;
  431.             }
  432.         }
  433.         #endregion Serialization
  434.        
  435.         // Returns a default DateTimeFormatInfo that will be universally
  436.         // supported and constant irrespective of the current culture.
  437.         // Used by FromString methods.
  438.         //
  439.        
  440.         public static DateTimeFormatInfo InvariantInfo {
  441.             get {
  442.                 if (invariantInfo == null) {
  443.                     DateTimeFormatInfo info = new DateTimeFormatInfo();
  444.                     info.Calendar.SetReadOnlyState(true);
  445.                     info.m_isReadOnly = true;
  446.                     invariantInfo = info;
  447.                 }
  448.                 return (invariantInfo);
  449.             }
  450.         }
  451.        
  452.         // Returns the current culture's DateTimeFormatInfo. Used by Parse methods.
  453.         //
  454.        
  455.         public static DateTimeFormatInfo CurrentInfo {
  456.             get {
  457.                 System.Globalization.CultureInfo culture = System.Threading.Thread.CurrentThread.CurrentCulture;
  458.                 if (!culture.m_isInherited) {
  459.                     DateTimeFormatInfo info = culture.dateTimeInfo;
  460.                     if (info != null) {
  461.                         return info;
  462.                     }
  463.                 }
  464.                 return (DateTimeFormatInfo)culture.GetFormat(typeof(DateTimeFormatInfo));
  465.             }
  466.         }
  467.        
  468.        
  469.         public static DateTimeFormatInfo GetInstance(IFormatProvider provider)
  470.         {
  471.             // Fast case for a regular CultureInfo
  472.             DateTimeFormatInfo info;
  473.             CultureInfo cultureProvider = provider as CultureInfo;
  474.             if (cultureProvider != null && !cultureProvider.m_isInherited) {
  475.                 info = cultureProvider.dateTimeInfo;
  476.                 if (info != null) {
  477.                     return info;
  478.                 }
  479.                 else {
  480.                     return cultureProvider.DateTimeFormat;
  481.                 }
  482.             }
  483.             // Fast case for a DTFI;
  484.             info = provider as DateTimeFormatInfo;
  485.             if (info != null) {
  486.                 return info;
  487.             }
  488.             if (provider != null) {
  489.                 info = provider.GetFormat(typeof(DateTimeFormatInfo)) as DateTimeFormatInfo;
  490.                 if (info != null) {
  491.                     return info;
  492.                 }
  493.             }
  494.             return CurrentInfo;
  495.         }
  496.        
  497.        
  498.         public object GetFormat(Type formatType)
  499.         {
  500.             return (formatType == typeof(DateTimeFormatInfo) ? this : null);
  501.         }
  502.        
  503.        
  504.         public object Clone()
  505.         {
  506.             DateTimeFormatInfo n = (DateTimeFormatInfo)MemberwiseClone();
  507.             // We can use the data member calendar in the setter, instead of the property Calendar,
  508.             // since the cloned copy should have the same state as the original copy.
  509.             n.calendar = (Calendar)this.Calendar.Clone();
  510.             n.m_isReadOnly = false;
  511.             return n;
  512.         }
  513.        
  514.        
  515.         public string AMDesignator {
  516.             get {
  517.                 BCLDebug.Assert(amDesignator != null, "DateTimeFormatInfo.AMDesignator, amDesignator != null");
  518.                 return (amDesignator);
  519.             }
  520.            
  521.             set {
  522.                 VerifyWritable();
  523.                 if (value == null) {
  524.                     throw new ArgumentNullException("value", Environment.GetResourceString("ArgumentNull_String"));
  525.                 }
  526.                 ClearTokenHashTable(true);
  527.                 amDesignator = value;
  528.             }
  529.         }
  530.        
  531.         private void InitializeOverridableProperties()
  532.         {
  533.             // These properties are not affected by calendar settings. And they should be always initialized.
  534.            
  535.             if (amDesignator == null) {
  536.                 amDesignator = m_cultureTableRecord.S1159;
  537.             }
  538.             if (pmDesignator == null) {
  539.                 pmDesignator = m_cultureTableRecord.S2359;
  540.             }
  541.             if (longTimePattern == null) {
  542.                 longTimePattern = m_cultureTableRecord.STIMEFORMAT;
  543.             }
  544.             if (firstDayOfWeek == -1) {
  545.                 firstDayOfWeek = m_cultureTableRecord.IFIRSTDAYOFWEEK;
  546.             }
  547.             if (calendarWeekRule == -1) {
  548.                 calendarWeekRule = m_cultureTableRecord.IFIRSTWEEKOFYEAR;
  549.             }
  550.            
  551.             // These 3 properties are affected by calendar settings.
  552.             if (yearMonthPattern == null) {
  553.                 yearMonthPattern = GetYearMonthPattern(calendar.ID);
  554.             }
  555.             if (shortDatePattern == null) {
  556.                 shortDatePattern = GetShortDatePattern(calendar.ID);
  557.             }
  558.             if (longDatePattern == null) {
  559.                 longDatePattern = GetLongDatePattern(calendar.ID);
  560.             }
  561.         }
  562.        
  563.        
  564.         public Calendar Calendar {
  565.             get {
  566.                 BCLDebug.Assert(calendar != null, "DateTimeFormatInfo.Calendar: calendar != null");
  567.                 return (calendar);
  568.             }
  569.            
  570.             set {
  571.                 VerifyWritable();
  572.                 if (value == null) {
  573.                     throw new ArgumentNullException("value", Environment.GetResourceString("ArgumentNull_Obj"));
  574.                 }
  575.                 if (value == calendar) {
  576.                     return;
  577.                 }
  578.                
  579.                 //
  580.                 // Because the culture is agile object which can be attached to a thread and then thread can travel
  581.                 // to another app domain then we prevent attaching any customized object to culture that we cannot contol.
  582.                 //
  583.                 CultureInfo.CheckDomainSafetyObject(value, this);
  584.                
  585.                 for (int i = 0; i < OptionalCalendars.Length; i++) {
  586.                     if (OptionalCalendars[i] == value.ID) {
  587.                         ClearTokenHashTable(false);
  588.                         //
  589.                         // Get the current Win32 user culture.
  590.                         //
  591.                         m_isDefaultCalendar = (value.ID == Calendar.CAL_GREGORIAN);
  592.                         /*
  593.                             When UseUserOverride is TRUE, we should follow the following table
  594.                             to retrieve date/time patterns.
  596.                             CurrentCulture:    Is the culture which creates the DTFI the current user default culture
  597.                                                 specified in the control panel?
  598.                             CurrentCalendar:    Is the specified calendar the current calendar specified in the control panel?
  599.                             n/r: not relavent, don't care.
  601.                             Case    CurrentCulture? CurrentCalendar?    GregorianLocalized? Get Data from
  602.                             ----    --------------- ----------------    ------------------- --------------------------
  603.                             1      Y              Y                  n/r                registry & culture.nlp (for user-overridable data)
  604.                             2      n/r            n/r                Y                  culture.nlp
  605.                             3      n/r            n/r                N                  CALENDAR.nlp*
  606.                         */                       
  607.                        
  608. if (calendar != null) {
  609.                             // clean related properties which are affected by the calendar setting,
  610.                             // so that they will be refreshed when they are accessed next time.
  611.                             //
  612.                            
  613.                             // These properites are in the order as appearing in calendar.xml.
  614.                             m_eraNames = null;
  615.                             m_abbrevEraNames = null;
  616.                             m_abbrevEnglishEraNames = null;
  617.                            
  618.                             shortDatePattern = null;
  619.                             yearMonthPattern = null;
  620.                             monthDayPattern = null;
  621.                             longDatePattern = null;
  622.                            
  623.                             dayNames = null;
  624.                             abbreviatedDayNames = null;
  625.                             m_superShortDayNames = null;
  626.                             monthNames = null;
  627.                             abbreviatedMonthNames = null;
  628.                             genitiveMonthNames = null;
  629.                             m_genitiveAbbreviatedMonthNames = null;
  630.                             leapYearMonthNames = null;
  631.                             formatFlags = DateTimeFormatFlags.NotInitialized;
  632.                            
  633.                             // These properies are not in calendar.xml, but they are dependent on the values like shortDatePattern.
  634.                             fullDateTimePattern = null;
  635.                             generalShortTimePattern = null;
  636.                             generalLongTimePattern = null;
  637.                             allShortDatePatterns = null;
  638.                             allLongDatePatterns = null;
  639.                             allYearMonthPatterns = null;
  640.                            
  641.                            
  642.                         }
  643.                        
  644.                         calendar = value;
  645.                        
  646.                         if (this.m_cultureTableRecord.UseCurrentCalendar(value.ID)) {
  647.                             //
  648.                             // [Case 1]
  649.                             //
  650.                             // If user overriden values are allowed, and the culture is the user default culture
  651.                             // and the specified calendar matches the calendar setting in the control panel,
  652.                             // use data from registry by setting bUseCalendarInfo to be false.
  653.                             //
  654.                             DTFIUserOverrideValues temp = new DTFIUserOverrideValues();
  655.                            
  656.                             // If this is the first time calendar is set, just assign
  657.                             // the value to calendar. We don't have to clean up
  658.                             // related fields.
  659.                             // We need to retrieve all user-override values and cache them to avoid to get different
  660.                             // values between calls to CultureInfo.ClearCachedData()
  661.                             m_cultureTableRecord.GetDTFIOverrideValues(ref temp);
  662.                            
  663.                            
  664.                             amDesignator = temp.amDesignator;
  665.                             pmDesignator = temp.pmDesignator;
  666.                             longTimePattern = temp.longTimePattern;
  667.                             firstDayOfWeek = (int)temp.firstDayOfWeek;
  668.                             calendarWeekRule = (int)temp.calendarWeekRule;
  669.                             shortDatePattern = temp.shortDatePattern;
  670.                             longDatePattern = temp.longDatePattern;
  671.                             yearMonthPattern = temp.yearMonthPattern;
  672.                            
  673.                             // To work around a Win9x data bug. GetLocaleInfo(LOCALE_SYEARMONTH) returns empty string in Win9x.
  674.                             // There is also a NLS bug that GetLocaleInfo returns incorrect YearMonth pattern when the reg key of for YearMonth does not
  675.                             // exists. GetDTFIOVerrideValues() will leave yearMonthPattern to be null in that case.
  676.                            
  677.                             // In these cases, fall back to the table value.
  678.                            
  679.                             if (yearMonthPattern == null || yearMonthPattern.Length == 0) {
  680.                                 yearMonthPattern = GetYearMonthPattern(value.ID);
  681.                             }
  682.                            
  683.                         }
  684.                         else {
  685.                             // Case 2 & Case 3
  686.                            
  687.                             InitializeOverridableProperties();
  688.                         }
  689.                         return;
  690.                     }
  691.                 }
  692.                 // The assigned calendar is not a valid calendar for this culture.
  693.                 throw new ArgumentOutOfRangeException("value", Environment.GetResourceString("Argument_InvalidCalendar"));
  694.             }
  695.         }
  696.        
  697.         internal int[] OptionalCalendars {
  698.             get {
  699.                 if (optionalCalendars == null) {
  700.                     optionalCalendars = this.m_cultureTableRecord.IOPTIONALCALENDARS;
  701.                 }
  702.                 return (optionalCalendars);
  703.             }
  704.         }
  705.        
  706. /*=================================GetEra==========================
  707.         **Action: Get the era value by parsing the name of the era.
  708.         **Returns: The era value for the specified era name.
  709.         **      -1 if the name of the era is not valid or not supported.
  710.         **Arguments: eraName    the name of the era.
  711.         **Exceptions: None.
  712.         ============================================================================*/       
  713.        
  714.        
  715.         public int GetEra(string eraName)
  716.         {
  717.             if (eraName == null) {
  718.                 throw new ArgumentNullException("eraName", Environment.GetResourceString("ArgumentNull_String"));
  719.             }
  720.            
  721.             // The following is based on the assumption that the era value is starting from 1, and has a
  722.             // serial values.
  723.             // If that ever changes, the code has to be changed.
  724.            
  725.             // The calls to String.Compare should use the current culture for the string comparisons, but the
  726.             // invariant culture when comparing against the english names.
  727.             for (int i = 0; i < EraNames.Length; i++) {
  728.                 // Compare the era name in a case-insensitive way.
  729.                 if (m_eraNames[i].Length > 0) {
  730.                     if (String.Compare(eraName, m_eraNames[i], true, CultureInfo.CurrentCulture) == 0) {
  731.                         return (i + 1);
  732.                     }
  733.                 }
  734.             }
  735.             for (int i = 0; i < AbbreviatedEraNames.Length; i++) {
  736.                 if (String.Compare(eraName, m_abbrevEraNames[i], true, CultureInfo.CurrentCulture) == 0) {
  737.                     return (i + 1);
  738.                 }
  739.             }
  740.             for (int i = 0; i < AbbreviatedEnglishEraNames.Length; i++) {
  741.                 // this comparison should use the InvariantCulture. The English name could have linguistically
  742.                 // interesting characters.
  743.                 if (String.Compare(eraName, m_abbrevEnglishEraNames[i], true, CultureInfo.InvariantCulture) == 0) {
  744.                     return (i + 1);
  745.                 }
  746.             }
  747.             return (-1);
  748.         }
  749.        
  750.         internal string[] EraNames {
  751.             get {
  752.                 if (m_eraNames == null) {
  753.                     if (Calendar.ID == Calendar.CAL_GREGORIAN) {
  754.                         // If the calendar is Gregorian localized calendar,
  755.                         // grab the localized name from culture.nlp.
  756.                         m_eraNames = new string[1] {this.m_cultureTableRecord.SADERA};
  757.                     }
  758.                     else if (Calendar.ID != Calendar.CAL_TAIWAN) {
  759.                         // Use Calendar property so that we initialized the calendar when necessary.
  760.                         BCLDebug.Assert(Calendar.ID > 0, "[DateTimeFormatInfo.EraNames] Expected Calendar.ID > 0");
  761.                         m_eraNames = CalendarTable.Default.SERANAMES(Calendar.ID);
  762.                     }
  763.                     else {
  764.                         // Special case for Taiwan calendar.
  765.                         // 0x0404 is the locale ID for Taiwan.
  766.                         m_eraNames = new string[] {CalendarTable.nativeGetEraName(1028, Calendar.ID)};
  767.                     }
  768.                 }
  769.                 return (m_eraNames);
  770.             }
  771.         }
  772.        
  773. /*=================================GetEraName==========================
  774.         **Action: Get the name of the era for the specified era value.
  775.         **Returns: The name of the specified era.
  776.         **Arguments:
  777.         **      era the era value.
  778.         **Exceptions:
  779.         **      ArguementException if the era valie is invalid.
  780.         ============================================================================*/       
  781.        
  782.        
  783.         public string GetEraName(int era)
  784.         {
  785.             if (era == Calendar.CurrentEra) {
  786.                 era = Calendar.CurrentEraValue;
  787.             }
  788.            
  789.             // The following is based on the assumption that the era value is starting from 1, and has a
  790.             // serial values.
  791.             // If that ever changes, the code has to be changed.
  792.             if ((--era) < EraNames.Length && (era >= 0)) {
  793.                 return (m_eraNames[era]);
  794.             }
  795.             throw new ArgumentOutOfRangeException("era", Environment.GetResourceString("ArgumentOutOfRange_InvalidEraValue"));
  796.         }
  797.        
  798.         internal string[] AbbreviatedEraNames {
  799.             get {
  800.                 if (m_abbrevEraNames == null) {
  801.                     if (Calendar.ID == Calendar.CAL_TAIWAN) {
  802.