//
// In order to convert some functionality to Visual C#, the Java Language Conversion Assistant
// creates "support classes" that duplicate the original functionality.
//
// Support classes replicate the functionality of the original code, but in some cases they are
// substantially different architecturally. Although every effort is made to preserve the
// original architecture of the application in the converted project, the user should be aware that
// the primary goal of these support classes is to replicate functionality, and that at times
// the architecture of the resulting solution may differ somewhat.
//
// Included in SQLite3 port to C# for use in testharness only;  2008 Noah B Hart
//$Header$

using System;
using System.Collections;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Threading;

/// <summary>
/// This interface should be implemented by any class whose instances are intended
/// to be executed by a thread.
/// </summary>
public interface IThreadRunnable
{
  /// <summary>
  /// This method has to be implemented in order that starting of the thread causes the object's
  /// run method to be called in that separately executing thread.
  /// </summary>
  void Run();
}

/// <summary>
/// Contains conversion support elements such as classes, interfaces and static methods.
/// </summary>
public class SupportClass
{
  /// <summary>
  /// Support class used to handle threads
  /// </summary>
  public class ThreadClass : IThreadRunnable
  {
    /// <summary>
    /// The instance of Thread
    /// </summary>
    private Thread threadField;

    /// <summary>
    /// Initializes a new instance of the ThreadClass class
    /// </summary>
    public ThreadClass()
    {
      threadField = new Thread( new ThreadStart( Run ) );
    }

    /// <summary>
    /// Initializes a new instance of the Thread class.
    /// </summary>
    /// <param name="Name">The name of the thread</param>
    public ThreadClass( string Name )
    {
      threadField = new Thread( new ThreadStart( Run ) );
      this.Name = Name;
    }

    /// <summary>
    /// Initializes a new instance of the Thread class.
    /// </summary>
    /// <param name="Start">A ThreadStart delegate that references the methods to be invoked when this thread begins executing</param>
    public ThreadClass( ThreadStart Start )
    {
      threadField = new Thread( Start );
    }

    /// <summary>
    /// Initializes a new instance of the Thread class.
    /// </summary>
    /// <param name="Start">A ThreadStart delegate that references the methods to be invoked when this thread begins executing</param>
    /// <param name="Name">The name of the thread</param>
    public ThreadClass( ThreadStart Start, string Name )
    {
      threadField = new Thread( Start );
      this.Name = Name;
    }

    /// <summary>
    /// This method has no functionality unless the method is overridden
    /// </summary>
    public virtual void Run()
    {
    }

    /// <summary>
    /// Causes the operating system to change the state of the current thread instance to ThreadState.Running
    /// </summary>
    public void Start()
    {
      threadField.Start();
    }

    /// <summary>
    /// Interrupts a thread that is in the WaitSleepJoin thread state
    /// </summary>
    public void Interrupt()
    {
      threadField.Interrupt();
    }

    /// <summary>
    /// Gets the current thread instance
    /// </summary>
    public Thread Instance
    {
      get
      {
        return threadField;
      }
      set
      {
        threadField = value;
      }
    }

    /// <summary>
    /// Gets or sets the name of the thread
    /// </summary>
    public string Name
    {
      get
      {
        return threadField.Name;
      }
      set
      {
        if ( threadField.Name == null )
          threadField.Name = value;
      }
    }

    /// <summary>
    /// Gets or sets a value indicating the scheduling priority of a thread
    /// </summary>
    public ThreadPriority Priority
    {
      get
      {
        return threadField.Priority;
      }
      set
      {
        threadField.Priority = value;
      }
    }

    /// <summary>
    /// Gets a value indicating the execution status of the current thread
    /// </summary>
    public bool IsAlive
    {
      get
      {
        return threadField.IsAlive;
      }
    }

    /// <summary>
    /// Gets or sets a value indicating whether or not a thread is a background thread.
    /// </summary>
    public bool IsBackground
    {
      get
      {
        return threadField.IsBackground;
      }
      set
      {
        threadField.IsBackground = value;
      }
    }

    /// <summary>
    /// Blocks the calling thread until a thread terminates
    /// </summary>
    public void Join()
    {
      threadField.Join();
    }

    /// <summary>
    /// Blocks the calling thread until a thread terminates or the specified time elapses
    /// </summary>
    /// <param name="MiliSeconds">Time of wait in milliseconds</param>
    public void Join( long MiliSeconds )
    {
      lock ( this )
      {
        threadField.Join( new TimeSpan( MiliSeconds * 10000 ) );
      }
    }

    /// <summary>
    /// Blocks the calling thread until a thread terminates or the specified time elapses
    /// </summary>
    /// <param name="MiliSeconds">Time of wait in milliseconds</param>
    /// <param name="NanoSeconds">Time of wait in nanoseconds</param>
    public void Join( long MiliSeconds, int NanoSeconds )
    {
      lock ( this )
      {
        threadField.Join( new TimeSpan( MiliSeconds * 10000 + NanoSeconds * 100 ) );
      }
    }

    /// <summary>
    /// Resumes a thread that has been suspended
    /// </summary>
    public void Resume()
    {
      threadField.Resume();
    }

    /// <summary>
    /// Raises a ThreadAbortException in the thread on which it is invoked,
    /// to begin the process of terminating the thread. Calling this method
    /// usually terminates the thread
    /// </summary>
    public void Abort()
    {
      threadField.Abort();
    }

    /// <summary>
    /// Raises a ThreadAbortException in the thread on which it is invoked,
    /// to begin the process of terminating the thread while also providing
    /// exception information about the thread termination.
    /// Calling this method usually terminates the thread.
    /// </summary>
    /// <param name="stateInfo">An object that contains application-specific information, such as state, which can be used by the thread being aborted</param>
    public void Abort( Object stateInfo )
    {
      lock ( this )
      {
        threadField.Abort( stateInfo );
      }
    }

    /// <summary>
    /// Suspends the thread, if the thread is already suspended it has no effect
    /// </summary>
    public void Suspend()
    {
      threadField.Suspend();
    }

    /// <summary>
    /// Obtain a String that represents the current Object
    /// </summary>
    /// <returns>A String that represents the current Object</returns>
    public override string ToString()
    {
      return "Thread[" + Name + "," + Priority.ToString() + "," + "" + "]";
    }

    /// <summary>
    /// Gets the currently running thread
    /// </summary>
    /// <returns>The currently running thread</returns>
    public static ThreadClass Current()
    {
      ThreadClass CurrentThread = new ThreadClass();
      CurrentThread.Instance = Thread.CurrentThread;
      return CurrentThread;
    }
  }


  /*******************************/
  /// <summary>
  /// Removes the first occurrence of an specific object from an ArrayList instance.
  /// </summary>
  /// <param name="arrayList">The ArrayList instance</param>
  /// <param name="element">The element to remove</param>
  /// <returns>True if item is found in the ArrayList; otherwise, false</returns>
  public static Boolean VectorRemoveElement( ArrayList arrayList, Object element )
  {
    Boolean containsItem = arrayList.Contains( element );
    arrayList.Remove( element );
    return containsItem;
  }

  /*******************************/
  /// <summary>
  /// Converts an array of sbytes to an array of bytes
  /// </summary>
  /// <param name="sbyteArray">The array of sbytes to be converted</param>
  /// <returns>The new array of bytes</returns>
  public static byte[] ToByteArray( sbyte[] sbyteArray )
  {
    byte[] byteArray = new byte[sbyteArray.Length];
    for ( int index = 0; index < sbyteArray.Length; index++ )
      byteArray[index] = (byte)sbyteArray[index];
    return byteArray;
  }

  /// <summary>
  /// Converts a string to an array of bytes
  /// </summary>
  /// <param name="sourceString">The string to be converted</param>
  /// <returns>The new array of bytes</returns>
  public static byte[] ToByteArray( string sourceString )
  {
    byte[] byteArray = new byte[sourceString.Length];
    for ( int index = 0; index < sourceString.Length; index++ )
      byteArray[index] = (byte)sourceString[index];
    return byteArray;
  }

  /// <summary>
  /// Converts a array of object-type instances to a byte-type array.
  /// </summary>
  /// <param name="tempObjectArray">Array to convert.</param>
  /// <returns>An array of byte type elements.</returns>
  public static byte[] ToByteArray( object[] tempObjectArray )
  {
    byte[] byteArray = new byte[tempObjectArray.Length];
    for ( int index = 0; index < tempObjectArray.Length; index++ )
      byteArray[index] = (byte)tempObjectArray[index];
    return byteArray;
  }


  /*******************************/
  /// <summary>
  /// This method returns the literal value received
  /// </summary>
  /// <param name="literal">The literal to return</param>
  /// <returns>The received value</returns>
  public static long Identity( long literal )
  {
    return literal;
  }

  /// <summary>
  /// This method returns the literal value received
  /// </summary>
  /// <param name="literal">The literal to return</param>
  /// <returns>The received value</returns>
  public static ulong Identity( ulong literal )
  {
    return literal;
  }

  /// <summary>
  /// This method returns the literal value received
  /// </summary>
  /// <param name="literal">The literal to return</param>
  /// <returns>The received value</returns>
  public static float Identity( float literal )
  {
    return literal;
  }

  /// <summary>
  /// This method returns the literal value received
  /// </summary>
  /// <param name="literal">The literal to return</param>
  /// <returns>The received value</returns>
  public static double Identity( double literal )
  {
    return literal;
  }

  /*******************************/
  /// <summary>
  /// Copies an array of chars obtained from a String into a specified array of chars
  /// </summary>
  /// <param name="sourceString">The String to get the chars from</param>
  /// <param name="sourceStart">Position of the String to start getting the chars</param>
  /// <param name="sourceEnd">Position of the String to end getting the chars</param>
  /// <param name="destinationArray">Array to return the chars</param>
  /// <param name="destinationStart">Position of the destination array of chars to start storing the chars</param>
  /// <returns>An array of chars</returns>
  public static void GetCharsFromString( string sourceString, int sourceStart, int sourceEnd, ref char[] destinationArray, int destinationStart )
  {
    int sourceCounter;
    int destinationCounter;
    sourceCounter = sourceStart;
    destinationCounter = destinationStart;
    while ( sourceCounter < sourceEnd )
    {
      destinationArray[destinationCounter] = (char)sourceString[sourceCounter];
      sourceCounter++;
      destinationCounter++;
    }
  }

  /*******************************/
  /// <summary>
  /// This class manages different issues for calendars.
  /// The different calendars are internally managed using a hash table structure.
  /// </summary>
  public class CalendarManager
  {
    /// <summary>
    /// Field number for get and set indicating the year.
    /// </summary>
    public const int YEAR = 0;

    /// <summary>
    /// Field number for get and set indicating the month.
    /// </summary>
    public const int MONTH = 1;

    /// <summary>
    /// Field number for get and set indicating the day of the month.
    /// </summary>
    public const int DATE = 2;

    /// <summary>
    /// Field number for get and set indicating the hour of the morning or afternoon.
    /// </summary>
    public const int HOUR = 3;

    /// <summary>
    /// Field number for get and set indicating the minute within the hour.
    /// </summary>
    public const int MINUTE = 4;

    /// <summary>
    /// Field number for get and set indicating the second within the minute.
    /// </summary>
    public const int SECOND = 5;

    /// <summary>
    /// Field number for get and set indicating the millisecond within the second.
    /// </summary>
    public const int MILLISECOND = 6;

    /// <summary>
    /// Field number for get and set indicating the day of the month.
    /// </summary>
    public const int DAY_OF_MONTH = 7;

    /// <summary>
    /// Field used to get or set the day of the week.
    /// </summary>
    public const int DAY_OF_WEEK = 8;

    /// <summary>
    /// Field number for get and set indicating the hour of the day.
    /// </summary>
    public const int HOUR_OF_DAY = 9;

    /// <summary>
    /// Field number for get and set indicating whether the HOUR is before or after noon.
    /// </summary>
    public const int AM_PM = 10;

    /// <summary>
    /// Value of the AM_PM field indicating the period of the day from midnight to just
    /// before noon.
    /// </summary>
    public const int AM = 11;

    /// <summary>
    /// Value of the AM_PM field indicating the period of the day from noon to just before midnight.
    /// </summary>
    public const int PM = 12;

    /// <summary>
    /// The hash table that contains the type of calendars and its properties.
    /// </summary>
    static public CalendarHashTable manager = new CalendarHashTable();

    /// <summary>
    /// Internal class that inherits from HashTable to manage the different calendars.
    /// This structure will contain an instance of Calendar that represents
    /// a type of calendar and its properties (represented by an instance of CalendarProperties
    /// class).
    /// </summary>
    public class CalendarHashTable : Hashtable
    {
      /// <summary>
      /// Gets the calendar current date and time.
      /// </summary>
      /// <param name="calendar">The calendar to get its current date and time.</param>
      /// <returns>A DateTime value that indicates the current date and time for the
      /// calendar given.</returns>
      public DateTime GetDateTime( Calendar calendar )
      {
        if ( this[calendar] != null )
          return ( (CalendarProperties)this[calendar] ).dateTime;
        else
        {
          CalendarProperties tempProps = new CalendarProperties();
          tempProps.dateTime = DateTime.Now;
          this.Add( calendar, tempProps );
          return this.GetDateTime( calendar );
        }
      }

      /// <summary>
      /// Sets the specified DateTime value to the specified calendar.
      /// </summary>
      /// <param name="calendar">The calendar to set its date.</param>
      /// <param name="date">The DateTime value to set to the calendar.</param>
      public void SetDateTime( Calendar calendar, DateTime date )
      {
        if ( this[calendar] != null )
        {
          ( (CalendarProperties)this[calendar] ).dateTime = date;
        }
        else
        {
          CalendarProperties tempProps = new CalendarProperties();
          tempProps.dateTime = date;
          this.Add( calendar, tempProps );
        }
      }

      /// <summary>
      /// Sets the corresponding field in an specified calendar with the value given.
      /// If the specified calendar does not have exist in the hash table, it creates a
      /// new instance of the calendar with the current date and time and then assings it
      /// the new specified value.
      /// </summary>
      /// <param name="calendar">The calendar to set its date or time.</param>
      /// <param name="field">One of the fields that composes a date/time.</param>
      /// <param name="fieldValue">The value to be set.</param>
      public void Set( Calendar calendar, int field, int fieldValue )
      {
        if ( this[calendar] != null )
        {
          DateTime tempDate = ( (CalendarProperties)this[calendar] ).dateTime;
          switch ( field )
          {
            case CalendarManager.DATE:
              tempDate = tempDate.AddDays( fieldValue - tempDate.Day );
              break;
            case CalendarManager.HOUR:
              tempDate = tempDate.AddHours( fieldValue - tempDate.Hour );
              break;
            case CalendarManager.MILLISECOND:
              tempDate = tempDate.AddMilliseconds( fieldValue - tempDate.Millisecond );
              break;
            case CalendarManager.MINUTE:
              tempDate = tempDate.AddMinutes( fieldValue - tempDate.Minute );
              break;
            case CalendarManager.MONTH:
              //Month value is 0-based. e.g., 0 for January
              tempDate = tempDate.AddMonths( fieldValue - ( tempDate.Month + 1 ) );
              break;
            case CalendarManager.SECOND:
              tempDate = tempDate.AddSeconds( fieldValue - tempDate.Second );
              break;
            case CalendarManager.YEAR:
              tempDate = tempDate.AddYears( fieldValue - tempDate.Year );
              break;
            case CalendarManager.DAY_OF_MONTH:
              tempDate = tempDate.AddDays( fieldValue - tempDate.Day );
              break;
            case CalendarManager.DAY_OF_WEEK:
              ;
              tempDate = tempDate.AddDays( ( fieldValue - 1 ) - (int)tempDate.DayOfWeek );
              break;
            case CalendarManager.HOUR_OF_DAY:
              tempDate = tempDate.AddHours( fieldValue - tempDate.Hour );
              break;

            default:
              break;
          }
          ( (CalendarProperties)this[calendar] ).dateTime = tempDate;
        }
        else
        {
          CalendarProperties tempProps = new CalendarProperties();
          tempProps.dateTime = DateTime.Now;
          this.Add( calendar, tempProps );
          this.Set( calendar, field, fieldValue );
        }
      }

      /// <summary>
      /// Sets the corresponding date (day, month and year) to the calendar specified.
      /// If the calendar does not exist in the hash table, it creates a new instance and sets
      /// its values.
      /// </summary>
      /// <param name="calendar">The calendar to set its date.</param>
      /// <param name="year">Integer value that represent the year.</param>
      /// <param name="month">Integer value that represent the month.</param>
      /// <param name="day">Integer value that represent the day.</param>
      public void Set( Calendar calendar, int year, int month, int day )
      {
        if ( this[calendar] != null )
        {
          this.Set( calendar, CalendarManager.YEAR, year );
          this.Set( calendar, CalendarManager.MONTH, month );
          this.Set( calendar, CalendarManager.DATE, day );
        }
        else
        {
          CalendarProperties tempProps = new CalendarProperties();
          //Month value is 0-based. e.g., 0 for January
          tempProps.dateTime = new DateTime( year, month + 1, day );
          this.Add( calendar, tempProps );
        }
      }

      /// <summary>
      /// Sets the corresponding date (day, month and year) and hour (hour and minute)
      /// to the calendar specified.
      /// If the calendar does not exist in the hash table, it creates a new instance and sets
      /// its values.
      /// </summary>
      /// <param name="calendar">The calendar to set its date and time.</param>
      /// <param name="year">Integer value that represent the year.</param>
      /// <param name="month">Integer value that represent the month.</param>
      /// <param name="day">Integer value that represent the day.</param>
      /// <param name="hour">Integer value that represent the hour.</param>
      /// <param name="minute">Integer value that represent the minutes.</param>
      public void Set( Calendar calendar, int year, int month, int day, int hour, int minute )
      {
        if ( this[calendar] != null )
        {
          this.Set( calendar, CalendarManager.YEAR, year );
          this.Set( calendar, CalendarManager.MONTH, month );
          this.Set( calendar, CalendarManager.DATE, day );
          this.Set( calendar, CalendarManager.HOUR, hour );
          this.Set( calendar, CalendarManager.MINUTE, minute );
        }
        else
        {
          CalendarProperties tempProps = new CalendarProperties();
          //Month value is 0-based. e.g., 0 for January
          tempProps.dateTime = new DateTime( year, month + 1, day, hour, minute, 0 );
          this.Add( calendar, tempProps );
        }
      }

      /// <summary>
      /// Sets the corresponding date (day, month and year) and hour (hour, minute and second)
      /// to the calendar specified.
      /// If the calendar does not exist in the hash table, it creates a new instance and sets
      /// its values.
      /// </summary>
      /// <param name="calendar">The calendar to set its date and time.</param>
      /// <param name="year">Integer value that represent the year.</param>
      /// <param name="month">Integer value that represent the month.</param>
      /// <param name="day">Integer value that represent the day.</param>
      /// <param name="hour">Integer value that represent the hour.</param>
      /// <param name="minute">Integer value that represent the minutes.</param>
      /// <param name="second">Integer value that represent the seconds.</param>
      public void Set( Calendar calendar, int year, int month, int day, int hour, int minute, int second )
      {
        if ( this[calendar] != null )
        {
          this.Set( calendar, CalendarManager.YEAR, year );
          this.Set( calendar, CalendarManager.MONTH, month );
          this.Set( calendar, CalendarManager.DATE, day );
          this.Set( calendar, CalendarManager.HOUR, hour );
          this.Set( calendar, CalendarManager.MINUTE, minute );
          this.Set( calendar, CalendarManager.SECOND, second );
        }
        else
        {
          CalendarProperties tempProps = new CalendarProperties();
          //Month value is 0-based. e.g., 0 for January
          tempProps.dateTime = new DateTime( year, month + 1, day, hour, minute, second );
          this.Add( calendar, tempProps );
        }
      }

      /// <summary>
      /// Gets the value represented by the field specified.
      /// </summary>
      /// <param name="calendar">The calendar to get its date or time.</param>
      /// <param name="field">One of the field that composes a date/time.</param>
      /// <returns>The integer value for the field given.</returns>
      public int Get( Calendar calendar, int field )
      {
        if ( this[calendar] != null )
        {
          int tempHour;
          switch ( field )
          {
            case CalendarManager.DATE:
              return ( (CalendarProperties)this[calendar] ).dateTime.Day;
            case CalendarManager.HOUR:
              tempHour = ( (CalendarProperties)this[calendar] ).dateTime.Hour;
              return tempHour > 12 ? tempHour - 12 : tempHour;
            case CalendarManager.MILLISECOND:
              return ( (CalendarProperties)this[calendar] ).dateTime.Millisecond;
            case CalendarManager.MINUTE:
              return ( (CalendarProperties)this[calendar] ).dateTime.Minute;
            case CalendarManager.MONTH:
              //Month value is 0-based. e.g., 0 for January
              return ( (CalendarProperties)this[calendar] ).dateTime.Month - 1;
            case CalendarManager.SECOND:
              return ( (CalendarProperties)this[calendar] ).dateTime.Second;
            case CalendarManager.YEAR:
              return ( (CalendarProperties)this[calendar] ).dateTime.Year;
            case CalendarManager.DAY_OF_MONTH:
              return ( (CalendarProperties)this[calendar] ).dateTime.Day;
            case CalendarManager.DAY_OF_WEEK:
              return (int)( ( (CalendarProperties)this[calendar] ).dateTime.DayOfWeek );
            case CalendarManager.HOUR_OF_DAY:
              return ( (CalendarProperties)this[calendar] ).dateTime.Hour;
            case CalendarManager.AM_PM:
              tempHour = ( (CalendarProperties)this[calendar] ).dateTime.Hour;
              return tempHour > 12 ? CalendarManager.PM : CalendarManager.AM;

            default:
              return 0;
          }
        }
        else
        {
          CalendarProperties tempProps = new CalendarProperties();
          tempProps.dateTime = DateTime.Now;
          this.Add( calendar, tempProps );
          return this.Get( calendar, field );
        }
      }

      /// <summary>
      /// Sets the time in the specified calendar with the long value.
      /// </summary>
      /// <param name="calendar">The calendar to set its date and time.</param>
      /// <param name="milliseconds">A long value that indicates the milliseconds to be set to
      /// the hour for the calendar.</param>
      public void SetTimeInMilliseconds( Calendar calendar, long milliseconds )
      {
        if ( this[calendar] != null )
        {
          ( (CalendarProperties)this[calendar] ).dateTime = new DateTime( milliseconds );
        }
        else
        {
          CalendarProperties tempProps = new CalendarProperties();
          tempProps.dateTime = new DateTime( TimeSpan.TicksPerMillisecond * milliseconds );
          this.Add( calendar, tempProps );
        }
      }

      /// <summary>
      /// Gets what the first day of the week is; e.g., Sunday in US, Monday in France.
      /// </summary>
      /// <param name="calendar">The calendar to get its first day of the week.</param>
      /// <returns>A DayOfWeek value indicating the first day of the week.</returns>
      public DayOfWeek GetFirstDayOfWeek( Calendar calendar )
      {
        if ( this[calendar] != null && ( (CalendarProperties)this[calendar] ).dateTimeFormat != null )
        {
          return ( (CalendarProperties)this[calendar] ).dateTimeFormat.FirstDayOfWeek;
        }
        else
        {
          CalendarProperties tempProps = new CalendarProperties();
          tempProps.dateTimeFormat = new DateTimeFormatInfo();
          tempProps.dateTimeFormat.FirstDayOfWeek = DayOfWeek.Sunday;
          this.Add( calendar, tempProps );
          return this.GetFirstDayOfWeek( calendar );
        }
      }

      /// <summary>
      /// Sets what the first day of the week is; e.g., Sunday in US, Monday in France.
      /// </summary>
      /// <param name="calendar">The calendar to set its first day of the week.</param>
      /// <param name="firstDayOfWeek">A DayOfWeek value indicating the first day of the week
      /// to be set.</param>
      public void SetFirstDayOfWeek( Calendar calendar, DayOfWeek firstDayOfWeek )
      {
        if ( this[calendar] != null && ( (CalendarProperties)this[calendar] ).dateTimeFormat != null )
        {
          ( (CalendarProperties)this[calendar] ).dateTimeFormat.FirstDayOfWeek = firstDayOfWeek;
        }
        else
        {
          CalendarProperties tempProps = new CalendarProperties();
          tempProps.dateTimeFormat = new DateTimeFormatInfo();
          this.Add( calendar, tempProps );
          this.SetFirstDayOfWeek( calendar, firstDayOfWeek );
        }
      }

      /// <summary>
      /// Removes the specified calendar from the hash table.
      /// </summary>
      /// <param name="calendar">The calendar to be removed.</param>
      public void Clear( Calendar calendar )
      {
        if ( this[calendar] != null )
          this.Remove( calendar );
      }

      /// <summary>
      /// Removes the specified field from the calendar given.
      /// If the field does not exists in the calendar, the calendar is removed from the table.
      /// </summary>
      /// <param name="calendar">The calendar to remove the value from.</param>
      /// <param name="field">The field to be removed from the calendar.</param>
      public void Clear( Calendar calendar, int field )
      {
        if ( this[calendar] != null )
          this.Remove( calendar );
        else
          this.Set( calendar, field, 0 );
      }

      /// <summary>
      /// Internal class that represents the properties of a calendar instance.
      /// </summary>
      class CalendarProperties
      {
        /// <summary>
        /// The date and time of a calendar.
        /// </summary>
        public DateTime dateTime;

        /// <summary>
        /// The format for the date and time in a calendar.
        /// </summary>
        public DateTimeFormatInfo dateTimeFormat;
      }
    }
  }

  /*******************************/
  /// <summary>
  /// Provides support for DateFormat
  /// </summary>
  public class DateTimeFormatManager
  {
    static public DateTimeFormatHashTable manager = new DateTimeFormatHashTable();

    /// <summary>
    /// Hashtable class to provide functionality for dateformat properties
    /// </summary>
    public class DateTimeFormatHashTable : Hashtable
    {
      /// <summary>
      /// Sets the format for datetime.
      /// </summary>
      /// <param name="format">DateTimeFormat instance to set the pattern</param>
      /// <param name="newPattern">A string with the pattern format</param>
      public void SetDateFormatPattern( DateTimeFormatInfo format, string newPattern )
      {
        if ( this[format] != null )
          ( (DateTimeFormatProperties)this[format] ).DateFormatPattern = newPattern;
        else
        {
          DateTimeFormatProperties tempProps = new DateTimeFormatProperties();
          tempProps.DateFormatPattern = newPattern;
          Add( format, tempProps );
        }
      }

      /// <summary>
      /// Gets the current format pattern of the DateTimeFormat instance
      /// </summary>
      /// <param name="format">The DateTimeFormat instance which the value will be obtained</param>
      /// <returns>The string representing the current datetimeformat pattern</returns>
      public string GetDateFormatPattern( DateTimeFormatInfo format )
      {
        if ( this[format] == null )
          return "d-MMM-yy";
        else
          return ( (DateTimeFormatProperties)this[format] ).DateFormatPattern;
      }

      /// <summary>
      /// Sets the datetimeformat pattern to the giving format
      /// </summary>
      /// <param name="format">The datetimeformat instance to set</param>
      /// <param name="newPattern">The new datetimeformat pattern</param>
      public void SetTimeFormatPattern( DateTimeFormatInfo format, string newPattern )
      {
        if ( this[format] != null )
          ( (DateTimeFormatProperties)this[format] ).TimeFormatPattern = newPattern;
        else
        {
          DateTimeFormatProperties tempProps = new DateTimeFormatProperties();
          tempProps.TimeFormatPattern = newPattern;
          Add( format, tempProps );
        }
      }

      /// <summary>
      /// Gets the current format pattern of the DateTimeFormat instance
      /// </summary>
      /// <param name="format">The DateTimeFormat instance which the value will be obtained</param>
      /// <returns>The string representing the current datetimeformat pattern</returns>
      public string GetTimeFormatPattern( DateTimeFormatInfo format )
      {
        if ( this[format] == null )
          return "h:mm:ss tt";
        else
          return ( (DateTimeFormatProperties)this[format] ).TimeFormatPattern;
      }

      /// <summary>
      /// Internal class to provides the DateFormat and TimeFormat pattern properties on .NET
      /// </summary>
      class DateTimeFormatProperties
      {
        public string DateFormatPattern = "d-MMM-yy";
        public string TimeFormatPattern = "h:mm:ss tt";
      }
    }
  }
  /*******************************/
  /// <summary>
  /// Gets the DateTimeFormat instance using the culture passed as parameter and sets the pattern to the time or date depending of the value
  /// </summary>
  /// <param name="dateStyle">The desired date style.</param>
  /// <param name="timeStyle">The desired time style</param>
  /// <param name="culture">The CultureInfo instance used to obtain the DateTimeFormat</param>
  /// <returns>The DateTimeFomatInfo of the culture and with the desired date or time style</returns>
  public static DateTimeFormatInfo GetDateTimeFormatInstance( int dateStyle, int timeStyle, CultureInfo culture )
  {
    DateTimeFormatInfo format = culture.DateTimeFormat;

    switch ( timeStyle )
    {
      case -1:
        DateTimeFormatManager.manager.SetTimeFormatPattern( format, "" );
        break;

      case 0:
        DateTimeFormatManager.manager.SetTimeFormatPattern( format, "h:mm:ss 'o clock' tt zzz" );
        break;

      case 1:
        DateTimeFormatManager.manager.SetTimeFormatPattern( format, "h:mm:ss tt zzz" );
        break;

      case 2:
        DateTimeFormatManager.manager.SetTimeFormatPattern( format, "h:mm:ss tt" );
        break;

      case 3:
        DateTimeFormatManager.manager.SetTimeFormatPattern( format, "h:mm tt" );
        break;
    }

    switch ( dateStyle )
    {
      case -1:
        DateTimeFormatManager.manager.SetDateFormatPattern( format, "" );
        break;

      case 0:
        DateTimeFormatManager.manager.SetDateFormatPattern( format, "dddd, MMMM dd%, yyy" );
        break;

      case 1:
        DateTimeFormatManager.manager.SetDateFormatPattern( format, "MMMM dd%, yyy" );
        break;

      case 2:
        DateTimeFormatManager.manager.SetDateFormatPattern( format, "d-MMM-yy" );
        break;

      case 3:
        DateTimeFormatManager.manager.SetDateFormatPattern( format, "M/dd/yy" );
        break;
    }

    return format;
  }

  /*******************************/
  /// <summary>
  /// Gets the DateTimeFormat instance and date instance to obtain the date with the format passed
  /// </summary>
  /// <param name="format">The DateTimeFormat to obtain the time and date pattern</param>
  /// <param name="date">The date instance used to get the date</param>
  /// <returns>A string representing the date with the time and date patterns</returns>
  public static string FormatDateTime( DateTimeFormatInfo format, DateTime date )
  {
    string timePattern = DateTimeFormatManager.manager.GetTimeFormatPattern( format );
    string datePattern = DateTimeFormatManager.manager.GetDateFormatPattern( format );
    return date.ToString( datePattern + " " + timePattern, format );
  }

  /*******************************/
  /// <summary>
  /// Adds a new key-and-value pair into the hash table
  /// </summary>
  /// <param name="collection">The collection to work with</param>
  /// <param name="key">Key used to obtain the value</param>
  /// <param name="newValue">Value asociated with the key</param>
  /// <returns>The old element associated with the key</returns>
  public static Object PutElement( IDictionary collection, Object key, Object newValue )
  {
    Object element = collection[key];
    collection[key] = newValue;
    return element;
  }

  /*******************************/
  /// <summary>
  /// Provides support functions to create read-write random acces files and write functions
  /// </summary>
  public class RandomAccessFileSupport
  {
    /// <summary>
    /// Creates a new random acces stream with read-write or read rights
    /// </summary>
    /// <param name="fileName">A relative or absolute path for the file to open</param>
    /// <param name="mode">Mode to open the file in</param>
    /// <returns>The new FileStream</returns>
    public static FileStream CreateRandomAccessFile( string fileName, string mode )
    {
      FileStream newFile = null;

      if ( mode.CompareTo( "rw" ) == 0 )
        newFile = new FileStream( fileName, FileMode.OpenOrCreate, FileAccess.ReadWrite );
      else if ( mode.CompareTo( "r" ) == 0 )
        newFile = new FileStream( fileName, FileMode.Open, FileAccess.Read );
      else
        throw new ArgumentException();

      return newFile;
    }

    /// <summary>
    /// Creates a new random acces stream with read-write or read rights
    /// </summary>
    /// <param name="fileName">File infomation for the file to open</param>
    /// <param name="mode">Mode to open the file in</param>
    /// <returns>The new FileStream</returns>
    public static FileStream CreateRandomAccessFile( FileInfo fileName, string mode )
    {
      return CreateRandomAccessFile( fileName.FullName, mode );
    }

    /// <summary>
    /// Writes the data to the specified file stream
    /// </summary>
    /// <param name="data">Data to write</param>
    /// <param name="fileStream">File to write to</param>
    public static void WriteBytes( string data, FileStream fileStream )
    {
      int index = 0;
      int length = data.Length;

      while ( index < length )
        fileStream.WriteByte( (byte)data[index++] );
    }

    /// <summary>
    /// Writes the received string to the file stream
    /// </summary>
    /// <param name="data">String of information to write</param>
    /// <param name="fileStream">File to write to</param>
    public static void WriteChars( string data, FileStream fileStream )
    {
      WriteBytes( data, fileStream );
    }

    /// <summary>
    /// Writes the received data to the file stream
    /// </summary>
    /// <param name="sByteArray">Data to write</param>
    /// <param name="fileStream">File to write to</param>
    public static void WriteRandomFile( sbyte[] sByteArray, FileStream fileStream )
    {
      byte[] byteArray = ToByteArray( sByteArray );
      fileStream.Write( byteArray, 0, byteArray.Length );
    }
  }

  /*******************************/
  /// <summary>
  /// Checks if a file have write permissions
  /// </summary>
  /// <param name="file">The file instance to check</param>
  /// <returns>True if have write permissions otherwise false</returns>
  public static bool FileCanWrite( FileInfo file )
  {
    return ( File.GetAttributes( file.FullName ) & FileAttributes.ReadOnly ) != FileAttributes.ReadOnly;
  }

  /*******************************/
  /// <summary>
  /// Checks if the giving File instance is a directory or file, and returns his Length
  /// </summary>
  /// <param name="file">The File instance to check</param>
  /// <returns>The length of the file</returns>
  public static long FileLength( FileInfo file )
  {
    if ( Directory.Exists( file.FullName ) )
      return 0;
    else
      return file.Length;
  }

  /*******************************/
  /// <summary>Reads a number of characters from the current source Stream and writes the data to the target array at the specified index.</summary>
  /// <param name="sourceStream">The source Stream to read from.</param>
  /// <param name="target">Contains the array of characteres read from the source Stream.</param>
  /// <param name="start">The starting index of the target array.</param>
  /// <param name="count">The maximum number of characters to read from the source Stream.</param>
  /// <returns>The number of characters read. The number will be less than or equal to count depending on the data available in the source Stream. Returns -1 if the end of the stream is reached.</returns>
  public static Int32 ReadInput( Stream sourceStream, ref byte[] target, int start, int count )
  {
    // Returns 0 bytes if not enough space in target
    if ( target.Length == 0 )
      return 0;

    byte[] receiver = new byte[target.Length];
    int bytesRead = sourceStream.Read( receiver, start, count );

    // Returns -1 if EOF
    if ( bytesRead == 0 )
      return -1;

    for ( int i = start; i < start + bytesRead; i++ )
      target[i] = (byte)receiver[i];

    return bytesRead;
  }

  /// <summary>Reads a number of characters from the current source TextReader and writes the data to the target array at the specified index.</summary>
  /// <param name="sourceTextReader">The source TextReader to read from</param>
  /// <param name="target">Contains the array of characteres read from the source TextReader.</param>
  /// <param name="start">The starting index of the target array.</param>
  /// <param name="count">The maximum number of characters to read from the source TextReader.</param>
  /// <returns>The number of characters read. The number will be less than or equal to count depending on the data available in the source TextReader. Returns -1 if the end of the stream is reached.</returns>
  public static Int32 ReadInput( TextReader sourceTextReader, ref sbyte[] target, int start, int count )
  {
    // Returns 0 bytes if not enough space in target
    if ( target.Length == 0 )
      return 0;

    char[] charArray = new char[target.Length];
    int bytesRead = sourceTextReader.Read( charArray, start, count );

    // Returns -1 if EOF
    if ( bytesRead == 0 )
      return -1;

    for ( int index = start; index < start + bytesRead; index++ )
      target[index] = (sbyte)charArray[index];

    return bytesRead;
  }

  /*******************************/
  /// <summary>
  /// Performs an unsigned bitwise right shift with the specified number
  /// </summary>
  /// <param name="number">Number to operate on</param>
  /// <param name="bits">Ammount of bits to shift</param>
  /// <returns>The resulting number from the shift operation</returns>
  public static int URShift( int number, int bits )
  {
    if ( number >= 0 )
      return number >> bits;
    else
      return ( number >> bits ) + ( 2 << ~bits );
  }

  /// <summary>
  /// Performs an unsigned bitwise right shift with the specified number
  /// </summary>
  /// <param name="number">Number to operate on</param>
  /// <param name="bits">Ammount of bits to shift</param>
  /// <returns>The resulting number from the shift operation</returns>
  public static int URShift( int number, long bits )
  {
    return URShift( number, (int)bits );
  }

  /// <summary>
  /// Performs an unsigned bitwise right shift with the specified number
  /// </summary>
  /// <param name="number">Number to operate on</param>
  /// <param name="bits">Ammount of bits to shift</param>
  /// <returns>The resulting number from the shift operation</returns>
  public static long URShift( long number, int bits )
  {
    if ( number >= 0 )
      return number >> bits;
    else
      return ( number >> bits ) + ( 2L << ~bits );
  }

  /// <summary>
  /// Performs an unsigned bitwise right shift with the specified number
  /// </summary>
  /// <param name="number">Number to operate on</param>
  /// <param name="bits">Ammount of bits to shift</param>
  /// <returns>The resulting number from the shift operation</returns>
  public static long URShift( long number, long bits )
  {
    return URShift( number, (int)bits );
  }

  /*******************************/
  /// <summary>
  /// Writes the exception stack trace to the received stream
  /// </summary>
  /// <param name="throwable">Exception to obtain information from</param>
  /// <param name="stream">Output sream used to write to</param>
  public static void WriteStackTrace( Exception throwable, TextWriter stream )
  {
    stream.Write( throwable.StackTrace );
    stream.Flush();
  }

  /*******************************/
  /// <summary>
  /// Removes the element with the specified key from a Hashtable instance.
  /// </summary>
  /// <param name="hashtable">The Hashtable instance</param>
  /// <param name="key">The key of the element to remove</param>
  /// <returns>The element removed</returns>
  public static Object HashtableRemove( Hashtable hashtable, Object key )
  {
    Object element = hashtable[key];
    hashtable.Remove( key );
    return element;
  }

  /*******************************/
  /// <summary>
  /// Converts an array of sbytes to an array of chars
  /// </summary>
  /// <param name="sByteArray">The array of sbytes to convert</param>
  /// <returns>The new array of chars</returns>
  public static char[] ToCharArray( sbyte[] sByteArray )
  {
    char[] charArray = new char[sByteArray.Length];
    sByteArray.CopyTo( charArray, 0 );
    return charArray;
  }

  /// <summary>
  /// Converts an array of bytes to an array of chars
  /// </summary>
  /// <param name="byteArray">The array of bytes to convert</param>
  /// <returns>The new array of chars</returns>
  public static char[] ToCharArray( byte[] byteArray )
  {
    char[] charArray = new char[byteArray.Length];
    byteArray.CopyTo( charArray, 0 );
    return charArray;
  }

  /*******************************/
  /// <summary>
  /// Receives a byte array and returns it transformed in an sbyte array
  /// </summary>
  /// <param name="byteArray">Byte array to process</param>
  /// <returns>The transformed array</returns>
  public static sbyte[] ToSByteArray( byte[] byteArray )
  {
    sbyte[] sbyteArray = new sbyte[byteArray.Length];
    for ( int index = 0; index < byteArray.Length; index++ )
      sbyteArray[index] = (sbyte)byteArray[index];
    return sbyteArray;
  }
  /*******************************/
  /// <summary>
  /// Returns the last element of an ArrayList instance.
  /// </summary>
  /// <param name="arrayList">The ArrayList instance</param>
  /// <returns>The last element of the ArrayList</returns>
  public static Object VectorLastElement( ArrayList arrayList )
  {
    return arrayList[arrayList.Count - 1];
  }

  /// <summary>
  /// Returns the last element of a Stack instance.
  /// </summary>
  /// <param name="stack">The Stack instance</param>
  /// <returns>The last element of the Stack</returns>
  public static Object VectorLastElement( Stack stack )
  {
    return stack.ToArray()[0];
  }


  /*******************************/
  /// <summary>
  /// Adds an element to the top end of a Stack instance.
  /// </summary>
  /// <param name="stack">The Stack instance</param>
  /// <param name="element">The element to add</param>
  /// <returns>The element added</returns>
  public static Object StackPush( Stack stack, Object element )
  {
    stack.Push( element );
    return element;
  }

  /*******************************/
  /// <summary>
  /// Creates an instance of a received Type.
  /// </summary>
  /// <param name="classType">The Type of the new class instance to return.</param>
  /// <returns>An Object containing the new instance.</returns>
  public static Object CreateNewInstance( Type classType )
  {
    Object instance = null;
    Type[] constructor = new Type[] { };
    ConstructorInfo[] constructors = null;

    constructors = classType.GetConstructors();

    if ( constructors.Length == 0 )
      throw new UnauthorizedAccessException();
    else
    {
      for ( int i = 0; i < constructors.Length; i++ )
      {
        ParameterInfo[] parameters = constructors[i].GetParameters();

        if ( parameters.Length == 0 )
        {
          instance = classType.GetConstructor( constructor ).Invoke( new Object[] { } );
          break;
        }
        else if ( i == constructors.Length - 1 )
          throw new MethodAccessException();
      }
    }
    return instance;
  }


  /*******************************/
  /// <summary>
  /// Obtains the int value depending of the type of modifiers that the constructor have
  /// </summary>
  /// <param name="constructor">The ConstructorInfo used to obtain the int value</param>
  /// <returns>The int value of the modifier present in the constructor. 1 if it's public, 2 if it's private, otherwise 4</returns>
  public static int GetConstructorModifiers( ConstructorInfo constructor )
  {
    int temp;
    if ( constructor.IsPublic )
      temp = 1;
    else if ( constructor.IsPrivate )
      temp = 2;
    else
      temp = 4;
    return temp;
  }

  /*******************************/
  /// <summary>
  /// Write an array of bytes int the FileStream specified.
  /// </summary>
  /// <param name="FileStreamWrite">FileStream that must be updated.</param>
  /// <param name="Source">Array of bytes that must be written in the FileStream.</param>
  public static void WriteOutput( FileStream FileStreamWrite, sbyte[] Source )
  {
    FileStreamWrite.Write( ToByteArray( Source ), 0, Source.Length );
  }


}