public SingleUnityUnitConversionMap(IUnit unit, IEqualityComparer<IUnit> unitEqualityComparer = null)
: base(unitEqualityComparer)
{
if (null == unit) throw new ArgumentNullException("unit");
Contract.EndContractBlock();
_singleUnit = unit;
}
public NotEqualValidator(object comparisonValue, IEqualityComparer equalityComparer)
: base(() => Messages.notequal_error)
{
ValueToCompare = comparisonValue;
comparer = equalityComparer;
SupportsStandaloneValidation = true;
}
public NotEqualValidator(PropertySelector func, MemberInfo memberToCompare, IEqualityComparer equalityComparer)
: base(() => Messages.notequal_error)
{
this.func = func;
this.comparer = equalityComparer;
MemberToCompare = memberToCompare;
}
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 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 BackgroundDownloader(IBackgroundTransferStorage storage, IBackgroundTransferConfig config)
{
_storage = storage;
_config = config;
_urlEquator = new FuncEqualityComparer<Uri>((url1, url2) => url1 == url2, url => url.GetHashCode());
}
/// <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 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;
}
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 EqualValidator(object valueToCompare, IEqualityComparer comparer)
: base(() => Messages.equal_error)
{
ValueToCompare = valueToCompare;
this.comparer = comparer;
SupportsStandaloneValidation = true;
}
public MarshalContext(IEqualityComparer equalityComparer)
{
stackMap = new Hashtable(equalityComparer);
useRepository = false;
caseSensitive = true;
AddConverters();
}
public EqualValidator(PropertySelector comparisonProperty, MemberInfo member, IEqualityComparer comparer)
: base(() => Messages.equal_error)
{
func = comparisonProperty;
MemberToCompare = member;
this.comparer = comparer;
}
public EqualValidator(Func<object, object> comparisonProperty, MemberInfo member, IEqualityComparer comparer)
: base(() => Messages.equal_error, ValidationErrors.Equal)
{
func = comparisonProperty;
MemberToCompare = member;
this.comparer = comparer;
}
public OrderedDictionary (int capacity, IEqualityComparer equalityComparer)
{
initialCapacity = (capacity < 0) ? 0 : capacity;
list = new ArrayList (initialCapacity);
hash = new Hashtable (initialCapacity, equalityComparer);
comparer = equalityComparer;
}
/// <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 BinaryUnitConversionMap(IUnitConversion<double> forwardOperation, IEqualityComparer<IUnit> unitEqualityComparer = null)
: base(unitEqualityComparer)
{
if (null == forwardOperation) throw new ArgumentNullException("forwardOperation");
Contract.EndContractBlock();
_forwardOperation = forwardOperation;
}
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 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);
}
/// <summary>
/// Initializes a new instance of the <see cref="SectionData"/> class
/// from a previous instance of <see cref="SectionData"/>.
/// </summary>
/// <remarks>
/// Data is deeply copied
/// </remarks>
/// <param name="ori">
/// The instance of the <see cref="SectionData"/> class
/// used to create the new instance.
/// </param>
/// <param name="searchComparer">
/// Search comparer.
/// </param>
public SectionData(SectionData ori, IEqualityComparer<string> searchComparer = null)
{
SectionName = ori.SectionName;
_searchComparer = searchComparer;
_leadingComments = new List<string>(ori._leadingComments);
_keyDataCollection = new KeyDataCollection(ori._keyDataCollection, searchComparer ?? ori._searchComparer);
}
public ChangeGraphBuilder(IEqualityComparer<IFileReference> fileReferenceComparer)
{
if(fileReferenceComparer == null)
throw new ArgumentNullException(nameof(fileReferenceComparer));
m_FileReferenceComparer = fileReferenceComparer;
}
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));
}
public static void Ctor(Dictionary<int, string> aThis, int capacity, IEqualityComparer<int> comparer)
{
if (capacity != 0)
{
throw new Exception("Capacity != 0 not supported yet!");
}
}
/// <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;
}
public void StringRunOnce(IEnumerable<string> source, IEqualityComparer<string> comparer, string value, bool expected)
{
if (comparer == null)
{
Assert.Equal(expected, source.RunOnce().Contains(value));
}
Assert.Equal(expected, source.RunOnce().Contains(value, comparer));
}
public SyncActionFactory(IEqualityComparer<IFileReference> fileReferenceComparer)
{
if (fileReferenceComparer == null)
{
throw new ArgumentNullException(nameof(fileReferenceComparer));
}
m_FileReferenceComparer = fileReferenceComparer;
}
public MotherNature(IEnumerable<IBe> initialPopulation, DarwinBase darwin, IGod god, IRandomOperations randomOperation, IEqualityComparer<IBe> comparer)
{
this.darwin = darwin;
population = initialPopulation;
this.god = god;
this.randomOperation = randomOperation;
this.comparer = comparer;
}
protected void Initialize(Claim identityClaim, IEqualityComparer<Claim> claimComparer)
{
if (identityClaim == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("identityClaim");
_identityClaim = identityClaim;
_claimComparer = claimComparer;
}
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));
}
static ResourceMapManager()
{
entryComparer = new ResourceEntryComparer();
mappingCache = new Dictionary<int, ResourceMapping>();
mapKeyCache = new Dictionary<ResourceMappingEntry, List<int>>();
Refresh();
}
public LocalizationDictionary(IEqualityComparer<string> comparer) {
Includes = new List<Include>();
this.comparer = comparer;
keys = new List<string>();
localesHash = new HashSet<string>(comparer);
keysHash = new HashSet<string>(comparer);
dictionaries = new Dictionary<string, Dictionary<string, string>>(comparer);
}
public ObservableDictionary(int capacity, IEqualityComparer <TKey> comparer)
{
InternalDictionary = new Dictionary <TKey, TValue>(capacity, comparer);
}
/// <summary>
/// Run-length encodes a sequence by converting consecutive instances of the same element into
/// a <c>KeyValuePair{T,int}</c> representing the item and its occurrence count. This overload
/// uses a custom equality comparer to identify equivalent items.
/// </summary>
/// <typeparam name="T">The type of the elements in the sequence</typeparam>
/// <param name="sequence">The sequence to run length encode</param>
/// <param name="comparer">The comparer used to identify equivalent items</param>
/// <returns>A sequence of <c>KeyValuePair{T,int}</c> where they key is the element and the value is the occurrence count</returns>
public static IEnumerable <KeyValuePair <T, int> > RunLengthEncode <T>(this IEnumerable <T> sequence, IEqualityComparer <T> comparer)
{
if (sequence == null)
{
throw new ArgumentNullException(nameof(sequence));
}
return(_(comparer ?? EqualityComparer <T> .Default));
IEnumerable <KeyValuePair <T, int> > _(IEqualityComparer <T> localComparer)
{
// This implementation could also have been written using a foreach loop,
// but it proved to be easier to deal with edge certain cases that occur
// (such as empty sequences) using an explicit iterator and a while loop.
var iter = sequence.GetEnumerator();
if (iter.MoveNext())
{
var prevItem = iter.Current;
var runCount = 1;
while (iter.MoveNext())
{
if (localComparer.Equals(prevItem, iter.Current))
{
++runCount;
}
else
{
yield return(new KeyValuePair <T, int>(prevItem, runCount));
prevItem = iter.Current;
runCount = 1;
}
}
yield return(new KeyValuePair <T, int>(prevItem, runCount));
}
}
}
public static IEqualityComparer <T> CreateComparer <V>(Func <T, V> keySelector, IEqualityComparer <V> comparer)
{
return(new CtkCommonEqualityComparer <V>(keySelector, comparer));
}
private void HandleChanging(IInvocation invocation, IPropertyBase property, IEqualityComparer comparer)
{
if (_checkEquality)
{
var oldValue = property.GetGetter().GetClrValue(invocation.Proxy);
var newValue = invocation.Arguments[^ 1];
public static IQueryable <TSource> UnionIf <TSource>(this IQueryable <TSource> first, bool condition, IQueryable <TSource> second, IEqualityComparer <TSource> comparer) => condition?first.Union(second, comparer) : first;
public SlimHashTable(Func <TValue, TKey> keyProvider, IEqualityComparer <TKey> comparer, ICollectionGrowthPolicy growthPolicy)
: this(keyProvider, 0, comparer, growthPolicy)
{
}
public static IAsyncEnumerable <TSource> Distinct <TSource, TKey>(this IAsyncEnumerable <TSource> source, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> comparer)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (keySelector == null)
{
throw new ArgumentNullException(nameof(keySelector));
}
if (comparer == null)
{
throw new ArgumentNullException(nameof(comparer));
}
return(new DistinctAsyncIterator <TSource, TKey>(source, keySelector, comparer));
}
private static IAsyncEnumerable <TSource> DistinctUntilChanged_ <TSource, TKey>(this IAsyncEnumerable <TSource> source, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> comparer)
{
return(new DistinctUntilChangedAsyncIterator <TSource, TKey>(source, keySelector, comparer));
}
public CtkCommonEqualityComparer(Func <T, V> keySelector, IEqualityComparer <V> comparer)
{
this.keySelector = keySelector;
this.comparer = comparer;
}
public ConcurrentSet(IEqualityComparer <T> comparer)
{
_inner = new ConcurrentDictionary <T, object>(comparer);
}
public MultiSetComparer(IEqualityComparer <T>?comparer = null)
{
_comparer = comparer ?? EqualityComparer <T> .Default;
}
public StringArrayComparer(IEqualityComparer <string> comparer)
{
_comparer = comparer;
}
private static IEnumerable <TSource> ExceptImpl <TSource>(this IEnumerable <TSource> first, IEnumerable <TSource> second, IEqualityComparer <TSource> comparer)
{
HashSet <TSource> set = new HashSet <TSource>(second, comparer);
foreach (var f in first)
{
//if (!set.Remove(f)) //It will not return distinct values from first
if (set.Add(f))
{
yield return(f);
}
}
}
/// <summary>
/// Initializes a new instance of the System.Collections.Generic.HashSet<T> class
/// that is empty and uses the specified equality comparer for the set type.
/// </summary>
/// <param name="comparer">
/// The System.Collections.Generic.IEqualityComparer<T> implementation to use
/// when comparing values in the set, or null to use the default System.Collections.Generic.EqualityComparer<T>
/// implementation for the set type.
/// </param>
public HashSet(IEqualityComparer <T> comparer)
{
this.dict = new Dictionary <T, object>(comparer);
}
public static IEnumerable <TSource> Except <TSource>(this IEnumerable <TSource> first, IEnumerable <TSource> second, IEqualityComparer <TSource> comparer)
{
if (first == null)
{
throw new ArgumentNullException("first");
}
if (second == null)
{
throw new ArgumentNullException("second");
}
return(ExceptImpl(first, second, comparer));
}
public ToDictionary(Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> comparer)
: base(new Dictionary <TKey, TElement>(comparer)) => (_keySelector, _elementSelector) = (keySelector, elementSelector);
public StringArrayComparer()
{
_comparer = StringComparer.Ordinal;
}
public RecentDictionary(int capacity, IEqualityComparer <K> comparer)
{
this.capacity = capacity;
keyToLink = new Dictionary <K, LinkedListNode <V> >(comparer);
}
private static bool DictionaryEqual <TKey, TValue>(IDictionary <TKey, TValue> dict1, IDictionary <TKey, TValue> dict2, IEqualityComparer <TValue> equalityComparer = null)
{
if (Equals(dict1, dict2))
{
return(true);
}
if (dict1 == null || dict2 == null || dict1.Count != dict2.Count)
{
return(false);
}
if (equalityComparer == null)
{
equalityComparer = EqualityComparer <TValue> .Default;
}
return(dict1.All(pair =>
{
return dict2.TryGetValue(pair.Key, out TValue val) && equalityComparer.Equals(pair.Value, val);
}));
}
public HashSet(IEqualityComparer <T> comparer)
{
items = new Dictionary <T, object?>(comparer);
}
public PersistenceSpecification <T> RegisterCheckedProperty(Property <T> property, IEqualityComparer equalityComparer)
{
property.EntityEqualityComparer = equalityComparer ?? entityEqualityComparer;
allProperties.Add(property);
property.HasRegistered(this);
return(this);
}
public static bool EqualsAny <T>(this T @this, IEqualityComparer <T> comparer, params T[] others)
{
return(others.Contains(@this, comparer));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="comparer">comparer to ensure the equality of 2 values</param>
public MemoryCacheBucket(IEqualityComparer <TValue> comparer)
{
_comparer = comparer;
}
public static IQueryable <TSource> DistinctIf <TSource>(this IQueryable <TSource> source, bool condition, IEqualityComparer <TSource> comparer) => condition?source.Distinct(comparer) : source;
public PersistenceSpecification(ISession session, IEqualityComparer entityEqualityComparer)
{
currentSession = session;
hasExistingSession = currentSession.Transaction != null && currentSession.Transaction.IsActive;
this.entityEqualityComparer = entityEqualityComparer;
}
public DictionaryDisposable(IEqualityComparer <TKey> comparer)
{
inner = new Dictionary <TKey, TValue>(comparer);
}
public PersistenceSpecification(ISessionSource source, IEqualityComparer entityEqualityComparer)
: this(source.CreateSession(), entityEqualityComparer)
{
}
/// <summary>
/// Compares two enumberables for equality, ordered according to the specified key and optional comparer. Handles null values gracefully.
/// </summary>
/// <typeparam name="TSource">The type of the list</typeparam>
/// <typeparam name="TKey">The type of the sorting key</typeparam>
/// <param name="self">This list</param>
/// <param name="other">The other list</param>
/// <param name="keySelector">The function to extract the key from each item in the list</param>
/// <param name="orderComparer">An optional comparer for comparing keys</param>
/// <param name="sequenceComparer">An optional comparer for sequences</param>
internal static bool OrderedEquals <TSource, TKey>(this IEnumerable <TSource> self, IEnumerable <TSource> other, Func <TSource, TKey> keySelector, IComparer <TKey> orderComparer = null, IEqualityComparer <TSource> sequenceComparer = null)
{
Debug.Assert(orderComparer != null || typeof(TKey) != typeof(string), "Argument " + "orderComparer" + " must be provided if " + "TKey" + " is a string.");
Debug.Assert(sequenceComparer != null || typeof(TSource) != typeof(string), "Argument " + "sequenceComparer" + " must be provided if " + "TSource" + " is a string.");
if (ReferenceEquals(self, other))
{
return(true);
}
if (self == null || other == null)
{
return(false);
}
return(self.OrderBy(keySelector, orderComparer).SequenceEqual(other.OrderBy(keySelector, orderComparer), sequenceComparer));
}
public SlimHashTable(Func <TValue, TKey> keyProvider, IEqualityComparer <TKey> comparer)
: this(keyProvider, 0, comparer, DefaultGrowthPolicy)
{
}
public ObservableDictionary(IDictionary <TKey, TValue> dictionary, IEqualityComparer <TKey> comparer)
{
InternalDictionary = new Dictionary <TKey, TValue>(dictionary, comparer);
}