public override bool SameMatcher(IMatcher other)
		{
			DateTimeMatcher dtOther = other as DateTimeMatcher;
			if (dtOther == null)
				return false;
			return m_end == dtOther.m_end && m_start == dtOther.m_start && m_type == dtOther.m_type;
		}

		public bool SameMatcher(IMatcher other)
		{
			if (other.GetType() != this.GetType())
				return false;
			ExactLiteralMatcher other1 = other as ExactLiteralMatcher;
			return m_target == other1.m_target && m_ws == other1.m_ws;
		}

 static void setComponentNames(Matcher matcher, IMatcher[] matchers)
 {
     var componentNames = getComponentNames(matchers);
     if(componentNames != null) {
         matcher.componentNames = componentNames;
     }
 }

 public VisualFingerprintMatchingFrm(IMatcher matcher, IResourceProvider resourceProvider, string resourcePath)
 {
     InitializeComponent();
     this.matcher = matcher;
     provider = resourceProvider;
     this.resourcePath = resourcePath;
     repository = new ResourceRepository(resourcePath);
 }

		public override bool Equals(IMatcher other)
		{
			var referenceMatcher = other as ReferenceMatcher;
			if (referenceMatcher == null)
				return false;

			return CompareValueTo(other);
		}

        static int[] extractIndices(IMatcher[] matchers)
        {
            var indices = new List<int>();
            for (int i = 0, matchersLength = matchers.Length; i < matchersLength; i++) {
                indices.AddRange(matchers[i].indices);
            }

            return indices.ToArray();
        }

		public bool Matches(IMatcher other)
		{
			if (this.Equals(other))
				return true;

			if (!this.CanMatch(other))
				return false;

			return this.MatchesCore(other);
		}

		private bool CompareValueTo(IMatcher other)
		{
			var valueMatcher = other as IValueMatcher;
			if (valueMatcher == null)
				return false;

			if (this.IsValueType)
				return Equals(this.reference, valueMatcher.Value);
			return ReferenceEquals(this.reference, valueMatcher.Value);
		}

 ReactiveSystem(Pool pool, IReactiveExecuteSystem subSystem, IMatcher[] triggers, GroupEventType[] eventTypes)
 {
     _subsystem = subSystem;
     var groups = new Group[triggers.Length];
     for (int i = 0, triggersLength = triggers.Length; i < triggersLength; i++) {
         groups[i] = pool.GetGroup(triggers[i]);
     }
     _observer = new GroupObserver(groups, eventTypes);
     _buffer = new List<Entity>();
 }

        static string[] getComponentNames(IMatcher[] matchers)
        {
            for (int i = 0; i < matchers.Length; i++) {
                var matcher = matchers[i] as Matcher;
                if(matcher != null && matcher.componentNames != null) {
                    return matcher.componentNames;
                }
            }

            return null;
        }

    public static Entity GetEntityWithOrder(this Pool pool, int order, IMatcher matcher)
    {
        Entity[] entities = pool.GetGroup(Matcher.AllOf(CoreGameMatcher.Order, matcher)).GetEntities();

        foreach(Entity e in entities){
            if(e.order.value == order){
                return e;
            }
        }
        return null;
    }

        public WindsorPersister(IDatabase database, IKernel kernel, IMatcher matcher)
            : base(database, matcher)
        {
            if (kernel == null)
            {
                throw new ArgumentNullException("kernel");
            }

            var converter = new WindsorConverter(kernel);
            Settings.Converters = new[] {converter};
        }

        static int[] mergeIndices(IMatcher[] matchers) {
            var indices = new int[matchers.Length];
            for (int i = 0, matchersLength = matchers.Length; i < matchersLength; i++) {
                var matcher = matchers[i];
                if (matcher.indices.Length != 1) {
                    throw new MatcherException(matcher);
                }
                indices[i] = matcher.indices[0];
            }

            return indices;
        }

 public static IMatcher<string> WithForwardSlashes(IMatcher<string> matcher)
 {            
     return Matchers.Function((string actual,IMatchDiagnostics diag) =>
     {
         if (actual != null)
         {
             actual = actual.Replace("\\", "/");
         }
         return matcher.Matches(actual, diag);
     },
     "ignoring slash type, " + matcher
   );
 }

        public TaskRouter(IMatcher matcher, IEnumerable<IExecutorImplementation> taskQueues)
        {
            if (matcher == null)
            {
                throw new ArgumentNullException("matcher");
            }

            if (taskQueues == null)
            {
                throw new ArgumentNullException("taskQueues");
            }

            _matcher = matcher;
            _executors = taskQueues.ToDictionary(x => x.Name, x => x);
        }

        private static void TestMatcher(IOmsFactory orders, IMatcher matcher)
        {
            var trades1 = matcher.AddOrder(orders.CreateOrder(10,Side.Buy,100));
            var trades2 = matcher.AddOrder(orders.CreateOrder(10, Side.Sell, 100));

            var tests = new List<Tuple<decimal, Side, ulong>>
            {
                new Tuple<decimal, Side, ulong>(10,Side.Buy,100),
                new Tuple<decimal, Side, ulong>(10,Side.Buy,100),
                new Tuple<decimal, Side, ulong>(10,Side.Buy,100),
                new Tuple<decimal, Side, ulong>(10,Side.Buy,100),
                new Tuple<decimal, Side, ulong>(10,Side.Buy,100),
                new Tuple<decimal, Side, ulong>(10,Side.Buy,100),
            };
        }

        // TODO:convert to use a generic type converter? Put into CoreMatchers?

        /// <summary>
        /// Attempt to parse the string to an int and apply the given int matcher
        /// </summary>
        /// <param name="intMatcher">The int matcher to match against</param>
        /// <returns>A matcher on string</returns>
        public static IMatcher<string> As(IMatcher<int?> intMatcher)
        {
            return Matchers.Function(
                (string actual, IMatchDiagnostics diagnostics) =>
                {
                    int intActual;
                    if (int.TryParse(actual, out intActual))
                    {
                        return intMatcher.Matches(intActual, diagnostics);
                    }
                    diagnostics.MisMatched("Couldn't parse the string '{0}' as an int", actual);
                    return false;
                }, 
                "string of int matching " + intMatcher);
        }

        public bool RemoveJobListenerMatcher(string listenerName, IMatcher<JobKey> matcher)
        {
            if (matcher == null)
            {
                throw new ArgumentException("Non-null value not acceptable.");
            }

            lock (globalJobListeners)
            {
                IList<IMatcher<JobKey>> matchers = globalJobListenersMatchers.TryGetAndReturn(listenerName);
                if (matchers == null)
                {
                    return false;
                }
                return matchers.Remove(matcher);
            }
        }

		public bool Equals(IMatcher other)
		{
			var paramsMatcher = other as ParamsMatcher;
			if (paramsMatcher == null)
				return false;

			if (paramsMatcher.matchers.Length != this.matchers.Length)
				return false;

			for(int i=0;i<this.matchers.Length;i++)
			{
				if(!this.matchers[i].Equals(paramsMatcher.matchers[i]))
					return false;
			}

			return true;
		}

        public static List<ResultItem> Find(string fileName, IMatcher matcher)
        {
            if (File.Exists(fileName) == false)
            {
                return null;
            }

            List<ResultItem> results = new List<ResultItem>();
            using (StreamReader sr = new StreamReader(fileName))
            {
                int lineNum = 0;
                string line = null;
                bool start = false;
                ResultItem result = null;
                while ((line = sr.ReadLine()) != null)
                {
                    lineNum++;
                    if (!start)
                    {
                        if (matcher.BeginMatch(line))
                        {
                            start = true;
                            result = new ResultItem(fileName);
                            result.LineNumber = lineNum;
                            result.AddContent(line);
                        }
                    }
                    else
                    {
                        if (matcher.EndMatch(line))
                        {
                            start = false;
                            results.Add(result);
                            result = null;
                        }
                        else
                        {
                            result.AddContent(line);
                        }
                    }
                }
                if (result != null) results.Add(result);
            }
            return results;
        }