/Source/ESB/Base/ThirdParty/Mvp.Xml-src-2.0/EXSLT/v2/src/Exslt/ExsltDatesAndTimes.cs

#region using



using System;

using System.Globalization;

using System.Xml;

using System.Xml.XPath;

using System.Text;

using System.Text.RegularExpressions;



#endregion



namespace Mvp.Xml.Exslt

{

	/// <summary>

	/// This class implements the EXSLT functions in the http://exslt.org/dates-and-times namespace.

	/// </summary>

	public class ExsltDatesAndTimes

	{

		private CultureInfo ci = new CultureInfo("en-US");



		private class ExsltDateTimeFactory

		{

			/// <summary>

			/// Parse a date and time for format-date() 

			/// </summary>

			/// <param name="d"></param>

			/// <returns></returns>

			public static ExsltDateTime ParseDateTime(string d)

			{

				// First try any of the classes in ParseDate

				try

				{

					return ParseDate(d);

				}

				catch(FormatException)

				{

				}

				

				try

				{

					TimeTZ t = new TimeTZ(d);

					return t;

				}

				catch(FormatException)

				{

				}				



				try

				{

					MonthDay t = new MonthDay(d);

					return t;

				}

				catch(FormatException)

				{

				}				



				try

				{

					Month t = new Month(d);

					return t;

				}

				catch(FormatException)

				{

				}	



				// Finally day -- don't catch the exception

				{

					Day t = new Day(d);

					return t;

				}

			}



			/// <summary>

			/// Initialize the structure with the current date, time and timezone

			/// </summary>

			public static ExsltDateTime ParseDate(string d)

			{

				// Try each potential class, from most specific to least specific.



				// First DateTimeTZ

				try

				{

					DateTimeTZ t = new DateTimeTZ(d);

					return t; 

				}

				catch(FormatException)

				{

				}



				// Next Date

				try

				{

					DateTZ t = new DateTZ(d);

					return t; 

				}

				catch(FormatException)

				{

				}



				// Next YearMonth

				try

				{

					YearMonth t = new YearMonth(d);

					return t; 

				}

				catch(FormatException)

				{

				}



				// Finally Year -- don't catch the exception for the last type

				{	

					YearTZ t = new YearTZ(d);

					return t; 

				}

			}

		}



		internal abstract class ExsltDateTime

		{

			public DateTime	d;

			public TimeSpan	ts = new TimeSpan(TimeSpan.MinValue.Ticks);



			protected CultureInfo ci = new CultureInfo("en-US");



			/// <summary>

			/// Initialize the structure with the current date, time and timezone

			/// </summary>

			public ExsltDateTime()

			{

				d = DateTime.Now;

				TimeZone tz = TimeZone.CurrentTimeZone;

				ts = tz.GetUtcOffset(d);

			}



			/// <summary>

			/// Initialize the DateTimeTZ structure with the date, time and timezone in the string.

			/// </summary>

			/// <param name="inS">An ISO8601 string</param>

			public ExsltDateTime(string inS)

			{

				String s = inS.Trim();

				d = DateTime.ParseExact(s, expectedFormats,	ci, DateTimeStyles.AdjustToUniversal);



				if (s.EndsWith("Z"))

					ts = new TimeSpan(0, 0, 0);

				else if (s.Length > 6)

				{

					String zoneStr = s.Substring(s.Length-6, 6);

					if (zoneStr[3] == ':')

					{

						try

						{

							int	hours = Int32.Parse(zoneStr.Substring(0,3));

							int minutes = Int32.Parse(zoneStr.Substring(4,2));

							if (hours < 0)

								minutes = -minutes;



							ts = new TimeSpan(hours, minutes, 0);

							d = d.Add(ts);	// Adjust to time zone relative time						

						}

						catch(Exception)

						{

						}

					}

				}

			}



			/// <summary>

			/// Exslt Copy constructor

			/// Initialize the structure with the date, time and timezone in the string.

			/// </summary>

			/// <param name="inS">An ExsltDateTime</param>

			public ExsltDateTime(ExsltDateTime inS)

			{

				d = inS.d;

				ts = inS.ts;

			}



			public bool HasTimeZone()

			{

				return !(TimeSpan.MinValue.Ticks == ts.Ticks);

			}



			public DateTime ToUniversalTime()

			{

				if (!HasTimeZone())

					return d;

				else

					return d.Subtract(ts);

			}



			/// <summary>

			/// Output as a standard (ISO8601) string

			/// </summary>

			/// <returns>the date and time as an ISO8601 string.  includes timezone</returns>

			public override string ToString()

			{

				return this.ToString(outputFormat);

			}



			/// <summary>

			/// Output as a formatted string

			/// </summary>

			/// <returns>the date and time as a formatted string.  includes timezone</returns>

			public string ToString(String of)

			{

				StringBuilder retString = new StringBuilder("");

						

				retString.Append(d.ToString(of));

				retString.Append(GetTimeZone());



				return retString.ToString();

			}



			public string GetTimeZone()

			{

				StringBuilder retString = new StringBuilder();



				// if no ts specified, output without ts

				if (HasTimeZone())

				{

					if (0 == ts.Hours && 0 == ts.Minutes)

						retString.Append('Z');

					else if (ts.Hours >= 0 && ts.Minutes >= 0)

					{

						retString.Append('+');

						retString.Append(ts.Hours.ToString().PadLeft(2, '0'));

						retString.Append(':');

						retString.Append(ts.Minutes.ToString().PadLeft(2, '0'));				

					}

					else

					{

						retString.Append('-');

						retString.Append((-ts.Hours).ToString().PadLeft(2, '0'));

						retString.Append(':');

						retString.Append((-ts.Minutes).ToString().PadLeft(2, '0'));

					}

				}

				

				return retString.ToString();

			}



			public string GetGMTOffsetTimeZone()

			{

				StringBuilder retString = new StringBuilder();



				// if no ts specified, output without ts

				if (HasTimeZone())

				{

					retString.Append("GMT");

					if (0 != ts.Hours || 0 != ts.Minutes)

					{

						retString.Append(GetTimeZone());

					}

				}

				

				return retString.ToString();

			}



			public string Get822TimeZone()

			{

				StringBuilder retString = new StringBuilder();



				// if no ts specified, output without ts

				if (HasTimeZone())

				{

					if (0 == ts.Hours && 0 == ts.Minutes)

						retString.Append("GMT");

					else if (ts.Hours >= 0 && ts.Minutes >= 0)

					{

						retString.Append('+');

						retString.Append(ts.Hours.ToString().PadLeft(2, '0'));

						retString.Append(ts.Minutes.ToString().PadLeft(2, '0'));				

					}

					else

					{

						retString.Append('-');

						retString.Append((-ts.Hours).ToString().PadLeft(2, '0'));

						retString.Append((-ts.Minutes).ToString().PadLeft(2, '0'));

					}

				}

				

				return retString.ToString();

			}



			protected abstract string[] expectedFormats {get;}

			protected abstract string outputFormat {get;}

		}



		internal class DateTimeTZ : ExsltDateTime

		{

			public DateTimeTZ() : base(){}

			public DateTimeTZ(string inS) : base(inS){}

			public DateTimeTZ(ExsltDateTime inS) : base(inS){}



			protected override string[] expectedFormats

			{

				get 

				{

					return new string[] {"yyyy-MM-dd\"T\"HH:mm:sszzz", 

											"yyyy-MM-dd\"T\"HH:mm:ssZ", 

											"yyyy-MM-dd\"T\"HH:mm:ss",

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.f"  

};

				}

			}



			protected override string outputFormat

			{

				get

				{

					return "yyyy-MM-dd\"T\"HH:mm:ss";

				}

			}

		}





		internal class DateTZ : ExsltDateTime

		{

			public DateTZ() : base(){}

			public DateTZ(string inS) : base(inS){}

			public DateTZ(ExsltDateTime inS) : base(inS){}



			protected override string[] expectedFormats

			{

				get

				{

					return new string[] {"yyyy-MM-dd\"T\"HH:mm:sszzz", 

											"yyyy-MM-dd\"T\"HH:mm:ssZ", 

											"yyyy-MM-dd\"T\"HH:mm:ss",

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.f",

											"yyyy-MM-ddzzz",

											"yyyy-MM-ddZ",

											"yyyy-MM-dd"};

				}

			}



			protected override string outputFormat

			{

				get

				{

					return "yyyy-MM-dd";

				}

			}

		}



		internal class TimeTZ : ExsltDateTime

		{

			public TimeTZ(string inS) : base(inS){}

			public TimeTZ() : base(){}



			protected override string[] expectedFormats

			{

				get

				{

					return new string[] {"yyyy-MM-dd\"T\"HH:mm:sszzz", 

											"yyyy-MM-dd\"T\"HH:mm:ssZ", 

											"yyyy-MM-dd\"T\"HH:mm:ss",

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.f",

											"HH:mm:sszzz",

											"HH:mm:ssZ",

											"HH:mm:ss"};

				}

			}



			protected override string outputFormat

			{

				get

				{

					return "HH:mm:ss";

				}

			}

		}



		internal class YearMonth : ExsltDateTime

		{

			public YearMonth() : base(){}

			public YearMonth(string inS) : base(inS){}

			public YearMonth(ExsltDateTime inS) : base(inS){}



			protected override string[] expectedFormats

			{

				get

				{

					return new string[] {"yyyy-MM-dd\"T\"HH:mm:sszzz", 

											"yyyy-MM-dd\"T\"HH:mm:ssZ", 

											"yyyy-MM-dd\"T\"HH:mm:ss",

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.f",

											"yyyy-MM-dd",

											"yyyy-MM"};

				}

			}



			protected override string outputFormat

			{

				get

				{

					return "yyyy-MM";

				}

			}

		}



		internal class YearTZ : ExsltDateTime

		{

			public YearTZ() : base(){}

			public YearTZ(string inS) : base(inS){}

			public YearTZ(ExsltDateTime inS) : base(inS){}



			protected override string[] expectedFormats

			{

				get

				{

					return new string[] {"yyyy-MM-dd\"T\"HH:mm:sszzz", 

											"yyyy-MM-dd\"T\"HH:mm:ssZ", 

											"yyyy-MM-dd\"T\"HH:mm:ss",

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.f",

											"yyyy-MM-dd",

											"yyyy-MM",

											"yyyy"};

				}

			}



			protected override string outputFormat

			{

				get

				{

					return "yyyy";

				}

			}

		}



		internal class Month : ExsltDateTime

		{

			public Month() : base(){}

			public Month(string inS) : base(inS){}

			public Month(ExsltDateTime inS) : base(inS){}



			protected override string[] expectedFormats

			{

				get

				{

					return new string[] {"yyyy-MM-dd\"T\"HH:mm:sszzz", 

										 "yyyy-MM-dd\"T\"HH:mm:ssZ", 

										 "yyyy-MM-dd\"T\"HH:mm:ss",

                                         "yyyy-MM-dd\"T\"HH:mm:ss.fffffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.f",   

										 "yyyy-MM-dd",

										 "yyyy-MM",

										 "--MM--"};

				}

			}



			protected override string outputFormat

			{

				get

				{

					return "--MM--";

				}

			}

		}



		internal class Day : ExsltDateTime

		{

			public Day() : base(){}

			public Day(string inS) : base(inS){}

			public Day(ExsltDateTime inS) : base(inS){}



			protected override string[] expectedFormats

			{

				get

				{

					return new string[] {"yyyy-MM-dd\"T\"HH:mm:sszzz", 

											"yyyy-MM-dd\"T\"HH:mm:ssZ", 

											"yyyy-MM-dd\"T\"HH:mm:ss",

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.f",

											"yyyy-MM-dd",

											"---dd",

											"--MM-dd"};

				}

			}



			protected override string outputFormat

			{

				get

				{

					return "---dd";

				}

			}

		}



		internal class MonthDay : ExsltDateTime

		{

			public MonthDay() : base(){}

			public MonthDay(string inS) : base(inS){}

			public MonthDay(ExsltDateTime inS) : base(inS){}



			protected override string[] expectedFormats

			{

				get

				{

					return new string[] {"yyyy-MM-dd\"T\"HH:mm:sszzz", 

											"yyyy-MM-dd\"T\"HH:mm:ssZ", 

											"yyyy-MM-dd\"T\"HH:mm:ss",

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ffZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.ff",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fzzz",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.fZ",  

                                            "yyyy-MM-dd\"T\"HH:mm:ss.f",

											"yyyy-MM-dd",

											"--MM-dd"};

				}

			}



			protected override string outputFormat

			{

				get

				{

					return "--MM-dd";

				}

			}

		}





		private string[] dayAbbrevs = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};

		private string[] dayNames = {"Sunday", "Monday", "Tuesday", 

										"Wednesday", "Thursday", "Friday", "Saturday"};



		private string[] monthAbbrevs = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",

											"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};

		private string[] monthNames = {"January", "February", "March", "April", "May", "June",

										  "July", "August", "September", 

										  "October", "November", "December"};



		

		/// <summary>

		/// Implements the following function

		///   string date:date-time()

		/// Output format is ISO 8601 (YYYY-MM-DDThh:mm:ss{Z | {+ | -}zz:zz}).

		/// YYYY - year with century

		/// MM - month in numbers with leading zero

		/// DD - day in numbers with leading zero

		/// T - the letter T

		/// hh - hours in numbers with leading zero (00-23).

		/// mm - minutes in numbers with leading zero (00-59).

		/// ss - seconds in numbers with leading zero (00-59).

		/// +/-zzzz - time zone expressed as hours and minutes from UTC.

		///		If UTC, then this is the letter Z

		///		If east of Greenwich, then -zz:zz (e.g. Pacific standard time is -08:00)

		///		If west of Greenwich, then +zz:zz (e.g. Tokyo is +09:00)

		/// </summary>

		/// <returns>The current time.</returns>		

		public string dateTime()

		{		

			DateTimeTZ	d = new DateTimeTZ();

			return dateTimeImpl(d);

		}

        

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public string dateTime_RENAME_ME() 

        {

            return dateTime();

        }    



		/// <summary>

		/// Implements the following function

		///   string date:date-time()

		/// </summary>

		/// <returns>The current date and time or the empty string if the 

		/// date is invalid </returns>        

		public string dateTime(string s){		

			try

			{

				DateTimeTZ d = new DateTimeTZ(s);

				return dateTimeImpl(d);

			}

			catch(FormatException)

			{

				return ""; 

			}

		}

		

		/// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public string dateTime_RENAME_ME(string d) 

        {

            return dateTime(d);

        }



		/// <summary>

		/// Internal function to format the date based on a date, rather than a string

		/// </summary>

		/// <returns>The formtted date and time as a ISO8601 string</returns>        



		internal string dateTimeImpl(DateTimeTZ dtz)

		{

			return dtz.ToString();

		}



		/// <summary>

		/// Implements the following function

		///   string date:date()

		/// </summary>

		/// <returns>The current date</returns>        

		public string date()

		{

			DateTZ dtz = new DateTZ();

			return dtz.ToString();

		}



		/// <summary>

		/// Implements the following function

		///   string date:date(string)

		/// </summary>

		/// <returns>The date part of the specified date or the empty string if the 

		/// date is invalid</returns>        

		public string date(string d)

		{

			try

			{

				DateTZ dtz = new DateTZ(d);				

				return dtz.ToString(); 

			}

			catch(FormatException)

			{

				return ""; 

			}

		}



		/// <summary>

		/// Implements the following function

		///   string date:time()

		/// </summary>

		/// <returns>The current time</returns>        

		public string time()

		{

			TimeTZ t = new TimeTZ();

			return t.ToString();

		}



		/// <summary>

		/// Implements the following function

		///   string date:time(string)

		/// </summary>

		/// <returns>The time part of the specified date or the empty string if the 

		/// date is invalid</returns>        

		public string time(string d)

		{

			try

			{

				TimeTZ t = new TimeTZ(d);

				return t.ToString(); 

			}

			catch(FormatException)

			{

				return ""; 

			}

		}

		



		/// <summary>

		/// Implements the following function

		///   number date:year()

		/// </summary>

		/// <returns>The current year</returns>        

		public double year()

		{

			return DateTime.Now.Year;

		}



		/// <summary>

		/// Implements the following function

		///   number date:year(string)

		/// </summary>

		/// <returns>The year part of the specified date or the empty string if the 

		/// date is invalid</returns>

		/// <remarks>Does not support dates in the format of the xs:yearMonth or 

		/// xs:gYear types</remarks>        

		public double year(string d)

		{

			try	

			{

				YearTZ date = new YearTZ(d);

				return date.d.Year; 

			}

			catch(FormatException)

			{

				return System.Double.NaN; 

			}

		}



		/// <summary>

		/// Helper method for calculating whether a year is a leap year. Algorithm 

		/// obtained from http://mindprod.com/jglossleapyear.html

		/// </summary>        

		private static bool IsLeapYear (int year) 

		{ 	

            try 

            {

                return CultureInfo.CurrentCulture.Calendar.IsLeapYear(year); 

            } 

            catch 

            {

                return false;

            }

		}





		/// <summary>

		/// Implements the following function

		///   boolean date:leap-year()

		/// </summary>

		/// <returns>True if the current year is a leap year.</returns>        

		public bool leapYear()

		{

			return IsLeapYear((int) year());

		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public bool leapYear_RENAME_ME() 

        {

            return leapYear();

        }



		/// <summary>

		/// Implements the following function

		///   boolean date:leap-year(string)

		/// </summary>

		/// <returns>True if the specified year is a leap year</returns>

		/// <remarks>Note that the spec says we should return NaN for a badly formatted input

		/// string.  This is impossible; we return false for a badly formatted input string.

		/// </remarks>        

		public bool leapYear(string d)

		{

			double y = year(d); 



			if (y == System.Double.NaN)

				return false;

			else

				return IsLeapYear((int)y);

		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public bool leapYear_RENAME_ME(string d) 

        {

            return leapYear(d);

        }



		/// <summary>

		/// Implements the following function

		///   number date:month-in-year()

		/// </summary>

		/// <returns>The current month</returns>        

		public double monthInYear()

		{

			return DateTime.Now.Month;

		}

        

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public double monthInYear_RENAME_ME() 

        {

            return monthInYear();

        }



		/// <summary>

		/// Implements the following function

		///   number date:month-in-year(string)

		/// </summary>

		/// <returns>The month part of the specified date or the empty string if the 

		/// date is invalid</returns>

		/// <remarks>Does not support dates in the format of xs:gYear</remarks>        

		public double monthInYear(string d)

		{

			try

			{

				Month date = new Month(d);

				return date.d.Month; 

			}

			catch(FormatException)

			{

				return System.Double.NaN; 

			}

		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public double monthInYear_RENAME_ME(string d) 

        {

            return monthInYear(d);

        }



		/// <summary>

		/// Helper funcitno to calculate the week number

		/// </summary>

		/// <returns>

		/// Returns the week in the year.  Obeys EXSLT spec, which specifies that counting follows 

		/// ISO 8601: week 1 in a year is the week containing the first Thursday of the year, with 

		/// new weeks beginning on a Monday

		/// </returns>

		/// <param name="d">The date for which we want to find the week</param>

		private double weekInYear(DateTime d)

		{

		    return CultureInfo.InvariantCulture.Calendar.GetWeekOfYear(d, 

										  System.Globalization.CalendarWeekRule.FirstFourDayWeek, 

										  System.DayOfWeek.Monday);

		}		        



		/// <summary>

		/// Implements the following function

		///   number date:week-in-year()

		/// </summary>

		/// <returns>

		/// The current week. Obeys EXSLT spec, which specifies that counting follows 

		/// ISO 8601: week 1 in a year is the week containing the first Thursday of the year, with 

		/// new weeks beginning on a Monday

		/// </returns>        

		public double weekInYear()

		{

			return this.weekInYear(DateTime.Now);

		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public double weekInYear_RENAME_ME() 

        {

            return weekInYear();

        }



		/// <summary>

		/// Implements the following function

		///   number date:week-in-year(string)

		/// </summary>

		/// <returns>The week part of the specified date or the empty string if the 

		/// date is invalid</returns>

		/// <remarks>Does not support dates in the format of the xs:yearMonth or 

		/// xs:gYear types. This method uses the Calendar.GetWeekOfYear() method 

		/// with the CalendarWeekRule and FirstDayOfWeek of the current culture.

		/// THE RESULTS OF CALLING THIS FUNCTION VARIES ACROSS CULTURES</remarks>        

		public double weekInYear(string d)

		{

			try

			{

				DateTZ dtz = new DateTZ(d);

				return weekInYear(dtz.d);

			}

			catch(FormatException)

			{

				return System.Double.NaN; 

			}

		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public double weekInYear_RENAME_ME(string d) 

        {

            return weekInYear(d);

        }



        /// <summary>

        /// Helper method. 

        /// </summary>

        /// <param name="d"></param>

        /// <returns></returns>

        private double weekInMonth(DateTime d)

		{

			//

			// mon = 1

			// tue = 2

			// sun = 7

			// week = ceil(((date-day) / 7)) + 1



			double offset = (d.DayOfWeek == DayOfWeek.Sunday) ? 7 : (double)d.DayOfWeek;

			return System.Math.Ceiling((d.Day-offset) / 7)+1;

        }



        /// <summary>

        /// Implements the following function

        ///   number date:week-in-month()

        /// </summary>

		/// <remarks>

		/// The current week in month as a number.  For the purposes of numbering, the first 

		/// day of the month is in week 1 and new weeks begin on a Monday (so the first and 

		/// last weeks in a month will often have less than 7 days in them). 

		/// </remarks>        

		public double weekInMonth()

        {

            return this.weekInMonth(DateTime.Now);

        }

        

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public double weekInMonth_RENAME_ME() 

        {

            return weekInMonth();

        }



        /// <summary>

        /// Implements the following function

        ///   number date:week-in-month(string)

        /// </summary>

        /// <returns>The week in month of the specified date or NaN if the 

        /// date is invalid</returns>

		/// <remarks>

		/// The current week in month as a number.  For the purposes of numbering, the first 

		/// day of the month is in week 1 and new weeks begin on a Monday (so the first and 

		/// last weeks in a month will often have less than 7 days in them). 

		/// </remarks>        

        public double weekInMonth(string d)

        {

            try

            {

                DateTZ date = new DateTZ(d); 

                return this.weekInMonth(date.d); 

            }

            catch(FormatException)

            {

                return System.Double.NaN; 

            }

        }

        

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public double weekInMonth_RENAME_ME(string d) 

        {

            return weekInMonth(d);

        }





		/// <summary>

		/// Implements the following function

		///   number date:day-in-year()

		/// </summary>

		/// <returns>The current day. </returns>        

		public double dayInYear()

		{

			return DateTime.Now.DayOfYear;

		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public double dayInYear_RENAME_ME() 

        {

            return dayInYear();

        }



		/// <summary>

		/// Implements the following function

		///   number date:day-in-year(string)

		/// </summary>

		/// <returns>

		/// The day part of the specified date or NaN if the date is invalid

		/// </returns>        

		public double dayInYear(string d)

		{

			try

			{

				DateTZ date = new DateTZ(d); 

				return date.d.DayOfYear; 

			}

			catch(FormatException)

			{

				return System.Double.NaN; 

			}

		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public double dayInYear_RENAME_ME(string d) 

        {

            return dayInYear(d);

        }



		/// <summary>

		/// Implements the following function

		///   number date:day-in-week()

		/// </summary>

		/// <returns>The current day in the week. 1=Sunday, 2=Monday,...,7=Saturday</returns>        

		public double dayInWeek()

		{

			return ((int) DateTime.Now.DayOfWeek) + 1;

		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public double dayInWeek_RENAME_ME() 

        {

            return dayInWeek();

        }



		/// <summary>

		/// Implements the following function

		///   number date:day-in-week(string)

		/// </summary>

		/// <returns>The day in the week of the specified date or NaN if the 

		/// date is invalid. The current day in the week. 1=Sunday, 2=Monday,...,7=Saturday

		/// </returns>        

		public double dayInWeek(string d){

			try

			{

				DateTZ date = new DateTZ(d); 

				return ((int)date.d.DayOfWeek) + 1; 

			}

			catch(FormatException)

			{

				return System.Double.NaN; 

			}

		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public double dayInWeek_RENAME_ME(string d) 

        {

            return dayInWeek(d);

        }





		/// <summary>

		/// Implements the following function

		///   number date:day-in-month()

		/// </summary>

		/// <returns>The current day. </returns>        

		public double dayInMonth()

		{

			return DateTime.Now.Day;

		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public double dayInMonth_RENAME_ME() 

        {

            return dayInMonth();

        }



		/// <summary>

		/// Implements the following function

		///   number date:day-in-month(string)

		/// </summary>

		/// <returns>The day part of the specified date or the empty string if the 

		/// date is invalid</returns>

		public double dayInMonth(string d)

		{

			try

			{

				Day date = new Day(d);

				return date.d.Day; 

			}

			catch(FormatException)

			{

				return System.Double.NaN; 

			}

		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public double dayInMonth_RENAME_ME(string d) 

        {

            return dayInMonth(d);

        }



		/// <summary>

		/// Helper method.

		/// </summary>

		/// <param name="day"></param>

		/// <returns></returns>

		private double dayOfWeekInMonth(int day)

		{

			// day of week in month = floor(((date-1) / 7)) + 1

			return ((day-1)/7) + 1;

		}



		/// <summary>

		/// Implements the following function

		///   number date:day-of-week-in-month()

		/// </summary>

		/// <returns>The current day of week in the month as a number. For instance 

		/// the third Friday of the month returns 3</returns>        

		public double dayOfWeekInMonth()

		{

			return this.dayOfWeekInMonth(DateTime.Now.Day);

		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public double dayOfWeekInMonth_RENAME_ME() 

        {

            return dayOfWeekInMonth();

        }



		/// <summary>

		/// Implements the following function

		///   number date:day-of-week-in-month(string)

		/// </summary>

		/// <returns>The day part of the specified date or NaN if the 

		/// date is invalid</returns>        

		public double dayOfWeekInMonth(string d)

		{

			try

			{

				DateTZ date = new DateTZ(d); 

				return this.dayOfWeekInMonth(date.d.Day); 

			}

			catch(FormatException)

			{

				return System.Double.NaN; 

			}

		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public double dayOfWeekInMonth_RENAME_ME(string d) 

        {

            return dayOfWeekInMonth(d);

        }

	

		/// <summary>

		/// Implements the following function

		///   number date:hour-in-day()

		/// </summary>

		/// <returns>The current hour of the day as a number.</returns>        

		public double hourInDay()

		{

			return DateTime.Now.Hour;

		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public double hourInDay_RENAME_ME() 

        {

            return hourInDay();

        }



		/// <summary>

		/// Implements the following function

		///   number date:hour-in-day(string)

		/// </summary>

		/// <returns>The current hour of the specified time or NaN if the 

		/// date is invalid</returns>        

		public double hourInDay(string d)

		{

			try

			{

				TimeTZ date = new TimeTZ(d); 

				return date.d.Hour; 

			}

			catch(FormatException)

			{

				return System.Double.NaN; 

			}

		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public double hourInDay_RENAME_ME(string d) 

        {

            return hourInDay(d);

        }



		/// <summary>

		/// Implements the following function

		///   number date:minute-in-hour()

		/// </summary>

		/// <returns>The minute of the current hour as a number. </returns>        

		public double minuteInHour()

		{

			return DateTime.Now.Minute;

		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public double minuteInHour_RENAME_ME() 

        {

            return minuteInHour();

        }



		/// <summary>

		/// Implements the following function

		///   number date:minute-in-hour(string)

		/// </summary>

		/// <returns>The minute of the hour of the specified time or NaN if the 

		/// date is invalid</returns>        

		public double minuteInHour(string d)

		{

			try

			{

				TimeTZ date = new TimeTZ(d); 

				return date.d.Minute; 

			}

			catch(FormatException)

			{

				return System.Double.NaN; 

			}

		}



        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public double minuteInHour_RENAME_ME(string d) 

        {

            return minuteInHour(d);

        }



		/// <summary>

		/// Implements the following function

		///   number date:second-in-minute()

		/// </summary>

		/// <returns>The seconds of the current minute as a number. </returns>        

		public double secondInMinute()

		{

			return DateTime.Now.Second;

		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public double secondInMinute_RENAME_ME() 

        {

            return secondInMinute();

        }		



		/// <summary>

		/// Implements the following function

		///   number date:second-in-minute(string)

		/// </summary>

		/// <returns>The seconds of the minute of the specified time or NaN if the 

		/// date is invalid</returns>        

		public double secondInMinute(string d)

		{

			try

			{

				TimeTZ date = new TimeTZ(d); 

				return date.d.Second; 

			}

			catch(FormatException)

			{

				return System.Double.NaN; 

			}

		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public double secondInMinute_RENAME_ME(string d) 

        {

            return secondInMinute(d);

        }



		/// <summary>

		/// Helper function for 

		///   string date:day-name()

		/// </summary>

		/// <returns>The Engish name of the current day</returns>        

		private string dayName(int dow)

		{

            if (dow <0 || dow >= dayNames.Length)

                return String.Empty;

			return dayNames[dow];

		}



		/// <summary>

		/// Implements the following function

		///   string date:day-name()

		/// </summary>

		/// <returns>The Engish name of the current day</returns>        

		public string dayName()

		{

			return dayName((int) DateTime.Now.DayOfWeek);

		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public string dayName_RENAME_ME() 

        {

            return dayName();

        }



		/// <summary>

		/// Implements the following function

		///   string date:day-name(string)

		/// </summary>

		/// <returns>The English name of the day of the specified date or the empty string if the 

		/// date is invalid</returns>        

		public string dayName(string d)

		{

			try

			{

				DateTZ date = new DateTZ(d); 

				return dayName((int) date.d.DayOfWeek);

			}

			catch(FormatException)

			{

				return ""; 

			}

		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public string dayName_RENAME_ME(string d) 

        {

            return dayName(d);

        }



		/// <summary>

		/// Helper function for 

		///   string date:day-abbreviation()

		/// </summary>

		/// <returns>The abbreviated English name of the current day</returns>        

		private string dayAbbreviation(int dow)

		{

            if (dow < 0 || dow >= dayAbbrevs.Length)

                return String.Empty;

			return dayAbbrevs[dow];

		}





		/// <summary>

		/// Implements the following function

		///   string date:day-abbreviation()

		/// </summary>

		/// <returns>The abbreviated English name of the current day</returns>        

		public string dayAbbreviation()

		{

			return dayAbbreviation((int)DateTime.Now.DayOfWeek);

		}



        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public string dayAbbreviation_RENAME_ME() 

        {

            return dayAbbreviation();

        }



		/// <summary>

		/// Implements the following function

		///   string date:day-abbreviation(string)

		/// </summary>

		/// <returns>The abbreviated English name of the day of the specified date or the 

		/// empty string if the input date is invalid</returns>        

		public string dayAbbreviation(string d)

		{

			try

			{

				DateTZ date = new DateTZ(d); 

				return dayAbbreviation((int)date.d.DayOfWeek);

			}

			catch(FormatException)

			{

				return ""; 

			}

		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public string dayAbbreviation_RENAME_ME(string d) 

        {

            return dayAbbreviation(d);

        }



		/// <summary>

		/// Helper Function for 

		///   string date:month-name()

		/// </summary>

		/// <returns>The name of the current month</returns>        

		private string monthName(int month)

		{

            if (month < 1 || month > monthNames.Length)

                return String.Empty;

			return monthNames[month-1];

		}



		/// <summary>

		/// Implements the following function

		///   string date:month-name()

		/// </summary>

		/// <returns>The name of the current month</returns>        

		public string monthName()

		{

			return monthName((int)monthInYear());

		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public string monthName_RENAME_ME() 

        {

            return monthName();

        }



		/// <summary>

		/// Implements the following function

		///   string date:month-name(string)

		/// </summary>

		/// <returns>The name of the month of the specified date or the empty string if the 

		/// date is invalid</returns>

		/// <remarks>Does not support dates in the format of xs:gYear types</remarks>        

		public string monthName(string d)

		{

			double month = monthInYear(d);

			if (month == System.Double.NaN)

				return "";

			else

				return monthName((int)month);

		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public string monthName_RENAME_ME(string d) 

        {

            return monthName(d);

        }



		/// <summary>

		/// Helper function for 

		///   string date:month-abbreviation()

		/// </summary>

		/// <returns>The abbreviated name of the current month</returns>        

		private string monthAbbreviation(int month)

		{

            if (month < 1 || month > monthAbbrevs.Length)

                return String.Empty;

			return monthAbbrevs[month-1];

		}



		/// <summary>

		/// Implements the following function

		///   string date:month-abbreviation()

		/// </summary>

		/// <returns>The abbreviated name of the current month</returns>        

		public string monthAbbreviation()

		{

			return monthAbbreviation((int)monthInYear());

		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public string monthAbbreviation_RENAME_ME() 

        {

            return monthAbbreviation();

        }



		/// <summary>

		/// Implements the following function

		///   string date:month-abbreviation(string)

		/// </summary>

		/// <returns>The abbreviated name of the month of the specified date or the empty string if the 

		/// date is invalid</returns>

		/// <remarks>Does not support dates in the format of the xs:yearMonth or 

		/// xs:gYear types</remarks>        

		public string monthAbbreviation(string d)

		{

			double month = monthInYear(d);

			if (month == System.Double.NaN)

				return "";

			else

				return monthAbbreviation((int)month);

		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public string monthAbbreviation_RENAME_ME(string d) 

        {

            return monthAbbreviation(d);

        }



		/// <summary>

		/// Implements the following function

		///   string date:format-date(string, string)

		/// </summary>

		/// <param name="d">The date to format</param>

		/// <param name="format">One of the format strings understood by the 

		/// Java 1.1 SimpleDateFormat method:

		/// 

		///  Symbol   Meaning                 Presentation        Example

		///------   -------                 ------------        -------

		///G        era designator          (Text)              AD

		///y        year                    (Number)            1996

		///M        month in year           (Text &amp; Number)     July &amp; 07

		///d        day in month            (Number)            10

		///h        hour in am/pm (1~12)    (Number)            12

		///H        hour in day (0~23)      (Number)            0

		///m        minute in hour          (Number)            30

		///s        second in minute        (Number)            55

		///S        millisecond             (Number)            978

		///E        day in week             (Text)              Tuesday

		///D        day in year             (Number)            189

		///F        day of week in month    (Number)            2 (2nd Wed in July)

		///w        week in year            (Number)            27

		///W        week in month           (Number)            2

		///a        am/pm marker            (Text)              PM

		///k        hour in day (1~24)      (Number)            24

		///K        hour in am/pm (0~11)    (Number)            0

		///z        time zone               (Text)              Pacific Standard Time

		///'        escape for text         (Delimiter)

		///''       single quote            (Literal)           '

		///</param>

		/// <returns>The formated date</returns>        

		public string formatDate(string d, string format)

		{

			try

			{

				ExsltDateTime oDate = ExsltDateTimeFactory.ParseDateTime(d);

				StringBuilder retString = new StringBuilder("");



				for (int i=0; i < format.Length;)

				{

					int s = i;

					switch(format[i])

					{

						case 'G'://        era designator          (Text)              AD

							while (i < format.Length && format[i]=='G'){i++;}



							if (Object.ReferenceEquals(oDate.GetType(), typeof(DateTimeTZ)) || 

								Object.ReferenceEquals(oDate.GetType(), typeof(DateTZ)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearMonth)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearTZ)))

							{

								if (oDate.d.Year < 0)

								{

									retString.Append("BC");

								}

								else

								{

									retString.Append("AD");

								}

							}

							break;



						case 'y'://        year                    (Number)            1996

							while (i < format.Length && format[i]=='y'){i++;}

							if (Object.ReferenceEquals(oDate.GetType(), typeof(DateTimeTZ)) || 

								Object.ReferenceEquals(oDate.GetType(), typeof(DateTZ)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearMonth)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearTZ)))

							{

								if (i-s == 2)

								{

									retString.Append((oDate.d.Year % 100).ToString().PadLeft(i-s, '0'));



								}

								else

								{

									retString.Append(oDate.d.Year.ToString().PadLeft(i-s, '0'));

								}

							}

							break;

						case 'M'://        month in year           (Text &amp; Number)     July &amp; 07

							while (i < format.Length && format[i]=='M'){i++;}



							if (Object.ReferenceEquals(oDate.GetType(), typeof(DateTimeTZ)) || 

								Object.ReferenceEquals(oDate.GetType(), typeof(DateTZ)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearMonth)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(Month)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(MonthDay)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearTZ)))

							{

								if (i-s <= 2)

									retString.Append(oDate.d.Month.ToString().PadLeft(i-s, '0'));

								else if (i-s == 3)

									retString.Append(monthAbbreviation(oDate.d.Month));

								else

									retString.Append(monthName(oDate.d.Month));

							}

							break;

						case 'd'://        day in month            (Number)            10

							while (i < format.Length && format[i]=='d'){i++;}



							if (Object.ReferenceEquals(oDate.GetType(), typeof(DateTimeTZ)) || 

								Object.ReferenceEquals(oDate.GetType(), typeof(DateTZ)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearMonth)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(MonthDay)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(Day)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearTZ)))

							{

								retString.Append(oDate.d.Day.ToString().PadLeft(i-s, '0'));

							}

							break;

						case 'h'://        hour in am/pm (1~12)    (Number)            12

							while (i < format.Length && format[i]=='h'){i++;}

							if (Object.ReferenceEquals(oDate.GetType(), typeof(DateTimeTZ)) || 

								Object.ReferenceEquals(oDate.GetType(), typeof(DateTZ)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearMonth)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(TimeTZ)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearTZ)))

							{

								int hour = oDate.d.Hour % 12;

								if (0 == hour)

									hour = 12;

								retString.Append(hour.ToString().PadLeft(i-s, '0'));

							}

							break;

						case 'H'://        hour in day (0~23)      (Number)            0

							while (i < format.Length && format[i]=='H'){i++;}

							if (Object.ReferenceEquals(oDate.GetType(), typeof(DateTimeTZ)) || 

								Object.ReferenceEquals(oDate.GetType(), typeof(DateTZ)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearMonth)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(TimeTZ)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearTZ)))

							{

								retString.Append(oDate.d.Hour.ToString().PadLeft(i-s, '0'));

							}

							break;

						case 'm'://        minute in hour          (Number)            30

							while (i < format.Length && format[i]=='m'){i++;}

							if (Object.ReferenceEquals(oDate.GetType(), typeof(DateTimeTZ)) || 

								Object.ReferenceEquals(oDate.GetType(), typeof(DateTZ)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearMonth)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(TimeTZ)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearTZ)))

							{

								retString.Append(oDate.d.Minute.ToString().PadLeft(i-s, '0'));

							}

							break;

						case 's'://        second in minute        (Number)            55

							while (i < format.Length && format[i]=='s'){i++;}

							if (Object.ReferenceEquals(oDate.GetType(), typeof(DateTimeTZ)) || 

								Object.ReferenceEquals(oDate.GetType(), typeof(DateTZ)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearMonth)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(TimeTZ)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearTZ)))

							{

								retString.Append(oDate.d.Second.ToString().PadLeft(i-s, '0'));

							}

							break;

						case 'S'://        millisecond             (Number)            978

							while (i < format.Length && format[i]=='S'){i++;}

                            if (Object.ReferenceEquals(oDate.GetType(), typeof(DateTimeTZ)) ||

                                Object.ReferenceEquals(oDate.GetType(), typeof(DateTZ)) ||

                                Object.ReferenceEquals(oDate.GetType(), typeof(YearMonth)) ||

                                Object.ReferenceEquals(oDate.GetType(), typeof(TimeTZ)) ||

                                Object.ReferenceEquals(oDate.GetType(), typeof(YearTZ)))

                            {                                

                                retString.Append(oDate.d.Millisecond.ToString().PadLeft(i-s, '0'));

                            }							

							break;

						case 'E'://        day in week             (Text)              Tuesday

							while (i < format.Length && format[i]=='E'){i++;}



							if (Object.ReferenceEquals(oDate.GetType(), typeof(DateTimeTZ)) || 

								Object.ReferenceEquals(oDate.GetType(), typeof(DateTZ)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearMonth)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearTZ)))

							{

								if (i-s <= 3)

								{

									retString.Append(dayAbbreviation((int)oDate.d.DayOfWeek));

								}

								else

								{

									retString.Append(dayName((int)oDate.d.DayOfWeek));

								}

							}

							break;

						case 'D'://        day in year             (Number)            189

							while (i < format.Length && format[i]=='D'){i++;}

							if (Object.ReferenceEquals(oDate.GetType(), typeof(DateTimeTZ)) || 

								Object.ReferenceEquals(oDate.GetType(), typeof(DateTZ)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearMonth)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearTZ)))

							{

								retString.Append(oDate.d.DayOfYear.ToString().PadLeft(i-s, '0'));

							}

							break;

						case 'F'://        day of week in month    (Number)            2 (2nd Wed in July)

							while (i < format.Length && format[i]=='F'){i++;}

							if (Object.ReferenceEquals(oDate.GetType(), typeof(DateTimeTZ)) || 

								Object.ReferenceEquals(oDate.GetType(), typeof(DateTZ)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearMonth)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(MonthDay)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(Day)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearTZ)))

							{

								retString.Append(dayOfWeekInMonth(oDate.d.Day).ToString().PadLeft(i-s, '0'));

							}

							break;

						case 'w'://        week in year            (Number)            27

							while (i < format.Length && format[i]=='w'){i++;}

							if (Object.ReferenceEquals(oDate.GetType(), typeof(DateTimeTZ)) || 

								Object.ReferenceEquals(oDate.GetType(), typeof(DateTZ)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearMonth)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearTZ)))

							{

								retString.Append(weekInYear(oDate.d));

							}

							break;

						case 'W'://        week in month           (Number)            2

							while (i < format.Length && format[i]=='W'){i++;}

							if (Object.ReferenceEquals(oDate.GetType(), typeof(DateTimeTZ)) || 

								Object.ReferenceEquals(oDate.GetType(), typeof(DateTZ)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearMonth)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearTZ)))

							{

								retString.Append(weekInMonth(oDate.d));

							}

							break;

						case 'a'://        am/pm marker            (Text)              PM

							while (i < format.Length && format[i]=='a'){i++;}

							if (Object.ReferenceEquals(oDate.GetType(), typeof(DateTimeTZ)) || 

								Object.ReferenceEquals(oDate.GetType(), typeof(DateTZ)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearMonth)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(TimeTZ)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearTZ)))

							{

								if (oDate.d.Hour < 12)

									retString.Append("AM");

								else

									retString.Append("PM");

							}

							break;

						case 'k'://        hour in day (1~24)      (Number)            24

							while (i < format.Length && format[i]=='k'){i++;}

							if (Object.ReferenceEquals(oDate.GetType(), typeof(DateTimeTZ)) || 

								Object.ReferenceEquals(oDate.GetType(), typeof(DateTZ)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearMonth)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(TimeTZ)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearTZ)))

							{

								int hour = oDate.d.Hour + 1;

								retString.Append(hour.ToString().PadLeft(i-s, '0'));

							}

							break;

						case 'K'://        hour in am/pm (0~11)    (Number)            0

							while (i < format.Length && format[i]=='K'){i++;}

							if (Object.ReferenceEquals(oDate.GetType(), typeof(DateTimeTZ)) || 

								Object.ReferenceEquals(oDate.GetType(), typeof(DateTZ)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearMonth)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(TimeTZ)) ||

								Object.ReferenceEquals(oDate.GetType(), typeof(YearTZ)))

							{

								int hour = oDate.d.Hour % 12;

								retString.Append(hour.ToString().PadLeft(i-s, '0'));

							}

							break;

						case 'z'://        time zone               (Text)              Pacific Standard Time

							while (i < format.Length && format[i]=='z'){i++;}

							//

							// BUGBUG: Need to convert to full timezone names or timezone abbrevs

							// if they are available.  Now cheating by using GMT offsets.

							retString.Append(oDate.GetGMTOffsetTimeZone());

							break;

						case 'Z'://			rfc 822 time zone

							while (i < format.Length && format[i]=='Z'){i++;}

							retString.Append(oDate.Get822TimeZone());

							break;

						case '\''://        escape for text         (Delimiter)

							if (i < format.Length && format[i+1] == '\'')

							{

								i++;

								while (i < format.Length && format[i]=='\''){i++;}

								retString.Append("'");

							}

							else

							{

								i++;

								while (i < format.Length && format[i]!='\'' && i <= format.Length){retString.Append(format.Substring(i++, 1));}

								if (i >= format.Length)return "";

								i++;

							}

							break;

						default:

							retString.Append(format[i]);

							i++;

							break;

					}

				}

	

				return retString.ToString();

			}



		

			catch(FormatException)

			{

				return ""; 

			}

		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public string formatDate_RENAME_ME(string d, string format) 

        {

            return formatDate(d, format);

        }





		/// <summary>

		/// Implements the following function

		///   string date:parse-date(string, string)

		/// BUGBUG: should use Java formatting strings, not Windows.

		/// </summary>

		/// <param name="d">The date to parse</param>

		/// <param name="format">One of the format strings understood by the 

		/// DateTime.ToString(string) method.</param>

		/// <returns>The parsed date</returns>        

		public string parseDate(string d, string format){

			try{

				DateTime date = DateTime.ParseExact(d, format, CultureInfo.CurrentCulture); 

				return XmlConvert.ToString(date, XmlDateTimeSerializationMode.RoundtripKind);

			}catch(FormatException){

				return ""; 

			}

		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public string parseDate_RENAME_ME(string d, string format) 

        {

            return parseDate(d, format);

        }

	

		/// <summary>

		/// Implements the following function 

		///    string:date:difference(string, string)

		/// </summary>

		/// <param name="start">The start date</param>

		/// <param name="end">The end date</param>

		/// <returns>A positive difference if start is before end otherwise a negative

		/// difference. The difference is in the ISO 8601 date difference format as either

		/// [-]P[yY][mM]

		/// or

		/// [-]P[dD][T][hH][mM][sS]

		/// P means a difference and is required

		/// At least one of Y M D H M S is required

		/// If a higher order component is 0, it is suppressed (for example, if there are 0 years and

		/// 1 month, then Y is suppressed.  If there are 1 years and 0 months, M is not suppressed)

		/// If the input format is yyyy-MM or yyyy, then the output is [-]P[yY][mM]

		/// If the input format includes days, hours, minutes or seconds, then the output is

		/// [-]P[dD][T][hH][mM][sS].

		/// If there H M and S are all 0, the T is suppressed.

		/// </returns>        

		public string difference(string start, string end)

		{		

			try

			{

				ExsltDateTime startdate = ExsltDateTimeFactory.ParseDate(start); 

				ExsltDateTime enddate   = ExsltDateTimeFactory.ParseDate(end); 



				// The rules are pretty tricky.  basically, interpret both strings as the least-

				// specific format

				if (Object.ReferenceEquals(startdate.GetType(), typeof(YearTZ)) || 

					Object.ReferenceEquals(enddate.GetType(), typeof(YearTZ)))

				{

					StringBuilder retString = new StringBuilder("");



					int	yearDiff = enddate.d.Year - startdate.d.Year;



					if (yearDiff < 0)

						retString.Append('-');



					retString.Append('P');

					retString.Append(Math.Abs(yearDiff));

					retString.Append('Y');



					return retString.ToString();

				}					

				else if (Object.ReferenceEquals(startdate.GetType(), typeof(YearMonth)) || 

					Object.ReferenceEquals(enddate.GetType(), typeof(YearMonth)))

				{

					StringBuilder retString = new StringBuilder("");



					int	yearDiff = enddate.d.Year - startdate.d.Year;

					int monthDiff = enddate.d.Month - startdate.d.Month;



					// Borrow from the year if necessary

					if ((yearDiff > 0) && (Math.Sign(monthDiff) == -1))

					{

						yearDiff--;

						monthDiff += 12;

					} 

					else if ((yearDiff < 0) && (Math.Sign(monthDiff) == 1))

					{

						yearDiff++;

						monthDiff -= 12;

					}





					if ((yearDiff < 0) || ((yearDiff == 0) && (monthDiff < 0)))

					{

						retString.Append('-');						

					}

					retString.Append('P');

					if (yearDiff != 0)

					{

						retString.Append(Math.Abs(yearDiff));

						retString.Append('Y');

					}

					retString.Append(Math.Abs(monthDiff));

					retString.Append('M');

	

					return retString.ToString();

				}

				else

				{

					// Simulate casting to the most truncated format.  i.e. if one 

					// Arg is DateTZ and the other is DateTimeTZ, get rid of the time

					// for both.

					if (Object.ReferenceEquals(startdate.GetType(), typeof(DateTZ)) || 

						Object.ReferenceEquals(enddate.GetType(), typeof(DateTZ)))

					{

						startdate = new DateTZ(startdate.d.ToString("yyyy-MM-dd"));

						enddate = new DateTZ(enddate.d.ToString("yyyy-MM-dd"));

					}



					TimeSpan ts = enddate.d.Subtract(startdate.d);

					return XmlConvert.ToString(ts);

				}

			}

			catch(FormatException)

			{

				return ""; 

			}

		}



		/// <summary>

		/// Implements the following function

		///    date:add(string, string)

		/// </summary>

		/// <param name="datetime">An ISO8601 date/time</param>

		/// <param name="duration">the duration to add</param>

		/// <returns>The new time</returns>        

		public string add(string datetime, string duration)

		{			

			try

			{

				ExsltDateTime date = ExsltDateTimeFactory.ParseDate(datetime); 

				//TimeSpan timespan = System.Xml.XmlConvert.ToTimeSpan(duration); 



				Regex durationRE = new Regex(

					@"^(-)?" +				// May begin with a - sign

					@"P" +					// Must contain P as first or 2nd char

					@"(?=\d+|(?:T\d+))" +		// Must contain at least one digit after P or after PT

					@"(?:(\d+)Y)?" +		// May contain digits plus Y for year

					@"(?:(\d+)M)?" +		// May contain digits plus M for month

					@"(?:(\d+)D)?" +		// May contain digits plus D for day

					@"(?=T\d+)?" +			// If there is a T here, must be digits afterwards

					@"T?" +					// May contain a T

					@"(?:(\d+)H)?" +		// May contain digits plus H for hours

					@"(?:(\d+)M)?" +		// May contain digits plus M for minutes

					@"(?:(\d+)S)?" +		// May contain digits plus S for seconds

					@"$", 

					RegexOptions.IgnoreCase | RegexOptions.Singleline

					);



				Match m = durationRE.Match(duration);



				int negation = 1, years = 0, months = 0, days = 0,

					hours = 0, minutes = 0, seconds = 0;



				if (m.Success)

				{

					//date.d = date.d.Add(timespan);

					// According to the XML datetime spec at 

					// http://www.w3.org/TR/xmlschema-2/#adding-durations-to-dateTimes, 

					// we need to first add the year/month part, then we can add the 

					// day/hour/minute/second part



					if (CultureInfo.InvariantCulture.CompareInfo.Compare(m.Groups[1].Value, "-") == 0)

						negation = -1;



					if (m.Groups[2].Length > 0)

						years = negation * int.Parse(m.Groups[2].Value);



					if (m.Groups[3].Length > 0)

						months = negation * int.Parse(m.Groups[3].Value);



					if (m.Groups[4].Length > 0)

						days = negation * int.Parse(m.Groups[4].Value);



					if (m.Groups[5].Length > 0)

						hours = negation * int.Parse(m.Groups[5].Value);



					if (m.Groups[6].Length > 0)

						minutes = negation * int.Parse(m.Groups[6].Value);



					if (m.Groups[7].Length > 0)

						seconds = negation * int.Parse(m.Groups[7].Value);



					date.d = date.d.AddYears(years);

					date.d = date.d.AddMonths(months);

					date.d = date.d.AddDays(days);

					date.d = date.d.AddHours(hours);

					date.d = date.d.AddMinutes(minutes);

					date.d = date.d.AddSeconds(seconds);



					// we should return the same format as passed in



					// return date.ToString("yyyy-MM-dd\"T\"HH:mm:ss");			

					return date.ToString();

				}

				else

				{

					return "";

				}

			}

			catch(FormatException)	

			{

				return ""; 

			}

		}





		/// <summary>

		/// Implements the following function

		///    string:date:add-duration(string, string)

		/// </summary>

        /// <param name="duration1">Initial duration</param>

        /// <param name="duration2">the duration to add</param>

		/// <returns>The new time</returns>        

		public string addDuration(string duration1, string duration2)

		{			

			try

			{

				TimeSpan timespan1 = XmlConvert.ToTimeSpan(duration1);

				TimeSpan timespan2 = XmlConvert.ToTimeSpan(duration2); 

				return XmlConvert.ToString(timespan1.Add(timespan2));

			}

			catch(FormatException)

			{

				return ""; 

			}



		}

		

        /// <summary>

        /// This wrapper method will be renamed during custom build 

        /// to provide conformant EXSLT function name.

        /// </summary>

        public string addDuration_RENAME_ME(string duration1, string duration2) 

        {

            return addDuration(duration1, duration2);

        }



		/// <summary>

		/// Helper method for date:seconds() that takes an ExsltDateTime. 

		/// </summary>

		/// <param name="d"></param>

		/// <returns>difference in seconds between the specified date and the

		/// epoch (1970-01-01T00:00:00Z)</returns>

		private double seconds(ExsltDateTime d)

		{

			DateTime epoch = new DateTime(1970, 1, 1, 0,0,0,0, CultureInfo.InvariantCulture.Calendar);

			return d.ToUniversalTime().Subtract(epoch).TotalSeconds;

		}



		/// <summary>

		/// Implements the following function

		///		number date:seconds()

		/// </summary>

		/// <returns>The amount of seconds since the epoch (1970-01-01T00:00:00Z)</returns>        

		public double seconds()

		{		 

			return seconds(new DateTimeTZ());

		}





		/// <summary>

		/// Implements the following function

		///		number date:seconds(string)

		/// </summary>

		/// <returns>If date passed in, the amount of seconds between the specified date and the 

		/// epoch (1970-01-01T00:00:00Z).  If timespan passed in, returns the number of seconds

		/// in the timespan.</returns>

		public double seconds(string datetime)

		{		 

			try

			{

				return seconds(ExsltDateTimeFactory.ParseDate(datetime));

			}

			catch(FormatException){ ; } //might be a duration



			try

			{

				TimeSpan duration = XmlConvert.ToTimeSpan(datetime); 

				return duration.TotalSeconds;

			}

			catch(FormatException)

			{

				return System.Double.NaN;

			}

		}



		/// <summary>

		/// Implements the following function 

		///		string date:sum(node-set)

		/// </summary>

		/// <param name="iterator">Nodeset of timespans</param>

		/// <returns>The sum of the timespans within a node set.</returns>        

		public string sum(XPathNodeIterator iterator)

		{

			

			TimeSpan sum = new TimeSpan(0,0,0,0); 

 

			if(iterator.Count == 0)

			{

				return ""; 

			}



			try

			{ 

				while(iterator.MoveNext())

				{

					sum = XmlConvert.ToTimeSpan(iterator.Current.Value).Add(sum);

				}

				

			}

			catch(FormatException)

			{

				return ""; 

			}



			return XmlConvert.ToString(sum) ; //XmlConvert.ToString(sum);

		}



		/// <summary>

		/// Implements the following function 

		///    string date:duration()

		/// </summary>

		/// <returns>seconds since the beginning of the epoch until now</returns>        

		public string duration()

		{

			return duration(seconds()); 

		}



		/// <summary>

		/// Implements the following function 

		///    string date:duration(number)

		/// </summary>

		/// <param name="seconds"></param>

		/// <returns></returns>        

		public string duration(double seconds)

		{

			return XmlConvert.ToString(TimeSpan.FromSeconds(seconds)); 

		}	

	}

}