Add Calendar class

source/icu.net.tests/CalendarTests.cs

@@ -0,0 +1,388 @@
+using System;
+using NUnit.Framework;
+using Icu;
+using System.Globalization;
+using System.Linq;
+
+
+namespace Icu.Tests
+{
+	[TestFixture]
+	class CalendarTests
+	{
+
+		[Test]
+		public void GetTimeZoneDisplayNameTest()
+		{
+			var timezone = new TimeZone("AST");
+			var cal = new GregorianCalendar(timezone);
+
+			var displayName = cal.GetTimeZoneDisplayName(Calendar.UCalendarDisplayNameType.Standard);
+
+			Assert.AreEqual("Alaska Standard Time", displayName);
+		}
+
+		[Test]
+		public void ClearTest()
+		{
+			var cal = new GregorianCalendar();
+			cal.Month = Calendar.UCalendarMonths.September;
+			cal.DayOfMonth = 4;
+
+			cal.Clear();
+
+			Assert.AreEqual(Calendar.UCalendarMonths.January, cal.Month);
+			Assert.AreEqual(1, cal.DayOfMonth);
+		}
+
+		[Test]
+		public void ClearFieldTest()
+		{
+			var cal = new GregorianCalendar();
+			cal.Month = Calendar.UCalendarMonths.September;
+
+			cal.Clear(Calendar.UCalendarDateFields.Month);
+
+			Assert.AreEqual(Calendar.UCalendarMonths.January, cal.Month);
+		}
+
+		[Test]
+		public void CloneTest()
+		{
+			var cal1 = new GregorianCalendar();
+
+			cal1.DayOfMonth = 5;
+			var cal2 = cal1.Clone();
+			cal2.DayOfMonth = 10;
+
+			Assert.AreEqual(5, cal1.DayOfMonth);
+		}
+
+		[Test]
+		public void RollTest()
+		{
+			var cal = new GregorianCalendar();
+			var startMonth = cal.Month;
+
+			cal.Roll(Calendar.UCalendarDateFields.DayOfMonth, 100);
+
+			Assert.AreEqual(startMonth, cal.Month);
+		}
+
+		[Test]
+		public void SetTest()
+		{
+			var cal = new GregorianCalendar(new TimeZone("UTC"));
+			cal.Clear();
+
+			cal.Set(Calendar.UCalendarDateFields.DayOfYear, 2);
+
+			Assert.AreEqual(24 * 60 * 60 * 1000, cal.GetTime());
+		}
+
+		[Test]
+		public void GetTest()
+		{
+			var cal = new GregorianCalendar(new TimeZone("UTC"));
+			var expected = 15;
+			cal.Set(Calendar.UCalendarDateFields.DayOfYear, expected);
+
+			var result = cal.Get(Calendar.UCalendarDateFields.DayOfYear);
+
+			Assert.AreEqual(expected, result);
+		}
+
+		[Test]
+		public void FieldDifferenceTest()
+		{
+			var cal = new GregorianCalendar();
+			var time = cal.GetTime();
+
+			cal.Add(Calendar.UCalendarDateFields.Hour, 2);
+			cal.Add(Calendar.UCalendarDateFields.Minute, 2);
+
+			var difference = cal.FieldDifference(time, Calendar.UCalendarDateFields.Minute);
+
+			Assert.AreEqual(time, cal.GetTime());
+			Assert.AreEqual(-122, difference);
+		}
+
+		[Test]
+		public void IsSetTest()
+		{
+			var cal = new GregorianCalendar();
+			cal.Month = Calendar.UCalendarMonths.September;
+			cal.DayOfMonth = 4;
+
+			var setBefore = cal.IsSet(Calendar.UCalendarDateFields.Month);
+			cal.Clear();
+			var setAfter = cal.IsSet(Calendar.UCalendarDateFields.Month);
+
+			Assert.AreEqual(true, setBefore);
+			Assert.AreEqual(false, setAfter);
+		}
+
+		[Test]
+		public void InDaylightTime()
+		{
+			var cal = new GregorianCalendar(new TimeZone("Europe/Warsaw"));
+
+			cal.Month = Calendar.UCalendarMonths.September;
+			cal.DayOfMonth = 1;
+
+			Assert.AreEqual(true, cal.InDaylightTime());
+		}
+
+		[Test]
+		public void SetTimeTest()
+		{
+			var cal = new GregorianCalendar(new TimeZone("UTC"));
+			cal.SetTime(0);
+
+			Assert.AreEqual(1970, cal.Year);
+			Assert.AreEqual(0, cal.Hour);
+			Assert.AreEqual(0, cal.Minute);
+			Assert.AreEqual(0, cal.Millisecond);
+		}
+
+		[Test]
+		public void ToDateTimeTest()
+		{
+			var cal = new GregorianCalendar();
+			var datetime = cal.ToDateTime();
+
+			Assert.AreEqual(cal.Year, datetime.Year);
+			Assert.AreEqual((int)cal.Month + 1, datetime.Month);
+			Assert.AreEqual(cal.DayOfMonth, datetime.Day);
+			Assert.AreEqual(cal.HourOfDay, datetime.Hour);
+			Assert.AreEqual(cal.Minute, datetime.Minute);
+			Assert.AreEqual(cal.Second, datetime.Second);
+			Assert.AreEqual(cal.Millisecond, datetime.Millisecond);
+		}
+
+		[Test]
+		public void SetTimeZoneTest()
+		{
+			var expected = new TimeZone("AST");
+			var cal = new GregorianCalendar(new TimeZone("UTC"));
+
+			cal.SetTimeZone(expected);
+			var result = cal.GetTimeZone();
+
+			Assert.AreEqual(expected.Id, result.Id);
+		}
+
+		[Test]
+		public void FirstDayOfWeekTest()
+		{
+			var cal = new GregorianCalendar(new TimeZone("UTC"));
+			var newDay = Calendar.UCalendarDaysOfWeek.Thursday;
+
+			var val0 = cal.FirstDayOfWeek;
+			cal.FirstDayOfWeek = newDay;
+			var val1 = cal.FirstDayOfWeek;
+
+			Assert.AreEqual(Calendar.UCalendarDaysOfWeek.Sunday, val0);
+			Assert.AreEqual(newDay, val1);
+		}
+
+		[Test]
+		public void WeekOfYearTest()
+		{
+			var cal = new GregorianCalendar(new TimeZone("UTC"));
+			cal.Clear();
+			cal.DayOfMonth = 4;
+			var newDay = Calendar.UCalendarDaysOfWeek.Thursday;
+
+			var val0 = cal.WeekOfYear;
+			cal.FirstDayOfWeek = newDay;
+			var val1 = cal.WeekOfYear;
+
+
+			Assert.AreEqual(2, val0);
+			Assert.AreEqual(1, val1);
+		}
+
+		[Test]
+		public void MinimalDaysInFirstWeekTest()
+		{
+			var cal = new GregorianCalendar(new TimeZone("UTC"));
+			cal.Clear();
+			cal.DayOfMonth = 4;
+			var newMinimum = 5;
+
+			var val0 = cal.WeekOfYear;
+			cal.MinimalDaysInFirstWeek = newMinimum;
+			var val1 = cal.WeekOfYear;
+
+			Assert.AreEqual(2, val0);
+			Assert.AreEqual(1, val1);
+		}
+
+		[Test]
+		public void SkippedWallTimeTest()
+		{
+			var cal = new GregorianCalendar(new TimeZone("America/New_York"));
+			cal.Year = 2011;
+			cal.HourOfDay = 0;
+			cal.Minute = 0;
+			cal.Month = Calendar.UCalendarMonths.March;
+			cal.DayOfMonth = 13;
+
+			cal.SkippedWallTimeOption = Calendar.UCalendarWallTimeOption.WalltimeFirst;
+			cal.Minute = 30;
+			cal.HourOfDay = 2;
+			var hour = cal.HourOfDay;
+			var minute = cal.Minute;
+
+			Assert.AreEqual(1, hour);
+			Assert.AreEqual(30, minute);
+		}
+
+		[Test]
+		public void RepeatedWallTimeTest()
+		{
+			var cal = new GregorianCalendar(new TimeZone("America/New_York"));
+			cal.Year = 2011;
+			cal.HourOfDay = 0;
+			cal.Minute = 0;
+			cal.Month = Calendar.UCalendarMonths.November;
+			cal.DayOfMonth = 6;
+
+			cal.RepeatedWallTimeOption = Calendar.UCalendarWallTimeOption.WalltimeFirst;
+			cal.Minute = 30;
+			cal.HourOfDay = 1;
+			cal.Add(Calendar.UCalendarDateFields.Minute, 60);
+			var hour = cal.HourOfDay;
+			var minute = cal.Minute;
+
+			Assert.AreEqual(1, hour);
+			Assert.AreEqual(30, minute);
+		}
+
+		[Test]
+		public void LenientTest_ThrowsArgumentException()
+		{
+
+			var cal = new GregorianCalendar(new TimeZone("America/New_York"));
+			cal.Year = 2011;
+			cal.HourOfDay = 0;
+			cal.Minute = 0;
+			cal.Month = Calendar.UCalendarMonths.March;
+			cal.DayOfMonth = 13;
+
+			cal.Lenient = false;
+			cal.SkippedWallTimeOption = Calendar.UCalendarWallTimeOption.WalltimeFirst;
+			cal.Minute = 30;
+			cal.HourOfDay = 2;
+
+			Assert.Throws<ArgumentException>(() => cal.GetTime());
+		}
+
+		[Test]
+		public void WeekOfMonthTest()
+		{
+			var cal = new GregorianCalendar(new TimeZone("UTC"));
+			cal.Clear();
+			cal.DayOfMonth = 4;
+			var newMinimum = 5;
+
+			var val0 = cal.WeekOfMonth;
+			cal.MinimalDaysInFirstWeek = newMinimum;
+			var val1 = cal.WeekOfMonth;
+
+			Assert.AreEqual(2, val0);
+			Assert.AreEqual(1, val1);
+		}
+
+		[Test]
+		public void EraTest()
+		{
+			var cal = new GregorianCalendar(new TimeZone("UTC"));
+
+			var era1 = cal.Era;
+			cal.Year = -1;
+			var era0 = cal.Era;
+
+			Assert.AreEqual(1, era1);
+			Assert.AreEqual(0, era0);
+		}
+
+		[Test]
+		public void ZoneOffsetTest()
+		{
+			var expected = 60 * 60 * 1000;
+			var zone = new TimeZone("Europe/Paris");
+			var cal = new GregorianCalendar(zone);
+
+			var offset = cal.ZoneOffset;
+
+			Assert.AreEqual(expected, offset);
+		}
+
+		[Test]
+		public void DstOffsetTest()
+		{
+			var expected0 = 60 * 60 * 1000;
+			var expected1 = 0;
+
+			var zone = new TimeZone("Europe/Paris");
+			var cal = new GregorianCalendar(zone);
+			cal.Month = Calendar.UCalendarMonths.July;
+			cal.DayOfMonth = 20;
+
+			var offset0 = cal.DstOffset;
+			cal.Month = Calendar.UCalendarMonths.January;
+			var offset1 = cal.DstOffset;
+
+			Assert.AreEqual(expected0, offset0);
+			Assert.AreEqual(expected1, offset1);
+
+		}
+
+		[Test]
+		public void AmPmTest()
+		{
+			var cal = new GregorianCalendar(new TimeZone("UTC"));
+
+			cal.HourOfDay = 3;
+			var val0 = cal.AmPm;
+			cal.HourOfDay = 14;
+			var val1 = cal.AmPm;
+
+			Assert.AreEqual(0, val0);
+			Assert.AreEqual(1, val1);
+		}
+
+		[Test]
+
+		public void SetTimeZone2Test()
+		{
+			var winId = "Romance Standard Time";
+			var expected = "Europe/Paris";
+			var timezone = TimeZoneInfo.FindSystemTimeZoneById(winId);
+			var cal = new GregorianCalendar(new TimeZone("UTC"));
+
+			cal.SetTimeZone(timezone);
+
+			var tz = cal.GetTimeZone();
+
+			Assert.AreEqual(expected, tz.Id);
+		}
+
+		[Test]
+		public void GetTimeZoneTest()
+		{
+			var timezone = new TimeZone("Europe/Zagreb");
+			var expected = "Central European Standard Time";
+
+			var cal = new GregorianCalendar(timezone);
+
+			var tz = cal.GetTimeZoneInfo();
+
+			Assert.AreEqual(expected, tz.Id);
+		}
+
+
+	}
+}

source/icu.net/Calendar/GregorianCalendar.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace Icu
+{
+	public class GregorianCalendar : Calendar
+	{
+		public GregorianCalendar()
+			: this(new Locale())
+		{
+		}
+
+		public GregorianCalendar(Locale locale)
+			:this(TimeZone.GetDefault(),locale)
+		{
+		}
+
+		public GregorianCalendar(TimeZone timezone)
+			:this(timezone, new Locale())
+		{
+		}
+
+		public GregorianCalendar(TimeZone timezone, Locale locale)
+		{
+			_locale = locale;
+			_calendarHandle = NativeMethods.ucal_open(timezone.Id,
+									 locale.Name, UCalendarType.Gregorian, out ErrorCode ec);
+			ExceptionFromErrorCode.ThrowIfError(ec);
+		}
+
+		private GregorianCalendar(SafeCalendarHandle handle)
+		{
+			_calendarHandle = handle;
+		}
+
+		public override Calendar Clone()
+		{
+			var handle = NativeMethods.ucal_clone(_calendarHandle, out ErrorCode status);
+			return new GregorianCalendar(handle);
+		}
+
+		public override bool InDaylightTime()
+		{
+			return NativeMethods.ucal_inDaylightTime(_calendarHandle, out _);
+		}
+	}
+}

source/icu.net/NativeMethods/NativeMethods_Calendar.cs

@@ -0,0 +1,404 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Icu
+{
+	internal static partial class NativeMethods
+	{
+		private class CalendarMehodsContainer
+		{
+
+
+			[UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
+			internal delegate void ucal_setTimeZoneDelegate(
+				Calendar.SafeCalendarHandle cal,
+				[MarshalAs(UnmanagedType.LPWStr)] string zoneID,
+				int len,
+				out ErrorCode ec);
+
+			[UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
+			internal delegate int ucal_getTimeZoneIdDelegate(
+				Calendar.SafeCalendarHandle cal,
+				IntPtr result,
+				int resultLength,
+				out ErrorCode ec);
+
+			[UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
+			internal delegate Calendar.SafeCalendarHandle ucal_openDelegate(
+				[MarshalAs(UnmanagedType.LPWStr)] string zoneID,
+				int len,
+				[MarshalAs(UnmanagedType.LPStr)] string locale,
+				Calendar.UCalendarType type,
+				out ErrorCode status);
+
+			[UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
+			internal delegate void ucal_closeDelegate(IntPtr cal);
+
+			[UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
+			internal delegate void ucal_addDelegate(
+				Calendar.SafeCalendarHandle cal,
+				Calendar.UCalendarDateFields field,
+				int amount,
+				out ErrorCode status);
+
+			[UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
+			internal delegate void ucal_rollDelegate(
+				Calendar.SafeCalendarHandle cal,
+				Calendar.UCalendarDateFields field,
+				int amount,
+				out ErrorCode status);
+
+			[UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
+			internal delegate int ucal_getDelegate(
+				Calendar.SafeCalendarHandle cal,
+				Calendar.UCalendarDateFields field,
+				out ErrorCode status);
+
+			[UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
+			internal delegate void ucal_clearDelegate(
+				Calendar.SafeCalendarHandle cal);
+
+			[UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
+			internal delegate void ucal_clearFieldDelegate(
+				Calendar.SafeCalendarHandle cal,
+				Calendar.UCalendarDateFields field);
+
+			[UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
+			internal delegate Calendar.SafeCalendarHandle ucal_cloneDelegate(
+				Calendar.SafeCalendarHandle cal,
+				out ErrorCode status);
+
+			[UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
+			internal delegate int ucal_getAttributeDelegate(
+				Calendar.SafeCalendarHandle cal,
+				Calendar.UCalendarAttribute attribute,
+				out ErrorCode status);
+
+			[UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
+			internal delegate int ucal_getFieldDifferenceDelegate(
+				Calendar.SafeCalendarHandle cal,
+				double target,
+				Calendar.UCalendarDateFields field,
+				out ErrorCode status);
+
+			[UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
+			internal delegate double ucal_getMillisDelegate(
+				Calendar.SafeCalendarHandle cal,
+				out ErrorCode status);
+
+			[UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
+			internal delegate double ucal_getNowDelegate();
+
+			[UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
+			internal delegate int ucal_getTimeZoneDisplayNameDelegate(
+				Calendar.SafeCalendarHandle cal,
+				Calendar.UCalendarDisplayNameType type,
+				[MarshalAs(UnmanagedType.LPStr)] string locale,
+				IntPtr result,
+				int resultLength,
+				out ErrorCode status);
+
+			[UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
+			internal delegate bool ucal_inDaylightTimeDelegate(
+				Calendar.SafeCalendarHandle cal,
+				out ErrorCode status);
+
+			[UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
+			internal delegate void ucal_setDelegate(
+				Calendar.SafeCalendarHandle cal,
+				Calendar.UCalendarDateFields field,
+				int value);
+
+			[UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
+			internal delegate bool ucal_isSetDelegate(
+				Calendar.SafeCalendarHandle cal,
+				Calendar.UCalendarDateFields field);
+
+			[UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
+			internal delegate void ucal_setAttributeDelegate(
+				Calendar.SafeCalendarHandle cal,
+				Calendar.UCalendarAttribute attr,
+				int newValue);
+
+			[UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
+			internal delegate void ucal_setDateTimeDelegate(
+				Calendar.SafeCalendarHandle cal,
+				int year, int month, int date,
+				out ErrorCode status);
+
+			[UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
+			internal delegate void ucal_setMillisDelegate(
+				Calendar.SafeCalendarHandle cal,
+				double dateTime,
+				out ErrorCode status);
+
+
+			internal ucal_openDelegate ucal_open;
+			internal ucal_closeDelegate ucal_close;
+			internal ucal_setTimeZoneDelegate ucal_setTimeZone;
+			internal ucal_getTimeZoneIdDelegate ucal_getTimeZoneId;
+			internal ucal_addDelegate ucal_add;
+			internal ucal_rollDelegate ucal_roll;
+			internal ucal_getDelegate ucal_get;
+			internal ucal_clearDelegate ucal_clear;
+			internal ucal_clearFieldDelegate ucal_clearField;
+			internal ucal_cloneDelegate ucal_clone;
+			internal ucal_getAttributeDelegate ucal_getAttribute;
+			internal ucal_getFieldDifferenceDelegate ucal_getFieldDifference;
+			internal ucal_getMillisDelegate ucal_getMillis;
+			internal ucal_getNowDelegate ucal_getNow;
+			internal ucal_getTimeZoneDisplayNameDelegate ucal_getTimeZoneDisplayName;
+			internal ucal_inDaylightTimeDelegate ucal_inDaylightTime;
+			internal ucal_setDelegate ucal_set;
+			internal ucal_isSetDelegate ucal_isSet;
+			internal ucal_setAttributeDelegate ucal_setAttribute;
+			internal ucal_setDateTimeDelegate ucal_setDateTime;
+			internal ucal_setMillisDelegate ucal_setMillis;
+		}
+
+		private static CalendarMehodsContainer _CalendarMethods;
+
+		private static CalendarMehodsContainer CalendarMethods =>
+			_CalendarMethods ??
+			(_CalendarMethods = new CalendarMehodsContainer());
+
+		#region Calendar
+
+
+		public static void ucal_setTimeZone(
+				Calendar.SafeCalendarHandle cal,
+				string zoneID,
+				int len,
+				out ErrorCode ec)
+		{
+			if (CalendarMethods.ucal_setTimeZone == null)
+				CalendarMethods.ucal_setTimeZone = GetMethod<CalendarMehodsContainer.ucal_setTimeZoneDelegate>(IcuI18NLibHandle, "ucal_setTimeZone");
+			CalendarMethods.ucal_setTimeZone(cal, zoneID, len, out ec);
+		}
+
+		public static int ucal_getTimeZoneId(
+			Calendar.SafeCalendarHandle cal,
+			out string result,
+			int resultLength,
+			out ErrorCode ec)
+		{
+			if (CalendarMethods.ucal_getTimeZoneId == null)
+				CalendarMethods.ucal_getTimeZoneId = GetMethod<CalendarMehodsContainer.ucal_getTimeZoneIdDelegate>(IcuI18NLibHandle, "ucal_getTimeZoneID");
+
+			IntPtr outBuf = Marshal.AllocHGlobal(resultLength * sizeof(char));
+			try
+			{
+				int length = CalendarMethods.ucal_getTimeZoneId(cal, outBuf, resultLength, out ec);
+				char[] buf = new char[Math.Min(resultLength, length)];
+				Marshal.Copy(outBuf, buf, 0, buf.Length);
+				result = new string(buf);
+				return length;
+			}
+			finally
+			{
+				Marshal.FreeHGlobal(outBuf);
+			}
+		}
+
+		public static Calendar.SafeCalendarHandle ucal_open(
+			   string zoneID,
+			   string locale,
+			   Calendar.UCalendarType type,
+			   out ErrorCode status)
+		{
+			if (CalendarMethods.ucal_open == null)
+				CalendarMethods.ucal_open = GetMethod<CalendarMehodsContainer.ucal_openDelegate>(IcuI18NLibHandle, "ucal_open");
+			return CalendarMethods.ucal_open(zoneID, zoneID.Length, locale, type, out status);
+		}
+
+		public static void ucal_close(IntPtr cal)
+		{
+			if (CalendarMethods.ucal_close == null)
+				CalendarMethods.ucal_close = GetMethod<CalendarMehodsContainer.ucal_closeDelegate>(IcuI18NLibHandle, "ucal_close");
+			CalendarMethods.ucal_close(cal);
+		}
+
+
+		public static void ucal_add(
+				Calendar.SafeCalendarHandle cal,
+				Calendar.UCalendarDateFields field,
+				int amount,
+				out ErrorCode status)
+		{
+			if (CalendarMethods.ucal_add == null)
+				CalendarMethods.ucal_add = GetMethod<CalendarMehodsContainer.ucal_addDelegate>(IcuI18NLibHandle, "ucal_add");
+			CalendarMethods.ucal_add(cal, field, amount, out status);
+		}
+		public static void ucal_roll(
+		Calendar.SafeCalendarHandle cal,
+		Calendar.UCalendarDateFields field,
+		int amount,
+		out ErrorCode status)
+		{
+			if (CalendarMethods.ucal_roll == null)
+				CalendarMethods.ucal_roll = GetMethod<CalendarMehodsContainer.ucal_rollDelegate>(IcuI18NLibHandle, "ucal_roll");
+			CalendarMethods.ucal_roll(cal, field, amount, out status);
+		}
+
+		public static int ucal_get(
+				Calendar.SafeCalendarHandle cal,
+				Calendar.UCalendarDateFields field,
+				out ErrorCode status)
+		{
+			if (CalendarMethods.ucal_get == null)
+				CalendarMethods.ucal_get = GetMethod<CalendarMehodsContainer.ucal_getDelegate>(IcuI18NLibHandle, "ucal_get");
+			return CalendarMethods.ucal_get(cal, field, out status);
+		}
+
+		public static int ucal_getAttribute(
+				Calendar.SafeCalendarHandle cal,
+				Calendar.UCalendarAttribute attribute,
+				out ErrorCode status)
+		{
+			if (CalendarMethods.ucal_getAttribute == null)
+				CalendarMethods.ucal_getAttribute = GetMethod<CalendarMehodsContainer.ucal_getAttributeDelegate>(IcuI18NLibHandle, "ucal_getAttribute");
+			return CalendarMethods.ucal_getAttribute(cal, attribute, out status);
+		}
+
+		public static void ucal_clear(
+		Calendar.SafeCalendarHandle cal)
+		{
+			if (CalendarMethods.ucal_clear == null)
+				CalendarMethods.ucal_clear = GetMethod<CalendarMehodsContainer.ucal_clearDelegate>(IcuI18NLibHandle, "ucal_clear");
+			CalendarMethods.ucal_clear(cal);
+		}
+
+		public static void ucal_clearField(
+		Calendar.SafeCalendarHandle cal,
+		Calendar.UCalendarDateFields field)
+		{
+			if (CalendarMethods.ucal_clearField == null)
+				CalendarMethods.ucal_clearField = GetMethod<CalendarMehodsContainer.ucal_clearFieldDelegate>(IcuI18NLibHandle, "ucal_clearField");
+			CalendarMethods.ucal_clearField(cal, field);
+		}
+
+		public static Calendar.SafeCalendarHandle ucal_clone(Calendar.SafeCalendarHandle cal, out ErrorCode status)
+		{
+			if (CalendarMethods.ucal_clone == null)
+				CalendarMethods.ucal_clone = GetMethod<CalendarMehodsContainer.ucal_cloneDelegate>(IcuI18NLibHandle, "ucal_clone");
+			return CalendarMethods.ucal_clone(cal, out status);
+		}
+
+		public static int ucal_getFieldDifference(
+				Calendar.SafeCalendarHandle cal,
+				double target,
+				Calendar.UCalendarDateFields field,
+				out ErrorCode status)
+		{
+			if (CalendarMethods.ucal_getFieldDifference == null)
+				CalendarMethods.ucal_getFieldDifference = GetMethod<CalendarMehodsContainer.ucal_getFieldDifferenceDelegate>(IcuI18NLibHandle, "ucal_getFieldDifference");
+			return CalendarMethods.ucal_getFieldDifference(cal, target, field, out status);
+		}
+
+		public static double ucal_getMillis(
+				Calendar.SafeCalendarHandle cal,
+				out ErrorCode status)
+		{
+			if (CalendarMethods.ucal_getMillis == null)
+				CalendarMethods.ucal_getMillis = GetMethod<CalendarMehodsContainer.ucal_getMillisDelegate>(IcuI18NLibHandle, "ucal_getMillis");
+			return CalendarMethods.ucal_getMillis(cal, out status);
+		}
+
+		public static double ucal_getNow()
+		{
+			if (CalendarMethods.ucal_getNow == null)
+				CalendarMethods.ucal_getNow = GetMethod<CalendarMehodsContainer.ucal_getNowDelegate>(IcuI18NLibHandle, "ucal_getNow");
+			return CalendarMethods.ucal_getNow();
+		}
+
+		public static int ucal_getTimeZoneDisplayName(
+					Calendar.SafeCalendarHandle cal,
+					Calendar.UCalendarDisplayNameType type,
+					string locale,
+					out string result,
+					int resultLength,
+					out ErrorCode status)
+		{
+			if (CalendarMethods.ucal_getTimeZoneDisplayName == null)
+				CalendarMethods.ucal_getTimeZoneDisplayName = GetMethod<CalendarMehodsContainer.ucal_getTimeZoneDisplayNameDelegate>(IcuI18NLibHandle, "ucal_getTimeZoneDisplayName");
+
+			IntPtr outBuf = Marshal.AllocHGlobal(resultLength * sizeof(char));
+			try
+			{
+				int length = CalendarMethods.ucal_getTimeZoneDisplayName(cal, type, locale, outBuf, resultLength, out status);
+				char[] buf = new char[Math.Min(resultLength, length)];
+				Marshal.Copy(outBuf, buf, 0, buf.Length);
+				result = new string(buf);
+				return length;
+			}
+			finally
+			{
+				Marshal.FreeHGlobal(outBuf);
+			}
+		}
+
+		public static bool ucal_inDaylightTime(
+				Calendar.SafeCalendarHandle cal,
+				out ErrorCode status)
+		{
+			if (CalendarMethods.ucal_inDaylightTime == null)
+				CalendarMethods.ucal_inDaylightTime = GetMethod<CalendarMehodsContainer.ucal_inDaylightTimeDelegate>(IcuI18NLibHandle, "ucal_inDaylightTime");
+			return CalendarMethods.ucal_inDaylightTime(cal, out status);
+		}
+
+
+		public static void ucal_set(
+				Calendar.SafeCalendarHandle cal,
+				Calendar.UCalendarDateFields field,
+				int value)
+		{
+			if (CalendarMethods.ucal_set == null)
+				CalendarMethods.ucal_set = GetMethod<CalendarMehodsContainer.ucal_setDelegate>(IcuI18NLibHandle, "ucal_set");
+			CalendarMethods.ucal_set(cal, field, value);
+		}
+		public static bool ucal_isSet(
+				Calendar.SafeCalendarHandle cal,
+				Calendar.UCalendarDateFields field)
+		{
+			if (CalendarMethods.ucal_isSet == null)
+				CalendarMethods.ucal_isSet = GetMethod<CalendarMehodsContainer.ucal_isSetDelegate>(IcuI18NLibHandle, "ucal_isSet");
+			return CalendarMethods.ucal_isSet(cal, field);
+		}
+
+		public static void ucal_setAttribute(
+				Calendar.SafeCalendarHandle cal,
+				Calendar.UCalendarAttribute attr,
+				int newValue)
+		{
+			if (CalendarMethods.ucal_setAttribute == null)
+				CalendarMethods.ucal_setAttribute = GetMethod<CalendarMehodsContainer.ucal_setAttributeDelegate>(IcuI18NLibHandle, "ucal_setAttribute");
+			CalendarMethods.ucal_setAttribute(cal, attr, newValue);
+		}
+
+		public static void ucal_setDateTime(
+				Calendar.SafeCalendarHandle cal,
+				int year, int month, int date,
+				out ErrorCode status)
+		{
+			if (CalendarMethods.ucal_setDateTime == null)
+				CalendarMethods.ucal_setDateTime = GetMethod<CalendarMehodsContainer.ucal_setDateTimeDelegate>(IcuI18NLibHandle, "ucal_setDateTime");
+			CalendarMethods.ucal_setDateTime(cal, year, month, date, out status);
+		}
+
+		public static void ucal_setMillis(
+				Calendar.SafeCalendarHandle cal,
+				double dateTime,
+				out ErrorCode status)
+		{
+			if (CalendarMethods.ucal_setMillis == null)
+				CalendarMethods.ucal_setMillis = GetMethod<CalendarMehodsContainer.ucal_setMillisDelegate>(IcuI18NLibHandle, "ucal_setMillis");
+			CalendarMethods.ucal_setMillis(cal, dateTime, out status);
+		}
+
+		#endregion
+	}
+}