public void can_match_5()
{
soll = new[] { 1, 2, 3, 4, 5, 6 };
ist = new[] { 1, 2, 3, 4, 5, 7 };
Assert.That(ist.Intersect(soll).Count(), Is.EqualTo(5));
Assert.That(ist.Intersect(soll).Count(), Is.EqualTo(soll.Intersect(ist).Count()));
}
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));
}
public async Task<bool> RequiresConsentAsync(Client client, ClaimsPrincipal user, IEnumerable<string> scopes)
{
if (client == null) throw new ArgumentNullException("client");
if (user == null) throw new ArgumentNullException("user");
if (!client.RequireConsent)
{
return false;
}
// TODO: validate that this is a correct statement
if (!client.AllowRememberConsent)
{
return true;
}
if (scopes == null || !scopes.Any())
{
return false;
}
var consent = await _store.LoadAsync(user.GetSubjectId(), client.ClientId);
if (consent != null && consent.Scopes != null)
{
var intersect = scopes.Intersect(consent.Scopes);
return !(scopes.Count() == intersect.Count());
}
return true;
}
private IEnumerable<EmployeeLogin> SRVCUpdateLogins(Helpers.Log.SessionInfo logSession, Repository.Logic.Repository rep,
long employeeId, IEnumerable<string> addLogins, IEnumerable<string> removeLogins)
{
#pragma warning disable 618
logSession.Add($"Try to get employee with id = {employeeId}");
var emp = rep.Get<Repository.Model.Employee>(e => e.EmployeeId == employeeId, false, new string[] { "Logins" }).FirstOrDefault();
if (emp == null)
throw new Exception(string.Format(Properties.Resources.STUFFINGSERVICE_EmployeeNotFound, employeeId));
var existedLogins = emp.Logins.Select(r => r.DomainLogin);
#region Add logins
if (addLogins != null && addLogins.Any())
{
logSession.Add($"Add logins...");
var addLoginsUpper = addLogins
.Except(existedLogins)
.ToArray()
.Select(r => rep.New<Repository.Model.EmployeeLogin>((er) =>
{
er.EmployeeLoginId = emp.EmployeeId;
er.DomainLogin = r;
}))
.ToArray();
logSession.Add($"Add this logins {addLoginsUpper.Concat(r => r.DomainLogin, ",")} for employee id = {employeeId}");
foreach (var r in addLoginsUpper)
emp.Logins.Add(r);
rep.AddRange(addLoginsUpper, saveAfterInsert: false);
}
#endregion
#region Remove rights
if (removeLogins != null && removeLogins.Any())
{
logSession.Add($"Remove logins...");
var removeLoginsUpper = removeLogins
.Intersect(existedLogins)
.ToArray()
.Join(emp.Logins, r => r, er => er.DomainLogin.ToUpper(), (r, er) => er)
.ToArray();
logSession.Add($"Remove this logins {removeLoginsUpper.Concat(r => r.DomainLogin, ",")} for employee id = {employeeId}");
foreach (var r in removeLoginsUpper)
emp.Logins.Remove(r);
rep.RemoveRange(removeLoginsUpper, saveAfterRemove: false);
}
#endregion
rep.SaveChanges();
return emp.Logins.Select(er => AutoMapper.Mapper.Map<EmployeeLogin>(er));
#pragma warning restore 618
}
static IEnumerable<int[]> Crossover(IEnumerable<int> father, IEnumerable<int> mother)
{
IEnumerable<int>
intersect = father.Intersect(mother), motherRest = mother.Except(intersect), fatherRest = father.Except(intersect);
int motherRestHalfSize = motherRest.Count() / 2, fatherRestRestHalfSize = fatherRest.Count() / 2;
yield return intersect.Concat(motherRest.Take(motherRestHalfSize)).Concat(fatherRest.Skip(fatherRestRestHalfSize)).ToArray();
yield return intersect.Concat(motherRest.Skip(motherRestHalfSize)).Concat(fatherRest.Take(fatherRestRestHalfSize)).ToArray();
}
public void AssertContainsAll(IEnumerable<int> expected, IEnumerable<int> actual)
{
int n1 = expected.Distinct().Count();
int n2 = actual.Distinct().Count();
Assert.AreEqual(n1, n2);
Assert.AreEqual(n1, expected.Intersect(actual).Count());
Assert.AreEqual(n2, actual.Intersect(expected).Count());
}
internal static string SuggestLanguage(IEnumerable<string> supportedLanguages, IEnumerable<string> preferredLanguages)
{
var intersection = preferredLanguages.Intersect(supportedLanguages);
if (intersection.Any())
return intersection.First();
return supportedLanguages.First();
}
public override IEnumerable<double?[]> UpperApproximation(IEnumerable<double?[]> X)
{
Debug.WriteLine("Standard AS Upper Approximation");
return IndiscernibilityClasses()
.Where(Ix => X.Intersect(Ix).Any())
.Aggregate(
Enumerable.Empty<double?[]>(),
(upX, Ix) => upX.Union(Ix))
;
}
/**
* Verification of a living cell
* if neighboring cells alive for at least two and no more than 3 then cell is alive
* @param currentGeneration
* @param cell
* @param neighboringCells
* @return if cells alive then true
*/
bool CheckLiveCell(IEnumerable<Cell> currentGeneration, Cell cell,
IEnumerable<Cell> neighboringCells)
{
if (cell != null && neighboringCells != null)
{
int countIntersect = currentGeneration.Intersect(neighboringCells).Count();
return (countIntersect == 2 || countIntersect == 3);
}
else
return false;
}
public double GetJaccardSimilarity(IEnumerable<int> s1, IEnumerable<int> s2)
{
if (s1.Count() < ShingleSize || s2.Count() < ShingleSize)
{
return double.NaN;
}
int cap = s1.Intersect(s2).Count();
int cup = s1.Union(s2).Count();
return (double)cap / cup;
}
public bool Validate(IEnumerable<char> data)
{
foreach(var s in Statements)
{
if(data.Intersect(s.Data).Count() < s.ExpectedAtLeast)
{
return false;
}
}
return true && data.Count() >= MinLenght;
}
public static string Negotiate(IEnumerable<string> server, IEnumerable<string> client)
{
if (!server.Any() || !client.Any()) {
return null;
}
var matches = client.Intersect(server);
if (!matches.Any()) {
throw new SubProtocolNegotiationFailureException("Unable to negotiate a subprotocol");
}
return matches.First();
}
public static FieldReference FindBackingField(this PropertyDefinition propertyDefinition)
{
IEnumerable <FieldReference> getFieldReferences = propertyDefinition.GetMethod?.Body?.Instructions
?.Where(instruction => instruction.OpCode == OpCodes.Ldsfld || instruction.OpCode == OpCodes.Ldfld)
.Select(instruction => (FieldReference)instruction.Operand);
IEnumerable <FieldReference> setFieldReferences = propertyDefinition.SetMethod?.Body?.Instructions
?.Where(instruction => instruction.OpCode == OpCodes.Stsfld || instruction.OpCode == OpCodes.Stfld)
.Select(instruction => (FieldReference)instruction.Operand);
return(getFieldReferences?.Intersect(
setFieldReferences ?? Enumerable.Empty <FieldReference>(),
FieldReferenceComparer.Instance)
.FirstOrDefault());
}
public static DetailedEvaluation Evaluate(this SentenceSegmenter segmenter, string paragraph,
IEnumerable<int> realBoundaryIndices)
{
IEnumerable<int> predictedIndices = segmenter.GetBoundaryIndices(paragraph);
// ReSharper disable PossibleMultipleEnumeration
IEnumerable<int> misses = realBoundaryIndices.Except(predictedIndices);
IEnumerable<int> falseAlarms = predictedIndices.Except(realBoundaryIndices);
IEnumerable<int> hits = realBoundaryIndices.Intersect(predictedIndices);
// ReSharper restore PossibleMultipleEnumeration
int eosCandidateCount = GetEosCharCount(segmenter.EosCandidates, paragraph);
return new DetailedEvaluation(hits, misses, falseAlarms, eosCandidateCount, paragraph);
}
/// <summary>
/// Searches the index for words in the search query
/// </summary>
/// <param name="query">Search query</param>
/// <returns>List of document IDs that match the query</returns>
public List <int> SearchWord(string query)
{
var words = _findWords.Matches(query);
IEnumerable <int> rtn = null;
for (var i = 0; i < words?.Count; i++)
{
var word = words[i].Value;
if (_index.ContainsKey(word))
{
rtn = rtn?.Intersect(_index[word].Keys) ?? _index[word].Keys;
}
else
{
return(new List <int>());
}
}
return(rtn?.ToList() ?? new List <int>());
}
/// <summary>
/// Checks if consent is required.
/// </summary>
/// <param name="client">The client.</param>
/// <param name="subject">The user.</param>
/// <param name="scopes">The scopes.</param>
/// <returns>Boolean if consent is required.</returns>
public virtual async Task<bool> RequiresConsentAsync(Client client, ClaimsPrincipal subject, IEnumerable<string> scopes)
{
if (client == null) throw new ArgumentNullException("client");
if (subject == null) throw new ArgumentNullException("subject");
if (!client.RequireConsent)
{
return false;
}
// TODO: validate that this is a correct statement
if (!client.AllowRememberConsent)
{
return true;
}
if (scopes == null || !scopes.Any())
{
return false;
}
// we always require consent for offline access if
// the client has not disabled RequireConsent
if (scopes.Contains(Constants.StandardScopes.OfflineAccess))
{
return true;
}
var consent = await _store.LoadAsync(subject.GetSubjectId(), client.ClientId);
if (consent != null && consent.Scopes != null)
{
var intersect = scopes.Intersect(consent.Scopes);
return !(scopes.Count() == intersect.Count());
}
return true;
}
/// <summary>
/// Add a formatted message representing a change in a relationship.
/// </summary>
public void AddChangedRelationship(string relName, IEnumerable <long> removed, IEnumerable <long> added, int count)
{
var sb = new StringBuilder();
var change = new ChangeRecord {
Field = relName
};
_changes.Add(change);
change.UpdateType = null;
var overlapping = removed.Intersect(added);
var reallyRemoved = removed.Except(overlapping);
if (reallyRemoved.Any())
{
sb.Append("removed ");
AddRelList(sb, reallyRemoved);
}
var reallyAdded = added.Except(overlapping);
if (reallyAdded.Any())
{
if (reallyRemoved.Any())
{
sb.Append(' ');
}
sb.Append("added ");
AddRelList(sb, reallyAdded.Except(overlapping));
}
change.Summary = sb.ToString();
}
public static TOwner HaveChecked <TData, TOwner>(this IFieldVerificationProvider <TData, CheckBoxList <TData, TOwner>, TOwner> should, TData value)
where TOwner : PageObject <TOwner>
{
should.CheckNotNull(nameof(should));
IEnumerable <TData> expectedIndividualValues = should.Component.GetIndividualValues(value);
string expectedIndividualValuesAsString = should.Component.ConvertIndividualValuesToString(expectedIndividualValues, true);
string expectedMessage = new StringBuilder().
Append("have checked").
AppendIf(expectedIndividualValues.Count() > 1, ":").
Append($" {expectedIndividualValuesAsString}").ToString();
AtataContext.Current.Log.Start(new VerificationLogSection(should.Component, $"{should.GetShouldText()} {expectedMessage}"));
IEnumerable <TData> actualIndividualValues = null;
bool doesSatisfy = AtataContext.Current.Driver.Try().Until(
_ =>
{
actualIndividualValues = should.Component.GetIndividualValues(should.Component.Get());
int intersectionsCount = expectedIndividualValues.Intersect(actualIndividualValues).Count();
return(should.IsNegation ? intersectionsCount == 0 : intersectionsCount == expectedIndividualValues.Count());
},
should.GetRetryOptions());
if (!doesSatisfy)
{
throw should.CreateAssertionException(
expectedMessage,
should.Component.ConvertIndividualValuesToString(actualIndividualValues, true));
}
AtataContext.Current.Log.EndSection();
return(should.Owner);
}
/// <summary>
/// All the optional parameter are required if <see cref="T"/> does not implement <see cref="IComparable"/>.
/// </summary>
/// <param name="referenceCol">Reference collection</param>
/// <param name="newCol">New collection</param>
/// <param name="keySortGetter"></param>
/// <returns></returns>
public IEnumerable <ComparisonResult <T> > Compare(IEnumerable <T> referenceCol, IEnumerable <T> newCol,
IEqualityComparer <T> identityComparer = null,
IEqualityComparer <T> contentComparer = null,
Func <T, Object> keySortGetter = null)
{
if (identityComparer == null)
{
identityComparer = EqualityComparer <T> .Default;
}
if (contentComparer == null)
{
contentComparer = EqualityComparer <T> .Default;
}
var removedItems = referenceCol.Except(newCol, identityComparer);
var addedItems = newCol.Except(referenceCol, identityComparer);
var remainingItemsInRef = referenceCol.Intersect(newCol, identityComparer);
var changedItems = remainingItemsInRef.Except(newCol, contentComparer);
var UnChangedItems = remainingItemsInRef.Except(changedItems);
var r = new List <ComparisonResult <T> >();
r.AddRange(removedItems.Select(itemRef => new ComparisonResult <T>(ComparisonStatus.Removed, itemRef)));
r.AddRange(addedItems.Select(itemNew => new ComparisonResult <T>(ComparisonStatus.Added, itemNew)));
r.AddRange(changedItems.Select(itemNew => new ComparisonResult <T>(ComparisonStatus.Modified, itemNew)));
r.AddRange(UnChangedItems.Select(itemNew => new ComparisonResult <T>(ComparisonStatus.Unchanged, itemNew)));
// var sorter = new Sorter(comparer);
var r2 = r.OrderBy(c => (keySortGetter == null) ? c.Item : keySortGetter(c.Item));
return(r2);
}
private void InitializeProperties(IEnumerable <string> updatableProperties)
{
_allProperties = _propertyCache.GetOrAdd(
_structuredType,
(backingType) => backingType
.GetProperties(BindingFlags.Instance | BindingFlags.Public)
.Where(p => (p.GetSetMethod() != null || TypeHelper.IsCollection(p.PropertyType)) && p.GetGetMethod() != null)
.Select <PropertyInfo, PropertyAccessor <T> >(p => new FastPropertyAccessor <T>(p))
.ToDictionary(p => p.Property.Name));
if (updatableProperties != null)
{
_updatableProperties = updatableProperties.Intersect(_allProperties.Keys).ToList();
}
else
{
_updatableProperties = new List <string>(_allProperties.Keys);
}
if (_dynamicDictionaryPropertyinfo != null)
{
_updatableProperties.Remove(_dynamicDictionaryPropertyinfo.Name);
}
}
public IEnumerable <TemplateAsset> GetResultWithoutFilter <T>(IFilter <T> filter)
{
IEnumerable <TemplateAsset> result = null;
foreach (var f in StandardFilters.Values.Concat(CustomFilters.Where(cf => cf.SelectedFilter != null).Select(cf => cf.SelectedFilter)).Except(new[] { filter }))
{
if (f.SavedItems != null)
{
if (result == null)
{
result = f.SavedItems;
}
else
{
result = result.Intersect(f.SavedItems);
}
}
}
if (result == null)
{
result = Base;
}
return(result);
}
public static IEnumerable <T> IntersectMany <T>(this IEnumerable <IEnumerable <T> > src)
{
IEnumerable <T> ret = null;
foreach (var subSrc in src)
{
if (ret == null)
{
ret = subSrc;
}
else
{
if (!ret.Any())
{
yield break;
}
ret = ret.Intersect(subSrc);
}
}
foreach (var item in (ret ?? Enumerable.Empty <T>()))
{
yield return(item);
}
}
public static IEnumerable <T> FilteredData(IEnumerable <FilterParams> filterParams, IEnumerable <T> data)
{
var distinctColumns = filterParams.Where(x => !string.IsNullOrEmpty(x.ColumnName))
.Select(x => x.ColumnName).Distinct();
foreach (var colName in distinctColumns)
{
var filterColumn = typeof(T).GetProperty(colName,
BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Public);
if (filterColumn != null)
{
var filterValues =
filterParams.Where(x => x.ColumnName.Equals(colName)).Distinct();
if (filterValues.Count() > 1)
{
var sameColData = Enumerable.Empty <T>();
foreach (var val in filterValues)
{
sameColData = sameColData.Concat(FilterData(val.FilterOption, data, filterColumn,
val.FilterValue));
}
data = data.Intersect(sameColData);
}
else
{
data = FilterData(filterValues.FirstOrDefault().FilterOption, data, filterColumn,
filterValues.FirstOrDefault().FilterValue);
}
}
}
return(data);
}
private static bool IsValidPpmLocation(string directory)
{
if (directory == null)
{
return false;
}
string[] requiredFiles =
{
Constants.PeloponneseExeName,
Constants.PeloponneseExeName + ".config",
"Microsoft.Research.Peloponnese.wrapper.cmd",
};
IEnumerable<string> requiredFilesLower = requiredFiles.Select(x => x.ToLower());
IEnumerable<string> filesPresent =
Directory.EnumerateFiles(directory, "*.exe", SearchOption.TopDirectoryOnly)
.Concat(Directory.EnumerateFiles(directory, "*.config", SearchOption.TopDirectoryOnly))
.Concat(Directory.EnumerateFiles(directory, "*.cmd", SearchOption.TopDirectoryOnly))
.Select(x => Path.GetFileName(x).ToLower());
return (filesPresent.Intersect(requiredFilesLower).Count() == requiredFilesLower.Count());
}
public ActionResult Filter(FiltrationViewModel filter)
{
IQueryable <Person> people = db.People;
if (!string.IsNullOrEmpty(filter.Name))
{
people = people.Where(p => p.Name.ToLower().Contains(filter.Name.ToLower()));
}
if (!string.IsNullOrEmpty(filter.SecondName))
{
people = people.Where(p => p.SecondName.ToLower().Contains(filter.SecondName.ToLower()));
}
if (filter.PhoneNumber != null)
{
people = people.Where(p => p.PhoneNumber.ToString().Contains(filter.PhoneNumber.ToString()));
}
if (filter.CompanyId != 0)
{
people = people.Where(p => p.CompanyId.ToString().Contains(filter.CompanyId.ToString()));
}
IEnumerable <Person> people1 = people.Include(p => p.Company).ToList();
if (filter.Skills != null)
{
List <Person> peopleSkilled = new List <Person>();
Skill[] skillet = new Skill[filter.Skills.Length];
for (int i = 0; i < filter.Skills.Length; i++)
{
skillet[i] = db.Skills.Find(filter.Skills[i]);
people1 = people1.Intersect(skillet[i].People);
}
}
filter.People = people1;
TempData["filterModel"] = filter;
return(RedirectToAction("Index"));
}
private IEnumerable <Book> AllAnd(List <IEnumerable <Book> > listofbooks)
{
IEnumerable <Book> books = null;
foreach (var listofbook in listofbooks)
{
if (listofbook != null)
{
books = listofbook;
break;
}
}
if (books != null)
{
foreach (IEnumerable <Book> listofbook in listofbooks)
{
if (listofbook != null)
{
books = books.Intersect(listofbook).ToList();
}
}
}
return(books);
}
public static void Main(string[] args)
{
WriteLine("# Part 2");
WriteLine("--------");
WriteLine();
// const string fname = "example.txt";
const string fname = "input.txt";
var groups = FileUtils.Read(fname).Split("\n\n");
var total = 0;
foreach (var group in groups)
{
var elems = group.Split("\n");
IEnumerable <char> common = elems[0];
foreach (var elem in elems)
{
common = common.Intersect(elem);
}
total += common.Count();
}
WriteLine(total);
}
public override bool Equals(object obj)
{
if (obj is Projection <T> )
{
var otherProjection = obj as Projection <T>;
if (item != null && otherProjection.item != null)
{
IEnumerable <string> properties = this.properties;
if (otherProjection.properties != null)
{
properties = properties?.Intersect(otherProjection.properties) ?? otherProjection.properties;
}
if (properties != null)
{
return(Compare(item, otherProjection.item, properties));
}
}
}
else if (obj != null && obj.GetType() == typeof(T))
{
return(Compare(item, (T)obj, properties));
}
return(base.Equals(obj));
}
private IEnumerable <Ksiazka> WszystkieI(List <IEnumerable <Ksiazka> > listaksiazek)
{
IEnumerable <Ksiazka> ksiazki = null;
foreach (var listaksiazki in listaksiazek)
{
if (listaksiazki != null)
{
ksiazki = listaksiazki;
break;
}
}
if (ksiazki != null)
{
foreach (IEnumerable <Ksiazka> listaksiazki in listaksiazek)
{
if (listaksiazki != null)
{
ksiazki = ksiazki.Intersect(listaksiazki).ToList();
}
}
}
return(ksiazki);
}
public IEnumerable <T?> Call(IEnumerable <T> input)
{
if (input.Contains(_current))
{
return(NoOutput);
}
var matching = input.Intersect(_options);
if (matching.Any())
{
_current = matching.First();
return(new[] { _current });
}
else if (_current is not null)
{
_current = null;
return(new[] { _current });
}
else
{
return(NoOutput);
}
}
public GeneticDiff(
IEnumerable <Gene <T> > genes1,
IEnumerable <Gene <T> > genes2,
IGeneChoice <T> geneChoice = null)
{
int maxInvoNb;
IEnumerable <int> commonInnovNbs;
IEnumerable <Gene <T> > allGenes;
commonInnovNbs = genes1.Select(x => x.InnovNb)
.Intersect(genes2.Select(x => x.InnovNb));
if (geneChoice == null)
{
Matching = genes1.Intersect(genes2, new GeneInovEq <T>())
.ToArray();
}
else
{
Matching = commonInnovNbs.Select(x =>
{
return(geneChoice.Choice(genes1.First(y => y.InnovNb == x),
genes2.First(y => y.InnovNb == x)));
}).ToArray();
}
allGenes = genes1.Concat(genes2);
maxInvoNb = allGenes.Max(x => x.InnovNb);
Disjoint = allGenes.Where(x =>
!commonInnovNbs.Contains(x.InnovNb) &&
x.InnovNb <= maxInvoNb).ToArray();
Excess = allGenes.Where(x =>
!commonInnovNbs.Contains(x.InnovNb) &&
x.InnovNb > maxInvoNb).ToArray();
}
/// <summary>
/// Initializes a new instance of the search input.
/// </summary>
/// <param name="options">Represents the search input options.</param>
/// <param name="searchString">Represents the text to search for.</param>
/// <param name="searchIn">Represents the fields in which to search for the given text.</param>
/// <param name="filter">Represents the filters to be applied to the results.</param>
/// <param name="sortBy">Represents the field based which to sort the results.</param>
/// <param name="sortDirection">Represents the direction in which to sort the results.</param>
/// <param name="itemsPerPage">Represents the number of items to be displayed at one time, on a single page.</param>
/// <param name="currentPage">Represents the current page of the search.</param>
public SearchInputViewModel(SearchOptionsViewModel options, string id = null, string searchString = null, IEnumerable <string> searchIn = null, IEnumerable <string> filter = null, string sortBy = null, string sortDirection = null, int?itemsPerPage = null, int?currentPage = 1)
{
// Check the search options for possible errors.
if (options.Filter == null || options.ItemsPerPage == null || options.SearchIn == null || options.SortBy == null || options.SortDirection == null)
{
// Throw an exception.
throw new ArgumentException();
}
// Assign the search options.
Options = options;
// Check if the given parameters are the default ones.
NeedsRedirect = searchIn == null || filter == null || string.IsNullOrEmpty(sortBy) || !Options.SortBy.ContainsKey(sortBy) || string.IsNullOrEmpty(sortDirection) || !Options.SortDirection.ContainsKey(sortDirection) || itemsPerPage == null || itemsPerPage.Value < 1;
// Get the default values for those that are null or invalid.
searchString = string.IsNullOrEmpty(searchString) ? string.Empty : searchString;
searchIn = searchIn ?? Enumerable.Empty <string>();
filter = filter ?? Enumerable.Empty <string>();
sortBy = string.IsNullOrEmpty(sortBy) || !Options.SortBy.ContainsKey(sortBy) ? Options.SortBy.FirstOrDefault().Key : sortBy;
sortDirection = string.IsNullOrEmpty(sortDirection) || !Options.SortDirection.ContainsKey(sortDirection) ? Options.SortDirection.FirstOrDefault().Key : sortDirection;
itemsPerPage = itemsPerPage == null || itemsPerPage.Value < 1 ? Options.ItemsPerPage.FirstOrDefault().Key : itemsPerPage.Value;
currentPage = currentPage == null || currentPage.Value < 1 ? 1 : currentPage.Value;
// Define the properties.
Id = id;
SearchString = searchString;
SortBy = sortBy;
SortDirection = sortDirection;
ItemsPerPage = itemsPerPage.Value;
CurrentPage = currentPage.Value;
SearchIn = searchIn.Intersect(Options.SearchIn.Keys);
Filter = filter.Intersect(Options.Filter.Keys);
// Check if there is a search string applied, but there are no values selected to search in.
if (!string.IsNullOrEmpty(SearchString) && !SearchIn.Any())
{
// Select all of them.
SearchIn = Options.SearchIn.Keys;
}
}
private void SearchByMultipleRadical(string Radicals, Action UpdateStatusRadicalCountTextFunc, Action UpdateDataViewToEmpty)
{
IEnumerable <char> IntersectedChars = null;
foreach (var Radical in Radicals)
{
if (Radical2Chars.TryGetValue(Radical, out string Chars))
{
if (IntersectedChars == null)
{
IntersectedChars = Chars.ToList();
continue;
}
IntersectedChars = IntersectedChars.Intersect(Chars.ToList());
}
else
{
IntersectedChars = null;
break;
}
}
if (IntersectedChars == null)
{
UpdateDataViewToEmpty();
return;
}
Dictionary <char, List <string> > result = new Dictionary <char, List <string> >();
foreach (var Char in IntersectedChars)
{
result.Add(Char, Char2Radicals[Char]);
}
RefreshDataViewWithChars(result, UpdateStatusRadicalCountTextFunc);
}
private static bool AreEqual(IEnumerable <string> collectionA, IEnumerable <string> collectionB)
{
if (collectionA == null && collectionB == null)
{
return(true);
}
if (collectionA == null && collectionB != null)
{
return(false);
}
if (collectionA != null && collectionB == null)
{
return(false);
}
if (collectionA.Count() != collectionB.Count())
{
return(false);
}
return(collectionA.Intersect(collectionB).Count() == collectionA.Count());
}
/// <summary>
/// Checks if consent is required.
/// </summary>
/// <param name="subject">The user.</param>
/// <param name="client">The client.</param>
/// <param name="scopes">The scopes.</param>
/// <returns>
/// Boolean if consent is required.
/// </returns>
/// <exception cref="System.ArgumentNullException">
/// client
/// or
/// subject
/// </exception>
public virtual async Task <bool> RequiresConsentAsync(ClaimsPrincipal subject, Client client, IEnumerable <string> scopes)
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
if (subject == null)
{
throw new ArgumentNullException(nameof(subject));
}
if (!client.RequireConsent)
{
return(false);
}
if (!client.AllowRememberConsent)
{
return(true);
}
if (scopes == null || !scopes.Any())
{
return(false);
}
var consent = await _userConsentStore.GetUserConsentAsync(subject.GetSubjectId(), client.ClientId);
if (consent?.Scopes != null)
{
var intersect = scopes.Intersect(consent.Scopes);
return(!(scopes.Count() == intersect.Count()));
}
return(true);
}
public static async Task PackageGame(string[] args)
{
var currentDirectory = Directory.GetCurrentDirectory();
var directoryInfo = new DirectoryInfo(currentDirectory);
var gameName = directoryInfo.Name;
DirectoryInfo[] directories = directoryInfo.GetDirectories();
IEnumerable <string> directoryNames = directories.Select((directoryInfo) => directoryInfo.Name);
IEnumerable <string> expectedNames = knownSuffixes.Select((suffix) => $"{gameName}.{suffix}");
var detectedTargets = directoryNames.Intersect(expectedNames).ToList();
// Bail if not in a known directory
if (detectedTargets.Count() == 0)
{
Console.WriteLine("Expected directory structure not found.");
Environment.Exit(-2);
}
if (args.Length == 1 || args[1] == "--all")
{
// Default to packaging whatever it can find.
foreach (var target in detectedTargets)
{
var suffix = target.Split(".").Last().ToLower();
await PackageTarget($"--{suffix}", gameName);
}
return;
}
for (var i = 1; i < args.Length; i++)
{
await PackageTarget(args[i], gameName);
}
}
private void SearchNOW_Clicked(object sender, EventArgs e)
{
SaveSearchingStops(StartRouteSearchBar.Text, ReachRouteSearchBar.Text);
List <string> startStopUids = StopSQLiteRepository.Instance
.Get(StartRouteSearchBar.Text).Select(entity => entity.StopID).ToList();
List <string> endStopUids = StopSQLiteRepository.Instance
.Get(ReachRouteSearchBar.Text).Select(entity => entity.StopID).ToList();
if (startStopUids.Count() <= 0 || endStopUids.Count() <= 0)
{
DisplayAlert("提醒", "查無此站牌", "重新輸入");
StartRouteSearchBar.Text = "";
ReachRouteSearchBar.Text = "";
return;
}
StopOnRouteSQLiteRepository stopOnRouteRepository = StopOnRouteSQLiteRepository.Instance;
IEnumerable <string> subrouteUidsPassStartStops = stopOnRouteRepository.Retrieve(startStopUids).Select(stopOnRoute => stopOnRoute.SubRouteUID).Distinct();
IEnumerable <string> subrouteUidsPassEndStops = stopOnRouteRepository.Retrieve(endStopUids).Select(stopOnRoute => stopOnRoute.SubRouteUID).Distinct();
IEnumerable <string> subrouteUids = subrouteUidsPassStartStops.Intersect(subrouteUidsPassEndStops);
IEnumerable <Route> routes = RouteSQLiteRepository.Instance.GetSubroute(subrouteUids);
MainSrollView.Content = CreateLayoutFromRoutes(routes);
}
/// <summary>
/// Lookup for a content item based on a <see cref="ContentIdentity"/>. If multiple
/// resolvers can give a result, the one with the highest priority is used. As soon as
/// only one content item is returned from resolvers, it is returned as the result.
/// </summary>
/// <param name="contentIdentity">The <see cref="ContentIdentity"/> instance to lookup</param>
/// <returns>The <see cref="ContentItem"/> instance represented by the identity object.</returns>
public ContentItem ResolveIdentity(ContentIdentity contentIdentity)
{
var resolvers = _identityResolverSelectors.Value
.Select(x => x.GetResolver(contentIdentity))
.Where(x => x != null)
.OrderByDescending(x => x.Priority);
if (!resolvers.Any())
{
return(null);
}
IEnumerable <ContentItem> contentItems = null;
foreach (var resolver in resolvers)
{
var resolved = resolver.Resolve(contentIdentity).ToArray();
// first pass
if (contentItems == null)
{
contentItems = resolved;
}
else // subsquent passes means we need to intersect
{
contentItems = contentItems.Intersect(resolved).ToArray();
}
if (contentItems.Count() == 1)
{
return(contentItems.First());
}
}
return(contentItems.FirstOrDefault());
}
private static IEnumerable <Project> GetProjectsToExamineWorker(
Solution solution,
IImmutableSet <Project> projects,
IEnumerable <ProjectId> projectsThatCouldReferenceType)
{
var dependencyGraph = solution.GetProjectDependencyGraph();
// Take the projects that were passed in, and find all the projects that
// they depend on (including themselves). i.e. if we have a solution that
// looks like:
// A <- B <- C <- D
// /
// └
// E
// and we're passed in 'B, C, E' as the project to search, then this set
// will be A, B, C, E.
var allProjectsThatTheseProjectsDependOn = projects
.SelectMany(p => dependencyGraph.GetProjectsThatThisProjectTransitivelyDependsOn(p.Id))
.Concat(projects.Select(p => p.Id)).ToSet();
// We then intersect this set with the actual set of projects that could reference
// the type. Say this list is B, C, D. The intersection of this list and the above
// one will then be 'B' and 'C'.
//
// In other words, there is no point searching A and E (because they can't even
// reference the type). And there's no point searching 'D' because it can't contribute
// any information that would affect the result in the projects we are asked to search
// within.
// Finally, because we're searching metadata and source symbols, this needs to be a project
// that actually supports compilations.
return(projectsThatCouldReferenceType.Intersect(allProjectsThatTheseProjectsDependOn)
.Select(id => solution.GetRequiredProject(id))
.Where(p => p.SupportsCompilation)
.ToList());
}
public ActionResult BooksCollection(Publication gotten, bool CB_Id = false, bool CB_Name = false, bool CB_Author = false, bool CB_BBK = false, bool CB_Pub = false, bool CB_Avail = false, string AvailableT = "")
{
if (Session["CurUsr"] == null)
{
Response.Redirect("~/Library/SignIn");
}
IEnumerable <Publication> pubs = DM.Book.publications();
if (CB_Id)
{
pubs = pubs.Intersect(DM.Book.publicationsById(gotten.Id));
}
if (CB_Name && gotten.Name != null)
{
pubs = pubs.Intersect(DM.Book.publicationsByName(gotten.Name));
}
if (CB_Author && gotten.Author != null)
{
pubs = pubs.Intersect(DM.Book.publicationsByAuthor(gotten.Author));
}
if (CB_BBK && gotten.BBK != null)
{
pubs = pubs.Intersect(DM.Book.publicationsByBBK(gotten.BBK));
}
if (CB_Pub && gotten.Publisher != null && gotten.Publisher.Name != null)
{
pubs = pubs.Intersect(DM.Book.publicationsByPub(gotten.Publisher.Name));
}
if (CB_Avail)
{
bool Avail = true;
if (AvailableT == "Нет в наличии")
{
Avail = false;
}
pubs = pubs.Intersect(DM.Book.publicationsByAvail(Avail));
}
ViewData["Books"] = pubs;
return(View());
}
private static IEnumerable<Language> GetAvailableLanguagesMatchingSearchQuery(SearchQuery query, IEnumerable<Language> languages)
{
return languages.Intersect(query.Languages);
}
public void NullableInt(IEnumerable<int?> first, IEnumerable<int?> second, int?[] expected)
{
Assert.Equal(expected, first.Intersect(second));
Assert.Equal(expected, first.Intersect(second, null));
}
/// <summary>Are there any common values between a and b?</summary>
public static bool SharesAnyValueWith <T>(this IEnumerable <T> a, IEnumerable <T> b)
=> a == null || b == null
? false
: a.Intersect(b).Any();
public static bool IsDirectedAtRobot(IEnumerable<string> tokens, IEnumerable<string> robotNames)
{
return tokens.Intersect(robotNames, StringComparer.OrdinalIgnoreCase).Any();
}
public static HtmlString AlphabeticPager(
this IHtmlHelper html,
string selectedLetter,
string alphabet,
IEnumerable<string> firstLetters,
string allLabel,
string allValue,
bool includeNumbers,
Func<string, string> pageLink)
{
//TagBuilder got funky in beta7 http://stackoverflow.com/questions/32416425/tagbuilder-innerhtml-in-asp-net-5-mvc-6
// so just using stringbuilder as of 2015-09-06
// probably can change back to TagBuilder after beta 8 as it should then have an .Append method to set innerhtml
var numbers = Enumerable.Range(0, 10).Select(i => i.ToString());
List<string> alphabetList;
if (string.IsNullOrEmpty(alphabet))
{
alphabetList = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray().ToStringList();
}
else
{
alphabetList = alphabet.ToCharArray().ToStringList();
}
if (string.IsNullOrEmpty(allLabel))
{
allLabel = "All";
}
alphabetList.Insert(0, allLabel);
if (includeNumbers)
{
alphabetList.Insert(1, "0-9");
}
var sb = new StringBuilder();
//var ul = new TagBuilder("ul");
//ul.AddCssClass("pagination");
//ul.AddCssClass("alpha");
sb.Append("<ul class='pagination alpha'>");
//BufferedHtmlContent innerHtml = new BufferedHtmlContent();
foreach (var letter in alphabetList)
{
//var li = new TagBuilder("li");
sb.Append("<li");
// firstletters is a list of which alpha chars actually have results
// so that ones without data can be non links
// if not provided then always make a link for every letter
if (letter == "All" || firstLetters == null || firstLetters.Contains(letter)
|| (firstLetters.Intersect(numbers).Any() && letter == "0-9"))
{
if (selectedLetter == letter || string.IsNullOrEmpty(selectedLetter) && letter == "All")
{
//li.AddCssClass("active");
//var span = new TagBuilder("span");
//span.SetInnerText(letter);
//li.InnerHtml = span;
sb.Append(" class='active'>");
sb.Append("<span>" + letter + "</span>");
sb.Append("</li>");
}
else
{
sb.Append(">");
//var a = new TagBuilder("a");
sb.Append("<a href='");
if (letter == allLabel)
{
sb.Append(pageLink(allValue) + "'");
//a.MergeAttribute("href", pageLink(allValue));
}
else
{
sb.Append(pageLink(letter) + "'");
// a.MergeAttribute("href", pageLink(letter));
}
sb.Append(">");
//a.SetInnerText(letter);
sb.Append(letter);
sb.Append("</a>");
//li.InnerHtml = a;
sb.Append("</li>");
}
}
else
{
sb.Append(" class='inactive'>");
sb.Append("<span>" + letter + "</span>");
sb.Append("</li>");
//li.AddCssClass("inactive");
//var span = new TagBuilder("span");
//span.SetInnerText(letter);
//li.InnerHtml = span;
}
//sb.Append(li.ToString());
}
//ul.InnerHtml = sb.ToString();
//ul.InnerHtml = new HtmlString(sb.ToString());
sb.Append("</ul>");
return new HtmlString(sb.ToString());
}
/// <summary>
/// Attempts to execute a plan.
/// </summary>
/// <param name="disabledPluginKeys">Plugins that must be disabled.</param>
/// <param name="stoppedPluginKeys">Plugins that must be stopped.</param>
/// <param name="runningPluginKeys">Plugins that must be running.</param>
/// <returns>A <see cref="IExecutionPlanError"/> that details the error if any.</returns>
public IExecutionPlanResult Execute( IEnumerable<IPluginInfo> disabledPluginKeys, IEnumerable<IPluginInfo> stoppedPluginKeys, IEnumerable<IPluginInfo> runningPluginKeys )
{
if( PluginCreator == null ) throw new InvalidOperationException( R.PluginCreatorIsNull );
if( ServiceReferencesBinder == null ) throw new InvalidOperationException( R.PluginConfiguratorIsNull );
int nbIntersect;
nbIntersect = disabledPluginKeys.Intersect( stoppedPluginKeys ).Count();
if( nbIntersect != 0 ) throw new CKException( R.DisabledAndStoppedPluginsIntersect, nbIntersect );
nbIntersect = disabledPluginKeys.Intersect( runningPluginKeys ).Count();
if( nbIntersect != 0 ) throw new CKException( R.DisabledAndRunningPluginsIntersect, nbIntersect );
nbIntersect = stoppedPluginKeys.Intersect( runningPluginKeys ).Count();
if( nbIntersect != 0 ) throw new CKException( R.StoppedAndRunningPluginsIntersect, nbIntersect );
List<PluginProxy> toDisable = new List<PluginProxy>();
List<PluginProxy> toStop = new List<PluginProxy>();
List<PluginProxy> toStart = new List<PluginProxy>();
foreach( IPluginInfo k in disabledPluginKeys )
{
PluginProxy p = EnsureProxy( k );
if( p.Status != RunningStatus.Disabled )
{
toDisable.Add( p );
if( p.Status != RunningStatus.Stopped )
{
toStop.Add( p );
}
}
}
foreach( IPluginInfo k in stoppedPluginKeys )
{
PluginProxy p = EnsureProxy( k );
if( p.Status != RunningStatus.Stopped )
{
toStop.Add( p );
}
}
// The lists toDisable and toStop are correctly filled.
// A plugin can be in both lists if it must be stopped and then disabled.
// Now, we attempt to activate the plugins that must run: if an error occurs,
// we leave and return the error since we did not change anything.
foreach( IPluginInfo k in runningPluginKeys )
{
PluginProxy p = EnsureProxy( k );
if( !p.IsLoaded )
{
if( !p.TryLoad( _serviceHost, PluginCreator ) )
{
Debug.Assert( p.LoadError != null );
_serviceHost.LogMethodError( PluginCreator.Method, p.LoadError );
// Unable to load the plugin: leave now.
return new ExecutionPlanResult() { Culprit = p.PluginKey, Status = ExecutionPlanResultStatus.LoadError };
}
Debug.Assert( p.LoadError == null );
Debug.Assert( p.Status == RunningStatus.Disabled );
_newlyLoadedPlugins.Add( p );
}
if( p.Status != RunningStatus.Started )
{
toStart.Add( p );
}
}
// The toStart list is ready: plugins inside are loaded without error.
// We stop all "toStop" plugin.
// Their "stop" methods will be called.
foreach( PluginProxy p in toStop )
{
if( p.Status > RunningStatus.Stopped )
{
try
{
SetPluginStatus( p, RunningStatus.Stopping );
p.RealPlugin.Stop();
_log.Debug( String.Format( "The {0} plugin has been successfully stopped.", p.PublicName ) );
}
catch( Exception ex )
{
#if DEBUG
//Helps the developper identify the culprit of exception
Debugger.Break();
#endif
_log.ErrorFormat( "There has been a problem when stopping the {0} plugin.", ex, p.PublicName );
_serviceHost.LogMethodError( p.GetImplMethodInfoStop(), ex );
}
}
}
// We un-initialize all "toStop" plugin.
// Their "Teardown" methods will be called.
// After that, they are all "stopped".
foreach( PluginProxy p in toStop )
{
try
{
if( p.Status > RunningStatus.Stopped )
{
SetPluginStatus( p, RunningStatus.Stopped );
p.RealPlugin.Teardown();
_log.Debug( String.Format( "The {0} plugin has been successfully torn down.", p.PublicName ) );
}
}
catch( Exception ex )
{
#if DEBUG
//Helps the developper identify the culprit of exceptions
Debugger.Break();
#endif
_log.ErrorFormat( "There has been a problem when tearing down the {0} plugin.", ex, p.PublicName );
_serviceHost.LogMethodError( p.GetImplMethodInfoTeardown(), ex );
}
}
Debug.Assert( toStop.All( p => p.Status <= RunningStatus.Stopped ) );
// Prepares the plugins to start so that they become the implementation
// of their Service and are at least stopped (instead of disabled).
foreach( PluginProxy p in toStart )
{
ServiceProxyBase service = p.Service;
// The call to service.SetImplementation, sets the implementation and takes
// the _status of the service into account: this status is at most Stopped
// since we necessarily stopped the previous implementation (if any) above.
if( service != null )
{
Debug.Assert( service.Status <= RunningStatus.Stopped );
service.SetPluginImplementation( p );
}
// This call will trigger an update of the service status.
if( p.Status == RunningStatus.Disabled ) SetPluginStatus( p, RunningStatus.Stopped );
}
// Now that services have been associated to their new implementation (in Stopped status), we
// can disable the plugins that must be disabled.
foreach( PluginProxy p in toDisable )
{
SetPluginStatus( p, RunningStatus.Disabled );
try
{
p.DisposeIfDisposable();
}
catch( Exception ex )
{
#if DEBUG
//Helps the developper identify the culprit of exceptions
Debugger.Break();
#endif
_log.ErrorFormat( "There has been a problem when disposing the {0} plugin.", ex, p.PublicName );
_serviceHost.LogMethodError( p.GetImplMethodInfoDispose(), ex );
}
}
// Before starting
for( int i = 0; i < toStart.Count; i++ )
{
PluginProxy p = toStart[i];
// We configure plugin's edition properties.
if( PluginConfigurator != null ) PluginConfigurator( p );
SetPluginStatus( p, RunningStatus.Starting );
IPluginSetupInfo info = new IPluginSetupInfo();
try
{
p.RealPlugin.Setup( info );
info.Clear();
_log.Debug( String.Format( "The {0} plugin has been successfully set up.", p.PublicName ) );
}
catch( Exception ex )
{
#if DEBUG
//Helps the developper identify the culprit of exceptions
Debugger.Break();
#endif
_log.ErrorFormat( "There has been a problem when setting up the {0} plugin.", ex, p.PublicName );
_serviceHost.LogMethodError( p.GetImplMethodInfoSetup(), ex );
// Revoking the call to Setup for all plugins that haven't been started yet.
//Will pass the plugin to states : Stopping and then Stopped
for( int j = 0; j <= i; j++ )
{
RevokeSetupCall( toStart[j] );
}
info.Error = ex;
return new ExecutionPlanResult() { Culprit = p.PluginKey, Status = ExecutionPlanResultStatus.SetupError, SetupInfo = info };
}
}
// Since we are now ready to start new plugins, it is now time to make the external world
// aware of the existence of any new plugins and configure them to run.
foreach( PluginProxy p in _newlyLoadedPlugins )
{
_loadedPlugins.Add( p.PluginKey.UniqueId, p );
}
Debug.Assert( ServiceReferencesBinder != null );
try
{
var listNew = new ReadOnlyCollectionOnICollection<PluginProxy>( _newlyLoadedPlugins );
//var disabled = new ReadOnlyCollectionAdapter<IPluginProxy, PluginProxy>( toDisable );
ServiceReferencesBinder( listNew );
}
catch( Exception ex )
{
_serviceHost.LogMethodError( ServiceReferencesBinder.Method, ex );
}
_newlyLoadedPlugins.Clear();
for( int i = 0; i < toStart.Count; i++ )
{
PluginProxy p = toStart[i];
try
{
SetPluginStatus( p, RunningStatus.Started );
p.RealPlugin.Start();
_log.Debug( String.Format( "The {0} plugin has been successfully started.", p.PublicName ) );
}
catch( Exception ex )
{
// Emitted as low level log.
_log.ErrorFormat( "There has been a problem when starting the {0} plugin.", ex, p.PublicName );
// Emitted as a log event.
_serviceHost.LogMethodError( p.GetImplMethodInfoStart(), ex );
//All the plugins already started when the exception was thrown have to be stopped + teardown (including this one in exception)
for( int j = 0; j <= i; j++ )
{
RevokeStartCall( toStart[j] );
}
// Revoking the call to Setup for all plugins that hadn't been started when the exception occured.
for( int j = i + 1; j < toStart.Count; j++ )
{
RevokeSetupCall( toStart[j] );
}
return new ExecutionPlanResult() { Culprit = p.PluginKey, Status = ExecutionPlanResultStatus.LoadError, Error = ex };
}
}
return new ExecutionPlanResult();
}
private bool IsTagNeeded(IEnumerable<string> filterTags, IEnumerable<string> currentTags)
{
if (IsEmptyTagList(filterTags))
return true;
if (currentTags == null)
return false;
return filterTags.Intersect(currentTags).Any();
}
private static bool HasAnyRole(DeploymentProcessResource deploymentProcess, IEnumerable<string> roles)
{
foreach (var step in deploymentProcess.Steps)
{
PropertyValueResource targetRolesProperty;
if (step.Properties.TryGetValue("Octopus.Action.TargetRoles", out targetRolesProperty))
{
var targetRoles = targetRolesProperty.Value.Split(',');
if (roles.Intersect(targetRoles).Any())
{
return true;
}
}
}
return false;
}
/// <summary>
/// Evaluate a term.
/// </summary>
/// <param name="factor">
/// Left term already read as part of the expression.
/// </param>
/// <returns>Test methods described by the expression.</returns>
/// <remarks>
/// Non-terminal created for left-factoring:
/// {Term'} :=
/// #empty#
/// ^ {Factor}{Term'}
/// </remarks>
private IEnumerable<ITestMethod> ReadTerm(IEnumerable<ITestMethod> factor)
{
if (TryMatch(Intersection))
{
return ReadTerm(factor.Intersect(ReadFactor()));
}
else
{
return factor;
}
}
private static bool IsModifed(NavigationProperty navigationProperty, IEnumerable<string> modifiedMembers)
{
var association = navigationProperty.RelationshipType as AssociationType;
if (association == null)
return false;
var referentialConstraint = association.ReferentialConstraints.FirstOrDefault();
if (referentialConstraint == null)
return false;
var toProperties = referentialConstraint
.ToProperties
.Select(p => p.Name)
.ToList();
return modifiedMembers.Intersect(toProperties).Any();
}
/// <summary>
/// Causes the Graph Pattern to be optimised if it isn't already
/// </summary>
/// <param name="gp">Graph Pattern</param>
/// <param name="variables">Variables that have occurred prior to this Pattern</param>
public void Optimise(GraphPattern gp, IEnumerable<String> variables)
{
//Our Variables is initially only those in our Triple Patterns since
//anything else is considered to be out of scope
List<String> ourVariables = (from tp in gp.TriplePatterns
from v in tp.Variables
select v).Distinct().ToList();
//Start by sorting the Triple Patterns in the list according to the ranking function
gp.TriplePatterns.Sort(this.GetRankingComparer());
//Apply reordering unless an optimiser has chosen to disable it
if (this.ShouldReorder)
{
if (gp.TriplePatterns.Count > 0)
{
//After we sort which gives us a rough optimisation we then may want to reorder
//based on the Variables that occurred previous to us OR if we're the Root Graph Pattern
if (!variables.Any())
{
//Optimise this Graph Pattern
//No previously occurring variables so must be the first Graph Pattern
if (gp.TriplePatterns.Count > 1)
{
HashSet<String> currVariables = new HashSet<String>();
gp.TriplePatterns[0].Variables.ForEach(v => currVariables.Add(v));
for (int i = 1; i < gp.TriplePatterns.Count - 1; i++)
{
if (currVariables.Count == 0)
{
gp.TriplePatterns[i].Variables.ForEach(v => currVariables.Add(v));
continue;
}
else if (currVariables.IsDisjoint(gp.TriplePatterns[i].Variables))
{
this.TryReorderPatterns(gp, currVariables.ToList(), i + 1, i);
gp.TriplePatterns[i].Variables.ForEach(v => currVariables.Add(v));
}
else
{
gp.TriplePatterns[i].Variables.ForEach(v => currVariables.Add(v));
}
}
}
}
else
{
//Optimise this Graph Pattern based on previously occurring variables
if (gp.TriplePatterns.Count > 1 && !gp.TriplePatterns[0].Variables.Any(v => variables.Contains(v)) && variables.Intersect(ourVariables).Any())
{
this.TryReorderPatterns(gp, variables.ToList(), 1, 0);
}
else if (gp.TriplePatterns.Count > 2)
{
//In the case where there are more than 2 patterns then we can try and reorder these
//in order to further optimise the pattern
this.TryReorderPatterns(gp, gp.TriplePatterns[0].Variables, 2, 1);
}
}
}
}
if (this.ShouldPlaceAssignments)
{
//First we need to place Assignments (LETs) in appropriate places within the Pattern
//This happens before Filter placement since Filters may use variables assigned to in LETs
if (gp.UnplacedAssignments.Any())
{
//Need to ensure that we sort Assignments
//This way those that use fewer variables get placed first
List<IAssignmentPattern> ps = gp.UnplacedAssignments.OrderBy(x => x).ToList();
//This next bit goes in a do loop as we want to keep attempting to place assignments while
//we are able to do so. If the count of unplaced assignments has decreased but is not
//zero it may be that we were unable to place some patterns as they relied on variables
//assigned in other LETs which weren't placed when we attempted to place them
//When we reach the point where no further placements have occurred or all assignments
//are placed we stop trying to place assignments
int c;
do
{
c = ps.Count;
int i = 0;
while (i < ps.Count)
{
if (this.TryPlaceAssignment(gp, ps[i]))
{
//Remove from Unplaced Assignments since it's been successfully placed in the Triple Patterns
//Don't increment the counter since the next Assignment is now at the index we're already at
ps.RemoveAt(i);
}
else
{
//Unable to place so increment counter
i++;
}
}
} while (c > ps.Count && ps.Count > 0);
}
}
//Regardless of what we've placed already we now place all remaining assignments
foreach (IAssignmentPattern assignment in gp.UnplacedAssignments.ToList())
{
gp.InsertAssignment(assignment, gp.TriplePatterns.Count);
}
if (this.ShouldPlaceFilters)
{
//Then we need to place the Filters in appropriate places within the Pattern
if (gp.UnplacedFilters.Any())
{
if (gp.TriplePatterns.Count == 0)
{
//Where there are no Triple Patterns the Graph Pattern just contains this Filter and possibly some
//child Graph Patterns. In such a case then we shouldn't place the Filters
}
else
{
foreach (ISparqlFilter f in gp.UnplacedFilters.ToList())
{
this.TryPlaceFilter(gp, f);
}
}
}
}
//Finally optimise the Child Graph Patterns
foreach (GraphPattern cgp in gp.ChildGraphPatterns)
{
//At each point the variables that have occurred are those in the Triple Patterns and
//those in previous Graph Patterns
cgp.Optimise(this, ourVariables);
ourVariables.AddRange(cgp.Variables);
}
//Note: Any remaining Unplaced Filters/Assignments are OK since the ToAlgebra() method of a GraphPattern
//will take care of placing these appropriately
}
/// <summary>
/// Verifica se o usuário possui qualquer um dos papéis informado.
/// </summary>
/// <param name="roleIds">Os ids dos papéis.</param>
/// <returns>
/// True se possui.
/// </returns>
public bool HasAnyRole(IEnumerable<int> roleIds)
{
return roleIds.Contains(RoleId) || roleIds.Intersect(SubstituingRoleIds).Any();
}
/// <summary>
/// The list does not contain the expected values.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="actual"></param>
/// <param name="expected"></param>
public static void MustNotContain <T>(this IEnumerable <T> actual, params T[] expected)
{
Assert.False(actual.Intersect(expected).Any());
}
//Jaccard or Tanimoto
protected double JaccardDistance(IEnumerable<int> t1, IEnumerable<int> t2)
{
var common = t1.Intersect(t2).Count();
return 1.0 - (1.0*common/(t1.Count() + t2.Count() - common));
}
private static IEnumerable GenerateEnumerable(Type objectType, FeatureLayerInfo layerInfo, IEnumerable<Graphic> graphics, string[] types, IEnumerable<Graphic> filter)
{
IEnumerable graphicsAfterFilter = filter != null ? graphics.Intersect<Graphic>(filter) : graphics;
var listType = typeof(ObservableCollection<>).MakeGenericType(new[] { objectType });
var listOfCustom = Activator.CreateInstance(listType);
foreach (Graphic g in graphicsAfterFilter)
{
var row = AttributeListToObject(objectType, layerInfo, g, null, types);
listType.GetMethod("Add").Invoke(listOfCustom, new[] { row });
}
return listOfCustom as IEnumerable;
}
private void buildIndexTables(IEnumerable<ITag> originalRootTags, TagUserAuthorizations auths)
{
//Search for visible tags and authorized photos
Dictionary<string, IPhoto> authorizedPhotos = new Dictionary<string, IPhoto>();
List<ITag> authorizedTags = getAuthorizedTags(originalRootTags, auths).ToList();
HashSet<ITag> visibleTags = new HashSet<ITag>();
foreach (var tag in authorizedTags)
{
foreach (var photo in tag.Photos)
{
//even not directly authorized tags can be traversed or can reference authorized photo.
//We register them, but not theirs photos.
photo.Tags
.ForEach(t => getTagsHierarchy(t)
.ForEach(t2 => visibleTags.Add(t2)));
//Register photos from a directly authorized tag.
authorizedPhotos[photo.Id] = photo;
}
}
//root tags
this.rootTags = (from rootTag in originalRootTags.Intersect(visibleTags)
select new InternalTag(rootTag, authorizedTags, visibleTags, null)).ToList();
//tag index
tags = new Dictionary<string, InternalTag>();
foreach (var rootTag in rootTags)
{
tags[rootTag.Id] = rootTag;
foreach(var subTag in rootTag.AllTags)
tags[subTag.Id] = subTag;
}
//Order photo in a timeline list.
var tempTimeline = new List<IPhoto>(authorizedPhotos.Values);
tempTimeline.Sort((p1, p2) => p2.Date.CompareTo(p1.Date));
timelinePhotos = new LinkedList<IPhoto>(tempTimeline);
//day index for timeline.
photosByDays = new Dictionary<DateTime, LinkedListNode<IPhoto>>();
for (var item = timelinePhotos.First; item != null; item = item.Next)
if (item == timelinePhotos.First || item.Previous.Value.Date.Date != item.Value.Date.Date)
photosByDays[item.Value.Date.Date] = item;
//photo ids index for timeline.
photosByIds = new Dictionary<string, LinkedListNode<IPhoto>>();
for (var item = timelinePhotos.First; item != null; item = item.Next)
photosByIds[item.Value.Id] = item;
}
/// <summary>
/// Combines the result of two collections and returns a collection of all objects that exist in both. Used to combine filters.
/// </summary>
/// <param name="list1"></param>
/// <param name="list2"></param>
/// <returns>Returns a collection of objects that exist in both lists</returns>
public IEnumerable <Loan> CombineFilteredLists(IEnumerable <Loan> list1, IEnumerable <Loan> list2)
{
return(list1.Intersect(list2));
}
public override IEnumerable<string> Execute(IEnumerable<string> firstReferences, IEnumerable<string> secondReferences)
{
var intersection = firstReferences.Intersect(secondReferences);
return intersection;
}
public bool CanEnforcePolicies(IEnumerable <LoadingDockPolicy> loadingDockPolicies)
{
return(loadingDockPolicies.Intersect(SupportedPolicies).Any());
}
//<summary>
// Filter an element list using another selector. A null selector results in no filtering.
//</summary>
//<param name="?"></param>
//<param name="selector"></param>
protected IEnumerable<IDomObject> filterElementsIgnoreNull(IEnumerable<IDomObject> elements, string selector)
{
if (selector=="")
{
return Objects.EmptyEnumerable<IDomObject>();
}
else if (selector == null)
{
return elements;
}
else
{
SelectorChain selectors = new SelectorChain(selector);
if (selectors.Count > 0)
{
selectors.ForEach(item=>item.TraversalType = TraversalType.Filter);
}
// this is kind of unfortunate but is required to keep the order correct. Probably a more efficient
// way to do it but works fine for now
return elements.Intersect(selectors.Select(Document, elements));
}
}
