ModernUO/Server/ClientVersion.cs

/***************************************************************************
 *                              ClientVersion.cs
 *                            -------------------
 *   begin                : May 1, 2002
 *   copyright            : (C) The RunUO Software Team
 *   email                : info@runuo.com
 *
 *   $Id$
 *
 ***************************************************************************/

/***************************************************************************
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 ***************************************************************************/

using System;
using System.Text;
using System.Collections;

namespace Server
{
	public enum ClientType
	{
		Regular,
		UOTD,
		God,
		SA
	}

	public class ClientVersion : IComparable, IComparer
	{
		public int Major { get; }

		public int Minor { get; }

		public int Revision { get; }

		public int Patch { get; }

		public ClientType Type { get; }

		public string SourceString { get; }

		public ClientVersion( int maj, int min, int rev, int pat ) : this( maj, min, rev, pat, ClientType.Regular )
		{
		}

		public ClientVersion( int maj, int min, int rev, int pat, ClientType type )
		{
			Major = maj;
			Minor = min;
			Revision = rev;
			Patch = pat;
			Type = type;

			SourceString = _ToStringImpl();
		}

		public static bool operator == ( ClientVersion l, ClientVersion r )
		{
			return ( Compare( l, r ) == 0 );
		}

		public static bool operator != ( ClientVersion l, ClientVersion r )
		{
			return ( Compare( l, r ) != 0 );
		}

		public static bool operator >= ( ClientVersion l, ClientVersion r )
		{
			return ( Compare( l, r ) >= 0 );
		}

		public static bool operator > ( ClientVersion l, ClientVersion r )
		{
			return ( Compare( l, r ) > 0 );
		}

		public static bool operator <= ( ClientVersion l, ClientVersion r )
		{
			return ( Compare( l, r ) <= 0 );
		}

		public static bool operator < ( ClientVersion l, ClientVersion r )
		{
			return ( Compare( l, r ) < 0 );
		}

		public override int GetHashCode()
		{
			return Major ^ Minor ^ Revision ^ Patch ^ (int)Type;
		}

		public override bool Equals( object obj )
		{
			if ( obj == null )
				return false;

			ClientVersion v = obj as ClientVersion;

			if ( v == null )
				return false;

			return Major == v.Major
				&& Minor == v.Minor
				&& Revision == v.Revision
				&& Patch == v.Patch
				&& Type == v.Type;
		}

		private string _ToStringImpl()
		{
			StringBuilder builder = new StringBuilder(16);

			builder.Append(Major);
			builder.Append('.');
			builder.Append(Minor);
			builder.Append('.');
			builder.Append(Revision);

			if (Major <= 5 && Minor <= 0 && Revision <= 6)	//Anything before 5.0.7
			{
				if (Patch > 0)
					builder.Append((char)('a' + (Patch - 1)));
			}
			else
			{
				builder.Append('.');
				builder.Append(Patch);
			}

			if (Type != ClientType.Regular)
			{
				builder.Append(' ');
				builder.Append(Type.ToString());
			}

			return builder.ToString();
		}

		public override string ToString()
		{
			return _ToStringImpl();
		}

		public ClientVersion( string fmt )
		{
			SourceString = fmt;

			try
			{
				fmt = fmt.ToLower();

				int br1 = fmt.IndexOf( '.' );
				int br2 = fmt.IndexOf( '.', br1 + 1 );

				int br3 = br2 + 1;
				while ( br3 < fmt.Length && char.IsDigit( fmt, br3 ) )
					br3++;

				Major = Utility.ToInt32( fmt.Substring( 0, br1 ) );
				Minor = Utility.ToInt32( fmt.Substring( br1 + 1, br2 - br1 - 1 ) );
				Revision = Utility.ToInt32( fmt.Substring( br2 + 1, br3 - br2 - 1 ) );

				if ( br3 < fmt.Length )
				{
					if ( Major <= 5 && Minor <= 0 && Revision <= 6 )	//Anything before 5.0.7
					{
						if ( !char.IsWhiteSpace( fmt, br3 ) )
							Patch = (fmt[br3] - 'a') + 1;
					}
					else
					{
						Patch = Utility.ToInt32( fmt.Substring( br3+1, fmt.Length - br3 - 1 ) );
					}
				}

				if ( fmt.IndexOf( "god" ) >= 0 || fmt.IndexOf( "gq" ) >= 0 )
					Type = ClientType.God;
				else if ( fmt.IndexOf( "third dawn" ) >= 0 || fmt.IndexOf( "uo:td" ) >= 0 || fmt.IndexOf( "uotd" ) >= 0 || fmt.IndexOf( "uo3d" ) >= 0 || fmt.IndexOf( "uo:3d" ) >= 0 )
					Type = ClientType.UOTD;
				else
					Type = ClientType.Regular;
			}
			catch
			{
				Major = 0;
				Minor = 0;
				Revision = 0;
				Patch = 0;
				Type = ClientType.Regular;
			}
		}

		public int CompareTo( object obj )
		{
			if ( obj == null )
				return 1;

			ClientVersion o = obj as ClientVersion;

			if ( o == null )
				throw new ArgumentException();

			if ( Major > o.Major )
				return 1;
			if ( Major < o.Major )
				return -1;
			if ( Minor > o.Minor )
				return 1;
			if ( Minor < o.Minor )
				return -1;
			if ( Revision > o.Revision )
				return 1;
			if ( Revision < o.Revision )
				return -1;
			if ( Patch > o.Patch )
				return 1;
			if ( Patch < o.Patch )
				return -1;
			return 0;
		}

		public static bool IsNull( object x )
		{
			return ReferenceEquals( x, null );
		}

		public int Compare( object x, object y )
		{
			if ( IsNull( x ) && IsNull( y ) )
				return 0;
			if ( IsNull( x ) )
				return -1;
			if ( IsNull( y ) )
				return 1;

			ClientVersion a = x as ClientVersion;
			ClientVersion b = y as ClientVersion;

			if ( IsNull( a ) || IsNull( b ) )
				throw new ArgumentException();

			return a.CompareTo( b );
		}

		public static int Compare( ClientVersion a, ClientVersion b )
		{
			if ( IsNull( a ) && IsNull( b ) )
				return 0;
			if ( IsNull( a ) )
				return -1;
			if ( IsNull( b ) )
				return 1;

			return a.CompareTo( b );
		}
	}
}