The Labs \ Source Viewer \ SSCLI \ System.Runtime.Remoting.Metadata.W3cXsd2001 \ SoapMonthDay

  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. // ==--==
  15. /*============================================================
  16. **
  17. **  File:    SoapInteropTypes.cs
  18. **
  19. **  Purpose: Types for Wsdl and Soap interop
  20. **
  21. **
  22. ===========================================================*/
  23. namespace System.Runtime.Remoting.Metadata.W3cXsd2001
  24. {
  25.     using System;
  26.     using System.Globalization;
  27.     using System.Text;
  28.    
  29.    
  30.     static internal class SoapType
  31.     {
  32.         static internal string FilterBin64(string value)
  33.         {
  34.             StringBuilder sb = new StringBuilder();
  35.             for (int i = 0; i < value.Length; i++) {
  36.                 if (!(value[i] == ' ' || value[i] == '\n' || value[i] == '\r'))
  37.                     sb.Append(value[i]);
  38.             }
  39.             return sb.ToString();
  40.         }
  41.        
  42.         static internal string LineFeedsBin64(string value)
  43.         {
  44.             // Add linefeeds every 76 characters
  45.             StringBuilder sb = new StringBuilder();
  46.             for (int i = 0; i < value.Length; i++) {
  47.                 if (i % 76 == 0)
  48.                     sb.Append('\n');
  49.                 sb.Append(value[i]);
  50.             }
  51.             return sb.ToString();
  52.         }
  53.        
  54.         static internal string Escape(string value)
  55.         {
  56.             if (value == null || value.Length == 0)
  57.                 return value;
  58.            
  59.             StringBuilder stringBuffer = new StringBuilder();
  60.             int index = value.IndexOf('&');
  61.             if (index > -1) {
  62.                 stringBuffer.Append(value);
  63.                 stringBuffer.Replace("&", "&#38;", index, stringBuffer.Length - index);
  64.             }
  65.            
  66.             index = value.IndexOf('"');
  67.             if (index > -1) {
  68.                 if (stringBuffer.Length == 0)
  69.                     stringBuffer.Append(value);
  70.                 stringBuffer.Replace("\"", "&#34;", index, stringBuffer.Length - index);
  71.             }
  72.            
  73.             index = value.IndexOf('\'');
  74.             if (index > -1) {
  75.                 if (stringBuffer.Length == 0)
  76.                     stringBuffer.Append(value);
  77.                 stringBuffer.Replace("'", "&#39;", index, stringBuffer.Length - index);
  78.             }
  79.            
  80.             index = value.IndexOf('<');
  81.             if (index > -1) {
  82.                 if (stringBuffer.Length == 0)
  83.                     stringBuffer.Append(value);
  84.                 stringBuffer.Replace("<", "&#60;", index, stringBuffer.Length - index);
  85.             }
  86.            
  87.             index = value.IndexOf('>');
  88.             if (index > -1) {
  89.                 if (stringBuffer.Length == 0)
  90.                     stringBuffer.Append(value);
  91.                 stringBuffer.Replace(">", "&#62;", index, stringBuffer.Length - index);
  92.             }
  93.            
  94.             index = value.IndexOf(Char.MinValue);
  95.             if (index > -1) {
  96.                 if (stringBuffer.Length == 0)
  97.                     stringBuffer.Append(value);
  98.                 stringBuffer.Replace(Char.MinValue.ToString(), "&#0;", index, stringBuffer.Length - index);
  99.             }
  100.            
  101.             string returnValue = null;
  102.            
  103.             if (stringBuffer.Length > 0)
  104.                 returnValue = stringBuffer.ToString();
  105.             else
  106.                 returnValue = value;
  107.            
  108.             return returnValue;
  109.         }
  110.        
  111.        
  112.        
  113.         static internal Type typeofSoapTime = typeof(SoapTime);
  114.         static internal Type typeofSoapDate = typeof(SoapDate);
  115.         static internal Type typeofSoapYearMonth = typeof(SoapYearMonth);
  116.         static internal Type typeofSoapYear = typeof(SoapYear);
  117.         static internal Type typeofSoapMonthDay = typeof(SoapMonthDay);
  118.         static internal Type typeofSoapDay = typeof(SoapDay);
  119.         static internal Type typeofSoapMonth = typeof(SoapMonth);
  120.         static internal Type typeofSoapHexBinary = typeof(SoapHexBinary);
  121.         static internal Type typeofSoapBase64Binary = typeof(SoapBase64Binary);
  122.         static internal Type typeofSoapInteger = typeof(SoapInteger);
  123.         static internal Type typeofSoapPositiveInteger = typeof(SoapPositiveInteger);
  124.         static internal Type typeofSoapNonPositiveInteger = typeof(SoapNonPositiveInteger);
  125.         static internal Type typeofSoapNonNegativeInteger = typeof(SoapNonNegativeInteger);
  126.         static internal Type typeofSoapNegativeInteger = typeof(SoapNegativeInteger);
  127.         static internal Type typeofSoapAnyUri = typeof(SoapAnyUri);
  128.         static internal Type typeofSoapQName = typeof(SoapQName);
  129.         static internal Type typeofSoapNotation = typeof(SoapNotation);
  130.         static internal Type typeofSoapNormalizedString = typeof(SoapNormalizedString);
  131.         static internal Type typeofSoapToken = typeof(SoapToken);
  132.         static internal Type typeofSoapLanguage = typeof(SoapLanguage);
  133.         static internal Type typeofSoapName = typeof(SoapName);
  134.         static internal Type typeofSoapIdrefs = typeof(SoapIdrefs);
  135.         static internal Type typeofSoapEntities = typeof(SoapEntities);
  136.         static internal Type typeofSoapNmtoken = typeof(SoapNmtoken);
  137.         static internal Type typeofSoapNmtokens = typeof(SoapNmtokens);
  138.         static internal Type typeofSoapNcName = typeof(SoapNcName);
  139.         static internal Type typeofSoapId = typeof(SoapId);
  140.         static internal Type typeofSoapIdref = typeof(SoapIdref);
  141.         static internal Type typeofSoapEntity = typeof(SoapEntity);
  142.         static internal Type typeofISoapXsd = typeof(ISoapXsd);
  143.     }
  144.    
  145.    
  146.     [System.Runtime.InteropServices.ComVisible(true)]
  147.     public interface ISoapXsd
  148.     {
  149.        
  150.         string GetXsdType();
  151.     }
  152.    
  153.     // Soap interop xsd types
  154.     //Convert from ISO Date to urt DateTime
  155.     // The form of the Date is yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fff or yyyy'-'MM'-'dd' or yyyy'-'MM'-'dd'T'HH':'mm':'ss
  156.    
  157.     [System.Runtime.InteropServices.ComVisible(true)]
  158.     public sealed class SoapDateTime
  159.     {
  160.        
  161.         public static string XsdType {
  162.             get { return "dateTime"; }
  163.         }
  164.        
  165.         private static string[] formats = {"yyyy-MM-dd'T'HH:mm:ss.fffffffzzz", "yyyy-MM-dd'T'HH:mm:ss.ffff", "yyyy-MM-dd'T'HH:mm:ss.ffffzzz", "yyyy-MM-dd'T'HH:mm:ss.fff", "yyyy-MM-dd'T'HH:mm:ss.fffzzz", "yyyy-MM-dd'T'HH:mm:ss.ff", "yyyy-MM-dd'T'HH:mm:ss.ffzzz", "yyyy-MM-dd'T'HH:mm:ss.f", "yyyy-MM-dd'T'HH:mm:ss.fzzz", "yyyy-MM-dd'T'HH:mm:ss",
  166.         "yyyy-MM-dd'T'HH:mm:sszzz", "yyyy-MM-dd'T'HH:mm:ss.fffff", "yyyy-MM-dd'T'HH:mm:ss.fffffzzz", "yyyy-MM-dd'T'HH:mm:ss.ffffff", "yyyy-MM-dd'T'HH:mm:ss.ffffffzzz", "yyyy-MM-dd'T'HH:mm:ss.fffffff", "yyyy-MM-dd'T'HH:mm:ss.ffffffff", "yyyy-MM-dd'T'HH:mm:ss.ffffffffzzz", "yyyy-MM-dd'T'HH:mm:ss.fffffffff", "yyyy-MM-dd'T'HH:mm:ss.fffffffffzzz",
  167.         "yyyy-MM-dd'T'HH:mm:ss.ffffffffff", "yyyy-MM-dd'T'HH:mm:ss.ffffffffffzzz"};
  168.        
  169.        
  170.         public static string ToString(DateTime value)
  171.         {
  172.             return value.ToString("yyyy-MM-dd'T'HH:mm:ss.fffffffzzz", CultureInfo.InvariantCulture);
  173.         }
  174.        
  175.        
  176.         public static DateTime Parse(string value)
  177.         {
  178.             DateTime dt;
  179.             try {
  180.                 if (value == null)
  181.                     dt = DateTime.MinValue;
  182.                 else {
  183.                     string time = value;
  184.                     if (value.EndsWith("Z", StringComparison.Ordinal))
  185.                         time = value.Substring(0, value.Length - 1) + "-00:00";
  186.                     dt = DateTime.ParseExact(time, formats, CultureInfo.InvariantCulture, DateTimeStyles.None);
  187.                 }
  188.                
  189.             }
  190.             catch (Exception) {
  191.                 throw new RemotingException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_SOAPInteropxsdInvalid"), "xsd:dateTime", value));
  192.             }
  193.            
  194.             return dt;
  195.         }
  196.        
  197.     }
  198.    
  199.    
  200.     [System.Runtime.InteropServices.ComVisible(true)]
  201.     public sealed class SoapDuration
  202.     {
  203.         // Convert from ISO/xsd TimeDuration to urt TimeSpan
  204.         // The form of the time duration is PxxYxxDTxxHxxMxx.xxxS or PxxYxxDTxxHxxMxxS
  205.         // Keep in sync with Message.cs
  206.        
  207.        
  208.         public static string XsdType {
  209.             get { return "duration"; }
  210.         }
  211.        
  212.         // calcuate carryover points by ISO 8601 : 1998 section 5.5.3.2.1 Alternate format
  213.         // algorithm not to exceed 12 months, 30 day
  214.         // note with this algorithm year has 360 days.
  215.         private static void CarryOver(int inDays, out int years, out int months, out int days)
  216.         {
  217.             years = inDays / 360;
  218.             int yearDays = years * 360;
  219.             months = Math.Max(0, inDays - yearDays) / 30;
  220.             int monthDays = months * 30;
  221.             days = Math.Max(0, inDays - (yearDays + monthDays));
  222.             days = inDays % 30;
  223.         }
  224.        
  225.        
  226.         public static string ToString(TimeSpan timeSpan)
  227.         {
  228.             StringBuilder sb = new StringBuilder(10);
  229.             sb.Length = 0;
  230.             if (TimeSpan.Compare(timeSpan, TimeSpan.Zero) < 1) {
  231.                 sb.Append('-');
  232.                 //timeSpan = timeSpan.Negate(); //negating timespan at top level not at each piece such as Day
  233.             }
  234.            
  235.             int years = 0;
  236.             int months = 0;
  237.             int days = 0;
  238.            
  239.             CarryOver(Math.Abs(timeSpan.Days), out years, out months, out days);
  240.            
  241.             sb.Append('P');
  242.             sb.Append(years);
  243.             sb.Append('Y');
  244.             sb.Append(months);
  245.             sb.Append('M');
  246.             sb.Append(days);
  247.             sb.Append("DT");
  248.             sb.Append(Math.Abs(timeSpan.Hours));
  249.             sb.Append('H');
  250.             sb.Append(Math.Abs(timeSpan.Minutes));
  251.             sb.Append('M');
  252.             sb.Append(Math.Abs(timeSpan.Seconds));
  253.             long timea = Math.Abs(timeSpan.Ticks % TimeSpan.TicksPerDay);
  254.             int t1 = (int)(timea % TimeSpan.TicksPerSecond);
  255.             if (t1 != 0) {
  256.                 string t2 = ParseNumbers.IntToString(t1, 10, 7, '0', 0);
  257.                 sb.Append('.');
  258.                 sb.Append(t2);
  259.             }
  260.             sb.Append('S');
  261.             return sb.ToString();
  262.         }
  263.        
  264.        
  265.         public static TimeSpan Parse(string value)
  266.         {
  267.             int sign = 1;
  268.            
  269.             try {
  270.                 if (value == null)
  271.                     return TimeSpan.Zero;
  272.                
  273.                 if (value[0] == '-')
  274.                     sign = -1;
  275.                
  276.                
  277.                 char[] c = value.ToCharArray();
  278.                 int[] timeValues = new int[7];
  279.                 string year = "0";
  280.                 string month = "0";
  281.                 string day = "0";
  282.                 string hour = "0";
  283.                 string minute = "0";
  284.                 string second = "0";
  285.                 string fraction = "0";
  286.                 bool btime = false;
  287.                 bool bmill = false;
  288.                 int beginField = 0;
  289.                
  290.                 for (int i = 0; i < c.Length; i++) {
  291.                     switch (c[i]) {
  292.                         case 'P':
  293.                             beginField = i + 1;
  294.                             break;
  295.                         case 'Y':
  296.                             year = new string(c, beginField, i - beginField);
  297.                             beginField = i + 1;
  298.                             break;
  299.                         case 'M':
  300.                             if (btime)
  301.                                 minute = new string(c, beginField, i - beginField);
  302.                             else
  303.                                 month = new string(c, beginField, i - beginField);
  304.                             beginField = i + 1;
  305.                             break;
  306.                         case 'D':
  307.                             day = new string(c, beginField, i - beginField);
  308.                             beginField = i + 1;
  309.                             break;
  310.                         case 'T':
  311.                             btime = true;
  312.                             beginField = i + 1;
  313.                             break;
  314.                         case 'H':
  315.                             hour = new string(c, beginField, i - beginField);
  316.                             beginField = i + 1;
  317.                             break;
  318.                         case '.':
  319.                             bmill = true;
  320.                             second = new string(c, beginField, i - beginField);
  321.                             beginField = i + 1;
  322.                             break;
  323.                         case 'S':
  324.                             if (!bmill)
  325.                                 second = new string(c, beginField, i - beginField);
  326.                             else
  327.                                 fraction = new string(c, beginField, i - beginField);
  328.                             break;
  329.                         case 'Z':
  330.                             break;
  331.                         default:
  332.                             // Number continue to loop until end of number
  333.                             break;
  334.                     }
  335.                 }
  336.                
  337.                 long ticks = sign * ((Int64.Parse(year, CultureInfo.InvariantCulture) * 360 + Int64.Parse(month, CultureInfo.InvariantCulture) * 30 + Int64.Parse(day, CultureInfo.InvariantCulture)) * TimeSpan.TicksPerDay + Int64.Parse(hour, CultureInfo.InvariantCulture) * TimeSpan.TicksPerHour + Int64.Parse(minute, CultureInfo.InvariantCulture) * TimeSpan.TicksPerMinute + Convert.ToInt64(Double.Parse(second + "." + fraction, CultureInfo.InvariantCulture) * (double)TimeSpan.TicksPerSecond));
  338.                 return new TimeSpan(ticks);
  339.             }
  340.             catch (Exception) {
  341.                 throw new RemotingException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_SOAPInteropxsdInvalid"), "xsd:duration", value));
  342.             }
  343.         }
  344.     }
  345.    
  346.     [Serializable()]
  347.     [System.Runtime.InteropServices.ComVisible(true)]
  348.     public sealed class SoapTime : ISoapXsd
  349.     {
  350.         DateTime _value = DateTime.MinValue;
  351.        
  352.         public static string XsdType {
  353.             get { return "time"; }
  354.         }
  355.        
  356.        
  357.         public string GetXsdType()
  358.         {
  359.             return XsdType;
  360.         }
  361.        
  362.         private static string[] formats = {"HH:mm:ss.fffffffzzz", "HH:mm:ss.ffff", "HH:mm:ss.ffffzzz", "HH:mm:ss.fff", "HH:mm:ss.fffzzz", "HH:mm:ss.ff", "HH:mm:ss.ffzzz", "HH:mm:ss.f", "HH:mm:ss.fzzz", "HH:mm:ss",
  363.         "HH:mm:sszzz", "HH:mm:ss.fffff", "HH:mm:ss.fffffzzz", "HH:mm:ss.ffffff", "HH:mm:ss.ffffffzzz", "HH:mm:ss.fffffff", "HH:mm:ss.ffffffff", "HH:mm:ss.ffffffffzzz", "HH:mm:ss.fffffffff", "HH:mm:ss.fffffffffzzz",
  364.         "HH:mm:ss.fffffffff", "HH:mm:ss.fffffffffzzz"};
  365.        
  366.        
  367.         public SoapTime()
  368.         {
  369.         }
  370.        
  371.        
  372.         public SoapTime(DateTime value)
  373.         {
  374.             _value = value;
  375.         }
  376.        
  377.        
  378.         public DateTime Value {
  379.             get { return _value; }
  380.             set { _value = new DateTime(1, 1, 1, value.Hour, value.Minute, value.Second, value.Millisecond); }
  381.         }
  382.        
  383.        
  384.         public override string ToString()
  385.         {
  386.             return _value.ToString("HH:mm:ss.fffffffzzz", CultureInfo.InvariantCulture);
  387.         }
  388.        
  389.        
  390.         public static SoapTime Parse(string value)
  391.         {
  392.             string time = value;
  393.             if (value.EndsWith("Z", StringComparison.Ordinal))
  394.                 time = value.Substring(0, value.Length - 1) + "-00:00";
  395.             SoapTime dt = new SoapTime(DateTime.ParseExact(time, formats, CultureInfo.InvariantCulture, DateTimeStyles.None));
  396.             return dt;
  397.         }
  398.     }
  399.    
  400.    
  401.     [Serializable()]
  402.     [System.Runtime.InteropServices.ComVisible(true)]
  403.     public sealed class SoapDate : ISoapXsd
  404.     {
  405.        
  406.         DateTime _value = DateTime.MinValue.Date;
  407.         int _sign = 0;
  408.        
  409.        
  410.         public static string XsdType {
  411.             get { return "date"; }
  412.         }
  413.        
  414.        
  415.        
  416.         public string GetXsdType()
  417.         {
  418.             return XsdType;
  419.         }
  420.        
  421.         private static string[] formats = {"yyyy-MM-dd", "'+'yyyy-MM-dd", "'-'yyyy-MM-dd", "yyyy-MM-ddzzz", "'+'yyyy-MM-ddzzz", "'-'yyyy-MM-ddzzz"};
  422.        
  423.        
  424.        
  425.         public SoapDate()
  426.         {
  427.         }
  428.        
  429.        
  430.         public SoapDate(DateTime value)
  431.         {
  432.             _value = value;
  433.         }
  434.        
  435.        
  436.         public SoapDate(DateTime value, int sign)
  437.         {
  438.             _value = value;
  439.             _sign = sign;
  440.         }
  441.        
  442.        
  443.         public DateTime Value {
  444.             get { return _value; }
  445.             set { _value = value.Date; }
  446.         }
  447.        
  448.        
  449.         public int Sign {
  450.             get { return _sign; }
  451.             set { _sign = value; }
  452.         }
  453.        
  454.        
  455.         public override string ToString()
  456.         {
  457.             if (_sign < 0)
  458.                 return _value.ToString("'-'yyyy-MM-dd", CultureInfo.InvariantCulture);
  459.             else
  460.                 return _value.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture);
  461.         }
  462.        
  463.        
  464.         public static SoapDate Parse(string value)
  465.         {
  466.             int sign = 0;
  467.             if (value[0] == '-')
  468.                 sign = -1;
  469.             return new SoapDate(DateTime.ParseExact(value, formats, CultureInfo.InvariantCulture, DateTimeStyles.None), sign);
  470.         }
  471.     }
  472.    
  473.    
  474.     [Serializable()]
  475.     [System.Runtime.InteropServices.ComVisible(true)]
  476.     public sealed class SoapYearMonth : ISoapXsd
  477.     {
  478.        
  479.         DateTime _value = DateTime.MinValue;
  480.         int _sign = 0;
  481.        
  482.        
  483.         public static string XsdType {
  484.             get { return "gYearMonth"; }
  485.         }
  486.        
  487.        
  488.         public string GetXsdType()
  489.         {
  490.             return XsdType;
  491.         }
  492.        
  493.         private static string[] formats = {"yyyy-MM", "'+'yyyy-MM", "'-'yyyy-MM", "yyyy-MMzzz", "'+'yyyy-MMzzz", "'-'yyyy-MMzzz"};
  494.        
  495.        
  496.        
  497.         public SoapYearMonth()
  498.         {
  499.         }
  500.        
  501.        
  502.         public SoapYearMonth(DateTime value)
  503.         {
  504.             _value = value;
  505.         }
  506.        
  507.        
  508.         public SoapYearMonth(DateTime value, int sign)
  509.         {
  510.             _value = value;
  511.             _sign = sign;
  512.         }
  513.        
  514.        
  515.        
  516.         public DateTime Value {
  517.             get { return _value; }
  518.             set { _value = value; }
  519.         }
  520.        
  521.        
  522.         public int Sign {
  523.             get { return _sign; }
  524.             set { _sign = value; }
  525.         }
  526.        
  527.        
  528.         public override string ToString()
  529.         {
  530.             if (_sign < 0)
  531.                 return _value.ToString("'-'yyyy-MM", CultureInfo.InvariantCulture);
  532.             else
  533.                 return _value.ToString("yyyy-MM", CultureInfo.InvariantCulture);
  534.         }
  535.        
  536.        
  537.         public static SoapYearMonth Parse(string value)
  538.         {
  539.             int sign = 0;
  540.             if (value[0] == '-')
  541.                 sign = -1;
  542.             return new SoapYearMonth(DateTime.ParseExact(value, formats, CultureInfo.InvariantCulture, DateTimeStyles.None), sign);
  543.         }
  544.     }
  545.    
  546.    
  547.     [Serializable()]
  548.     [System.Runtime.InteropServices.ComVisible(true)]
  549.     public sealed class SoapYear : ISoapXsd
  550.     {
  551.        
  552.         DateTime _value = DateTime.MinValue;
  553.         int _sign = 0;
  554.        
  555.        
  556.         public static string XsdType {
  557.             get { return "gYear"; }
  558.         }
  559.        
  560.        
  561.         public string GetXsdType()
  562.         {
  563.             return XsdType;
  564.         }
  565.        
  566.         private static string[] formats = {"yyyy", "'+'yyyy", "'-'yyyy", "yyyyzzz", "'+'yyyyzzz", "'-'yyyyzzz"};
  567.        
  568.        
  569.        
  570.         public SoapYear()
  571.         {
  572.         }
  573.        
  574.        
  575.         public SoapYear(DateTime value)
  576.         {
  577.             _value = value;
  578.         }
  579.        
  580.        
  581.         public SoapYear(DateTime value, int sign)
  582.         {
  583.             _value = value;
  584.             _sign = sign;
  585.         }
  586.        
  587.        
  588.        
  589.         public DateTime Value {
  590.             get { return _value; }
  591.             set { _value = value; }
  592.         }
  593.        
  594.        
  595.         public int Sign {
  596.             get { return _sign; }
  597.             set { _sign = value; }
  598.         }
  599.        
  600.        
  601.         public override string ToString()
  602.         {
  603.             if (_sign < 0)
  604.                 return _value.ToString("'-'yyyy", CultureInfo.InvariantCulture);
  605.             else
  606.                 return _value.ToString("yyyy", CultureInfo.InvariantCulture);
  607.         }
  608.        
  609.        
  610.         public static SoapYear Parse(string value)
  611.         {
  612.             int sign = 0;
  613.             if (value[0] == '-')
  614.                 sign = -1;
  615.             return new SoapYear(DateTime.ParseExact(value, formats, CultureInfo.InvariantCulture, DateTimeStyles.None), sign);
  616.         }
  617.     }
  618.    
  619.    
  620.     [Serializable()]
  621.     [System.Runtime.InteropServices.ComVisible(true)]
  622.     public sealed class SoapMonthDay : ISoapXsd
  623.     {
  624.         DateTime _value = DateTime.MinValue;
  625.        
  626.        
  627.         public static string XsdType {
  628.             get { return "gMonthDay"; }
  629.         }
  630.        
  631.        
  632.         public string GetXsdType()
  633.         {
  634.             return XsdType;
  635.         }
  636.        
  637.         private static string[] formats = {"--MM-dd", "--MM-ddzzz"};
  638.        
  639.        
  640.        
  641.         public SoapMonthDay()
  642.         {
  643.         }
  644.        
  645.        
  646.         public SoapMonthDay(DateTime value)
  647.         {
  648.             _value = value;
  649.         }
  650.        
  651.        
  652.         public DateTime Value {
  653.             get { return _value; }
  654.             set { _value = value; }
  655.         }
  656.        
  657.        
  658.         public override string ToString()
  659.         {
  660.             return _value.ToString("'--'MM'-'dd", CultureInfo.InvariantCulture);
  661.         }
  662.        
  663.        
  664.         public static SoapMonthDay Parse(string value)
  665.         {
  666.             return new SoapMonthDay(DateTime.ParseExact(value, formats, CultureInfo.InvariantCulture, DateTimeStyles.None));
  667.         }
  668.     }
  669.    
  670.    
  671.     [Serializable()]
  672.     [System.Runtime.InteropServices.ComVisible(true)]
  673.     public sealed class SoapDay : ISoapXsd
  674.     {
  675.         DateTime _value = DateTime.MinValue;
  676.        
  677.        
  678.         public static string XsdType {
  679.             get { return "gDay"; }
  680.         }
  681.        
  682.        
  683.         public string GetXsdType()
  684.         {
  685.             return XsdType;
  686.         }
  687.        
  688.        
  689.         private static string[] formats = {"---dd", "---ddzzz"};
  690.        
  691.        
  692.         public SoapDay()
  693.         {
  694.         }
  695.        
  696.        
  697.         public SoapDay(DateTime value)
  698.         {
  699.             _value = value;
  700.         }
  701.        
  702.        
  703.         public DateTime Value {
  704.             get { return _value; }
  705.             set { _value = value; }
  706.         }
  707.        
  708.        
  709.         public override string ToString()
  710.         {
  711.             return _value.ToString("---dd", CultureInfo.InvariantCulture);
  712.         }
  713.        
  714.        
  715.         public static SoapDay Parse(string value)
  716.         {
  717.             return new SoapDay(DateTime.ParseExact(value, formats, CultureInfo.InvariantCulture, DateTimeStyles.None));
  718.         }
  719.     }
  720.    
  721.    
  722.     [Serializable()]
  723.     [System.Runtime.InteropServices.ComVisible(true)]
  724.     public sealed class SoapMonth : ISoapXsd
  725.     {
  726.         DateTime _value = DateTime.MinValue;
  727.        
  728.        
  729.         public static string XsdType {
  730.             get { return "gMonth"; }
  731.         }
  732.        
  733.        
  734.         public string GetXsdType()
  735.         {
  736.             return XsdType;
  737.         }
  738.        
  739.         private static string[] formats = {"--MM--", "--MM--zzz"};
  740.        
  741.        
  742.        
  743.         public SoapMonth()
  744.         {
  745.         }
  746.        
  747.        
  748.         public SoapMonth(DateTime value)
  749.         {
  750.             _value = value;
  751.         }
  752.        
  753.        
  754.         public DateTime Value {
  755.             get { return _value; }
  756.             set { _value = value; }
  757.         }
  758.        
  759.        
  760.         public override string ToString()
  761.         {
  762.             return _value.ToString("--MM--", CultureInfo.InvariantCulture);
  763.         }
  764.        
  765.        
  766.         public static SoapMonth Parse(string value)
  767.         {
  768.             return new SoapMonth(DateTime.ParseExact(value, formats, CultureInfo.InvariantCulture, DateTimeStyles.None));
  769.         }
  770.     }
  771.    
  772.    
  773.     [Serializable()]
  774.     [System.Runtime.InteropServices.ComVisible(true)]
  775.     public sealed class SoapHexBinary : ISoapXsd
  776.     {
  777.         byte[] _value;
  778.        
  779.         public static string XsdType {
  780.             get { return "hexBinary"; }
  781.         }
  782.        
  783.        
  784.         public string GetXsdType()
  785.         {
  786.             return XsdType;
  787.         }
  788.        
  789.        
  790.         public SoapHexBinary()
  791.         {
  792.         }
  793.        
  794.        
  795.         public SoapHexBinary(byte[] value)
  796.         {
  797.             _value = value;
  798.         }
  799.        
  800.        
  801.         public byte[] Value {
  802.             get { return _value; }
  803.             set { _value = value; }
  804.         }
  805.        
  806.         StringBuilder sb = new StringBuilder(100);
  807.        
  808.         public override string ToString()
  809.         {
  810.             sb.Length = 0;
  811.             for (int i = 0; i < _value.Length; i++) {
  812.                 string s = _value[i].ToString("X", CultureInfo.InvariantCulture);
  813.                 if (s.Length == 1)
  814.                     sb.Append('0');
  815.                 sb.Append(s);
  816.             }
  817.             return sb.ToString();
  818.         }
  819.        
  820.        
  821.         public static SoapHexBinary Parse(string value)
  822.         {
  823.             return new SoapHexBinary(ToByteArray(SoapType.FilterBin64(value)));
  824.         }
  825.        
  826.        
  827.        
  828.         private static byte[] ToByteArray(string value)
  829.         {
  830.             char[] cA = value.ToCharArray();
  831.             if (cA.Length % 2 != 0) {
  832.                 throw new RemotingException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_SOAPInteropxsdInvalid"), "xsd:hexBinary", value));
  833.             }
  834.             byte[] bA = new byte[cA.Length / 2];
  835.             for (int i = 0; i < cA.Length / 2; i++) {
  836.                 bA[i] = (byte)(ToByte(cA[i * 2], value) * 16 + ToByte(cA[i * 2 + 1], value));
  837.             }
  838.            
  839.             return bA;
  840.         }
  841.        
  842.         private static byte ToByte(char c, string value)
  843.         {
  844.             byte b = (byte)0;
  845.             string s = c.ToString();
  846.             try {
  847.                 s = c.ToString();
  848.                 b = Byte.Parse(s, NumberStyles.HexNumber, CultureInfo.InvariantCulture);
  849.             }
  850.             catch (Exception) {
  851.                 throw new RemotingException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_SOAPInteropxsdInvalid"), "xsd:hexBinary", value));
  852.             }
  853.            
  854.             return b;
  855.         }
  856.     }
  857.    
  858.    
  859.     [Serializable()]
  860.     [System.Runtime.InteropServices.ComVisible(true)]
  861.     public sealed class SoapBase64Binary : ISoapXsd
  862.     {
  863.         byte[] _value;
  864.        
  865.        
  866.         public static string XsdType {
  867.             get { return "base64Binary"; }
  868.         }
  869.        
  870.        
  871.         public string GetXsdType()
  872.         {
  873.             return XsdType;
  874.         }
  875.        
  876.        
  877.         public SoapBase64Binary()
  878.         {
  879.         }
  880.        
  881.        
  882.         public SoapBase64Binary(byte[] value)
  883.         {
  884.             _value = value;
  885.         }
  886.        
  887.        
  888.         public byte[] Value {
  889.             get { return _value; }
  890.             set { _value = value; }
  891.         }
  892.        
  893.        
  894.         public override string ToString()
  895.         {
  896.             if (_value == null)
  897.                 return null;
  898.            
  899.             // Put in line feeds every 76 characters.
  900.             return SoapType.LineFeedsBin64(Convert.ToBase64String(_value));
  901.         }
  902.        
  903.         public static SoapBase64Binary Parse(string value)
  904.         {
  905.             if (value == null || value.Length == 0)
  906.                 return new SoapBase64Binary(new byte[0]);
  907.            
  908.             byte[] bA;
  909.             try {
  910.                 bA = Convert.FromBase64String(SoapType.FilterBin64(value));
  911.             }
  912.             catch (Exception) {
  913.                 throw new RemotingException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_SOAPInteropxsdInvalid"), "base64Binary", value));
  914.             }
  915.             return new SoapBase64Binary(bA);
  916.         }
  917.     }
  918.    
  919.    
  920.     [Serializable()]
  921.     [System.Runtime.InteropServices.ComVisible(true)]
  922.     public sealed class SoapInteger : ISoapXsd
  923.     {
  924.         decimal _value;
  925.        
  926.        
  927.         public static string XsdType {
  928.             get { return "integer"; }
  929.         }
  930.        
  931.        
  932.         public string GetXsdType()
  933.         {
  934.             return XsdType;
  935.         }
  936.        
  937.        
  938.         public SoapInteger()
  939.         {
  940.         }
  941.        
  942.        
  943.         public SoapInteger(decimal value)
  944.         {
  945.             _value = Decimal.Truncate(value);
  946.         }
  947.        
  948.        
  949.         public decimal Value {
  950.             get { return _value; }
  951.             set { _value = Decimal.Truncate(value); }
  952.         }
  953.        
  954.        
  955.         public override string ToString()
  956.         {
  957.             return _value.ToString(CultureInfo.InvariantCulture);
  958.         }
  959.        
  960.        
  961.         public static SoapInteger Parse(string value)
  962.         {
  963.             return new SoapInteger(Decimal.Parse(value, NumberStyles.Integer, CultureInfo.InvariantCulture));
  964.         }
  965.     }
  966.    
  967.    
  968.     [Serializable()]
  969.     [System.Runtime.InteropServices.ComVisible(true)]
  970.     public sealed class SoapPositiveInteger : ISoapXsd
  971.     {
  972.         decimal _value;
  973.        
  974.        
  975.         public static string XsdType {
  976.             get { return "positiveInteger"; }
  977.         }
  978.        
  979.        
  980.         public string GetXsdType()
  981.         {
  982.             return XsdType;
  983.         }
  984.        
  985.        
  986.         public SoapPositiveInteger()
  987.         {
  988.         }
  989.        
  990.        
  991.        
  992.         public SoapPositiveInteger(decimal value)
  993.         {
  994.             _value = Decimal.Truncate(value);
  995.             if (_value < Decimal.One)
  996.                 throw new RemotingException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_SOAPInteropxsdInvalid"), "xsd:positiveInteger", value));
  997.         }
  998.        
  999.        
  1000.         public decimal Value {
  1001.             get { return _value; }
  1002.             set {
  1003.                 _value = Decimal.Truncate(value);
  1004.                 if (_value < Decimal.One)
  1005.                     throw new RemotingException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_SOAPInteropxsdInvalid"), "xsd:positiveInteger", value));
  1006.             }
  1007.         }
  1008.        
  1009.        
  1010.         public override string ToString()
  1011.         {
  1012.             return _value.ToString(CultureInfo.InvariantCulture);
  1013.         }
  1014.        
  1015.        
  1016.         public static SoapPositiveInteger Parse(string value)
  1017.         {
  1018.             return new SoapPositiveInteger(Decimal.Parse(value, NumberStyles.Integer, CultureInfo.InvariantCulture));
  1019.         }
  1020.     }
  1021.    
  1022.    
  1023.     [Serializable()]
  1024.     [System.Runtime.InteropServices.ComVisible(true)]
  1025.     public sealed class SoapNonPositiveInteger : ISoapXsd
  1026.     {
  1027.         decimal _value;
  1028.        
  1029.        
  1030.         public static string XsdType {
  1031.             get { return "nonPositiveInteger"; }
  1032.         }
  1033.        
  1034.        
  1035.         public string GetXsdType()
  1036.         {
  1037.             return XsdType;
  1038.         }
  1039.        
  1040.        
  1041.         public SoapNonPositiveInteger()
  1042.         {
  1043.         }
  1044.        
  1045.        
  1046.         public SoapNonPositiveInteger(decimal value)
  1047.         {
  1048.             _value = Decimal.Truncate(value);
  1049.             if (_value > Decimal.Zero)
  1050.                 throw new RemotingException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_SOAPInteropxsdInvalid"), "xsd:nonPositiveInteger", value));
  1051.         }
  1052.        
  1053.        
  1054.         public decimal Value {
  1055.             get { return _value; }
  1056.             set {
  1057.                 _value = Decimal.Truncate(value);
  1058.                 if (_value > Decimal.Zero)
  1059.                     throw new RemotingException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_SOAPInteropxsdInvalid"), "xsd:nonPositiveInteger", value));
  1060.             }
  1061.         }
  1062.        
  1063.        
  1064.         public override string ToString()
  1065.         {
  1066.             return _value.ToString(CultureInfo.InvariantCulture);
  1067.         }
  1068.        
  1069.        
  1070.         public static SoapNonPositiveInteger Parse(string value)
  1071.         {
  1072.             return new SoapNonPositiveInteger(Decimal.Parse(value, NumberStyles.Integer, CultureInfo.InvariantCulture));
  1073.         }
  1074.     }
  1075.    
  1076.    
  1077.     [Serializable()]
  1078.     [System.Runtime.InteropServices.ComVisible(true)]
  1079.     public sealed class SoapNonNegativeInteger : ISoapXsd
  1080.     {
  1081.         decimal _value;
  1082.        
  1083.        
  1084.         public static string XsdType {
  1085.             get { return "nonNegativeInteger"; }
  1086.         }
  1087.        
  1088.        
  1089.        
  1090.         public string GetXsdType()
  1091.         {
  1092.             return XsdType;
  1093.         }
  1094.        
  1095.        
  1096.         public SoapNonNegativeInteger()
  1097.         {
  1098.         }
  1099.        
  1100.         public SoapNonNegativeInteger(decimal value)
  1101.         {
  1102.             _value = Decimal.Truncate(value);
  1103.             if (_value < Decimal.Zero)
  1104.                 throw new RemotingException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_SOAPInteropxsdInvalid"), "xsd:nonNegativeInteger", value));
  1105.         }
  1106.        
  1107.        
  1108.         public decimal Value {
  1109.             get { return _value; }
  1110.             set {
  1111.                 _value = Decimal.Truncate(value);
  1112.                 if (_value < Decimal.Zero)
  1113.                     throw new RemotingException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_SOAPInteropxsdInvalid"), "xsd:nonNegativeInteger", value));
  1114.             }
  1115.         }
  1116.        
  1117.        
  1118.         public override string ToString()
  1119.         {
  1120.             return _value.ToString(CultureInfo.InvariantCulture);
  1121.         }
  1122.        
  1123.        
  1124.         public static SoapNonNegativeInteger Parse(string value)
  1125.         {
  1126.             return new SoapNonNegativeInteger(Decimal.Parse(value, NumberStyles.Integer, CultureInfo.InvariantCulture));
  1127.         }
  1128.     }
  1129.    
  1130.    
  1131.     [Serializable()]
  1132.     [System.Runtime.InteropServices.ComVisible(true)]
  1133.     public sealed class SoapNegativeInteger : ISoapXsd
  1134.     {
  1135.         decimal _value;
  1136.        
  1137.        
  1138.         public static string XsdType {
  1139.             get { return "negativeInteger"; }
  1140.         }
  1141.        
  1142.        
  1143.         public string GetXsdType()
  1144.         {
  1145.             return XsdType;
  1146.         }
  1147.        
  1148.        
  1149.         public SoapNegativeInteger()
  1150.         {
  1151.         }
  1152.        
  1153.        
  1154.         public SoapNegativeInteger(decimal value)
  1155.         {
  1156.             _value = Decimal.Truncate(value);
  1157.             if (value > Decimal.MinusOne)
  1158.                 throw new RemotingException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_SOAPInteropxsdInvalid"), "xsd:negativeInteger", value));
  1159.         }
  1160.        
  1161.        
  1162.         public decimal Value {
  1163.             get { return _value; }
  1164.             set {
  1165.                 _value = Decimal.Truncate(value);
  1166.                 if (_value > Decimal.MinusOne)
  1167.                     throw new RemotingException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_SOAPInteropxsdInvalid"), "xsd:negativeInteger", value));
  1168.             }
  1169.         }
  1170.        
  1171.        
  1172.         public override string ToString()
  1173.         {
  1174.             return _value.ToString(CultureInfo.InvariantCulture);
  1175.         }
  1176.        
  1177.        
  1178.         public static SoapNegativeInteger Parse(string value)
  1179.         {
  1180.             return new SoapNegativeInteger(Decimal.Parse(value, NumberStyles.Integer, CultureInfo.InvariantCulture));
  1181.         }
  1182.     }
  1183.    
  1184.     [Serializable()]
  1185.     [System.Runtime.InteropServices.ComVisible(true)]
  1186.     public sealed class SoapAnyUri : ISoapXsd
  1187.     {
  1188.         string _value;
  1189.        
  1190.        
  1191.         public static string XsdType {
  1192.             get { return "anyURI"; }
  1193.         }
  1194.        
  1195.        
  1196.         public string GetXsdType()
  1197.         {
  1198.             return XsdType;
  1199.         }
  1200.        
  1201.        
  1202.         public SoapAnyUri()
  1203.         {
  1204.         }
  1205.        
  1206.        
  1207.         public SoapAnyUri(string value)
  1208.         {
  1209.             _value = value;
  1210.         }
  1211.        
  1212.        
  1213.         public string Value {
  1214.             get { return _value; }
  1215.             set { _value = value; }
  1216.         }
  1217.        
  1218.        
  1219.         public override string ToString()
  1220.         {
  1221.             return _value;
  1222.         }
  1223.        
  1224.        
  1225.         public static SoapAnyUri Parse(string value)
  1226.         {
  1227.             return new SoapAnyUri(value);
  1228.         }
  1229.     }
  1230.    
  1231.    
  1232.     [Serializable()]
  1233.     [System.Runtime.InteropServices.ComVisible(true)]
  1234.     public sealed class SoapQName : ISoapXsd
  1235.     {
  1236.         string _name;
  1237.         string _namespace;
  1238.         string _key;
  1239.        
  1240.        
  1241.         public static string XsdType {
  1242.             get { return "QName"; }
  1243.         }
  1244.        
  1245.        
  1246.         public string GetXsdType()
  1247.         {
  1248.             return XsdType;
  1249.         }
  1250.        
  1251.        
  1252.         public SoapQName()
  1253.         {
  1254.         }
  1255.        
  1256.        
  1257.         public SoapQName(string value)
  1258.         {
  1259.             _name = value;
  1260.         }
  1261.        
  1262.        
  1263.        
  1264.         public SoapQName(string key, string name)
  1265.         {
  1266.             _name = name;
  1267.             _key = key;
  1268.         }
  1269.        
  1270.        
  1271.         public SoapQName(string key, string name, string namespaceValue)
  1272.         {
  1273.             _name = name;
  1274.             _namespace = namespaceValue;
  1275.             _key = key;
  1276.         }
  1277.        
  1278.        
  1279.         public string Name {
  1280.             get { return _name; }
  1281.             set { _name = value; }
  1282.         }
  1283.        
  1284.        
  1285.         public string Namespace {
  1286.             get { /*
  1287.                 if (_namespace == null || _namespace.Length == 0)
  1288.                     throw new RemotingException(String.Format(Environment.GetResourceString("Remoting_SOAPQNameNamespace"), _name));
  1289.                     */
  1290. return _namespace; }
  1291.             set { _namespace = value; }
  1292.         }
  1293.        
  1294.        
  1295.         public string Key {
  1296.             get { return _key; }
  1297.             set { _key = value; }
  1298.         }
  1299.        
  1300.        
  1301.        
  1302.         public override string ToString()
  1303.         {
  1304.             if (_key == null || _key.Length == 0)
  1305.                 return _name;
  1306.             else
  1307.                 return _key + ":" + _name;
  1308.         }
  1309.        
  1310.        
  1311.         public static SoapQName Parse(string value)
  1312.         {
  1313.             if (value == null)
  1314.                 return new SoapQName();
  1315.            
  1316.             string key = "";
  1317.             string name = value;
  1318.            
  1319.             int index = value.IndexOf(':');
  1320.             if (index > 0) {
  1321.                 key = value.Substring(0, index);
  1322.                 name = value.Substring(index + 1);
  1323.             }
  1324.            
  1325.             return new SoapQName(key, name);
  1326.         }
  1327.     }
  1328.    
  1329.    
  1330.     [Serializable()]
  1331.     [System.Runtime.InteropServices.ComVisible(true)]
  1332.     public sealed class SoapNotation : ISoapXsd
  1333.     {
  1334.         string _value;
  1335.        
  1336.        
  1337.         public static string XsdType {
  1338.             get { return "NOTATION"; }
  1339.         }
  1340.        
  1341.        
  1342.         public string GetXsdType()
  1343.         {
  1344.             return XsdType;
  1345.         }
  1346.        
  1347.        
  1348.         public SoapNotation()
  1349.         {
  1350.         }
  1351.        
  1352.        
  1353.         public SoapNotation(string value)
  1354.         {
  1355.             _value = value;
  1356.         }
  1357.        
  1358.        
  1359.         public string Value {
  1360.             get { return _value; }
  1361.             set { _value = value; }
  1362.         }
  1363.        
  1364.        
  1365.         public override string ToString()
  1366.         {
  1367.             return _value;
  1368.         }
  1369.        
  1370.        
  1371.         public static SoapNotation Parse(string value)
  1372.         {
  1373.             return new SoapNotation(value);
  1374.         }
  1375.     }
  1376.    
  1377.    
  1378.     // Used to pass a string to xml which won't be escaped.
  1379.    
  1380.     [Serializable()]
  1381.     [System.Runtime.InteropServices.ComVisible(true)]
  1382.     public sealed class SoapNormalizedString : ISoapXsd
  1383.     {
  1384.         string _value;
  1385.        
  1386.        
  1387.         public static string XsdType {
  1388.             get { return "normalizedString"; }
  1389.         }
  1390.        
  1391.        
  1392.         public string GetXsdType()
  1393.         {
  1394.             return XsdType;
  1395.         }
  1396.        
  1397.        
  1398.         public SoapNormalizedString()
  1399.         {
  1400.         }
  1401.        
  1402.         public SoapNormalizedString(string value)
  1403.         {
  1404.             _value = Validate(value);
  1405.         }
  1406.        
  1407.         public string Value {
  1408.             get { return _value; }
  1409.             set { _value = Validate(value); }
  1410.         }
  1411.        
  1412.         public override string ToString()
  1413.         {
  1414.             return SoapType.Escape(_value);
  1415.         }
  1416.        
  1417.         public static SoapNormalizedString Parse(string value)
  1418.         {
  1419.             return new SoapNormalizedString(value);
  1420.         }
  1421.        
  1422.         private string Validate(string value)
  1423.         {
  1424.             if (value == null || value.Length == 0)
  1425.                 return value;
  1426.            
  1427.             char[] validateChar = {(char)13, (char)10, (char)9};
  1428.            
  1429.             int index = value.LastIndexOfAny(validateChar);
  1430.            
  1431.             if (index > -1)
  1432.                 throw new RemotingException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_SOAPInteropxsdInvalid"), "xsd:normalizedString", value));
  1433.            
  1434.             return value;
  1435.         }
  1436.        
  1437.     }
  1438.    
  1439.     [Serializable()]
  1440.     [System.Runtime.InteropServices.ComVisible(true)]
  1441.     public sealed class SoapToken : ISoapXsd
  1442.     {
  1443.         string _value;
  1444.        
  1445.         public static string XsdType {
  1446.             get { return "token"; }
  1447.         }
  1448.        
  1449.         public string GetXsdType()
  1450.         {
  1451.             return XsdType;
  1452.         }
  1453.        
  1454.         public SoapToken()
  1455.         {
  1456.         }
  1457.        
  1458.         public SoapToken(string value)
  1459.         {
  1460.             _value = Validate(value);
  1461.         }
  1462.        
  1463.         public string Value {
  1464.             get { return _value; }
  1465.             set { _value = Validate(value); }
  1466.         }
  1467.        
  1468.         public override string ToString()
  1469.         {
  1470.             return SoapType.Escape(_value);
  1471.         }
  1472.        
  1473.         public static SoapToken Parse(string value)
  1474.         {
  1475.             return new SoapToken(value);
  1476.         }
  1477.        
  1478.         private string Validate(string value)
  1479.         {
  1480.             if (value == null || value.Length == 0)
  1481.                 return value;
  1482.            
  1483.             char[] validateChar = {(char)13, (char)9};
  1484.            
  1485.             int index = value.LastIndexOfAny(validateChar);
  1486.            
  1487.             if (index > -1)
  1488.                 throw new RemotingException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_SOAPInteropxsdInvalid"), "xsd:token", value));
  1489.            
  1490.             if (value.Length > 0) {
  1491.                 if (Char.IsWhiteSpace(value[0]) || Char.IsWhiteSpace(value[value.Length - 1]))
  1492.                     throw new RemotingException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_SOAPInteropxsdInvalid"), "xsd:token", value));
  1493.             }
  1494.            
  1495.             index = value.IndexOf(" ");
  1496.             if (index > -1)
  1497.                 throw new RemotingException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_SOAPInteropxsdInvalid"), "xsd:token", value));
  1498.            
  1499.             return value;
  1500.         }
  1501.     }
  1502.    
  1503.    
  1504.     [Serializable()]
  1505.     [System.Runtime.InteropServices.ComVisible(true)]
  1506.     public sealed class SoapLanguage : ISoapXsd
  1507.     {
  1508.         string _value;
  1509.        
  1510.         public static string XsdType {
  1511.             get { return "language"; }
  1512.         }
  1513.        
  1514.         public string GetXsdType()
  1515.         {
  1516.             return XsdType;
  1517.         }
  1518.        
  1519.         public SoapLanguage()
  1520.         {
  1521.         }
  1522.        
  1523.         public SoapLanguage(string value)
  1524.         {
  1525.             _value = value;
  1526.         }
  1527.        
  1528.         public string Value {
  1529.             get { return _value; }
  1530.             set { _value = value; }
  1531.         }
  1532.        
  1533.         public override string ToString()
  1534.         {
  1535.             return SoapType.Escape(_value);
  1536.         }
  1537.        
  1538.         public static SoapLanguage Parse(string value)
  1539.         {
  1540.             return new SoapLanguage(value);
  1541.         }
  1542.     }
  1543.    
  1544.     [Serializable()]
  1545.     [System.Runtime.InteropServices.ComVisible(true)]
  1546.     public sealed class SoapName : ISoapXsd
  1547.     {
  1548.         string _value;
  1549.        
  1550.         public static string XsdType {
  1551.             get { return "Name"; }
  1552.         }
  1553.        
  1554.         public string GetXsdType()
  1555.         {
  1556.             return XsdType;
  1557.         }
  1558.        
  1559.         public SoapName()
  1560.         {
  1561.         }
  1562.        
  1563.         public SoapName(string value)
  1564.         {
  1565.             _value = value;
  1566.         }
  1567.        
  1568.         public string Value {
  1569.             get { return _value; }
  1570.             set { _value = value; }
  1571.         }
  1572.        
  1573.         public override string ToString()
  1574.         {
  1575.             return SoapType.Escape(_value);
  1576.         }
  1577.        
  1578.         public static SoapName Parse(string value)
  1579.         {
  1580.             return new SoapName(value);
  1581.         }
  1582.     }
  1583.    
  1584.     [Serializable()]
  1585.     [System.Runtime.InteropServices.ComVisible(true)]
  1586.     public sealed class SoapIdrefs : ISoapXsd
  1587.     {
  1588.         string _value;
  1589.        
  1590.         public static string XsdType {
  1591.             get { return "IDREFS"; }
  1592.         }
  1593.        
  1594.         public string GetXsdType()
  1595.         {
  1596.             return XsdType;
  1597.         }
  1598.        
  1599.         public SoapIdrefs()
  1600.         {
  1601.         }
  1602.        
  1603.         public SoapIdrefs(string value)
  1604.         {
  1605.             _value = value;
  1606.         }
  1607.        
  1608.         public string Value {
  1609.             get { return _value; }
  1610.             set { _value = value; }
  1611.         }
  1612.        
  1613.         public override string ToString()
  1614.         {
  1615.             return SoapType.Escape(_value);
  1616.         }
  1617.        
  1618.         public static SoapIdrefs Parse(string value)
  1619.         {
  1620.             return new SoapIdrefs(value);
  1621.         }
  1622.     }
  1623.    
  1624.     [Serializable()]
  1625.     [System.Runtime.InteropServices.ComVisible(true)]
  1626.     public sealed class SoapEntities : ISoapXsd
  1627.     {
  1628.         string _value;
  1629.        
  1630.         public static string XsdType {
  1631.             get { return "ENTITIES"; }
  1632.         }
  1633.        
  1634.         public string GetXsdType()
  1635.         {
  1636.             return XsdType;
  1637.         }
  1638.        
  1639.        
  1640.         public SoapEntities()
  1641.         {
  1642.         }
  1643.        
  1644.         public SoapEntities(string value)
  1645.         {
  1646.             _value = value;
  1647.         }
  1648.        
  1649.         public string Value {
  1650.             get { return _value; }
  1651.             set { _value = value; }
  1652.         }
  1653.        
  1654.         public override string ToString()
  1655.         {
  1656.             return SoapType.Escape(_value);
  1657.         }
  1658.        
  1659.         public static SoapEntities Parse(string value)
  1660.         {
  1661.             return new SoapEntities(value);
  1662.         }
  1663.     }
  1664.    
  1665.     [Serializable()]
  1666.     [System.Runtime.InteropServices.ComVisible(true)]
  1667.     public sealed class SoapNmtoken : ISoapXsd
  1668.     {
  1669.         string _value;
  1670.        
  1671.         public static string XsdType {
  1672.             get { return "NMTOKEN"; }
  1673.         }
  1674.        
  1675.         public string GetXsdType()
  1676.         {
  1677.             return XsdType;
  1678.         }
  1679.        
  1680.         public SoapNmtoken()
  1681.         {
  1682.         }
  1683.        
  1684.         public SoapNmtoken(string value)
  1685.         {
  1686.             _value = value;
  1687.         }
  1688.        
  1689.         public string Value {
  1690.             get { return _value; }
  1691.             set { _value = value; }
  1692.         }
  1693.        
  1694.         public override string ToString()
  1695.         {
  1696.             return SoapType.Escape(_value);
  1697.         }
  1698.        
  1699.         public static SoapNmtoken Parse(string value)
  1700.         {
  1701.             return new SoapNmtoken(value);
  1702.         }
  1703.     }
  1704.    
  1705.     [Serializable()]
  1706.     [System.Runtime.InteropServices.ComVisible(true)]
  1707.     public sealed class SoapNmtokens : ISoapXsd
  1708.     {
  1709.         string _value;
  1710.        
  1711.         public static string XsdType {
  1712.             get { return "NMTOKENS"; }
  1713.         }
  1714.        
  1715.         public string GetXsdType()
  1716.         {
  1717.             return XsdType;
  1718.         }
  1719.        
  1720.         public SoapNmtokens()
  1721.         {
  1722.         }
  1723.        
  1724.         public SoapNmtokens(string value)
  1725.         {
  1726.             _value = value;
  1727.         }
  1728.        
  1729.         public string Value {
  1730.             get { return _value; }
  1731.             set { _value = value; }
  1732.         }
  1733.        
  1734.         public override string ToString()
  1735.         {
  1736.             return SoapType.Escape(_value);
  1737.         }
  1738.        
  1739.         public static SoapNmtokens Parse(string value)
  1740.         {
  1741.             return new SoapNmtokens(value);
  1742.         }
  1743.     }
  1744.    
  1745.     [Serializable()]
  1746.     [System.Runtime.InteropServices.ComVisible(true)]
  1747.     public sealed class SoapNcName : ISoapXsd
  1748.     {
  1749.         string _value;
  1750.        
  1751.         public static string XsdType {
  1752.             get { return "NCName"; }
  1753.         }
  1754.        
  1755.        
  1756.        
  1757.         public string GetXsdType()
  1758.         {
  1759.             return XsdType;
  1760.         }
  1761.        
  1762.         public SoapNcName()
  1763.         {
  1764.         }
  1765.        
  1766.         public SoapNcName(string value)
  1767.         {
  1768.             _value = value;
  1769.         }
  1770.        
  1771.         public string Value {
  1772.             get { return _value; }
  1773.             set { _value = value; }
  1774.         }
  1775.        
  1776.         public override string ToString()
  1777.         {
  1778.             return SoapType.Escape(_value);
  1779.         }
  1780.        
  1781.         public static SoapNcName Parse(string value)
  1782.         {
  1783.             return new SoapNcName(value);
  1784.         }
  1785.     }
  1786.    
  1787.     [Serializable()]
  1788.     [System.Runtime.InteropServices.ComVisible(true)]
  1789.     public sealed class SoapId : ISoapXsd
  1790.     {
  1791.         string _value;
  1792.        
  1793.         public static string XsdType {
  1794.             get { return "ID"; }
  1795.         }
  1796.        
  1797.         public string GetXsdType()
  1798.         {
  1799.             return XsdType;
  1800.         }
  1801.        
  1802.         public SoapId()
  1803.         {
  1804.         }
  1805.        
  1806.         public SoapId(string value)
  1807.         {
  1808.             _value = value;
  1809.         }
  1810.        
  1811.         public string Value {
  1812.             get { return _value; }
  1813.             set { _value = value; }
  1814.         }
  1815.        
  1816.         public override string ToString()
  1817.         {
  1818.             return SoapType.Escape(_value);
  1819.         }
  1820.        
  1821.         public static SoapId Parse(string value)
  1822.         {
  1823.             return new SoapId(value);
  1824.         }
  1825.     }
  1826.    
  1827.     [Serializable()]
  1828.     [System.Runtime.InteropServices.ComVisible(true)]
  1829.     public sealed class SoapIdref : ISoapXsd
  1830.     {
  1831.         string _value;
  1832.        
  1833.         public static string XsdType {
  1834.             get { return "IDREF"; }
  1835.         }
  1836.        
  1837.         public string GetXsdType()
  1838.         {
  1839.             return XsdType;
  1840.         }
  1841.        
  1842.         public SoapIdref()
  1843.         {
  1844.         }
  1845.        
  1846.         public SoapIdref(string value)
  1847.         {
  1848.             _value = value;
  1849.         }
  1850.        
  1851.         public string Value {
  1852.             get { return _value; }
  1853.             set { _value = value; }
  1854.         }
  1855.        
  1856.         public override string ToString()
  1857.         {
  1858.             return SoapType.Escape(_value);
  1859.         }
  1860.        
  1861.         public static SoapIdref Parse(string value)
  1862.         {
  1863.             return new SoapIdref(value);
  1864.         }
  1865.     }
  1866.    
  1867.     [Serializable()]
  1868.     [System.Runtime.InteropServices.ComVisible(true)]
  1869.     public sealed class SoapEntity : ISoapXsd
  1870.     {
  1871.         string _value;
  1872.        
  1873.         public static string XsdType {
  1874.             get { return "ENTITY"; }
  1875.         }
  1876.        
  1877.         public string GetXsdType()
  1878.         {
  1879.             return XsdType;
  1880.         }
  1881.        
  1882.         public SoapEntity()
  1883.         {
  1884.         }
  1885.        
  1886.         public SoapEntity(string value)
  1887.         {
  1888.             _value = value;
  1889.         }
  1890.        
  1891.         public string Value {
  1892.             get { return _value; }
  1893.             set { _value = value; }
  1894.         }
  1895.        
  1896.         public override string ToString()
  1897.         {
  1898.             return SoapType.Escape(_value);
  1899.         }
  1900.        
  1901.         public static SoapEntity Parse(string value)
  1902.         {
  1903.             return new SoapEntity(value);
  1904.         }
  1905.     }
  1906. }
  1907. // namespace System.Runtime.Remoting.Metadata

Developer Fusion