/// <summary>
        /// Initializes a new instance of the <see cref="EqualToEntityPropertyValidator"/> class.
        /// </summary>
        /// <param name="memberToCompareFunc">The member to compare function.</param>
        /// <param name="member">The member.</param>
        /// <param name="ownerType">The owner type.</param>
        /// <param name="confirmProperty">if set to <c>true</c> [confirm property].</param>
        /// <param name="comparer">The comparer.</param>
        /// <exception cref="System.ArgumentNullException">
        /// memberToCompareFunc
        /// or
        /// member
        /// or
        /// ownerType
        /// </exception>
        public EqualToEntityPropertyValidator(Func<object, object> memberToCompareFunc, MemberInfo member, Type ownerType, bool confirmProperty = true, IEqualityComparer comparer = null)
        {
            if (memberToCompareFunc == null)
            {
                throw new ArgumentNullException("memberToCompareFunc");
            }

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

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

            OwnerType = ownerType;
            m_MemberToCompareFunc = memberToCompareFunc;
            m_MemberToCompareMemberInfo = member;
            m_ConfirmProperty = confirmProperty;
            m_Comparer = comparer;
            m_ValidatorProperties = new ValidatorProperties
                                        {
                                            { Constants.ValidationMessageParameterNames.MEMBER_TO_COMPARE_MEMBER_INFO, m_MemberToCompareMemberInfo },
                                            { Constants.ValidationMessageParameterNames.OWNER_TYPE, ownerType }
                                        };
        }

 public MatchResult TryMatch(string s, IEqualityComparer<string> comparer)
 {
     if (s == null)
     {
         throw new ArgumentNullException(nameof(s));
     }
     if (disposed)
     {
         throw new ObjectDisposedException(GetType().FullName);
     }
     if (s.Length == 0)
     {
         return MatchResult.FromMatch(string.Empty, s);
     }
     var buffer = new char[s.Length];
     var len = textSource.ReadBlock(buffer, 0, buffer.Length);
     var next = new string(buffer, 0, len);
     if (len == 0)
     {
         endOfInput = true;
         return MatchResult.FromEndOfInput(s);
     }
     if (!comparer.Equals(s, next))
     {
         textSource.Unread(buffer, 0, len);
         return MatchResult.FromMismatch(next, s);
     }
     Interlocked.Add(ref offset, len);
     return MatchResult.FromMatch(next, s);
 }

		public OrderedDictionary (int capacity, IEqualityComparer equalityComparer)
		{
			initialCapacity = (capacity < 0) ? 0 : capacity;
			list = new ArrayList (initialCapacity);
			hash = new Hashtable (initialCapacity, equalityComparer);
			comparer = equalityComparer;
		}

        public static bool ContainsClaim(this IEnumerable<ClaimSet> claimSets, Claim searchClaim, Claim issuerIdentityClaim, ClaimSearchMode searchMode, IEqualityComparer<Claim> comparer)
        {
            IEnumerable<ClaimSet> searchSet =
                GetClaimSetsCore(claimSets, issuerIdentityClaim, searchMode);

            foreach (ClaimSet set in searchSet)
            {
                bool found = false;
                if (comparer != null)
                {
                    found = set.ContainsClaim(searchClaim, comparer);
                }
                else
                {
                    found = set.ContainsClaim(searchClaim);
                }

                if (found)
                {
                    return true;
                }
            }

            return false;
        }

 public EqualValidator(Func<object, object> comparisonProperty, MemberInfo member, IEqualityComparer comparer)
     : base(() => Messages.equal_error, ValidationErrors.Equal)
 {
     func = comparisonProperty;
     MemberToCompare = member;
     this.comparer = comparer;
 }

 public BinaryUnitConversionMap(IUnitConversion<double> forwardOperation, IEqualityComparer<IUnit> unitEqualityComparer = null)
     : base(unitEqualityComparer)
 {
     if (null == forwardOperation) throw new ArgumentNullException("forwardOperation");
     Contract.EndContractBlock();
     _forwardOperation = forwardOperation;
 }

 public MarshalContext(IEqualityComparer equalityComparer)
 {
     stackMap = new Hashtable(equalityComparer);
     useRepository = false;
     caseSensitive = true;
     AddConverters();
 }

 public static bool EvaluateQuery(ArrayList<string> text, ArrayList<QueryToken> queryPlan, out bool result, IEqualityComparer<string> tokenComparer)
 {
     result = false;
     Stack<bool> stack = new Stack<bool>();
     foreach (QueryToken token in queryPlan)
     {
         bool b;
         switch (GetTokenType(token))
         {
             case TokenType.Term:
                 stack.Push(Contains(token, text, tokenComparer));
                 break;
             case TokenType.Operator: // AND/OR
                 if (stack.Count <= 1) { return false; }
                 bool b1 = stack.Pop();
                 bool b2 = stack.Pop();
                 b = b1 && b2;
                 if (token == "OR") { b = b1 || b2; }
                 stack.Push(b);
                 break;
             case TokenType.Function: // NOT
                 if (stack.Count == 0) { return false; }
                 b = stack.Pop();
                 stack.Push(!b);
                 break;
         }
     }
     if (stack.Count != 1) { return false; }
     result = stack.Pop();
     return true;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="MemberComparer"/> 
 /// class with the supplied <see cref="IEqualityComparer"/> to support
 /// the comparison of properties and fields.
 /// </summary>
 /// <param name="comparer">
 /// The supplied <see cref="IEqualityComparer"/>.
 /// </param>
 public MemberComparer(IEqualityComparer comparer)
     : this(
         comparer,
         new TrueSpecification<PropertyInfo>(),
         new TrueSpecification<FieldInfo>())
 {
 }

        public DynamicEntity(MissingMemberBehavior missingMemberBehavior,
			IDynamicEntityConverter converter = null, IEqualityComparer<string> comparer = null)
        {
            _missingMemberBehavior = missingMemberBehavior;
            _dataDictionary = new Dictionary<string, object>(comparer ?? StringComparer.InvariantCultureIgnoreCase);
            _converter = converter ?? new NullConverter();
        }

        public MappedHtmlNodeToReferenceNode(MappedHtmlNode parent, HtmlNode htmlNode, HtmlNode referenceNode, IEqualityComparer<HtmlNode> comparer, PropertyNameState propertyNameState)
            : base(parent)
        {
            if (htmlNode == null)
            {
                throw new ArgumentNullException("htmlNode");
            }

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

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

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

            this.htmlNode = htmlNode;
            this.referenceNode = referenceNode;
            this.comparer = comparer;
            this.propertyNameState = propertyNameState;

            base.children = MapChildren();


        }

 public EqualValidator(PropertySelector comparisonProperty, MemberInfo member, IEqualityComparer comparer)
     : base(() => Messages.equal_error)
 {
     func = comparisonProperty;
     MemberToCompare = member;
     this.comparer = comparer;
 }

 public NotEqualValidator(Func<object, object> func, MemberInfo memberToCompare, IEqualityComparer equalityComparer)
     : base(() => Messages.notequal_error, ValidationErrors.NotEqual)
 {
     this.func = func;
     this.comparer = equalityComparer;
     MemberToCompare = memberToCompare;
 }

 public NotEqualValidator(object comparisonValue, IEqualityComparer equalityComparer)
     : base(() => Messages.notequal_error)
 {
     ValueToCompare = comparisonValue;
     comparer = equalityComparer;
     SupportsStandaloneValidation = true;
 }

 public SingleUnityUnitConversionMap(IUnit unit, IEqualityComparer<IUnit> unitEqualityComparer = null)
     : base(unitEqualityComparer)
 {
     if (null == unit) throw new ArgumentNullException("unit");
     Contract.EndContractBlock();
     _singleUnit = unit;
 }

 public void Int(IEnumerable<int> first, IEnumerable<int> second, IEqualityComparer<int> comparer, IEnumerable<int> expected)
 {
     if (comparer == null)
     {
         Assert.Equal(expected, first.Except(second));
     }
     Assert.Equal(expected, first.Except(second, comparer));
 }

 /// <summary>
 /// Initializes a new instance of a Dimension, that uses the given comparer
 /// to compare values.
 /// </summary>
 /// <param name="comparer">The equality comparer to use.</param>
 public Dimension(IEqualityComparer comparer)
 {
     if (comparer == null)
     {
         throw new ArgumentNullException("comparer");
     }
     this.comparer = comparer;
 }

        protected void Initialize(Claim identityClaim, IEqualityComparer<Claim> claimComparer)
        {
            if (identityClaim == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("identityClaim");

            _identityClaim = identityClaim;
            _claimComparer = claimComparer;
        }

 public static void Ctor(Dictionary<int, string> aThis, int capacity, IEqualityComparer<int> comparer)
 {
     if (capacity != 0)
     {
         throw new Exception("Capacity != 0 not supported yet!");
     }
     
 }

 public void String(IEnumerable<string> first, IEnumerable<string> second, IEqualityComparer<string> comparer, string[] expected)
 {
     if (comparer == null)
     {
         Assert.Equal(expected, first.Intersect(second));
     }
     Assert.Equal(expected, first.Intersect(second, comparer));
 }