[Dotnetmock-developer] dotnetmock/DotNetMock/Dynamic/Predicates AndPredicate.cs,NONE,1.1 IsAnything.cs,NONE,1.1 IsCloseTo.cs,NONE,1.1 IsEqual.cs,NONE,1.1 IsEqualIgnoreCase.cs,NONE,1.1 IsEqualIgnoreWhiteSpace.cs,NONE,1.1 IsIn.cs,NONE,1.1 IsMatch.cs,NONE,1.1 IsNull.cs,NONE,1.1 IsTypeOf.cs,NONE,1.1 NotEqual.cs,NONE,1.1 NotIn.cs,NONE,1.1 NotNull.cs,NONE,1.1 NotPredicate.cs,NONE,1.1 OrPredicate.cs,NONE,1.1 Predicate.cs,NONE,1.1

[<gc...@us...>]

Update of /cvsroot/dotnetmock/dotnetmock/DotNetMock/Dynamic/Predicates
In directory usw-pr-cvs1:/tmp/cvs-serv28292/DotNetMock/Dynamic/Predicates

Added Files:
	AndPredicate.cs IsAnything.cs IsCloseTo.cs IsEqual.cs 
	IsEqualIgnoreCase.cs IsEqualIgnoreWhiteSpace.cs IsIn.cs 
	IsMatch.cs IsNull.cs IsTypeOf.cs NotEqual.cs NotIn.cs 
	NotNull.cs NotPredicate.cs OrPredicate.cs Predicate.cs 
Log Message:



--- NEW FILE: AndPredicate.cs ---
using System;

namespace DotNetMock.Dynamic.Predicates
{
	public class AndPredicate : IPredicate
	{
		private IPredicate p1, p2;
		
		public AndPredicate(IPredicate p1, IPredicate p2) 
		{
			this.p1 = p1;
			this.p2 = p2;
		}
		
		public bool Eval(object currentValue) 
		{
			return p1.Eval(currentValue) && p2.Eval(currentValue);
		}
	}
}

--- NEW FILE: IsAnything.cs ---
using System;

namespace DotNetMock.Dynamic.Predicates
{
	public class IsAnything : IPredicate
	{
		public bool Eval(object currentValue) 
		{
			return true;
		}
	}
}

--- NEW FILE: IsCloseTo.cs ---
using System;
using System.Globalization;

namespace DotNetMock.Dynamic.Predicates
{
	public class IsCloseTo : IPredicate 
	{
		
		private double expected;
		private double error;
		
		public IsCloseTo(double expected, double error)
		{
			this.expected = expected;
			this.error = error;
		}
		
		public bool Eval(object currentValue)
		{
			try
			{
				double actual = Convert.ToDouble(currentValue, CultureInfo.CurrentCulture);
				return Math.Abs(actual - expected) <= error;
			}
			catch (FormatException)
			{
				return false;
			}
		}
	}
}

--- NEW FILE: IsEqual.cs ---
using System;

namespace DotNetMock.Dynamic.Predicates
{
	public class IsEqual : IPredicate 
	{
		private object compare;
		
		public IsEqual(object compare)
		{
			this.compare = compare;
		}

		public bool Eval(object currentValue)
		{
			return compare.Equals(currentValue);
		}
	}
}

--- NEW FILE: IsEqualIgnoreCase.cs ---
using System;
using System.Globalization;

namespace DotNetMock.Dynamic.Predicates
{
	public class IsEqualIgnoreCase : IPredicate 
	{
		private IPredicate p;
		
		public IsEqualIgnoreCase(object compare)
		{
			p = new IsEqual(compare.ToString().ToLower(CultureInfo.CurrentCulture));
		}

		public bool Eval(object currentValue)
		{
			return p.Eval(currentValue.ToString().ToLower(CultureInfo.CurrentCulture));
		}
	}
}

--- NEW FILE: IsEqualIgnoreWhiteSpace.cs ---
using System;
using System.Text;

namespace DotNetMock.Dynamic.Predicates
{
	public class IsEqualIgnoreWhiteSpace : IPredicate
	{
		private IPredicate p;
		
		public IsEqualIgnoreWhiteSpace(object compare)
		{
			p = new IsEqual(StripSpace(compare.ToString()));
		}

		public bool Eval(object currentValue)
		{
			return p.Eval(StripSpace(currentValue.ToString()));
		}
		
		public static string StripSpace(string s)
		{
			StringBuilder result = new StringBuilder();
			bool lastWasSpace = true;
			foreach(char c in s)
			{
				if (Char.IsWhiteSpace(c))
				{
					if (!lastWasSpace)
					{
						result.Append(' ');
					}
					lastWasSpace = true;					
				}
				else
				{
					result.Append(c);
					lastWasSpace = false;					
				}
			}
			return result.ToString().Trim();
		}
	}
}

--- NEW FILE: IsIn.cs ---
using System;

namespace DotNetMock.Dynamic.Predicates
{
	public class IsIn : IPredicate 
	{
		private object[] inList;
		
		public IsIn(params object[] inList)
		{
			if (inList.Length == 1 && inList[0].GetType().IsArray)
			{
				Array arr = (Array)inList[0];
				this.inList = new object[arr.Length];
				arr.CopyTo(this.inList, 0);
			}
			else
			{
				this.inList = inList;
			}
		}

		public bool Eval(object currentValue)
		{
			foreach (object o in inList)
			{
				if (o.Equals(currentValue))
				{
					return true;
				}
			}
			return false;
		}
	}
}

--- NEW FILE: IsMatch.cs ---
using System;
using System.Text.RegularExpressions;

namespace DotNetMock.Dynamic.Predicates
{
	public class IsMatch : IPredicate 
	{
		private Regex regex;
		
		public IsMatch(Regex regex)
		{
			this.regex = regex;
		}
		
		public IsMatch(String regex) : this(new Regex(regex))
		{
		}
		
		public IsMatch(String regex, bool ignoreCase) : 
			this(new Regex(regex, ignoreCase ? RegexOptions.IgnoreCase : RegexOptions.None)) 
		{
		}
		
		public bool Eval(object currentValue)
		{
			return currentValue == null ? false : regex.IsMatch(currentValue.ToString());
		}
	}
}

--- NEW FILE: IsNull.cs ---
using System;

namespace DotNetMock.Dynamic.Predicates
{
	public class IsNull : IPredicate
	{
		public bool Eval(object currentValue)
		{
			return currentValue == null;
		}
	}
}

--- NEW FILE: IsTypeOf.cs ---
using System;

namespace DotNetMock.Dynamic.Predicates
{
	public class IsTypeOf : IPredicate 
	{
		private Type type;
		
		public IsTypeOf(Type type)
		{
			this.type = type;
		}

		public bool Eval(object currentValue)
		{
			return currentValue == null ? false : type.IsAssignableFrom(currentValue.GetType()); 
		}
	}
}

--- NEW FILE: NotEqual.cs ---
using System;

namespace DotNetMock.Dynamic.Predicates
{
	public class NotEqual : IPredicate
	{
		private IPredicate p;
		
		public NotEqual(object compare)
		{
			p = new NotPredicate(new IsEqual(compare));
		}

		public bool Eval(object currentValue)
		{
			return p.Eval(currentValue);
		}
	}
}

--- NEW FILE: NotIn.cs ---
using System;

namespace DotNetMock.Dynamic.Predicates
{
	public class NotIn : IPredicate 
	{
		private IPredicate p;
		
		public NotIn(params object[] inList)
		{
			p = new NotPredicate(new IsIn(inList));
		}

		public bool Eval(object currentValue)
		{
			return p.Eval(currentValue);
		}
	}
}

--- NEW FILE: NotNull.cs ---
using System;

namespace DotNetMock.Dynamic.Predicates
{
	public class NotNull : IPredicate 
	{
		public bool Eval(object currentValue)
		{
			return currentValue != null;
		}
	}
}

--- NEW FILE: NotPredicate.cs ---
using System;

namespace DotNetMock.Dynamic.Predicates
{
	public class NotPredicate : IPredicate 
	{
		private IPredicate p;
		
		public NotPredicate(IPredicate p)
		{
			this.p = p;
		}
		
		public bool Eval(object currentValue) 
		{
			return !p.Eval(currentValue);
		}
	}
}

--- NEW FILE: OrPredicate.cs ---
using System;

namespace DotNetMock.Dynamic.Predicates
{
	public class OrPredicate : IPredicate
	{
		private IPredicate p1, p2;
		
		public OrPredicate(IPredicate p1, IPredicate p2)
		{
			this.p1 = p1;
			this.p2 = p2;
		}
		
		public bool Eval(object currentValue)
		{
			return p1.Eval(currentValue) || p2.Eval(currentValue);
		}
	}
}

--- NEW FILE: Predicate.cs ---
using System;

namespace DotNetMock.Dynamic.Predicates
{
	public class Predicate : IPredicate
	{
		public delegate bool Method(object currentValue);
		private Method m;
		
		public Predicate(Method m)
		{
			this.m = m;	
		}
		
		public bool Eval(object currentValue)
		{
			return m(currentValue);
		}
	}
}