/Utilities/XmlUtility.cs

Large files files are truncated, but you can click here to view the full file

/*

AdamMil.Utilities is a library providing generally useful utilities for

.NET development.



http://www.adammil.net/

Copyright (C) 2010-2016 Adam Milazzo



This program is free software; you can redistribute it and/or

modify it under the terms of the GNU General Public License

as published by the Free Software Foundation; either version 2

of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software

Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/



using System;

using System.Globalization;

using System.Text;

using System.Text.RegularExpressions;

using System.Xml;



namespace AdamMil.Utilities

{



#region XmlDuration

/// <summary>Represents an <c>xs:duration</c> value.</summary>

/// <remarks>An <see cref="XmlDuration"/> works like a <see cref="TimeSpan"/> value, except that it maintains a distinction between the

/// number of years and months in the duration, which may vary in actual length, and the days, hours, minutes, and seconds, which do not.

/// For example, January is longer than February and leap years are longer than regular years, so an <c>xs:duration</c> of <c>P1Y2M</c>

/// (1 year and 2 months) adds a variable amount of real time depending on the date to which it's added. The <see cref="TimeSpan"/>

/// structure does not capture this distinction, and is therefore inappropriate to represent an <c>xs:duration</c> value.

/// <para>The <c>xs:duration</c> format does have some limitations to be aware of, however. An <c>xs:duration</c> can represent a positive

/// or negative span of time, but it cannot represent a span of time where the variable portion is positive and the fixed portion is

/// negative, or vice versa. For instance, you can have a period of one month and one day, or negative one month and negative one day, but

/// you cannot have a period of one month and negative one day or vice versa. This also prevents durations from being added together when

/// the result would not be entirely positive or negative (or zero).

/// </para>

/// <para>The XML Schema specification says "Time durations are added by simply adding each of their fields, respectively, without

/// overflow", where "fields" refers to the components such as month, day, hour, etc.  Since adding without overflow is not really

/// possible in a fixed amount of space, and we desire to keep the structure as small as possible without placing tight restrictions on the

/// range of each component, and we want to relax the restrictions on having components with differing signs, adding two

/// <see cref="XmlDuration"/> values will allow overflow between fields. For instance, adding two durations of 40 seconds will yield a

/// duration of 1 minute and 20 seconds rather than a duration of 80 seconds. (The two are equivalent in all ways except for their string

/// representation.) Similarly, adding a duration of -10 seconds to a duration of 1 minute will not be an error but will instead yield a

/// duration of 50 seconds.

/// </para>

/// <para>The <see cref="XmlDuration"/> type is limited to maximums of 2147483647 total months (as any combination of years and months)

/// and approximately 10675199.1167 total days (as any combination of days, hours, minutes, etc). This is not a limitation inherent to the

/// <c>xs:duration</c> format, but one imposed by the fixed amount of space available in the <see cref="XmlDuration"/> structure.

/// </para>

/// </remarks>

[Serializable]

public struct XmlDuration

{

  /// <summary>Represents the number of ticks in one millisecond.</summary>

  public const long TicksPerMillisecond = 10*1000L; // one tick is 100 nanoseconds, the same as that used by DateTime, Timespan, etc.

  /// <summary>Represents the number of ticks in one second.</summary>

  public const long TicksPerSecond = TicksPerMillisecond * 1000;

  /// <summary>Represents the number of ticks in one minute.</summary>

  public const long TicksPerMinute = TicksPerSecond * 60;

  /// <summary>Represents the number of ticks in one hour.</summary>

  public const long TicksPerHour = TicksPerMinute * 60;

  /// <summary>Represents the number of ticks in one day.</summary>

  public const long TicksPerDay = TicksPerHour * 24;



  /// <summary>Initializes a new <see cref="XmlDuration"/> from the given <see cref="TimeSpan"/> value.</summary>

  /// <remarks>All <see cref="TimeSpan"/> values except <see cref="TimeSpan.MinValue"/> can be represented as an <see cref="XmlDuration"/>.</remarks>

  /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="timeSpan"/> equals <see cref="TimeSpan.MinValue"/>.</exception>

  public XmlDuration(TimeSpan timeSpan)

  {

    if(timeSpan.Ticks < 0)

    {

      _ticks = -timeSpan.Ticks; // TODO: it would be nice to remove this limitation

      if(_ticks < 0) throw new ArgumentOutOfRangeException("TimeSpan.MinValue cannot be represented as an XmlDuration.");

      _months = 0x80000000;

    }

    else

    {

      _months = 0;

      _ticks  = timeSpan.Ticks;

    }

  }



  /// <summary>Initializes a new <see cref="XmlDuration"/> from the given number of years, months, and days.</summary>

  /// <include file="documentation.xml" path="/Utilities/XmlDuration/AddSubRemarks/node()"/>

  public XmlDuration(int years, int months, int days)

  {

    if(days < -10675199 || days > 10675199) throw OverflowError();

    _ticks  = days * TicksPerDay;

    _months = GetTotalMonths(years, months);

    FixSign();

  }



  /// <summary>Initializes a new <see cref="XmlDuration"/> from the given components.</summary>

  /// <include file="documentation.xml" path="/Utilities/XmlDuration/AddSubRemarks/node()"/>

  public XmlDuration(int years, int months, int days, int hours, int minutes, int seconds)

  {

    if(days < -10675199 || days > 10675199 || hours < -256204778 || hours > 256204778) throw OverflowError();

    _ticks  = Add(days * TicksPerDay, Add(hours * TicksPerHour, minutes*TicksPerMinute + seconds*TicksPerSecond));

    _months = GetTotalMonths(years, months);

    FixSign();

  }



  /// <summary>Initializes a new <see cref="XmlDuration"/> from the given components.</summary>

  /// <include file="documentation.xml" path="/Utilities/XmlDuration/AddSubRemarks/node()"/>

  public XmlDuration(int years, int months, int days, int hours, int minutes, int seconds, int milliseconds)

  {

    if(days < -10675199 || days > 10675199 || hours < -256204778 || hours > 256204778) throw OverflowError();

    _ticks = Add(days * TicksPerDay,

                 Add(hours * TicksPerHour, minutes*TicksPerMinute + seconds*TicksPerSecond + milliseconds*TicksPerMillisecond));

    _months = GetTotalMonths(years, months);

    FixSign();

  }



  /// <summary>Initializes a new <see cref="XmlDuration"/> from a number of years and months to add, and a number of 100-nanosecond ticks

  /// to add.

  /// </summary>

  /// <include file="documentation.xml" path="/Utilities/XmlDuration/AddSubRemarks/node()"/>

  public XmlDuration(int years, int months, long ticks)

  {

    _ticks  = ticks;

    _months = GetTotalMonths(years, months);

    FixSign();

  }



  /// <summary>Initializes a new <see cref="XmlDuration"/> from a number months to add or subtract, and a number of 100-nanosecond ticks to

  /// add or subtract, and a boolean that indicates whether the duration should be negative (i.e. whether we should subtract instead of

  /// add). The numbers of months and ticks must be non-negative.

  /// </summary>

  /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="totalMonths"/> or <paramref name="ticks"/> is negative.</exception>

  public XmlDuration(int totalMonths, long ticks, bool isNegative)

  {

    if(totalMonths < 0 || ticks < 0) throw new ArgumentOutOfRangeException("An argument was negative.");

    if(isNegative && totalMonths == 0 && ticks == 0) isNegative = false;

    _ticks  = ticks;

    _months = (uint)totalMonths | (isNegative ? 0x80000000 : 0u);

  }



  XmlDuration(uint encodedMonths, long ticks)

  {

    _ticks  = ticks;

    _months = encodedMonths;

  }



  /// <summary>Gets the non-negative days component of this duration value.</summary>

  public int Days

  {

    get { return (int)(_ticks / TicksPerDay); }

  }



  /// <summary>Gets the non-negative hours component of this duration value.</summary>

  public int Hours

  {

    get { return (int)(_ticks % TicksPerDay / TicksPerHour); }

  }



  /// <summary>Gets the non-negative milliseconds component of this duration value, excluding the fractional part.</summary>

  public int Milliseconds

  {

    get { return (int)(_ticks % TicksPerSecond) / (int)TicksPerMillisecond; }

  }



  /// <summary>Gets the non-negative minutes component of this duration value.</summary>

  public int Minutes

  {

    get { return (int)(_ticks % TicksPerHour / TicksPerMinute); }

  }



  /// <summary>Gets the non-negative months component of this duration value.</summary>

  public int Months

  {

    get { return TotalMonths % 12; }

  }



  /// <summary>Gets whether the </summary>

  public bool IsNegative

  {

    get { return (int)_months < 0; }

  }



  /// <summary>Gets the non-negative seconds component of this duration value, including the fractional part.</summary>

  public double Seconds

  {

    get { return (int)(_ticks % TicksPerMinute) / (double)TicksPerSecond; }

  }



  /// <summary>Gets the non-negative number of ticks encapsulating the day and time components of this duration value.</summary>

  public long Ticks

  {

    get { return _ticks; }

  }



  /// <summary>Gets the non-negative seconds component of this duration value, excluding the fractional part.</summary>

  public int WholeSeconds

  {

    get { return (int)(_ticks % TicksPerMinute) / (int)TicksPerSecond; }

  }



  /// <summary>Gets the non-negative years component of this duration value.</summary>

  public int Years

  {

    get { return TotalMonths / 12; }

  }



  /// <summary>Gets the non-negative total number of months in this duration value.</summary>

  public int TotalMonths

  {

    get { return (int)(_months & 0x7FFFFFFF); }

  }



  /// <summary>Returns the absolute value of this duration, which will be an <see cref="XmlDuration"/> of the same length but with

  /// <see cref="IsNegative"/> equal to false.

  /// </summary>

  public XmlDuration Abs()

  {

    return new XmlDuration((uint)TotalMonths, _ticks);

  }



  /// <summary>Adds the given duration to this duration and returns the result.</summary>

  /// <include file="documentation.xml" path="/Utilities/XmlDuration/AddSubRemarks/node()"/>

  public XmlDuration Add(XmlDuration duration)

  {

    if(((uint)(_months ^ duration._months) & 0x80000000) == 0) // if the two durations have the same sign...

    {

      return new XmlDuration(Add(TotalMonths, duration.TotalMonths), Add(_ticks, duration._ticks), IsNegative);

    }

    else // if the durations have opposite signs...

    {

      long ticks = _ticks - duration._ticks;

      int months = TotalMonths - duration.TotalMonths;



      // if the resulting components have opposite signs, the value cannot be represented as an xs:duration

      if(months < 0 ? ticks > 0 : months > 0 && ticks < 0) throw UnrepresentableError();



      return months < 0 ? new XmlDuration(-months, -ticks, !IsNegative) : new XmlDuration(months, ticks, IsNegative);

    }

  }



  /// <summary>Adds the given number of days (which can be negative) to this duration and returns the result.</summary>

  /// <include file="documentation.xml" path="/Utilities/XmlDuration/AddSubRemarks/node()"/>

  public XmlDuration AddDays(double days)

  {

    return AddTicks((long)(days * TicksPerDay + 0.5));

  }



  /// <summary>Adds the given number of hours (which can be negative) to this duration and returns the result.</summary>

  /// <include file="documentation.xml" path="/Utilities/XmlDuration/AddSubRemarks/node()"/>

  public XmlDuration AddHours(double hours)

  {

    return AddTicks((long)(hours * TicksPerHour + 0.5));

  }



  /// <summary>Adds the given number of milliseconds (which can be negative) to this duration and returns the result.</summary>

  /// <include file="documentation.xml" path="/Utilities/XmlDuration/AddSubRemarks/node()"/>

  public XmlDuration AddMilliseconds(double seconds)

  {

    return AddTicks((long)(seconds * TicksPerMillisecond + 0.5));

  }



  /// <summary>Adds the given number of minutes (which can be negative) to this duration and returns the result.</summary>

  /// <include file="documentation.xml" path="/Utilities/XmlDuration/AddSubRemarks/node()"/>

  public XmlDuration AddMinutes(double minutes)

  {

    return AddTicks((long)(minutes * TicksPerMinute + 0.5));

  }



  /// <summary>Adds the given number of months (which can be negative) to this duration and returns the result.</summary>

  /// <include file="documentation.xml" path="/Utilities/XmlDuration/AddSubRemarks/node()"/>

  public XmlDuration AddMonths(int months)

  {

    if(IsNegative == (months < 0))

    {

      months = Add(TotalMonths, months);

    }

    else

    {

      months = TotalMonths - months;

      if(months < 0) throw UnrepresentableError(); // if the result changed sign, it can't be represented as an xs:duration

    }

    return new XmlDuration(months, _ticks, IsNegative);

  }



  /// <summary>Adds the given number of seconds (which can be negative) to this duration and returns the result.</summary>

  /// <include file="documentation.xml" path="/Utilities/XmlDuration/AddSubRemarks/node()"/>

  public XmlDuration AddSeconds(double seconds)

  {

    return AddTicks((long)(seconds * TicksPerSecond + 0.5));

  }



  /// <summary>Adds the given number of ticks (which can be negative) to this duration and returns the result.</summary>

  /// <include file="documentation.xml" path="/Utilities/XmlDuration/AddSubRemarks/node()"/>

  public XmlDuration AddTicks(long ticks)

  {

    if(IsNegative == (ticks < 0))

    {

      ticks = Add(_ticks, ticks);

    }

    else

    {

      ticks = _ticks - ticks;

      if(ticks < 0) throw UnrepresentableError(); // if the result changed sign, it can't be represented as an xs:duration

    }

    return new XmlDuration(TotalMonths, ticks, IsNegative);

  }



  /// <summary>Adds the given number of years (which can be negative) to this duration and returns the result.</summary>

  /// <include file="documentation.xml" path="/Utilities/XmlDuration/AddSubRemarks/node()"/>

  public XmlDuration AddYears(int years)

  {

    if(years < -178956970 || years > 178956970) throw OverflowError();

    return AddMonths(years*12);

  }



  /// <inheritdoc/>

  public override bool Equals(object obj)

  {

    return obj is XmlDuration && Equals((XmlDuration)obj);

  }



  /// <summary>Determines whether the given duration equals this one.</summary>

  public bool Equals(XmlDuration other)

  {

    return _ticks == other._ticks && _months == other._months;

  }



  /// <inheritdoc/>

  public override int GetHashCode()

  {

    return (int)((uint)(ulong)_ticks ^ (uint)((ulong)_ticks >> 32) ^ (uint)_months);

  }



  /// <summary>Returns an <see cref="XmlDuration"/> with the same length as this one, but the opposite sign.</summary>

  public XmlDuration Negate()

  {

    return new XmlDuration(TotalMonths, _ticks, !IsNegative);

  }



  /// <summary>Subtractions the given duration from this one and returns the result.</summary>

  /// <include file="documentation.xml" path="/Utilities/XmlDuration/AddSubRemarks/node()"/>

  public XmlDuration Subtract(XmlDuration duration)

  {

    return Add(duration.Negate());

  }



  /// <summary>Returns the duration as an <c>xs:duration</c> value, which is an ISO 8601 duration as extended by the XML Schema

  /// specification.

  /// </summary>

  /// <remarks>For example, <c>P1Y2MT2H</c> represents a duration of one year, two months, and two hours.</remarks>

  public override string ToString()

  {

    StringBuilder sb = new StringBuilder(40);

    if(IsNegative) sb.Append('-');

    sb.Append('P');

    if(TotalMonths != 0)

    {

      RenderComponent(sb, Years, 'Y');

      RenderComponent(sb, Months, 'M');

    }

    if(_ticks != 0)

    {

      RenderComponent(sb, Days, 'D');

      int hours = Hours, minutes = Minutes, secondTicks = (int)(_ticks % TicksPerMinute);

      if((hours|minutes|secondTicks) != 0)

      {

        sb.Append('T');

        RenderComponent(sb, hours, 'H');

        RenderComponent(sb, minutes, 'M');

        if(secondTicks != 0)

        {

          int component = secondTicks / (int)TicksPerSecond; // whole seconds

          sb.Append(component.ToStringInvariant());

          component = secondTicks % (int)TicksPerSecond; // fractional seconds in 100 ns units

          if(component != 0) sb.Append('.').Append(component.ToStringInvariant().PadLeft(7, '0').TrimEnd('0'));

          sb.Append('S');

        }

      }

    }



    if(sb.Length <= 2) sb.Append("0D"); // there has to be at least one component, so add 0 days if we haven't added any components so far

    return sb.ToString();

  }



  /// <summary>Returns a <see cref="TimeSpan"/> that represents the same duration as this <see cref="XmlDuration"/>. Note that not all

  /// <see cref="XmlDuration"/> values can be represented as <see cref="TimeSpan"/> values.

  /// </summary>

  /// <remarks><see cref="TimeSpan"/> values can only represent fixed lengths of time. Month and years are not fixed lengths of time

  /// and so durations having non-zero months or years cannot be represented as time spans.

  /// </remarks>

  /// <exception cref="InvalidOperationException">Thrown if the <see cref="XmlDuration"/> cannot be represented as a

  /// <see cref="TimeSpan"/>.

  /// </exception>

  public TimeSpan ToTimeSpan()

  {

    if(TotalMonths != 0)

    {

      throw new InvalidOperationException("This duration cannot be represented by a TimeSpan because it has a variable-length component.");

    }

    return new TimeSpan(IsNegative ? -Ticks : Ticks);

  }



  /// <summary>Adds two durations together and returns the result.</summary>

  /// <include file="documentation.xml" path="/Utilities/XmlDuration/AddSubRemarks/node()"/>

  public static XmlDuration operator+(XmlDuration a, XmlDuration b)

  {

    return a.Add(b);

  }



  /// <summary>Subtracts <paramref name="b"/> from <paramref name="a"/> and returns the result.</summary>

  /// <include file="documentation.xml" path="/Utilities/XmlDuration/AddSubRemarks/node()"/>

  public static XmlDuration operator-(XmlDuration a, XmlDuration b)

  {

    return a.Add(b.Negate());

  }



  /// <summary>Negates an <see cref="XmlDuration"/> and returns the result.</summary>

  public static XmlDuration operator-(XmlDuration duration)

  {

    return duration.Negate();

  }



  /// <summary>Determines if two durations are equal.</summary>

  public static bool operator==(XmlDuration a, XmlDuration b)

  {

    return a._ticks == b._ticks && a._months == b._months;

  }



  /// <summary>Determines if two durations are unequal.</summary>

  public static bool operator!=(XmlDuration a, XmlDuration b)

  {

    return a._ticks != b._ticks || a._months != b._months;

  }



  /// <summary>Adds a duration to a <see cref="DateTime"/> and returns the resulting <see cref="DateTime"/>.</summary>

  public static DateTime Add(DateTime dateTime, XmlDuration duration)

  {

    if(duration._months != 0) dateTime = dateTime.AddMonths(duration.IsNegative ? -duration.TotalMonths : (int)duration._months);

    if(duration._ticks != 0) dateTime = dateTime.AddTicks(duration.IsNegative ? -duration._ticks : duration._ticks);

    return dateTime;

  }



  /// <summary>Adds a duration to a <see cref="DateTimeOffset"/> and returns the resulting <see cref="DateTimeOffset"/>.</summary>

  public static DateTimeOffset Add(DateTimeOffset dateTime, XmlDuration duration)

  {

    if(duration._months != 0) dateTime = dateTime.AddMonths(duration.IsNegative ? -duration.TotalMonths : (int)duration._months);

    if(duration._ticks != 0) dateTime = dateTime.AddTicks(duration.IsNegative ? -duration._ticks : duration._ticks);

    return dateTime;

  }



  /// <summary>Parses an <see cref="XmlDuration"/> from an ISO 8601 duration string as extended by the XML Schema specification.</summary>

  /// <remarks>For example, <c>P1Y2MT2H</c> represents a duration of one year, two months, and two hours.</remarks>

  public static XmlDuration Parse(string str)

  {

    if(str == null) throw new ArgumentNullException();

    XmlDuration duration;

    if(!TryParse(str, out duration)) throw new FormatException();

    return duration;

  }



  /// <summary>Subtracts a duration from a <see cref="DateTime"/> and returns the resulting <see cref="DateTime"/>.</summary>

  public static DateTime Subtract(DateTime dateTime, XmlDuration duration)

  {

    if(duration._months != 0) dateTime = dateTime.AddMonths(duration.IsNegative ? (int)duration._months : -duration.TotalMonths);

    if(duration._ticks != 0) dateTime = dateTime.AddTicks(duration.IsNegative ? duration._ticks : -duration._ticks);

    return dateTime;

  }



  /// <summary>Subtracts a duration from a <see cref="DateTimeOffset"/> and returns the resulting <see cref="DateTimeOffset"/>.</summary>

  public static DateTimeOffset Subtract(DateTimeOffset dateTime, XmlDuration duration)

  {

    if(duration._months != 0) dateTime = dateTime.AddMonths(duration.IsNegative ? (int)duration._months : -duration.TotalMonths);

    if(duration._ticks != 0) dateTime = dateTime.AddTicks(duration.IsNegative ? duration._ticks : -duration._ticks);

    return dateTime;

  }



  /// <summary>Attempts to parses an <see cref="XmlDuration"/> from an ISO 8601 duration string as extended by the XML Schema

  /// specification.

  /// </summary>

  /// <remarks>For example, <c>P1Y2MT2H</c> represents a duration of one year, two months, and two hours.</remarks>

  public static bool TryParse(string str, out XmlDuration duration)

  {

    if(!string.IsNullOrEmpty(str))

    {

      Match m = reDuration.Match(str);

      if(m.Success)

      {

        // parse all of the components

        int years, months, days, hours, totalMonths;

        long mins;

        double seconds;

        bool hadComponent = false;



        if(!ParseGroup(m.Groups["y"], 178956970, ref hadComponent, out years) ||

           !ParseGroup(m.Groups["mo"], int.MaxValue, ref hadComponent, out months) ||

           !ParseGroup(m.Groups["d"], 10675199, ref hadComponent, out days))

        {

          goto failed;

        }



        Group g = m.Groups["h"];

        bool hadTimeComponent = g.Success;

        if(!ParseGroup(g, 256204778, ref hadComponent, out hours)) goto failed;



        g = m.Groups["min"];

        hadTimeComponent |= g.Success;

        if(!g.Success) mins = 0;

        else if(!InvariantCultureUtility.TryParseExact(g.Value, out mins) || mins > 15372286728) goto failed;

        else hadComponent = true;



        g = m.Groups["s"];

        hadTimeComponent |= g.Success;

        if(!g.Success)

        {

          seconds = 0;

        }

        else if(!double.TryParse(g.Value, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out seconds) ||

                seconds > 922337203685.47747)

        {

          goto failed;

        }

        else

        {

          hadComponent = true;

        }



        long longMonths = years*12 + months;

        totalMonths = (int)longMonths;

        if(totalMonths != longMonths) goto failed; // fail if the total months overflow



        long ticks = days * TicksPerDay;

        if((ticks += hours*TicksPerHour) < 0 || (ticks += mins*TicksPerMinute) < 0 || (ticks += (long)(seconds*TicksPerSecond + 0.5)) < 0)

        {

          goto failed; // fail if the ticks overflow

        }



        // fail if no components were specified (at least one component is required) or if an empty time component was specified

        // (which the standard says is illegal)

        if(!hadComponent || !hadTimeComponent && m.Groups["time"].Success) goto failed;



        duration = new XmlDuration(totalMonths, ticks, m.Groups["n"].Success);

        return true;

      }

    }



    failed:

    duration = default(XmlDuration);

    return false;

  }



  /// <summary>The largest possible negative <see cref="XmlDuration"/>.</summary>

  public static readonly XmlDuration MinValue = new XmlDuration((uint)int.MaxValue | 0x80000000, long.MaxValue);



  /// <summary>The largest possible positive <see cref="XmlDuration"/>.</summary>

  public static readonly XmlDuration MaxValue = new XmlDuration((uint)int.MaxValue, long.MaxValue);



  /// <summary>A zero <see cref="XmlDuration"/>.</summary>

  public static readonly XmlDuration Zero = new XmlDuration();



  void FixSign()

  {

    // if the two parts have different signs, the value can't be represented as an xs:duration

    if((int)_months < 0 ? _ticks > 0 : (int)_months > 0 && _ticks < 0) throw UnrepresentableError();

    // otherwise, if a value was negative and it's not possible to negate both values (because a value is at the minimum)...

    if(((int)_months < 0 || _ticks < 0) && ((_months = (uint)-(int)_months ^ 0x80000000) == 0 || (_ticks = -_ticks) < 0))

    {

      throw OverflowError(); // then it's out of range

    }

  }



  long _ticks;

  uint _months;



  static int Add(int a, int b)

  {

    try { return checked(a + b); }

    catch(OverflowException) { throw OverflowError(); }

  }



  static long Add(long a, long b)

  {

    try { return checked(a + b); }

    catch(OverflowException) { throw OverflowError(); }

  }



  static uint GetTotalMonths(int years, int months)

  {

    long totalMonths = years*12L + months;

    int intValue = (int)totalMonths;

    if(totalMonths != intValue || intValue == int.MinValue) throw OverflowError();

    return (uint)intValue;

  }



  static ArgumentOutOfRangeException OverflowError()

  {

    return new ArgumentOutOfRangeException("The result would be outside the range of XmlDuration.");

  }



  static bool ParseGroup(Group group, int maxValue, ref bool hadValue, out int value)

  {

    if(!group.Success) value = 0; // missing components are implicitly equal to zero

    else if(!InvariantCultureUtility.TryParseExact(group.Value, out value) || value > maxValue) return false;

    else hadValue = true;

    return true;

  }



  static void RenderComponent(StringBuilder sb, int component, char c)

  {

    if(component != 0) sb.Append(component.ToStringInvariant()).Append(c);

  }



  static ArgumentException UnrepresentableError()

  {

    return new ArgumentException("The result is not representable as an xs:duration because the fixed and variable portions of the " +

                                 "duration have opposite signs.");

  }



  static readonly Regex reDuration =

    new Regex(@"^\s*(?<n>-)?P(?:(?<y>[0-9]+)Y)?(?:(?<mo>[0-9]+)M)?(?:(?<d>[0-9]+)D)?(?<time>T(?:(?<h>[0-9]+)H)?(?:(?<min>[0-9]+)M)?(?:(?<s>[0-9]+(?:\.[0-9]+))S)?)?\s*$",

              RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.Singleline);

}

#endregion



#region XmlDocumentExtensions

/// <summary>Provides useful extensinos to the <see cref="XmlDocument"/> class.</summary>

public static class XmlDocumentExtensions

{

  /// <summary>Creates a new <see cref="XmlElement"/> having the given text content.</summary>

  public static XmlElement CreateElementWithContent(this XmlDocument document, string qualifiedName, string textValue)

  {

    XmlElement element = document.CreateElement(qualifiedName);

    if(textValue != null) element.AppendChild(document.CreateTextNode(textValue));

    return element;

  }

}

#endregion



#region XmlElementExtensions

/// <summary>Provides useful extensions to the <see cref="XmlElement"/> class.</summary>

public static class XmlElementExtensions

{

  /// <summary>Appends the given <see cref="XmlElement"/> to the end of the list of child nodes, and returns the element.</summary>

  public static XmlElement AppendElement(this XmlElement element, XmlElement newChild)

  {

    if(element == null) throw new ArgumentNullException();

    element.AppendChild(newChild);

    return newChild;

  }



  /// <summary>Returns the named attribute value.</summary>

  public static string GetAttribute(this XmlElement element, XmlQualifiedName attributeName)

  {

    if(element == null || attributeName == null) throw new ArgumentNullException();

    return element.GetAttribute(attributeName.Name, attributeName.Namespace);

  }



  /// <summary>Sets the named attribute with a value based on a boolean.</summary>

  public static void SetAttribute(this XmlElement element, string attributeName, bool value)

  {

    if(element == null) throw new ArgumentNullException();

    element.SetAttribute(attributeName, XmlConvert.ToString(value));

  }



  /// <summary>Sets the named attribute with a value based on a byte.</summary>

  public static void SetAttribute(this XmlElement element, string attributeName, byte value)

  {

    if(element == null) throw new ArgumentNullException();

    element.SetAttribute(attributeName, XmlConvert.ToString(value));

  }



  /// <summary>Sets the named attribute with a value based on a character.</summary>

  public static void SetAttribute(this XmlElement element, string attributeName, char value)

  {

    if(element == null) throw new ArgumentNullException();

    element.SetAttribute(attributeName, XmlConvert.ToString(value));

  }



  /// <summary>Sets the named attribute with a value based on a <see cref="DateTime"/>. The <see cref="DateTimeKind"/> of the

  /// <see cref="DateTime"/> will be preserved.

  /// </summary>

  public static void SetAttribute(this XmlElement element, string attributeName, DateTime dateTimeValue)

  {

    element.SetAttribute(attributeName, dateTimeValue, XmlDateTimeSerializationMode.RoundtripKind);

  }



  /// <summary>Sets the named attribute with a value based on a <see cref="DateTime"/>.</summary>

  public static void SetAttribute(this XmlElement element, string attributeName, DateTime dateTimeValue,

                                  XmlDateTimeSerializationMode dateTimeMode)

  {

    if(element == null) throw new ArgumentNullException();

    element.SetAttribute(attributeName, XmlConvert.ToString(dateTimeValue, dateTimeMode));

  }



  /// <summary>Sets the named attribute with a value based on a <see cref="Decimal"/>.</summary>

  public static void SetAttribute(this XmlElement element, string attributeName, decimal value)

  {

    if(element == null) throw new ArgumentNullException();

    element.SetAttribute(attributeName, XmlConvert.ToString(value));

  }



  /// <summary>Sets the named attribute with a value based on a 64-bit floating point value.</summary>

  public static void SetAttribute(this XmlElement element, string attributeName, double value)

  {

    if(element == null) throw new ArgumentNullException();

    element.SetAttribute(attributeName, XmlConvert.ToString(value));

  }



  /// <summary>Sets the named attribute with a value based on a <see cref="Guid"/>.</summary>

  public static void SetAttribute(this XmlElement element, string attributeName, Guid value)

  {

    if(element == null) throw new ArgumentNullException();

    element.SetAttribute(attributeName, XmlConvert.ToString(value));

  }



  /// <summary>Sets the named attribute with a value based on a 16-bit integer.</summary>

  public static void SetAttribute(this XmlElement element, string attributeName, short value)

  {

    if(element == null) throw new ArgumentNullException();

    element.SetAttribute(attributeName, XmlConvert.ToString(value));

  }



  /// <summary>Sets the named attribute with a value based on a 32-bit integer.</summary>

  public static void SetAttribute(this XmlElement element, string attributeName, int value)

  {

    if(element == null) throw new ArgumentNullException();

    element.SetAttribute(attributeName, XmlConvert.ToString(value));

  }



  /// <summary>Sets the named attribute with a value based on a 64-bit integer.</summary>

  public static void SetAttribute(this XmlElement element, string attributeName, long value)

  {

    if(element == null) throw new ArgumentNullException();

    element.SetAttribute(attributeName, XmlConvert.ToString(value));

  }



  /// <summary>Sets the named attribute with a value based on an 8-bit integer.</summary>

  [CLSCompliant(false)]

  public static void SetAttribute(this XmlElement element, string attributeName, sbyte value)

  {

    if(element == null) throw new ArgumentNullException();

    element.SetAttribute(attributeName, XmlConvert.ToString(value));

  }



  /// <summary>Sets the named attribute with a value based on an 32-bit floating point value.</summary>

  public static void SetAttribute(this XmlElement element, string attributeName, float value)

  {

    if(element == null) throw new ArgumentNullException();

    element.SetAttribute(attributeName, XmlConvert.ToString(value));

  }



  /// <summary>Sets the named attribute with a value based on an <see cref="TimeSpan"/>.</summary>

  public static void SetAttribute(this XmlElement element, string attributeName, TimeSpan value)

  {

    if(element == null) throw new ArgumentNullException();

    element.SetAttribute(attributeName, XmlConvert.ToString(value));

  }



  /// <summary>Sets the named attribute with a value based on a 16-bit unsigned integer.</summary>

  [CLSCompliant(false)]

  public static void SetAttribute(this XmlElement element, string attributeName, ushort value)

  {

    if(element == null) throw new ArgumentNullException();

    element.SetAttribute(attributeName, XmlConvert.ToString(value));

  }



  /// <summary>Sets the named attribute with a value based on a 32-bit unsigned integer.</summary>

  [CLSCompliant(false)]

  public static void SetAttribute(this XmlElement element, string attributeName, uint value)

  {

    if(element == null) throw new ArgumentNullException();

    element.SetAttribute(attributeName, XmlConvert.ToString(value));

  }



  /// <summary>Sets the named attribute with a value based on a 64-bit unsigned integer.</summary>

  [CLSCompliant(false)]

  public static void SetAttribute(this XmlElement element, string attributeName, ulong value)

  {

    if(element == null) throw new ArgumentNullException();

    element.SetAttribute(attributeName, XmlConvert.ToString(value));

  }



  /// <summary>Sets the named attribute with a value based on an <see cref="XmlDuration"/>.</summary>

  public static void SetAttribute(this XmlElement element, string attributeName, XmlDuration value)

  {

    if(element == null) throw new ArgumentNullException();

    element.SetAttribute(attributeName, value.ToString());

  }



  /// <summary>Sets the named attribute.</summary>

  public static void SetAttribute(this XmlElement element, XmlQualifiedName attributeName, string value)

  {

    if(element == null || attributeName == null) throw new ArgumentNullException();

    element.SetAttribute(attributeName.Name, attributeName.Namespace, value);

  }



  /// <summary>Sets the named attribute, using the specified prefix.</summary>

  public static void SetAttribute(this XmlElement element, string prefix, string localName, string namespaceUri, string value)

  {

    if(element == null) throw new ArgumentNullException();

    XmlAttribute attr = element.GetAttributeNode(localName, namespaceUri);

    if(attr == null || !attr.Prefix.OrdinalEquals(prefix))

    {

      attr = element.OwnerDocument.CreateAttribute(prefix, localName, namespaceUri);

      element.SetAttributeNode(attr);

    }

    attr.Value = value;

  }



  /// <summary>Sets the named attribute with a value based on the date portion of a <see cref="DateTime"/>.</summary>

  public static void SetDateAttribute(this XmlElement element, string attributeName, DateTime value)

  {

    if(element == null) throw new ArgumentNullException();

    element.SetAttribute(attributeName, value.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture));

  }



  /// <summary>Sets the named attribute with a value based on the time portion of a <see cref="DateTime"/>. The

  /// <see cref="DateTimeKind"/> of the <see cref="DateTime"/> will be preserved.

  /// </summary>

  public static void SetTimeAttribute(this XmlElement element, string attributeName, DateTime value)

  {

    element.SetTimeAttribute(attributeName, value, XmlDateTimeSerializationMode.RoundtripKind);

  }



  /// <summary>Sets the named attribute with a value based on a <see cref="DateTime"/>.</summary>

  public static void SetTimeAttribute(this XmlElement element, string attributeName, DateTime value,

                                      XmlDateTimeSerializationMode mode)

  {

    if(element == null) throw new ArgumentNullException();

    element.SetAttribute(attributeName, XmlConvert.ToString(value, mode).Substring(11)); // strip off the date portion

  }

}

#endregion



#region XmlNamespaceResolverExtensions

/// <summary>Provides useful extensions to the <see cref="IXmlNamespaceResolver"/> class.</summary>

public static class XmlNamespaceResolverExtensions

{

  /// <summary>Parses a qualified name (i.e. a name of the form <c>prefix:localName</c> or <c>namespaceUri:localName</c>) into an

  /// <see cref="XmlQualifiedName"/> in the context of the current namespace resolver. This method also accepts local names.

  /// </summary>

  public static XmlQualifiedName ParseQualifiedName(this IXmlNamespaceResolver resolver, string qualifiedName)

  {

    if(resolver == null) throw new ArgumentNullException();

    return string.IsNullOrEmpty(qualifiedName) ?

      XmlQualifiedName.Empty : XmlUtility.ParseQualifiedName(qualifiedName, resolver.LookupNamespace);

  }

}

#endregion



#region XmlNodeExtensions

/// <summary>Provides useful extensions to the <see cref="XmlNode"/> class.</summary>

public static class XmlNodeExtensions

{

  /// <summary>Returns the value of the named attribute, or <c>default(T)</c> if the attribute was unspecified.</summary>

  public static T GetAttribute<T>(this XmlNode node, string attrName, Converter<string, T> converter)

  {

    return GetAttribute<T>(node, attrName, converter, default(T));

  }



  /// <summary>Returns the value of the named attribute, or the given default value if the attribute was unspecified.</summary>

  public static T GetAttribute<T>(this XmlNode node, string attrName, Converter<string, T> converter,

                                  T defaultValue)

  {

    if(converter == null) throw new ArgumentNullException("converter");

    XmlAttribute an = GetAttributeNode(node, attrName);

    return an == null ? defaultValue : converter(an.Value);

  }



  /// <summary>Returns the value of the named attribute, or null if the attribute was unspecified.</summary>

  public static string GetAttributeValue(this XmlNode node, string attrName)

  {

    return GetAttributeValue(node, attrName, null);

  }



  /// <summary>Returns the value of the named attribute, or the given default value if the attribute was unspecified.</summary>

  public static string GetAttributeValue(this XmlNode node, string attrName, string defaultValue)

  {

    XmlAttribute an = GetAttributeNode(node, attrName);

    return an == null ? defaultValue : an.Value;

  }



  /// <summary>Returns the value of the named attribute as a boolean, or false if the attribute was unspecified or empty.</summary>

  public static bool GetBoolAttribute(this XmlNode node, string attrName)

  {

    return GetBoolAttribute(node, attrName, false);

  }



  /// <summary>Returns the value of the named attribute as a boolean, or the given

  /// default value if the attribute was unspecified or empty.

  /// </summary>

  public static bool GetBoolAttribute(this XmlNode node, string attrName, bool defaultValue)

  {

    string attrValue = GetAttributeValue(node, attrName);

    return string.IsNullOrEmpty(attrValue) ? defaultValue : XmlConvert.ToBoolean(attrValue);

  }



  /// <summary>Returns the value of the named attribute as a byte, or 0 if the attribute was unspecified or empty.</summary>

  public static byte GetByteAttribute(this XmlNode node, string attrName)

  {

    return GetByteAttribute(node, attrName, 0);

  }



  /// <summary>Returns the value of the named attribute as a byte, or the given default

  /// value if the attribute was unspecified or empty.

  /// </summary>

  public static byte GetByteAttribute(this XmlNode node, string attrName, byte defaultValue)

  {

    string attrValue = GetAttributeValue(node, attrName);

    return string.IsNullOrEmpty(attrValue) ? defaultValue : XmlConvert.ToByte(attrValue);

  }



  /// <summary>Returns the value of the named attribute as a character, or the nul character if the attribute was unspecified or empty.</summary>

  public static char GetCharAttribute(this XmlNode node, string attrName)

  {

    return GetCharAttribute(node, attrName, '\0');

  }



  /// <summary>Returns the value of the named attribute as a character, or the given default

  /// value if the attribute was unspecified or empty.

  /// </summary>

  public static char GetCharAttribute(this XmlNode node, string attrName, char defaultValue)

  {

    string attrValue = GetAttributeValue(node, attrName);

    return string.IsNullOrEmpty(attrValue) ? defaultValue : XmlConvert.ToChar(attrValue);

  }



  /// <summary>Returns the value of the named attribute as a nullable datetime, or null if the attribute was unspecified or empty.</summary>

  public static DateTime? GetDateTimeAttribute(this XmlNode node, string attrName)

  {

    return GetDateTimeAttribute(node, attrName, (DateTime?)null);

  }



  /// <summary>Returns the value of the named attribute as a nullable datetime, or the given default

  /// value if the attribute was unspecified or empty.

  /// </summary>

  public static DateTime? GetDateTimeAttribute(this XmlNode node, string attrName, DateTime? defaultValue)

  {

    string attrValue = GetAttributeValue(node, attrName);

    return string.IsNullOrEmpty(attrValue) ?

      defaultValue : XmlConvert.ToDateTime(attrValue, XmlDateTimeSerializationMode.Unspecified);

  }



  /// <summary>Returns the value of the named attribute as a decimal, or 0 if the attribute was unspecified or empty.</summary>

  public static decimal GetDecimalAttribute(this XmlNode node, string attrName)

  {

    return GetDecimalAttribute(node, attrName, 0);

  }



  /// <summary>Returns the value of the named attribute as a decimal, or the given default

  /// value if the attribute was unspecified or empty.

  /// </summary>

  public static decimal GetDecimalAttribute(this XmlNode node, string attrName, decimal defaultValue)

  {

    string attrValue = GetAttributeValue(node, attrName);

    return string.IsNullOrEmpty(attrValue) ? defaultValue : XmlConvert.ToDecimal(attrValue);

  }



  /// <summary>Returns the value of the named attribute as a 64-bit floating point value, or 0 if the attribute was unspecified or empty.</summary>

  public static double GetDoubleAttribute(this XmlNode node, string attrName)

  {

    return GetDoubleAttribute(node, attrName, 0);

  }



  /// <summary>Returns the value of the named attribute as a 64-bit floating point value, or the given default

  /// value if the attribute was unspecified or empty.

  /// </summary>

  public static double GetDoubleAttribute(this XmlNode node, string attrName, double defaultValue)

  {

    string attrValue = GetAttributeValue(node, attrName);

    return string.IsNullOrEmpty(attrValue) ? defaultValue : XmlConvert.ToDouble(attrValue);

  }



  /// <summary>Returns the value of the named attribute as an <see cref="XmlDuration"/>, or

  /// an empty duration if the attribute was unspecified or empty.

  /// </summary>

  public static XmlDuration GetDurationAttribute(this XmlNode node, string attrName)

  {

    return GetDurationAttribute(node, attrName, XmlDuration.Zero);

  }



  /// <summary>Returns the value of the named attribute as a <see cref="XmlDuration"/>, or

  /// the given default value if the attribute was unspecified or empty.

  /// </summary>

  public static XmlDuration GetDurationAttribute(this XmlNode node, string attrName, XmlDuration defaultValue)

  {

    string attrValue = GetAttributeValue(node, attrName);

    return string.IsNullOrEmpty(attrValue) ? defaultValue : XmlDuration.Parse(attrValue);

  }



  /// <summary>Returns the value of the named attribute as a <see cref="Guid"/>, or <see cref="Guid.Empty" />

  /// if the attribute was unspecified or empty.

  /// </summary>

  public static Guid GetGuidAttribute(this XmlNode node, string attrName)

  {

    return GetGuidAttribute(node, attrName, Guid.Empty);

  }



  /// <summary>Returns the value of the named attribute as a <see cref="Guid"/>, or the given default

  /// value if the attribute was unspecified or empty.

  /// </summary>

  public static Guid GetGuidAttribute(this XmlNode node, string attrName, Guid defaultValue)

  {

    string attrValue = GetAttributeValue(node, attrName);

    return string.IsNullOrEmpty(attrValue) ? defaultValue : XmlConvert.ToGuid(attrValue);

  }



  /// <summary>Searches the node and its ancestors for the given attribute and returns the first one found, or null if the attribute was

  /// not defined on the node or any ancestor.

  /// </summary>

  public static XmlAttribute GetInheritedAttributeNode(this XmlNode node, string qualifiedName)

  {

    if(node == null) throw new ArgumentNullException();

    while(node.NodeType != XmlNodeType.Document)

    {

      XmlAttribute attr = node.Attributes[qualifiedName];

      if(attr != null) return attr;

      node = node.ParentNode;

    }

    return null;

  }



  /// <summary>Searches the node and its ancestors for the given attribute and returns the first one found, or null if the attribute was

  /// not defined on the node or any ancestor.

  /// </summary>

  public static XmlAttribute GetInheritedAttributeNode(this XmlNode node, XmlQualifiedName qualifiedName)

  {

    if(node == null || qualifiedName == null) throw new ArgumentNullException();

    while(node.NodeType != XmlNodeType.Document)

    {

      XmlAttribute attr = node.Attributes[qualifiedName.Name, qualifiedName.Namespace];

      if(attr != null) return attr;

      node = node.ParentNode;

    }

    return null;

  }



  /// <summary>Searches the node and its ancestors for the given attribute and returns the value of the first one found, or null if the

  /// attribute was not defined on the node or any ancestor.

  /// </summary>

  public static string GetInheritedAttributeValue(this XmlNode node, string qualifiedName)

  {

    return GetInheritedAttributeValue(node, qualifiedName, null);

  }



  /// <summary>Searches the node and its ancestors for the given attribute and returns the value of the first one found, or the given

  /// default value if the attribute was not defined on the node or any ancestor.

  /// </summary>

  public static string GetInheritedAttributeValue(this XmlNode node, string qualifiedName, string defaultValue)

  {

    XmlAttribute attr = node.GetInheritedAttributeNode(qualifiedName);

    return attr == null ? defaultValue : attr.Value;

  }



  /// <summary>Searches the node and its ancestors for the given attribute and returns the value of the first one found, or null if the

  /// attribute was not defined on the node or any ancestor.

  /// </summary>

  public static string GetInheritedAttributeValue(this XmlNode node, XmlQualifiedName qualifiedName)

  {

    return GetInheritedAttributeValue(node, qualifiedName, null);

  }



  /// <summary>Searches the node and its ancestors for the given attribute and returns the value of the first one found, or the given

  /// default value if the attribute was not defined on the node or any ancestor.

  /// </summary>

  public static string GetInheritedAttributeValue(this XmlNode node, XmlQualifiedName qualifiedName, string defaultValue)

  {

    XmlAttribute attr = node.GetInheritedAttributeNode(qualifiedName);

    return attr == null ? defaultValue : attr.Value;

  }



  /// <summary>Returns the value of the named attribute as a 16-bit signed integer, or 0 if the attribute was unspecified or empty.</summary>

  public static short GetInt16Attribute(this XmlNode node, string attrName)

  {

    return GetInt16Attribute(node, attrName, 0);

  }



  /// <summary>Returns the value of the named attribute as a 16-bit signed integer, or the given default

  /// value if the attribute was unspecified or empty.

  /// </summary>

  public static short GetInt16Attribute(this XmlNode node, string attrName, short defaultValue)

  {

    string attrValue = GetAttributeValue(node, attrName);

    return string.IsNullOrEmpty(attrValue) ? defaultValue : XmlConvert.ToInt16(attrValue);

  }



  /// <summary>Returns the value of the named attribute as a 32-bit signed integer, or 0 if the attribute was unspecified or empty.</summary>

  public static int GetInt32Attribute(this XmlNode node, string attrName)

  {

    return GetInt32Attribute(node, attrName, 0);

  }



  /// <summary>Returns the value of the named attribute as a 32-bit signed in…

Large files files are truncated, but you can click here to view the full file