private void VerifyFoldChanges(SrmDocument testDocument, GroupComparisonDef groupComparisonDef,
IDictionary <string, LinearFitResult> expectedResults)
{
var groupComparer = new GroupComparer(groupComparisonDef, testDocument, new QrFactorizationCache());
foreach (var protein in testDocument.MoleculeGroups)
{
var groupComparisonResult = groupComparer.CalculateFoldChanges(protein, null).FirstOrDefault();
LinearFitResult expectedResult;
if (expectedResults.TryGetValue(protein.Name, out expectedResult))
{
Assert.IsNotNull(groupComparisonResult);
var foldChange = groupComparisonResult.LinearFitResult;
Assert.AreEqual(expectedResult.EstimatedValue, foldChange.EstimatedValue, 1E-5);
Assert.AreEqual(expectedResult.DegreesOfFreedom, foldChange.DegreesOfFreedom);
Assert.AreEqual(expectedResult.StandardError, foldChange.StandardError, 1E-5);
Assert.AreEqual(expectedResult.TValue, foldChange.TValue, 1E-5);
Assert.AreEqual(expectedResult.PValue, foldChange.PValue, 1E-5);
}
else
{
Assert.IsNull(groupComparisonResult);
var standardPeptides = protein.Molecules.Where(mol => !string.IsNullOrEmpty(mol.GlobalStandardType)).ToArray();
Assert.AreNotEqual(0, standardPeptides.Length);
}
}
}
public void CompareAveragingWithMSstats()
{
var srmDocument = LoadRatPlasmaDocument();
var documentContainer = new MemoryDocumentContainer();
documentContainer.SetDocument(documentContainer.Document, srmDocument);
GroupComparisonModel model = new GroupComparisonModel(documentContainer, null);
model.GroupComparisonDef = GroupComparisonDef.EMPTY.ChangeControlAnnotation("Condition")
.ChangeControlValue("Healthy")
.ChangeIdentityAnnotation("BioReplicate")
.ChangeSummarizationMethod(SummarizationMethod.AVERAGING)
.ChangePerProtein(false);
var expectedValues = MsStatsTestUtil.ReadExpectedResults(typeof(MSstatsAveragingTest),
"RatPlasmaTestingResult.csv");
var groupComparer = new GroupComparer(model.GroupComparisonDef, srmDocument, new QrFactorizationCache());
foreach (var protein in srmDocument.PeptideGroups)
{
foreach (var peptide in protein.Peptides)
{
var result = groupComparer.CalculateFoldChange(new GroupComparisonSelector(protein, peptide, IsotopeLabelType.light, null, new GroupIdentifier("Diseased")), null);
var expectedResult = expectedValues[peptide.Peptide.Sequence];
Assert.AreEqual(expectedResult.EstimatedValue, result.LinearFitResult.EstimatedValue,
(expectedResult.StandardError + result.LinearFitResult.StandardError) * 2, peptide.Peptide.Sequence);
}
}
}
protected GroupComparer CreateGroupHeader(BaseComparer sc)
{
GroupComparer gc = new GroupComparer(sc.ColumnCollection, sc.ListIndex, sc.ObjectArray);
IndexList.Add(gc);
return(gc);
}
public void CompareAveragingWithMSstats()
{
var srmDocument = LoadRatPlasmaDocument();
var documentContainer = new MemoryDocumentContainer();
documentContainer.SetDocument(documentContainer.Document, srmDocument);
GroupComparisonModel model = new GroupComparisonModel(documentContainer, null);
model.GroupComparisonDef = GroupComparisonDef.EMPTY.ChangeControlAnnotation("Condition")
.ChangeControlValue("Healthy")
.ChangeIdentityAnnotation("BioReplicate")
.ChangeSummarizationMethod(SummarizationMethod.AVERAGING)
.ChangePerProtein(false);
var expectedValues = MsStatsTestUtil.ReadExpectedResults(typeof (MSstatsAveragingTest),
"RatPlasmaTestingResult.csv");
var groupComparer = new GroupComparer(model.GroupComparisonDef, srmDocument, new QrFactorizationCache());
foreach (var protein in srmDocument.PeptideGroups)
{
foreach (var peptide in protein.Peptides)
{
var result = groupComparer.CalculateFoldChange(new GroupComparisonSelector(protein, peptide, IsotopeLabelType.light, null, new GroupIdentifier("Diseased")), null);
var expectedResult = expectedValues[peptide.Peptide.Sequence];
Assert.AreEqual(expectedResult.EstimatedValue, result.LinearFitResult.EstimatedValue,
(expectedResult.StandardError + result.LinearFitResult.StandardError) * 2, peptide.Peptide.Sequence);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DataManager"/> class.
/// </summary>
private DataManager()
{
this.groups = new List <Group>();
this.comparer = new GroupComparer();
this.customers = new List <Customer>();
this.customerComparer = new CustomerComparer();
}
public override bool is_condition_met(List <List <int> > hand, params object[] args)
{
int winTile = ((int)args[0]) / 4;
List <Meld> melds = (List <Meld>)args[1];
bool isTsumo = (bool)args[2];
var gc = new GroupComparer <int>();
List <List <int> > openSets = melds.Select(x => x.tiles_34).ToList();
var chiSets = hand.Where(x => Utils.is_chi(x) && x.Contains(winTile) && !(openSets.Contains(x, gc)));
var ponSets = hand.Where(x => Utils.is_pon_or_kan(x));
var closed_pons = new List <List <int> >();
foreach (var pon in ponSets)
{
if (openSets.Contains(pon, gc))
{
continue;
}
//if we do the ron on syanpon wait our pon will be consider as open
// and it is not 789999 set
if (pon.Contains(winTile) && !isTsumo && chiSets.Count() == 0)
{
continue;
}
closed_pons.Add(pon);
}
return(closed_pons.Count == 3);
}
public void TestProteinAbundance()
{
var srmDocument = LoadRatPlasmaDocument();
var documentContainer = new MemoryDocumentContainer();
documentContainer.SetDocument(srmDocument, documentContainer.Document);
var skylineDataSchema = new SkylineDataSchema(documentContainer, DataSchemaLocalizer.INVARIANT);
GroupComparisonModel model = new GroupComparisonModel(documentContainer, null);
model.GroupComparisonDef = GroupComparisonDef.EMPTY.ChangeControlAnnotation("Condition")
.ChangeControlValue("Healthy")
.ChangeSummarizationMethod(SummarizationMethod.AVERAGING)
.ChangePerProtein(true);
var groupComparer = new GroupComparer(model.GroupComparisonDef, srmDocument, new QrFactorizationCache());
foreach (var moleculeGroup in srmDocument.MoleculeGroups)
{
if (moleculeGroup.Molecules.Any(mol => null != mol.GlobalStandardType))
{
continue;
}
var foldChangeResult = groupComparer.CalculateFoldChange(new GroupComparisonSelector(moleculeGroup, null, IsotopeLabelType.light, null, new GroupIdentifier("Diseased")), null);
var xValues = new List <double>();
var yValues = new List <double>();
var protein = new Protein(skylineDataSchema, new IdentityPath(moleculeGroup.PeptideGroup));
foreach (var proteinResult in protein.Results.Values)
{
var abundance = proteinResult.Abundance;
if (!abundance.HasValue)
{
continue;
}
var condition = proteinResult.Replicate.ChromatogramSet.Annotations.GetAnnotation("Condition");
if (condition == "Healthy")
{
xValues.Add(0);
}
else if (condition == "Diseased")
{
xValues.Add(1);
}
yValues.Add(Math.Log(abundance.Value));
}
Assert.AreEqual(xValues.Count, foldChangeResult.ReplicateCount);
if (!xValues.Any())
{
continue;
}
var yStatistics = new Statistics(yValues);
var xStatistics = new Statistics(xValues);
var slope = yStatistics.Slope(xStatistics);
var actualFoldChange = Math.Exp(slope);
var expectedFoldChange = Math.Pow(2.0, foldChangeResult.LinearFitResult.EstimatedValue);
AssertEx.AreEqual(expectedFoldChange, actualFoldChange, .01);
}
}
public GroupComparisonResults(
GroupComparer groupComparer,
IEnumerable<GroupComparisonResult> resultRows,
DateTime startTime,
DateTime endTime)
{
GroupComparer = groupComparer;
ResultRows = ImmutableList.ValueOf(resultRows);
StartTime = startTime;
EndTime = endTime;
}
public void CanGroup_All_Elements_Contains_Children()
{
GroupColumn groupComparer = new GroupColumn("GroupItem", 1, ListSortDirection.Ascending);
var tableStrategy = GroupTableStrategyFactory(groupComparer);
tableStrategy.Bind();
foreach (BaseComparer element in tableStrategy.IndexList)
{
GroupComparer checkComparer = element as GroupComparer;
Assert.That(checkComparer.IndexList.Count > 0);
}
}
public void CanGroup_All_Elements_are_GroupComparer()
{
GroupColumn groupComparer = new GroupColumn("GroupItem", 1, ListSortDirection.Ascending);
ICSharpCode.Reports.Core.ListStrategy.TableStrategy tableStrategy = GroupTableStrategyFactory(groupComparer);
tableStrategy.Bind();
foreach (BaseComparer element in tableStrategy.IndexList)
{
GroupComparer checkComparer = element as GroupComparer;
Assert.IsNotNull(checkComparer);
}
}
/// <summary>
/// Index, group, sort and insert an entity to the collection.
/// If group doesn't exist, it will be created and sorted.
/// </summary>
/// <param name="item">The item to insert into.</param>
/// <param name="ignoreBackendFlatList">Whether ignore backend list or not.</param>
private void AddInternal(CommonViewItemModel item, bool ignoreBackendFlatList = false)
{
if (item != null)
{
var index = Indexer.GetIndexForGroup(item);
// If group exists
if (_itemsIndex.ContainsKey(index))
{
_itemsIndex[index].Add(item);
}
// Or create group
else
{
var newCreatedGroup = new GroupedItems(index, Indexer, ItemComparer);
_itemsIndex.Add(index, newCreatedGroup);
var processed = false;
if (Items.Count != 0)
{
for (int i = 0; i < Items.Count; i++)
{
if (GroupComparer.Compare(Items[i].Title, index) >= 0)
{
Items.Insert(i, newCreatedGroup);
processed = true;
break;
}
}
}
if (!processed)
{
Items.Add(newCreatedGroup);
}
// Add item
newCreatedGroup.Add(item);
}
// Add backend item (optional)
if (!ignoreBackendFlatList)
{
_entityCopies.Add(item);
}
// Notify change if required (precondition: IsEmpty == true)
if (IsEmpty)
{
IsEmpty = false;
}
}
}
private int RenderGroupIfNeeded(object item, object previous, int index)
{
bool isAlternateRow = index % 2 != 0 && (AlternatingGroupFooterTemplate != null || AlternatingGroupHeaderTemplate != null);
if (GroupComparer.Compare(item, previous) == 1)
{
RenderTemplate(isAlternateRow ? AlternatingGroupFooterTemplate : GroupFooterTemplate, previous, index);
}
if (GroupComparer.Compare(previous, item) == -1)
{
RenderTemplate(isAlternateRow ? AlternatingGroupHeaderTemplate : GroupHeaderTemplate, item, index++);
}
return(index);
}
public override bool is_condition_met(List <List <int> > hand, params object[] args)
{
var ponSets = hand.Where(x => Utils.is_pon_or_kan(x));
var sous = new List <List <int> >();
var pins = new List <List <int> >();
var mans = new List <List <int> >();
foreach (var pon in ponSets)
{
if (Utils.is_sou(pon[0]))
{
sous.Add(pon);
}
if (Utils.is_man(pon[0]))
{
mans.Add(pon);
}
if (Utils.is_pin(pon[0]))
{
pins.Add(pon);
}
}
var gc = new GroupComparer <int>();
foreach (var sou in sous)
{
var simpleSou = sou.Select(x => Utils.simplify(x)).ToList();
foreach (var man in mans)
{
var simpleMan = man.Select(x => Utils.simplify(x)).ToList();
foreach (var pin in pins)
{
var simplePin = pin.Select(x => Utils.simplify(x)).ToList();
if (simpleMan.SequenceEqual(simplePin) && simpleMan.SequenceEqual(simpleSou))
{
return(true);
}
}
}
}
return(false);
}
protected static void ShowIndexList(IndexList list)
{
foreach (BaseComparer element in list)
{
string s = String.Format("{0} ", element.ObjectArray[0]);
GroupComparer gc = element as GroupComparer;
if (gc != null)
{
s = s + "GroupHeader";
if (gc.IndexList != null)
{
s = s + String.Format(" <{0}> Childs", gc.IndexList.Count);
}
System.Console.WriteLine(s);
foreach (BaseComparer c in gc.IndexList)
{
Console.WriteLine("---- {0}", c.ObjectArray[0]);
}
}
}
}
public GroupComparisonRefinementData(SrmDocument document, double adjustedPValCutoff,
double foldChangeCutoff, int?msLevel, List <GroupComparisonDef> groupComparisonDefs,
SrmSettingsChangeMonitor progressMonitor)
{
_progressMonitor = progressMonitor;
_foldChangeCutoff = foldChangeCutoff;
_adjustedPValCutoff = adjustedPValCutoff;
if (msLevel.HasValue)
{
_msLevel = msLevel.Value;
}
else
{
_msLevel = document.PeptideTransitions.Any(t => !t.IsMs1) ? 2 : 1;
}
Data = new List <List <GroupComparisonRow> >();
foreach (var groupComparisonDef in groupComparisonDefs)
{
var groupComparer = new GroupComparer(groupComparisonDef, document, _qrFactorizationCache);
var results = GroupComparisonModel.ComputeResults(groupComparer, document, null, null, progressMonitor);
var adjustedPValues = PValues.AdjustPValues(results.Select(
row => row.LinearFitResult.PValue)).ToArray();
var foldChangeList = new List <GroupComparisonRow>();
for (int iRow = 0; iRow < results.Count; iRow++)
{
var resultRow = results[iRow];
FoldChangeResult foldChangeResult = new FoldChangeResult(groupComparisonDef.ConfidenceLevel,
adjustedPValues[iRow], resultRow.LinearFitResult, double.NaN);
foldChangeList.Add(new GroupComparisonRow(resultRow.Selector.Protein, resultRow.Selector.Peptide,
resultRow.Selector.MsLevel,
foldChangeResult));
}
Data.Add(foldChangeList);
}
}
protected void BuildGroup(IndexList list)
{
string compVal = String.Empty;
IndexList.Clear();
IndexList childList = null;
foreach (BaseComparer element in list)
{
string groupValue = ExtractValue(element);
if (compVal != groupValue)
{
childList = new IndexList();
GroupComparer gc = CreateGroupHeader(element);
gc.IndexList = childList;
}
CreateGroupedChildren(childList, element);
compVal = groupValue;
}
// ShowIndexList(IndexList);
}
public override bool is_condition_met(List <List <int> > hand, params object[] args)
{
var chis = hand.Where(x => Utils.is_chi(x));
if (chis.Count() < 3)
{
return(false);
}
var sou = new List <List <int> >();
var pin = new List <List <int> >();
var man = new List <List <int> >();
foreach (var chi in chis)
{
if (U.is_sou(chi[0]))
{
sou.Add(chi);
}
else if (U.is_man(chi[0]))
{
man.Add(chi);
}
else if (U.is_pin(chi[0]))
{
pin.Add(chi);
}
}
var suits = new List <List <List <int> > >
{
sou, man, pin
};
var one = new List <int> {
0, 1, 2
};
var two = new List <int> {
3, 4, 5
};
var three = new List <int> {
6, 7, 8
};
var comp = new GroupComparer <int>();
foreach (var suit in suits)
{
if (suit.Count() < 3)
{
continue;
}
var simpleSets = new List <List <int> >();
foreach (var set in suit)
{
simpleSets.Add(new List <int> {
U.simplify(set[0]), U.simplify(set[1]), U.simplify(set[2])
});
}
if (simpleSets.Contains(one, comp) && simpleSets.Contains(two, comp) && simpleSets.Contains(three, comp))
{
return(true);
}
}
return(false);
}
public GroupMerger(Sort groupSort)
{
groupComp = new GroupComparer <T>(groupSort);
queue = new TreeSet <MergedGroup <T> >(groupComp);
groupsSeen = new HashMap <T, MergedGroup <T> >();
}
protected GroupComparer CreateGroupHeader (BaseComparer sc)
{
GroupComparer gc = new GroupComparer(sc.ColumnCollection,sc.ListIndex,sc.ObjectArray);
IndexList.Add(gc);
return gc;
}
public GroupMerger(Sort groupSort)
{
groupComp = new GroupComparer <T>(groupSort);
queue = new JCG.SortedSet <MergedGroup <T> >(groupComp);
groupsSeen = new JCG.Dictionary <T, MergedGroup <T> >();
}
private void GetGroupsAction()
{
bool IsUserGroupsExist = false;
IsError = false;
if (IsUsersFound && SelectedSearchedUser != null && SelectedSearchedUser.AccountName != null)
{
IsBusy = true;
UpdateUserGroupsCommand.IsEnabled = false;
UserGroups.Clear();
UserGroupServiceAgent.GetUserGroups(SelectedSearchedUser.AccountName, (userGroups,oe) =>
{
_dispatcher.BeginInvoke(new Action(() =>
{
//IsBusy = true;
UserGroups.Clear();
//if (userGroups != null && userGroups.Count > 0)
if (userGroups != null)
{
IsUserGroupsExist = true;
userGroups.ForEach(group =>
{
var igroup = new Group()
{
Id = group.Id,
Name = group.Name,
IsEnabled = false,
OriginalIsSelected = true,
IsSelected = true,
IsModified = false,
Owner = group.Owner,
OwnerTitle = group.OwnerTitle
};
UserGroups.Add(igroup);
});
UserGroupServiceAgent.GetAllGroups((groups, ie) =>
{
_dispatcher.BeginInvoke(new Action(() =>
{
if (!IsUserGroupsExist) UserGroups.Clear();
if (groups != null && groups.Count > 0)
{
groups.ForEach(group =>
{
var igroup = new Group()
{
Id = group.Id,
Name = group.Title,
IsEnabled = false,
OriginalIsSelected = false,
IsSelected = false,
IsModified = false,
EditOwner = group.Owner,
OwnerTitle= group.OwnerTitle
};
if (IsUserGroupsExist)
{
GroupComparer comparer = new GroupComparer();
if (!UserGroups.Contains(igroup, comparer))
UserGroups.Add(igroup);
}
else
{
UserGroups.Add(igroup);
}
});
}
else
{
IsError = true;
ErrorMessage = Logger.BuildLogMessageForUser(ie, "No groups found!");
}
IsBusy = false;
}));
});
}
else
{
IsError = true;
ErrorMessage = Logger.BuildLogMessageForUser(oe, "No groups found!");
IsBusy = false;
}
}));
}
);
}
}
private GroupComparisonResults ComputeComparisonResults(GroupComparer groupComparer, SrmDocument document,
CancellationToken cancellationToken)
{
DateTime startTime = DateTime.Now;
List<GroupComparisonResult> results = new List<GroupComparisonResult>();
if (groupComparer.IsValid)
{
var peptideGroups = document.PeptideGroups.ToArray();
for (int i = 0; i < peptideGroups.Length; i++)
{
int percentComplete = 100 * i / peptideGroups.Length;
lock (_lock)
{
cancellationToken.ThrowIfCancellationRequested();
_percentComplete = percentComplete;
}
var peptideGroup = peptideGroups[i];
IEnumerable<PeptideDocNode> peptides;
if (groupComparer.ComparisonDef.PerProtein)
{
peptides = new PeptideDocNode[] {null};
}
else
{
peptides = peptideGroup.Peptides;
}
foreach (var peptide in peptides)
{
results.AddRange(groupComparer.CalculateFoldChanges(peptideGroup, peptide));
}
}
}
DateTime endTime = DateTime.Now;
return new GroupComparisonResults(groupComparer, results, startTime, endTime);
}
// synchronously process the request, fill up responseBuffer, and return statusCode
public int Process(HttpCtx ctx, int dummy)
{
// first step: check if the cache already has the calculated result for this set of parameters
var cacheKey = ctx.Params.GetParamKey();
if (CachedResults.TryGetValue(cacheKey, out var cachedList))
{
// bingo! already calculated before
composeResponse(ctx, cachedList, ctx.Params.Limit);
return(200);
}
var limit = 0;
var order = 0;
Keys keyMask = new Keys();
var keys = new List <Keys>();
var queryMask = new GroupQueryMask();
bool empty = false;
ArraySegment <int> likers = null;
int locationFrom = -1, locationTo = -1;
int statusFrom = -1, statusTo = -1;
int sexFrom = -1, sexTo = -1;
int yearFrom = -1, yearTo = -1;
int interestFrom = -1, interestTo = -1;
foreach (var query in ctx.Params)
{
var value = query.Value;
if (value.IsEmpty)
{
return(400);
}
if (query.Key == "query_id")
{
} // ignore
else
if (query.Key == "limit")
{
if (!value.TryToInt(out limit))
{
return(400);
}
if (limit <= 0 || limit > 50)
{
return(400);
}
}
else
if (query.Key == "keys")
{
foreach (var key in value.Split(','))
{
var bit = Keys.None;
if (key == "sex")
{
bit = Keys.Sex;
keys.Add(Keys.Sex);
queryMask |= GroupQueryMask.KeySex;
}
else
if (key == "status")
{
bit = Keys.Status;
keys.Add(Keys.Status);
queryMask |= GroupQueryMask.KeyStatus;
}
else
if (key == "interests")
{
bit = Keys.Interests;
keys.Add(Keys.Interests);
queryMask |= GroupQueryMask.KeyInterest;
}
else
if (key == "country")
{
bit = Keys.Country;
keys.Add(Keys.Country);
queryMask |= GroupQueryMask.KeyCountry;
}
else
if (key == "city")
{
bit = Keys.City;
keys.Add(Keys.City);
queryMask |= GroupQueryMask.KeyCity;
}
if (bit == Keys.None)
{
return(400);
}
else
{
keyMask |= bit;
}
}
if (keyMask == Keys.None)
{
return(400);
}
}
else
if (query.Key == "order")
{
if (!value.TryToInt(out order))
{
return(400);
}
if (order != 1 && order != -1)
{
return(400);
}
}
else
if (query.Key == "sex")
{
if (value == "m")
{
sexFrom = sexTo = 1;
}
else
if (value == "f")
{
sexFrom = sexTo = 2;
}
else
{
return(400);
}
queryMask |= GroupQueryMask.Sex;
}
else
if (query.Key == "status")
{
if (value == DtoAccount.s_Free)
{
statusFrom = statusTo = 1;
}
else
if (value == DtoAccount.s_Taken)
{
statusFrom = statusTo = 2;
}
else
if (value == DtoAccount.s_Complicated)
{
statusFrom = statusTo = 3;
}
else
{
return(400);
}
queryMask |= GroupQueryMask.Status;
}
else
if (query.Key == "country")
{
if (store.Countries.TryGetValue(value, out IRange countryInd))
{
locationFrom = locationTo = countryInd.Index;
}
else
{
empty = true;
}
queryMask |= GroupQueryMask.Country;
}
else
if (query.Key == "city")
{
if (store.Cities.TryGetValue(value, out IRange cityInd))
{
locationFrom = locationTo = cityInd.Index;
}
else
{
empty = true;
}
queryMask |= GroupQueryMask.City;
}
else
if (query.Key == "interests")
{
if (store.Interests.TryGetValue(value, out IRange interestRange))
{
interestFrom = interestTo = interestRange.Index;
}
else
{
empty = true;
}
queryMask |= GroupQueryMask.Interests;
}
else
if (query.Key == "likes")
{
if (!value.TryToInt(out int extId))
{
return(400);
}
if (!Mapper.ExtIdToIntId(extId, out int id))
{
return(404);
}
var acct = store.Accounts[id];
if (acct.LikedByIdx == 0 || acct.LikedByCount == 0)
{
empty = true;
}
else
{
likers = new ArraySegment <int>(store.LikedBy, acct.LikedByIdx, acct.LikedByCount);
}
queryMask |= GroupQueryMask.Likes;
}
else
if (query.Key == "birth")
{
if (value.TryToInt(out int birthYear))
{
if (store.BirthYears.TryGetValue(birthYear, out IRange yearMap))
{
yearFrom = yearTo = yearMap.Index;
}
else
{
empty = true;
}
}
else
{
return(400);
}
queryMask |= GroupQueryMask.Birth;
}
else
if (query.Key == "joined")
{
if (value.TryToInt(out int joinYear))
{
if (store.JoinYears.TryGetValue(joinYear, out IRange yearMap))
{
yearFrom = yearTo = yearMap.Index;
}
else
{
empty = true;
}
}
else
{
return(400);
}
queryMask |= GroupQueryMask.Joined;
}
else // all other parameters are invalid
{
return(400);
}
}
if (limit == 0 || order == 0)
{
return(400);
}
if (empty) // shortcut, no groups will be found
{
return(212); // empty groups
}
// extend the from/to ranges based on the keys
{
if (keyMask.HasFlag(Keys.City) && locationFrom < 0)
{
locationFrom = 0;
locationTo = store.Cities.Count;
}
if (keyMask.HasFlag(Keys.Country) && locationFrom < 0)
{
locationFrom = 0;
locationTo = store.Countries.Count;
}
if (keyMask.HasFlag(Keys.Sex) && sexFrom < 0)
{
sexFrom = 1;
sexTo = 2;
}
if (keyMask.HasFlag(Keys.Status) && statusFrom < 0)
{
statusFrom = 1;
statusTo = 3;
}
if (keyMask.HasFlag(Keys.Interests) && interestFrom < 0)
{
interestFrom = 1;
interestTo = store.Interests.Count - 1;
}
}
// find the correct hypercube out of 4, or create new one for likes
IHypercube cube = null;
CubeKind cubeKind = CubeKind.None;
if (keyMask.HasFlag(Keys.City) || queryMask.HasFlag(GroupQueryMask.City))
{
if (queryMask.HasFlag(GroupQueryMask.Birth))
{
if (queryMask.HasFlag(GroupQueryMask.Likes))
{
cubeKind = CubeKind.CityBirth;
}
else
{
cube = store.CubeCityBirth;
}
}
else
{
if (queryMask.HasFlag(GroupQueryMask.Likes))
{
cubeKind = CubeKind.CityJoined;
}
else
{
cube = store.CubeCityJoined;
}
}
}
else
{
if (queryMask.HasFlag(GroupQueryMask.Birth))
{
if (queryMask.HasFlag(GroupQueryMask.Likes))
{
cubeKind = CubeKind.CountryBirth;
}
else
{
cube = store.CubeCountryBirth;
}
}
else
{
if (queryMask.HasFlag(GroupQueryMask.Likes))
{
cubeKind = CubeKind.CountryJoined;
}
else
{
cube = store.CubeCountryJoined;
}
}
}
HypercubeHash cubeHash = null;
// for likes, create a custom hypercube and fill it up
if (cube == null && likers != null)
{
if (!Pool <HypercubeHash> .TryGet(out cubeHash))
{
cubeHash = new HypercubeHash(cubeKind, 20000);
}
else
{
cubeHash.Reset(cubeKind);
}
cube = cubeHash;
foreach (var id in likers)
{
var acct = store.Accounts[id];
int statusIdx = (acct.Flags >> 1) & 3;
int sexIdx = (acct.Flags & Account.Male) > 0 ? 1 : 2;
int locationIdx = 0;
int yearIdx = 0;
switch (cubeKind)
{
case CubeKind.CityBirth:
locationIdx = acct.CityIdx;
yearIdx = acct.BirthIdx;
break;
case CubeKind.CityJoined:
locationIdx = acct.CityIdx;
yearIdx = acct.JoinedIdx;
break;
case CubeKind.CountryBirth:
locationIdx = acct.CountryIdx;
yearIdx = acct.BirthIdx;
break;
case CubeKind.CountryJoined:
locationIdx = acct.CountryIdx;
yearIdx = acct.JoinedIdx;
break;
default:
throw new Exception("Unexpected CubeKind");
}
cubeHash.Include(locationIdx, statusIdx, sexIdx, yearIdx, acct.InterestMask);
}
}
else
{
cubeKind = cube.Kind;
}
// calculate the size of the group
var size =
(locationTo - locationFrom + 1) *
(statusTo - statusFrom + 1) *
(sexTo - sexFrom + 1) *
(yearTo - yearFrom + 1) *
(interestTo - interestFrom + 1);
var groupList = new List <GroupItem>(size);
cube.Slice(
locationFrom, locationTo,
statusFrom, statusTo,
sexFrom, sexTo,
yearFrom, yearTo,
interestFrom, interestTo,
visit);
// local function, called by the cube
void visit(int location, int status, int sex, int year, int interest, int count)
{
var gi = new GroupItem {
store = store, Count = count
};
if (keyMask.HasFlag(Keys.Interests))
{
gi.interest = (byte)interest;
}
if (keyMask.HasFlag(Keys.Status))
{
gi.status = (byte)status;
}
if (keyMask.HasFlag(Keys.Sex))
{
gi.sex = (byte)sex;
}
if (keyMask.HasFlag(Keys.City))
{
gi.city = (short)location;
}
if (keyMask.HasFlag(Keys.Country))
{
gi.country = (byte)location;
}
groupList.Add(gi);
}
if (groupList.Count == 0)
{
if (cubeHash != null)
{
Pool <HypercubeHash> .Release(cubeHash);
}
CachedResults.TryAdd(cacheKey, groupList);
return(212);
}
var groupComparer = new GroupComparer(order, keys);
groupList.Sort(groupComparer);
composeResponse(ctx, groupList, limit);
// add to the cache for later reuse
if (groupList.Count > 50)
{
groupList.RemoveRange(50, groupList.Count - 50);
}
CachedResults.TryAdd(cacheKey, groupList);
// clean up
if (cubeHash != null)
{
Pool <HypercubeHash> .Release(cubeHash);
}
ctx.ContextType = "GetGroup";
return(200);
}
private void RestartCalculation()
{
var srmDocument = Document;
var groupComparisonDef = GroupComparisonDef;
if (_results != null)
{
if (Equals(_results.Document, srmDocument) && Equals(_results.GroupComparer.ComparisonDef, groupComparisonDef))
{
return;
}
}
if (null != _cancellationTokenSource)
{
_cancellationTokenSource.Cancel();
_cancellationTokenSource = null;
}
if (0 == _modelChangedListeners.Count)
{
return;
}
if (_groupComparer == null || !Equals(srmDocument, _groupComparer.SrmDocument) ||
!Equals(groupComparisonDef, _groupComparer.ComparisonDef))
{
_groupComparer = new GroupComparer(groupComparisonDef, srmDocument, _qrFactorizationCache);
}
_cancellationTokenSource = new CancellationTokenSource();
if (null != GroupComparisonDef && null != Document)
{
_percentComplete = 0;
GroupComparer groupComparer = _groupComparer;
var cancellationToken = _cancellationTokenSource.Token;
AddErrorHandler(Task.Factory.StartNew(() =>
{
var results = ComputeComparisonResults(groupComparer, srmDocument, cancellationToken);
lock (_lock)
{
if (!cancellationToken.IsCancellationRequested)
{
Results = results;
_percentComplete = 100;
}
}
}, _cancellationTokenSource.Token));
}
}
