#W# Initial Commit: Avatars Conquest

Scripts/Commands/Generic/Extensions/BaseExtension.cs

@@ -0,0 +1,184 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Server.Commands.Generic
+{
+	public delegate BaseExtension ExtensionConstructor();
+
+	public sealed class ExtensionInfo
+	{
+		private static Dictionary<string, ExtensionInfo> m_Table = new Dictionary<string, ExtensionInfo>( StringComparer.InvariantCultureIgnoreCase );
+
+		public static Dictionary<string, ExtensionInfo> Table
+		{
+			get { return m_Table; }
+		}
+
+		public static void Register( ExtensionInfo ext )
+		{
+			m_Table[ext.m_Name] = ext;
+		}
+
+		private int m_Order;
+
+		private string m_Name;
+		private int m_Size;
+
+		private ExtensionConstructor m_Constructor;
+
+		public int Order
+		{
+			get { return m_Order; }
+		}
+
+		public string Name
+		{
+			get { return m_Name; }
+		}
+
+		public int Size
+		{
+			get { return m_Size; }
+		}
+
+		public bool IsFixedSize
+		{
+			get { return ( m_Size >= 0 ); }
+		}
+
+		public ExtensionConstructor Constructor
+		{
+			get { return m_Constructor; }
+		}
+
+		public ExtensionInfo( int order, string name, int size, ExtensionConstructor constructor )
+		{
+			m_Name = name;
+			m_Size = size;
+
+			m_Order = order;
+
+			m_Constructor = constructor;
+		}
+	}
+
+	public sealed class Extensions : List<BaseExtension>
+	{
+		public Extensions()
+		{
+		}
+
+		public bool IsValid( object obj )
+		{
+			for ( int i = 0; i < this.Count; ++i )
+			{
+				if ( !this[i].IsValid( obj ) )
+					return false;
+			}
+
+			return true;
+		}
+
+		public void Filter( ArrayList list )
+		{
+			for ( int i = 0; i < this.Count; ++i )
+				this[i].Filter( list );
+		}
+
+		public static Extensions Parse( Mobile from, ref string[] args )
+		{
+			Extensions parsed = new Extensions();
+
+			int size = args.Length;
+
+			Type baseType = null;
+
+			for ( int i = args.Length - 1; i >= 0; --i )
+			{
+				ExtensionInfo extInfo = null;
+
+				if ( !ExtensionInfo.Table.TryGetValue( args[i], out extInfo ) )
+					continue;
+
+				if ( extInfo.IsFixedSize && i != ( size - extInfo.Size - 1 ) )
+					throw new Exception( "Invalid extended argument count." );
+
+				BaseExtension ext = extInfo.Constructor();
+
+				ext.Parse( from, args, i + 1, size - i - 1 );
+
+				if ( ext is WhereExtension )
+					baseType = ( ext as WhereExtension ).Conditional.Type;
+
+				parsed.Add( ext );
+
+				size = i;
+			}
+
+			parsed.Sort( delegate( BaseExtension a, BaseExtension b )
+			{
+				return ( a.Order - b.Order );
+			} );
+
+			AssemblyEmitter emitter = null;
+
+			foreach ( BaseExtension update in parsed )
+				update.Optimize( from, baseType, ref emitter );
+
+			if ( size != args.Length )
+			{
+				string[] old = args;
+				args = new string[size];
+
+				for ( int i = 0; i < args.Length; ++i )
+					args[i] = old[i];
+			}
+
+			return parsed;
+		}
+	}
+
+	public abstract class BaseExtension
+	{
+		public abstract ExtensionInfo Info { get; }
+
+		public string Name
+		{
+			get { return Info.Name; }
+		}
+
+		public int Size
+		{
+			get { return Info.Size; }
+		}
+
+		public bool IsFixedSize
+		{
+			get { return Info.IsFixedSize; }
+		}
+
+		public int Order
+		{
+			get { return Info.Order; }
+		}
+
+		public virtual void Optimize( Mobile from, Type baseType, ref AssemblyEmitter assembly )
+		{
+		}
+
+		public virtual void Parse( Mobile from, string[] arguments, int offset, int size )
+		{
+		}
+
+		public virtual bool IsValid( object obj )
+		{
+			return true;
+		}
+
+		public virtual void Filter( ArrayList list )
+		{
+		}
+	}
+}