public static async Task <List <HitomiIndexMetadata> > Search3(HitomiDataQuery query)
{
int number = Environment.ProcessorCount;
int term = HitomiData.Instance.metadata_collection.Count / number;
List <Task <List <HitomiIndexMetadata> > > arr_task = new List <Task <List <HitomiIndexMetadata> > >();
for (int i = 0; i < number; i++)
{
int k = i;
if (k != number - 1)
{
arr_task.Add(new Task <List <HitomiIndexMetadata> >(() => search_internal(query, k * term, k * term + term)));
}
else
{
arr_task.Add(new Task <List <HitomiIndexMetadata> >(() => search_internal(query, k * term, HitomiData.Instance.metadata_collection.Count)));
}
}
Parallel.ForEach(arr_task, task => task.Start());
await Task.WhenAll(arr_task);
List <HitomiIndexMetadata> result = new List <HitomiIndexMetadata>();
for (int i = 0; i < number; i++)
{
result.AddRange(arr_task[i].Result);
}
result.Sort((a, b) => b.ID - a.ID);
return(result);
}
private static List <HitomiIndexMetadata> search_internal(HitomiDataQuery query, int starts, int ends)
{
List <HitomiIndexMetadata> result = new List <HitomiIndexMetadata>();
for (int i = starts; i < ends; i++)
{
var v = HitomiData.Instance.metadata_collection[i];
if (query.Common.Contains(v.ID.ToString()))
{
result.Add(v);
continue;
}
string lang = "n/a"; //v.Language;
if (v.Language >= 0)
{
lang = HitomiData.Instance.index.Languages[v.Language];
}
if (Settings.Instance.Model.Language != "all" &&
Settings.Instance.Model.Language != lang)
{
continue;
}
if (query.Language != null &&
query.Language != lang)
{
continue;
}
if (query.TagExclude != null)
{
if (v.Tags != null)
{
int intersec_count = 0;
foreach (var tag in query.TagExclude)
{
if (v.Tags.Any(vtag => HitomiData.Instance.index.Tags[vtag].ToLower().Replace(' ', '_') == tag.ToLower()))
{
intersec_count++;
}
if (intersec_count > 0)
{
break;
}
}
if (intersec_count > 0)
{
continue;
}
}
}
bool[] check = new bool[query.Common.Count];
if (query.Common.Count > 0)
{
IntersectCountSplit(v.Name.Split(' '), query.Common, ref check);
if (v.Tags != null)
{
IntersectCountSplit(v.Tags.Select(x => HitomiData.Instance.index.Tags[x]).ToArray(), query.Common, ref check);
}
if (v.Artists != null)
{
IntersectCountSplit(v.Artists.Select(x => HitomiData.Instance.index.Artists[x]).ToArray(), query.Common, ref check);
}
if (v.Groups != null)
{
IntersectCountSplit(v.Groups.Select(x => HitomiData.Instance.index.Groups[x]).ToArray(), query.Common, ref check);
}
if (v.Parodies != null)
{
IntersectCountSplit(v.Parodies.Select(x => HitomiData.Instance.index.Series[x]).ToArray(), query.Common, ref check);
}
if (v.Characters != null)
{
IntersectCountSplit(v.Characters.Select(x => HitomiData.Instance.index.Characters[x]).ToArray(), query.Common, ref check);
}
}
bool connect = false;
if (check.Length == 0)
{
check = new bool[1]; check[0] = true;
}
if (check[0] && v.Artists != null && query.Artists != null)
{
check[0] = IsIntersect(v.Artists.Select(x => HitomiData.Instance.index.Artists[x]).ToArray(), query.Artists); connect = true;
}
else if (query.Artists != null)
{
check[0] = false;
}
if (check[0] && v.Tags != null && query.TagInclude != null)
{
check[0] = IsIntersect(v.Tags.Select(x => HitomiData.Instance.index.Tags[x]).ToArray(), query.TagInclude); connect = true;
}
else if (query.TagInclude != null)
{
check[0] = false;
}
if (check[0] && v.Groups != null && query.Groups != null)
{
check[0] = IsIntersect(v.Groups.Select(x => HitomiData.Instance.index.Groups[x]).ToArray(), query.Groups); connect = true;
}
else if (query.Groups != null)
{
check[0] = false;
}
if (check[0] && v.Parodies != null && query.Series != null)
{
check[0] = IsIntersect(v.Parodies.Select(x => HitomiData.Instance.index.Series[x]).ToArray(), query.Series); connect = true;
}
else if (query.Series != null)
{
check[0] = false;
}
if (check[0] && v.Characters != null && query.Characters != null)
{
check[0] = IsIntersect(v.Characters.Select(x => HitomiData.Instance.index.Characters[x]).ToArray(), query.Characters); connect = true;
}
else if (query.Characters != null)
{
check[0] = false;
}
if (check[0] && v.Type != null && query.Type != null)
{
check[0] = query.Type.Any(x => v.Type >= 0 && x == HitomiData.Instance.index.Types[v.Type].Replace(' ', '_')); connect = true;
}
else if (query.Type != null)
{
check[0] = false;
}
if (check.All((x => x)) && ((query.Common.Count == 0 && connect) || query.Common.Count > 0))
{
result.Add(v);
}
}
// required
result.Sort((a, b) => b.ID - a.ID);
return(result);
}
