private static void Main(string[] args) { Sort<string> sort = new Sort<string>(); string[] array = new string[10] { "table", "coffee", "tea", "juice", "1", "apple", "sea", "tree", "leopard", "ant", }; Console.WriteLine("Before sorting:"); sort.Print(array); sort.SortArray(array, CompareStrings); Console.WriteLine("After sorting:"); sort.Print(array); }
public Particle (int par1x, int par2y, Color par4color, Sort par5type) { life = 1F; int side = rand.Next (3, 5); if (par5type == Sort.Fog) side = rand.Next (5, 15); link = new Vector2 (par1x, par2y); if (par5type == Sort.Fixed) { int g = rand.Next (1, 3); if (g != 1) g = -1; int h = rand.Next (1, 3); if (h != 1) h = -1; par1x += rand.Next (0, 15) * g; par2y += rand.Next (0, 15) * h; } shape = new Rectangle (par1x, par2y, side, side); position = new Vector2 (shape.X, shape.Y); color = par4color; sprite = new Texture2D (Core.graphicsD, 1, 1); sprite.SetData (new Color[]{ color }); if(par5type != Sort.Fog) light = EffectManager.addLight (new Light (shape.X + shape.Width / 2, shape.Y + shape.Height / 2, side / 10F, color)); else life = 0.3F; type = par5type; }
/// <summary> /// Retrieves items from pocket /// with the given filters /// </summary> /// <param name="state">The state.</param> /// <param name="favorite">The favorite.</param> /// <param name="tag">The tag.</param> /// <param name="contentType">Type of the content.</param> /// <param name="sort">The sort.</param> /// <param name="search">The search.</param> /// <param name="domain">The domain.</param> /// <param name="since">The since.</param> /// <param name="count">The count.</param> /// <param name="offset">The offset.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns></returns> /// <exception cref="PocketException"></exception> public async Task<IEnumerable<PocketItem>> Get( State? state = null, bool? favorite = null, string tag = null, ContentType? contentType = null, Sort? sort = null, string search = null, string domain = null, DateTime? since = null, int? count = null, int? offset = null, CancellationToken cancellationToken = default(CancellationToken) ) { RetrieveParameters parameters = new RetrieveParameters() { State = state, Favorite = favorite, Tag = tag, ContentType = contentType, Sort = sort, DetailType = DetailType.complete, Search = search, Domain = domain, Since = since.HasValue ? ((DateTime)since).ToUniversalTime() : since, Count = count, Offset = offset }; return (await Request<Retrieve>("get", cancellationToken, parameters.Convert())).Items ?? new List<PocketItem>(); }
public static async Task<Response<List<Image>>> GetGallery(Section? section = null, Sort? sort = null, Window? window = null, bool? showViral = null, int? page = null) { string uri = "gallery"; if (section != null) { uri += "/" + section.ToString().ToLower(); if(sort != null) { uri += "/" + sort.ToString().ToLower(); if(window != null) { uri += "/" + window.ToString().ToLower(); if (showViral != null) { uri += "/" + showViral.ToString(); if (page != null) { uri += "/" + page; } } } } } return await NetworkHelper.GetRequest<List<Image>>(uri); }
/// <summary>Gets events.</summary> /// <param name="pagination">Pagination.</param> /// <param name="filter">Filters for events.</param> /// <param name="sort">Sort.</param> /// <returns>List of events matching passed filter criteria.</returns> public ListPaginated<EventDTO> GetAll(Pagination pagination, FilterEvents filter = null, Sort sort = null) { if (filter == null) return this.GetList<EventDTO>(MethodKey.EventsAll, pagination, ""); return this.GetList<EventDTO>(MethodKey.EventsAll, pagination, "", sort, filter.GetValues()); }
public List<User> Search(string request, Sort sort, out int count, int offset = 0, SearchProfileFields[] fields = null) { List<User> users = new List<User>(); NameValueCollection qs = new NameValueCollection(); qs["q"] = request; if (fields != null) qs["fields"] = String.Join(",", from field in fields select field.ToString()); qs["sort"] = ((int)sort).ToString(); qs["offset"] = offset.ToString(); XmlDocument answer = VkResponse.ExecuteCommand("users.search", qs); XmlNode node = answer.SelectSingleNode("response/count"); if (node != null) count = Convert.ToInt32(node.InnerText); else { count = 0; } XmlNodeList usersNodes = answer.SelectNodes("response/user"); if (usersNodes != null) foreach (XmlNode user in usersNodes) { users.Add(new User(user)); } return users; }
// // GET: /Advertisements/ public ActionResult List(Sort sort = Sort.PublishDate, uint minPrice = 0, uint maxPrice = Int32.MaxValue) { log.Debug("Run List()"); var advertisements = repository.Advertisements.Where(adv => minPrice <= adv.Price && adv.Price <= maxPrice).OrderBy(sort); var advertisementsListPagemodel = new AdvertisementsListPage(advertisements, sort, new AdvertisementsFilter(minPrice, maxPrice)); return View(advertisementsListPagemodel); }
public void WithNullParameters_ThrowsException() { Sort sort = new Sort(); var ex = Assert.Throws<ArgumentNullException>( () => Generator.Object.Select(ClassMap.Object, null, null, null)); StringAssert.Contains("cannot be null", ex.Message); Assert.AreEqual("Parameters", ex.ParamName); }
public ActionResult GetItems(Sort v) { var options = new[] { new SelectableItem(Sort.None, "None", v == Sort.None), new SelectableItem(Sort.Asc, "Asc", v== Sort.Asc), new SelectableItem(Sort.Desc, "Desc", v== Sort.Desc) }; return Json(options); }
public PersonnageJouable(int id, string nom, int lvl, int exp, EnumTypePersonnage tp, Equipement eq, CaracteristiquesPersonnage cp, ArbreCompetence ac) { _id = id; _nom = nom; _lvl = lvl; _exp = exp; _sort = new Sort[20]; _typePersonnage = tp; _equipement = eq; _CPersonnage = cp; _ACompetence = ac; }
public void BubbleSortSlowest_Fail_EmptyArray() { // ARRANGE Sort sortAlgos = new Sort(); int[] testNums = { }; // ACT sortAlgos.BubbleSlowest(testNums); // ASSERT // ExpectedException attribute }
public Ennemi(int id, string nom, int lvl, int exp, EnumTypePersonnage tp, Equipement eq, CaracteristiquesPersonnage cp, EnumStatusEnnemi st, Ia ia) { _id = id; _nom = nom; _lvl = lvl; _exp = exp; _sort = new Sort[20]; _typePersonnage = tp; _equipement = eq; _CPersonnage = cp; _status = st; _ia = ia; }
public static IEnumerable<Advertisement> OrderBy(this IEnumerable<Advertisement> advertisements, Sort sort) { switch (sort) { case Sort.Name: return advertisements.OrderBy(adv => adv.Name); case Sort.Price: return advertisements.OrderBy(adv => adv.Price); case Sort.PublishDate: default: return advertisements.OrderBy(adv => adv.PublishDate); } }
public static async Task<Response<List<Image>>> GetTopicGallery(int topicId, Sort? sort = null, int? page = null) { //{topicId}/{sort}/{page} string uri = "topics/" + topicId; if (sort != null) { if (page != null) { uri += "/" + page; } } return await NetworkHelper.GetRequest<List<Image>>(uri); }
public void BubbleSortSlower_Success_Descending() { // ARRANGE Sort sortAlgos = new Sort(SortOrder.Desc); // ACT int[] result = sortAlgos.BubbleSlower(testNumsUnordered); // ASSERT for (int i = 0; i < result.Length; i++) { Assert.AreEqual(testNumsOrderedDesc[i], result[i]); } }
public void BubbleSortSlowest_Success() { // ARRANGE Sort sortAlgos = new Sort(); // ACT int[] result = sortAlgos.BubbleSlowest(testNumsUnordered); // ASSERT for (int i = 0; i < result.Length; i++) { Assert.AreEqual(testNumsOrderedAsc[i], result[i]); } }
/* Simple Bubble sort using pointer to function for chosing to sort by SSN ascending */ public static void BubbleSort(IPayable[] employees, Sort sort) { for(int i = employees.Length; i > 0; i--) { for (int j = 1; j < i; j++) { IPayable temp = employees[j - 1]; //use pointer to function if((sort(employees[j], employees[j - 1]) < 1)){ //swap employees[j - 1] = employees[j]; employees[j] = temp; }//end if }//end for }//end for }
public static async Task<Response<List<Image>>> GetTopicGallery(int topicId, Sort? sort = null, Window? window = null, int? page = null) { //{topicId}/{sort}/{window}/{page} string uri = "topics/" + topicId; if (sort != null) { uri += "/" + sort.ToString().ToLower(); if (window != null) { uri += "/" + window.ToString().ToLower(); if (page != null) { uri += "/" + page; } } } return await NetworkHelper.GetRequest<List<Image>>(uri); }
/// <summary> /// Gets the gallery /// </summary> /// <param name="section"></param> /// <param name="sort"></param> /// <param name="page"></param> /// <param name="showViral">Used only when section is "user"</param> /// <returns></returns> public static async Task<Response<List<Image>>> GetGallery(Section? section = null, Sort? sort = null, int? page = null, bool? showViral = null) { string uri = "gallery"; if (section != null) { uri += "/" + section.ToString().ToLower(); if (sort != null) { if (page != null) { uri += "/" + page; } } } if (showViral != null) uri += ("?showViral=" + showViral.ToString().ToLower()); var response = await NetworkHelper.GetRequest<List<Image>>(uri); return response; }
public static async Task<Response<List<Image>>> GetSubreddditGallery(string subreddit, Sort? sort = null, Window? window = null, int? page = null) { //{ subreddit}/{ sort}/{ window}/{ page} string uri = "gallery/r/" + subreddit; if (sort != null) { uri += "/" + sort.ToString().ToLower(); if (window != null) { uri += "/" + window.ToString().ToLower(); if (page != null) { uri += "/" + page; } } } return await NetworkHelper.GetRequest<List<Image>>(uri); }
public void Objects() { string str; object nested = new Outer.Nested<int>(); str = CSharpObjectFormatter.Instance.FormatObject(nested, s_inline); Assert.Equal(@"Outer.Nested<int> { A=1, B=2 }", str); str = CSharpObjectFormatter.Instance.FormatObject(nested, new ObjectFormattingOptions(memberFormat: MemberDisplayFormat.NoMembers)); Assert.Equal(@"Outer.Nested<int>", str); str = CSharpObjectFormatter.Instance.FormatObject(A<int>.X, new ObjectFormattingOptions(memberFormat: MemberDisplayFormat.NoMembers)); Assert.Equal(@"A<int>.B<int>", str); object obj = new A<int>.B<bool>.C.D<string, double>.E(); str = CSharpObjectFormatter.Instance.FormatObject(obj, new ObjectFormattingOptions(memberFormat: MemberDisplayFormat.NoMembers)); Assert.Equal(@"A<int>.B<bool>.C.D<string, double>.E", str); var sort = new Sort(); str = CSharpObjectFormatter.Instance.FormatObject(sort, new ObjectFormattingOptions(maxLineLength: 51, memberFormat: MemberDisplayFormat.Inline)); Assert.Equal(@"Sort { aB=-1, ab=1, Ac=-1, Ad=1, ad=-1, aE=1, a ...", str); Assert.Equal(51, str.Length); str = CSharpObjectFormatter.Instance.FormatObject(sort, new ObjectFormattingOptions(maxLineLength: 5, memberFormat: MemberDisplayFormat.Inline)); Assert.Equal(@"S ...", str); Assert.Equal(5, str.Length); str = CSharpObjectFormatter.Instance.FormatObject(sort, new ObjectFormattingOptions(maxLineLength: 4, memberFormat: MemberDisplayFormat.Inline)); Assert.Equal(@"...", str); str = CSharpObjectFormatter.Instance.FormatObject(sort, new ObjectFormattingOptions(maxLineLength: 3, memberFormat: MemberDisplayFormat.Inline)); Assert.Equal(@"...", str); str = CSharpObjectFormatter.Instance.FormatObject(sort, new ObjectFormattingOptions(maxLineLength: 2, memberFormat: MemberDisplayFormat.Inline)); Assert.Equal(@"...", str); str = CSharpObjectFormatter.Instance.FormatObject(sort, new ObjectFormattingOptions(maxLineLength: 1, memberFormat: MemberDisplayFormat.Inline)); Assert.Equal(@"...", str); str = CSharpObjectFormatter.Instance.FormatObject(sort, new ObjectFormattingOptions(maxLineLength: 80, memberFormat: MemberDisplayFormat.Inline)); Assert.Equal(@"Sort { aB=-1, ab=1, Ac=-1, Ad=1, ad=-1, aE=1, aF=-1, AG=1 }", str); }
public void Run() { using (Context ctx = new Context()) { Symbol s1 = ctx.MkSymbol(1); Symbol s2 = ctx.MkSymbol(1); Symbol s3 = ctx.MkSymbol(2); Sort[] domain = new Sort[0]; Sort range = ctx.IntSort; TestDriver.CheckAssertion("a1", s1 == s2); TestDriver.CheckAssertion("a2", s1 != s3); TestDriver.CheckAssertion("a3", ctx.MkSymbol("x") != s1); TestDriver.CheckAssertion("a4", ctx.MkSymbol("x") == ctx.MkSymbol("x")); TestDriver.CheckAssertion("a5", ctx.MkFuncDecl("f", domain, range) == ctx.MkFuncDecl("f", domain, range)); TestDriver.CheckAssertion("a6", ctx.MkFuncDecl("f", domain, range) != ctx.MkFuncDecl("g", domain, range)); TestDriver.CheckAssertion("a7", ctx.MkUninterpretedSort("s") == ctx.MkUninterpretedSort("s")); TestDriver.CheckAssertion("a8", ctx.MkUninterpretedSort("s") != ctx.MkUninterpretedSort("t")); TestDriver.CheckAssertion("a9", ctx.MkUninterpretedSort("s") != ctx.IntSort); TestDriver.CheckAssertion("a10", ctx.MkConst("x", range) == ctx.MkConst("x", range)); TestDriver.CheckAssertion("a11", ctx.MkConst("x", range) == ctx.MkConst(ctx.MkSymbol("x"), range)); TestDriver.CheckAssertion("a12", ctx.MkConst("x", range) != ctx.MkConst("y", range)); } }
public void TestRandom() { int numberOfRuns = TestUtil.NextInt32(Random, 3, 6); for (int iter = 0; iter < numberOfRuns; iter++) { if (Verbose) { Console.WriteLine(string.Format("TEST: iter={0} total={1}", iter, numberOfRuns)); } int numDocs = TestUtil.NextInt32(Random, 100, 1000) * RandomMultiplier; int numGroups = TestUtil.NextInt32(Random, 1, numDocs); if (Verbose) { Console.WriteLine("TEST: numDocs=" + numDocs + " numGroups=" + numGroups); } List <BytesRef> groups = new List <BytesRef>(); for (int i = 0; i < numGroups; i++) { string randomValue; do { // B/c of DV based impl we can't see the difference between an empty string and a null value. // For that reason we don't generate empty string groups. randomValue = TestUtil.RandomRealisticUnicodeString(Random); } while ("".Equals(randomValue, StringComparison.Ordinal)); groups.Add(new BytesRef(randomValue)); } string[] contentStrings = new string[TestUtil.NextInt32(Random, 2, 20)]; if (Verbose) { Console.WriteLine("TEST: create fake content"); } for (int contentIDX = 0; contentIDX < contentStrings.Length; contentIDX++) { StringBuilder sb = new StringBuilder(); sb.append("real").append(Random.nextInt(3)).append(' '); int fakeCount = Random.nextInt(10); for (int fakeIDX = 0; fakeIDX < fakeCount; fakeIDX++) { sb.append("fake "); } contentStrings[contentIDX] = sb.toString(); if (Verbose) { Console.WriteLine(" content=" + sb.toString()); } } Directory dir = NewDirectory(); RandomIndexWriter w = new RandomIndexWriter( Random, dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random))); bool preFlex = "Lucene3x".Equals(w.IndexWriter.Config.Codec.Name, StringComparison.Ordinal); bool canUseIDV = !preFlex; DocValuesType valueType = vts[Random.nextInt(vts.Length)]; Document doc = new Document(); Document docNoGroup = new Document(); Field group = NewStringField("group", "", Field.Store.NO); doc.Add(group); Field valuesField = null; if (canUseIDV) { switch (valueType) { case DocValuesType.BINARY: valuesField = new BinaryDocValuesField("group_dv", new BytesRef()); break; case DocValuesType.SORTED: valuesField = new SortedDocValuesField("group_dv", new BytesRef()); break; default: fail("unhandled type"); break; } doc.Add(valuesField); } Field sort1 = NewStringField("sort1", "", Field.Store.NO); doc.Add(sort1); docNoGroup.Add(sort1); Field sort2 = NewStringField("sort2", "", Field.Store.NO); doc.Add(sort2); docNoGroup.Add(sort2); Field sort3 = NewStringField("sort3", "", Field.Store.NO); doc.Add(sort3); docNoGroup.Add(sort3); Field content = NewTextField("content", "", Field.Store.NO); doc.Add(content); docNoGroup.Add(content); Int32Field id = new Int32Field("id", 0, Field.Store.NO); doc.Add(id); docNoGroup.Add(id); GroupDoc[] groupDocs = new GroupDoc[numDocs]; for (int i = 0; i < numDocs; i++) { BytesRef groupValue; if (Random.nextInt(24) == 17) { // So we test the "doc doesn't have the group'd // field" case: groupValue = null; } else { groupValue = groups[Random.nextInt(groups.size())]; } GroupDoc groupDoc = new GroupDoc( i, groupValue, groups[Random.nextInt(groups.size())], groups[Random.nextInt(groups.size())], new BytesRef(string.Format(CultureInfo.InvariantCulture, "{0:D5}", i)), contentStrings[Random.nextInt(contentStrings.Length)] ); if (Verbose) { Console.WriteLine(" doc content=" + groupDoc.content + " id=" + i + " group=" + (groupDoc.group == null ? "null" : groupDoc.group.Utf8ToString()) + " sort1=" + groupDoc.sort1.Utf8ToString() + " sort2=" + groupDoc.sort2.Utf8ToString() + " sort3=" + groupDoc.sort3.Utf8ToString()); } groupDocs[i] = groupDoc; if (groupDoc.group != null) { group.SetStringValue(groupDoc.group.Utf8ToString()); if (canUseIDV) { valuesField.SetBytesValue(new BytesRef(groupDoc.group.Utf8ToString())); } } sort1.SetStringValue(groupDoc.sort1.Utf8ToString()); sort2.SetStringValue(groupDoc.sort2.Utf8ToString()); sort3.SetStringValue(groupDoc.sort3.Utf8ToString()); content.SetStringValue(groupDoc.content); id.SetInt32Value(groupDoc.id); if (groupDoc.group == null) { w.AddDocument(docNoGroup); } else { w.AddDocument(doc); } } DirectoryReader r = w.GetReader(); w.Dispose(); // NOTE: intentional but temporary field cache insanity! FieldCache.Int32s docIdToFieldId = FieldCache.DEFAULT.GetInt32s(SlowCompositeReaderWrapper.Wrap(r), "id", false); int[] fieldIdToDocID = new int[numDocs]; for (int i = 0; i < numDocs; i++) { int fieldId = docIdToFieldId.Get(i); fieldIdToDocID[fieldId] = i; } try { IndexSearcher s = NewSearcher(r); if (typeof(SlowCompositeReaderWrapper).IsAssignableFrom(s.IndexReader.GetType())) { canUseIDV = false; } else { canUseIDV = !preFlex; } for (int contentID = 0; contentID < 3; contentID++) { ScoreDoc[] hits = s.Search(new TermQuery(new Term("content", "real" + contentID)), numDocs).ScoreDocs; foreach (ScoreDoc hit in hits) { GroupDoc gd = groupDocs[docIdToFieldId.Get(hit.Doc)]; assertTrue(gd.score == 0.0); gd.score = hit.Score; int docId = gd.id; assertEquals(docId, docIdToFieldId.Get(hit.Doc)); } } foreach (GroupDoc gd in groupDocs) { assertTrue(gd.score != 0.0); } for (int searchIter = 0; searchIter < 100; searchIter++) { if (Verbose) { Console.WriteLine("TEST: searchIter=" + searchIter); } string searchTerm = "real" + Random.nextInt(3); bool sortByScoreOnly = Random.nextBoolean(); Sort sortWithinGroup = GetRandomSort(sortByScoreOnly); AbstractAllGroupHeadsCollector allGroupHeadsCollector = CreateRandomCollector("group", sortWithinGroup, canUseIDV, valueType); s.Search(new TermQuery(new Term("content", searchTerm)), allGroupHeadsCollector); int[] expectedGroupHeads = CreateExpectedGroupHeads(searchTerm, groupDocs, sortWithinGroup, sortByScoreOnly, fieldIdToDocID); int[] actualGroupHeads = allGroupHeadsCollector.RetrieveGroupHeads(); // The actual group heads contains Lucene ids. Need to change them into our id value. for (int i = 0; i < actualGroupHeads.Length; i++) { actualGroupHeads[i] = docIdToFieldId.Get(actualGroupHeads[i]); } // Allows us the easily iterate and assert the actual and expected results. Array.Sort(expectedGroupHeads); Array.Sort(actualGroupHeads); if (Verbose) { Console.WriteLine("Collector: " + allGroupHeadsCollector.GetType().Name); Console.WriteLine("Sort within group: " + sortWithinGroup); Console.WriteLine("Num group: " + numGroups); Console.WriteLine("Num doc: " + numDocs); Console.WriteLine("\n=== Expected: \n"); foreach (int expectedDocId in expectedGroupHeads) { GroupDoc expectedGroupDoc = groupDocs[expectedDocId]; string expectedGroup = expectedGroupDoc.group == null ? null : expectedGroupDoc.group.Utf8ToString(); Console.WriteLine( string.Format(CultureInfo.InvariantCulture, "Group:{0,10} score{1:0.0#######,5} Sort1:{2,10} Sort2:{3,10} Sort3:{4,10} doc:{5,10}", expectedGroup, expectedGroupDoc.score, expectedGroupDoc.sort1.Utf8ToString(), expectedGroupDoc.sort2.Utf8ToString(), expectedGroupDoc.sort3.Utf8ToString(), expectedDocId) ); } Console.WriteLine("\n=== Actual: \n"); foreach (int actualDocId in actualGroupHeads) { GroupDoc actualGroupDoc = groupDocs[actualDocId]; string actualGroup = actualGroupDoc.group == null ? null : actualGroupDoc.group.Utf8ToString(); Console.WriteLine( string.Format(CultureInfo.InvariantCulture, "Group:{0,10} score{1:0.0#######,5} Sort1:{2,10} Sort2:{3,10} Sort3:{4,10} doc:{5,10}", actualGroup, actualGroupDoc.score, actualGroupDoc.sort1.Utf8ToString(), actualGroupDoc.sort2.Utf8ToString(), actualGroupDoc.sort3.Utf8ToString(), actualDocId) ); } Console.WriteLine("\n==================================================================================="); } assertArrayEquals(expectedGroupHeads, actualGroupHeads); } } finally { QueryUtils.PurgeFieldCache(r); } r.Dispose(); dir.Dispose(); } }
public void TestBasic() { string groupField = "author"; Directory dir = NewDirectory(); RandomIndexWriter w = new RandomIndexWriter( Random, dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random)).SetMergePolicy(NewLogMergePolicy())); bool canUseIDV = !"Lucene3x".Equals(w.IndexWriter.Config.Codec.Name, StringComparison.Ordinal); DocValuesType valueType = vts[Random.nextInt(vts.Length)]; // 0 Document doc = new Document(); AddGroupField(doc, groupField, "author1", canUseIDV, valueType); doc.Add(NewTextField("content", "random text", Field.Store.NO)); doc.Add(NewStringField("id_1", "1", Field.Store.NO)); doc.Add(NewStringField("id_2", "1", Field.Store.NO)); w.AddDocument(doc); // 1 doc = new Document(); AddGroupField(doc, groupField, "author1", canUseIDV, valueType); doc.Add(NewTextField("content", "some more random text blob", Field.Store.NO)); doc.Add(NewStringField("id_1", "2", Field.Store.NO)); doc.Add(NewStringField("id_2", "2", Field.Store.NO)); w.AddDocument(doc); // 2 doc = new Document(); AddGroupField(doc, groupField, "author1", canUseIDV, valueType); doc.Add(NewTextField("content", "some more random textual data", Field.Store.NO)); doc.Add(NewStringField("id_1", "3", Field.Store.NO)); doc.Add(NewStringField("id_2", "3", Field.Store.NO)); w.AddDocument(doc); w.Commit(); // To ensure a second segment // 3 doc = new Document(); AddGroupField(doc, groupField, "author2", canUseIDV, valueType); doc.Add(NewTextField("content", "some random text", Field.Store.NO)); doc.Add(NewStringField("id_1", "4", Field.Store.NO)); doc.Add(NewStringField("id_2", "4", Field.Store.NO)); w.AddDocument(doc); // 4 doc = new Document(); AddGroupField(doc, groupField, "author3", canUseIDV, valueType); doc.Add(NewTextField("content", "some more random text", Field.Store.NO)); doc.Add(NewStringField("id_1", "5", Field.Store.NO)); doc.Add(NewStringField("id_2", "5", Field.Store.NO)); w.AddDocument(doc); // 5 doc = new Document(); AddGroupField(doc, groupField, "author3", canUseIDV, valueType); doc.Add(NewTextField("content", "random blob", Field.Store.NO)); doc.Add(NewStringField("id_1", "6", Field.Store.NO)); doc.Add(NewStringField("id_2", "6", Field.Store.NO)); w.AddDocument(doc); // 6 -- no author field doc = new Document(); doc.Add(NewTextField("content", "random word stuck in alot of other text", Field.Store.NO)); doc.Add(NewStringField("id_1", "6", Field.Store.NO)); doc.Add(NewStringField("id_2", "6", Field.Store.NO)); w.AddDocument(doc); // 7 -- no author field doc = new Document(); doc.Add(NewTextField("content", "random word stuck in alot of other text", Field.Store.NO)); doc.Add(NewStringField("id_1", "7", Field.Store.NO)); doc.Add(NewStringField("id_2", "7", Field.Store.NO)); w.AddDocument(doc); IndexReader reader = w.GetReader(); IndexSearcher indexSearcher = NewSearcher(reader); w.Dispose(); int maxDoc = reader.MaxDoc; Sort sortWithinGroup = new Sort(new SortField("id_1", SortFieldType.INT32, true)); var allGroupHeadsCollector = CreateRandomCollector(groupField, sortWithinGroup, canUseIDV, valueType); indexSearcher.Search(new TermQuery(new Term("content", "random")), allGroupHeadsCollector); assertTrue(ArrayContains(new int[] { 2, 3, 5, 7 }, allGroupHeadsCollector.RetrieveGroupHeads())); assertTrue(OpenBitSetContains(new int[] { 2, 3, 5, 7 }, allGroupHeadsCollector.RetrieveGroupHeads(maxDoc), maxDoc)); allGroupHeadsCollector = CreateRandomCollector(groupField, sortWithinGroup, canUseIDV, valueType); indexSearcher.Search(new TermQuery(new Term("content", "some")), allGroupHeadsCollector); assertTrue(ArrayContains(new int[] { 2, 3, 4 }, allGroupHeadsCollector.RetrieveGroupHeads())); assertTrue(OpenBitSetContains(new int[] { 2, 3, 4 }, allGroupHeadsCollector.RetrieveGroupHeads(maxDoc), maxDoc)); allGroupHeadsCollector = CreateRandomCollector(groupField, sortWithinGroup, canUseIDV, valueType); indexSearcher.Search(new TermQuery(new Term("content", "blob")), allGroupHeadsCollector); assertTrue(ArrayContains(new int[] { 1, 5 }, allGroupHeadsCollector.RetrieveGroupHeads())); assertTrue(OpenBitSetContains(new int[] { 1, 5 }, allGroupHeadsCollector.RetrieveGroupHeads(maxDoc), maxDoc)); // STRING sort type triggers different implementation Sort sortWithinGroup2 = new Sort(new SortField("id_2", SortFieldType.STRING, true)); allGroupHeadsCollector = CreateRandomCollector(groupField, sortWithinGroup2, canUseIDV, valueType); indexSearcher.Search(new TermQuery(new Term("content", "random")), allGroupHeadsCollector); assertTrue(ArrayContains(new int[] { 2, 3, 5, 7 }, allGroupHeadsCollector.RetrieveGroupHeads())); assertTrue(OpenBitSetContains(new int[] { 2, 3, 5, 7 }, allGroupHeadsCollector.RetrieveGroupHeads(maxDoc), maxDoc)); Sort sortWithinGroup3 = new Sort(new SortField("id_2", SortFieldType.STRING, false)); allGroupHeadsCollector = CreateRandomCollector(groupField, sortWithinGroup3, canUseIDV, valueType); indexSearcher.Search(new TermQuery(new Term("content", "random")), allGroupHeadsCollector); // 7 b/c higher doc id wins, even if order of field is in not in reverse. assertTrue(ArrayContains(new int[] { 0, 3, 4, 6 }, allGroupHeadsCollector.RetrieveGroupHeads())); assertTrue(OpenBitSetContains(new int[] { 0, 3, 4, 6 }, allGroupHeadsCollector.RetrieveGroupHeads(maxDoc), maxDoc)); indexSearcher.IndexReader.Dispose(); dir.Dispose(); }
public IActionResult Edit(Sort tog) { db.Entry(tog).State = EntityState.Modified; db.SaveChanges(); return(RedirectToAction("Index")); }
/// <summary> /// Utility method, to search and also collect all hits /// into the provided <see cref="ICollector"/>. /// </summary> public static TopDocs SearchAfter(IndexSearcher searcher, ScoreDoc after, Query q, Filter filter, int n, Sort sort, bool doDocScores, bool doMaxScore, ICollector fc) { if (sort == null) { throw new ArgumentException("sort must not be null"); } return(DoSearch(searcher, after, q, filter, n, sort, doDocScores, doMaxScore, fc)); }
public Task <SearchResult> SearchAsync(int channelId, int pageNo, int pageSize, Sort sort) { throw new NotImplementedException(); }
public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer) { if (untypedValue == null) { serializer.Serialize(writer, null); return; } Sort value = (Sort)untypedValue; switch (value) { case Sort.SortColor: serializer.Serialize(writer, "-color"); return; case Sort.SortFill: serializer.Serialize(writer, "-fill"); return; case Sort.SortFillOpacity: serializer.Serialize(writer, "-fillOpacity"); return; case Sort.SortOpacity: serializer.Serialize(writer, "-opacity"); return; case Sort.SortShape: serializer.Serialize(writer, "-shape"); return; case Sort.SortSize: serializer.Serialize(writer, "-size"); return; case Sort.SortStroke: serializer.Serialize(writer, "-stroke"); return; case Sort.SortStrokeOpacity: serializer.Serialize(writer, "-strokeOpacity"); return; case Sort.SortStrokeWidth: serializer.Serialize(writer, "-strokeWidth"); return; case Sort.SortText: serializer.Serialize(writer, "-text"); return; case Sort.SortX: serializer.Serialize(writer, "-x"); return; case Sort.SortY: serializer.Serialize(writer, "-y"); return; case Sort.Ascending: serializer.Serialize(writer, "ascending"); return; case Sort.Color: serializer.Serialize(writer, "color"); return; case Sort.Descending: serializer.Serialize(writer, "descending"); return; case Sort.Fill: serializer.Serialize(writer, "fill"); return; case Sort.FillOpacity: serializer.Serialize(writer, "fillOpacity"); return; case Sort.Opacity: serializer.Serialize(writer, "opacity"); return; case Sort.Shape: serializer.Serialize(writer, "shape"); return; case Sort.Size: serializer.Serialize(writer, "size"); return; case Sort.Stroke: serializer.Serialize(writer, "stroke"); return; case Sort.StrokeOpacity: serializer.Serialize(writer, "strokeOpacity"); return; case Sort.StrokeWidth: serializer.Serialize(writer, "strokeWidth"); return; case Sort.Text: serializer.Serialize(writer, "text"); return; case Sort.X: serializer.Serialize(writer, "x"); return; case Sort.Y: serializer.Serialize(writer, "y"); return; } throw new Exception("Cannot marshal type Sort"); }
/// <summary> /// Specifies how groups are sorted. /// Defaults to <see cref="Sort.RELEVANCE"/>. /// </summary> /// <param name="groupSort">The sort for the groups.</param> /// <returns><c>this</c></returns> public virtual GroupingSearch SetGroupSort(Sort groupSort) { this.groupSort = groupSort; return this; }
private AbstractAllGroupHeadsCollector CreateRandomCollector(string groupField, Sort sortWithinGroup, bool canUseIDV, DocValuesType valueType) { AbstractAllGroupHeadsCollector collector; if (Random.nextBoolean()) { ValueSource vs = new BytesRefFieldSource(groupField); collector = new FunctionAllGroupHeadsCollector(vs, new Hashtable(), sortWithinGroup); } else { collector = TermAllGroupHeadsCollector.Create(groupField, sortWithinGroup); } if (Verbose) { Console.WriteLine("Selected implementation: " + collector.GetType().Name); } return(collector); }
public void MergeSort_EmptyInputArray_ThrowsArgumentException() { Assert.Throws <ArgumentException>(() => Sort.MergeSort(new int[] { })); }
public void MergeSort_CorrectInputArray_PositiveTest(int[] array, int[] sortedArray) { Sort.MergeSort(array); Assert.AreEqual(array, sortedArray); }
public ActionResult ordenar() { Sort.heapSort(dados.vetor, dados.vetor.Count); return(RedirectToAction("Start", "HeapSort")); }
public object GetAll() { var queryValues = Request.RequestUri.ParseQueryString(); int page = Convert.ToInt32(queryValues["page"]); int start = Convert.ToInt32(queryValues["start"]); int limit = Convert.ToInt32(queryValues["limit"]); int id = Convert.ToInt32(queryValues["id"]); int orden = Convert.ToInt32(queryValues["orden"]); int grouped = Convert.ToInt32(queryValues["grouped"]); #region Configuramos el orden de la consulta si se obtuvo como parametro string strOrder = !string.IsNullOrWhiteSpace(queryValues["sort"]) ? queryValues["sort"] : ""; strOrder = strOrder.Replace('[', ' '); strOrder = strOrder.Replace(']', ' '); Sort sort; if (!string.IsNullOrWhiteSpace(strOrder)) { sort = JsonConvert.DeserializeObject <Sort>(strOrder); } else { sort = new Sort(); } #endregion string query = !string.IsNullOrWhiteSpace(queryValues["query"]) ? queryValues["query"] : ""; int totalRecords = 0; try { if (id == 0) { object json; string msgError = ""; IList <CurrRate> lista; lista = repository.GetList(query, sort, page, start, limit, ref totalRecords, ref msgError); if (grouped == 1) { lista = (from p in lista orderby p.CurrencyId group p by p.CurrencyCode into grp select new CurrRate { CurrencyId = grp.Last().CurrencyId, CurrencyCode = grp.Last().CurrencyCode, CurrencyRate = grp.Last().CurrencyRate }).ToList(); } json = new { total = totalRecords, data = lista, success = true }; return(json); } else { string msgError = ""; CurrRate estatus = repository.Get(id, ref msgError); object json = new { data = estatus, success = true, message = msgError }; return(json); } } catch (Exception ex) { LogManager.Write("ERROR:" + Environment.NewLine + "\tMETHOD = " + this.GetType().FullName + "." + MethodBase.GetCurrentMethod().Name + Environment.NewLine + "\tMESSAGE = " + ex.Message); object error = new { message = ex.Message }; object json = new { message = ex.Message, success = false }; return(json); } }
protected override async Task <XBMCRPC.VideoLibrary.GetMoviesResponse> GetMovies(Movie fields, Limits limits, Sort sort) { XBMCRPC.VideoLibrary.GetMoviesResponse mvs; if (_appContext.Settings.ShowWatched) { mvs = await _appContext.XBMC.VideoLibrary.GetMovies(fields, limits, sort); } else { mvs = await _appContext.XBMC.VideoLibrary.GetMovies(new Rule.Movies() { field = Movies.playcount, Operator = Operators.Is, value = "0" }, fields, limits, sort); } return(mvs); }
// Make sure the documents returned by the search match the expected list // Copied from TestSort.java private void AssertMatches(IndexSearcher searcher, Query query, Sort sort, string expectedResult) { ScoreDoc[] result = searcher.Search(query, null, 1000, sort).ScoreDocs; StringBuilder buff = new StringBuilder(10); int n = result.Length; for (int i = 0; i < n; ++i) { Document doc = searcher.Doc(result[i].Doc); IndexableField[] v = doc.GetFields("tracer"); for (int j = 0; j < v.Length; ++j) { buff.Append(v[j].StringValue); } } Assert.AreEqual(expectedResult, buff.ToString()); }
public static string ExportToJson(this ENV.Data.Entity entity, FilterBase where = null, Sort orderBy = null, params ColumnBase[] columns) { var vmc = new ViewModel { From = entity }; if (where != null) { vmc.Where.Add(where); } if (orderBy != null) { vmc.OrderBy = orderBy; } return(vmc.ExportRows().ToJson()); }
/// <summary> /// Specified how documents inside a group are sorted. /// Defaults to <see cref="Sort.RELEVANCE"/>. /// </summary> /// <param name="sortWithinGroup">The sort for documents inside a group</param> /// <returns><c>this</c></returns> public virtual GroupingSearch SetSortWithinGroup(Sort sortWithinGroup) { this.sortWithinGroup = sortWithinGroup; return this; }
private static TopDocs DoSearch(IndexSearcher searcher, ScoreDoc after, Query q, Filter filter, int n, Sort sort, bool doDocScores, bool doMaxScore, ICollector fc) { if (filter != null) { q = new FilteredQuery(q, filter); } int limit = searcher.IndexReader.MaxDoc; if (limit == 0) { limit = 1; } n = Math.Min(n, limit); if (after != null && after.Doc >= limit) { throw new ArgumentException("after.doc exceeds the number of documents in the reader: after.doc=" + after.Doc + " limit=" + limit); } if (sort != null) { if (after != null && !(after is FieldDoc)) { // TODO: if we fix type safety of TopFieldDocs we can // remove this throw new ArgumentException("after must be a FieldDoc; got " + after); } const bool fillFields = true; var hitsCollector = TopFieldCollector.Create(sort, n, (FieldDoc)after, fillFields, doDocScores, doMaxScore, false); searcher.Search(q, MultiCollector.Wrap(hitsCollector, fc)); return(hitsCollector.GetTopDocs()); } else { // TODO: can we pass the right boolean for // in-order instead of hardwired to false...? we'd // need access to the protected IS.search methods // taking Weight... could use reflection... var hitsCollector = TopScoreDocCollector.Create(n, after, false); searcher.Search(q, MultiCollector.Wrap(hitsCollector, fc)); return(hitsCollector.GetTopDocs()); } }
protected override async Task <KODIRPC.VideoLibrary.GetMoviesResponse> GetMovies(Movie fields, Limits limits, Sort sort) { var mvs = await _appContext.XBMC.VideoLibrary.GetMovieDetails(_query, Movie.AllFields()); return(new KODIRPC.VideoLibrary.GetMoviesResponse() { limits = new LimitsReturned() { total = 1 }, movies = new List <KODIRPC.Video.Details.Movie>() { mvs.moviedetails } }); }
/// <summary> /// 字段分组统计(支持分页) /// </summary> /// <param name="indexSearcher"></param> /// <param name="pageSize"></param> /// <param name="pageIndex"></param> /// <param name="query"></param> /// <param name="recordCount"></param> /// <param name="groupKeyValueList">分组结果</param> /// <param name="filter"></param> /// <param name="sortFields"></param> /// <returns></returns> public static Dictionary <Document, ScoreDoc> SelectGroup(IndexSearcher indexSearcher, int pageSize, int pageIndex, Query query, out int recordCount, out GroupKeyValueList groupKeyValueList, Filter filter = null, params SortField[] sortFields) { recordCount = 0; groupKeyValueList = null; Dictionary <Document, ScoreDoc> dictPager = new Dictionary <Document, ScoreDoc>(); int maxDoc = indexSearcher.IndexReader.MaxDoc; if (maxDoc == 0) {//返回索引可用的最大的索引ID return(dictPager); } TopDocs docs = null; string key = string.Format(CACHE_KEY, query.ToString(), string.Join("_", sortFields.Select(item => item.ToString())), filter == null ? string.Empty : filter.ToString()); string listKey = key + string.Format(",PAGE_INDEX:{0},PAGE_SIZE:{1}", pageIndex, pageSize); string groupKey = "GROUP:::" + key; docs = MemCache.MemoryCacheBus.Get(listKey) as TopDocs; groupKeyValueList = MemCache.MemoryCacheBus.Get(groupKey) as GroupKeyValueList; if (docs == null || groupKeyValueList == null) { //https://searchcode.com/codesearch/view/7233825/ int start = pageIndex * pageSize; start = Math.Min(start, maxDoc); using (GroupCollectorField groupCollectorField = new GroupCollectorField("NameValue")) { if (sortFields.Length > 0) {//先排序,后分页 Sort sort = new Sort(); sort.SetSort(sortFields); TopFieldCollector topFieldCollector = TopFieldCollector.Create(sort, start, true, false, false, !query.CreateWeight(indexSearcher).GetScoresDocsOutOfOrder()); GroupCollectorWrapper groupCollectorWrapper = new GroupCollectorWrapper(start, topFieldCollector, groupCollectorField); indexSearcher.Search(query, filter, groupCollectorWrapper); start = start - pageSize; if (start < 0) { start = 0; } docs = topFieldCollector.TopDocs(start, pageSize);//只返回前start条记录 } else {//不支持排序,只有分页 TopScoreDocCollector topScoreDocCollector = TopScoreDocCollector.Create(start + 1, !query.CreateWeight(indexSearcher).GetScoresDocsOutOfOrder()); GroupCollectorWrapper groupCollectorWrapper = new GroupCollectorWrapper(start, topScoreDocCollector, groupCollectorField); indexSearcher.Search(query, filter, groupCollectorWrapper); start = start - pageSize; if (start < 0) { start = 0; } docs = topScoreDocCollector.TopDocs(start, pageSize); //只返回前start条记录 } groupCollectorField.GroupKeyValueDocCountList.Sort(); //排序 groupKeyValueList = ObjectExtensions.Clone(groupCollectorField.GroupKeyValueDocCountList); if (docs != null && groupKeyValueList != null) { TimeSpan timeSpan = TimeSpan.FromMinutes(CACHE_TIME); MemCache.MemoryCacheBus.Insert(groupKey, groupKeyValueList, timeSpan); MemCache.MemoryCacheBus.Insert(listKey, docs, timeSpan); } } } #region 返回搜索的结果集合 if (docs != null) { recordCount = docs.TotalHits; //搜索结果总数量 ScoreDoc[] scoreDocs = docs.ScoreDocs; //搜索的结果集合 if (scoreDocs != null) { foreach (ScoreDoc scoreDoc in scoreDocs) { if (scoreDoc.Doc != int.MaxValue && scoreDoc.Score != System.Single.NegativeInfinity) { dictPager.Add(indexSearcher.Doc(scoreDoc.Doc), scoreDoc); } } } } if (dictPager.Count == 0) {//如果没有取出符合条件的结果删除缓存。wyp MemCache.MemoryCacheBus.Delete(listKey); } if (groupKeyValueList.Count == 0) {//如果没有取出符合条件的结果删除缓存。wyp MemCache.MemoryCacheBus.Delete(groupKey); } #endregion groupKeyValueList = groupKeyValueList ?? new GroupKeyValueList(0); return(dictPager); }
protected override Expression VisitMethodCall(MethodCallExpression node) { Trace(MethodBase.GetCurrentMethod(), node); Expression visited = null; try { visited = base.VisitMethodCall(node); } catch (SnNotSupportedException e) { throw SnExpression.CallingAsEnunerableExpectedError(node.Method.Name, e); } if (!(visited is MethodCallExpression methodCallExpr)) { throw new NotSupportedException("#VisitMethodCall if visited is not null"); } var methodName = methodCallExpr.Method.Name; switch (methodName) { case "OfType": // Do nothing. Type of expression has been changed so a TypeIs predicate will be created. case "Where": // do nothing break; case "Take": var topExpr = GetArgumentAsConstant(methodCallExpr, 1); this.Top = (int)topExpr.Value; break; case "Skip": var skipExpr = GetArgumentAsConstant(methodCallExpr, 1); this.Skip = (int)skipExpr.Value; break; case "LongCount": case "Count": if (methodCallExpr.Arguments.Count == 2) { if (_predicates.Count > 1) // There is Where in the main expression { CombineTwoPredicatesOnStack(); } } this.CountOnly = true; break; case "ThenBy": case "OrderBy": Sort.Add(CreateSortInfoFromExpr(node, false)); break; case "ThenByDescending": case "OrderByDescending": Sort.Add(CreateSortInfoFromExpr(node, true)); break; case "StartsWith": var startsWithExpr = GetArgumentAsConstant(methodCallExpr, 0); var startsWithArg = (string)startsWithExpr.Value; BuildWildcardPredicate(GetPropertyName(methodCallExpr.Object), WildcardPosition.AtEnd, startsWithArg); break; case "EndsWith": var endsWithExpr = GetArgumentAsConstant(methodCallExpr, 0); var endsWithArg = (string)endsWithExpr.Value; BuildWildcardPredicate(GetPropertyName(methodCallExpr.Object), WildcardPosition.AtStart, endsWithArg); break; case "Contains": var arg0 = methodCallExpr.Arguments[0]; if (arg0 is ConstantExpression constantExpr) { if (constantExpr.Type != typeof(string)) { throw new NotSupportedException( $"Calling Contains on an instance of type {constantExpr.Type} is not supported. Allowed types: string, IEnumerable<Node>."); } var containsArg = (string)constantExpr.Value; BuildWildcardPredicate(GetPropertyName(methodCallExpr.Object), WildcardPosition.AtStartAndEnd, containsArg); break; } if (arg0 is MemberExpression memberExpr) { if (memberExpr.Type != typeof(IEnumerable <Node>)) { throw NotSupportedException(node, "#2"); } if (!(methodCallExpr.Arguments[1] is ConstantExpression rightConstant)) { throw NotSupportedException(node, "#1"); } var nodeValue = (Node)rightConstant.Value; BuildTextPredicate(memberExpr.Member.Name, nodeValue); break; } throw NotSupportedException(node, "#3"); case "FirstOrDefault": case "First": ElementSelection = "first"; this.Top = 1; this.ThrowIfEmpty = methodName == "First"; if (methodCallExpr.Arguments.Count == 2) { if (_predicates.Count > 1) { CombineTwoPredicatesOnStack(); } } break; case "SingleOrDefault": case "Single": ElementSelection = "single"; this.ThrowIfEmpty = methodName == "Single"; if (methodCallExpr.Arguments.Count == 2) { if (_predicates.Count > 1) { CombineTwoPredicatesOnStack(); } } break; case "LastOrDefault": case "Last": ElementSelection = "last"; this.ThrowIfEmpty = methodName == "Last"; if (methodCallExpr.Arguments.Count == 2) { if (_predicates.Count > 1) { CombineTwoPredicatesOnStack(); } } break; case "ElementAtOrDefault": case "ElementAt": ElementSelection = "elementat"; this.ThrowIfEmpty = methodName == "ElementAt"; var constExpr = GetArgumentAsConstant(methodCallExpr, 1); var index = Convert.ToInt32(constExpr.Value); this.Skip = index; this.Top = 1; break; case "Any": ElementSelection = "first"; this.CountOnly = true; this.ExistenceOnly = true; this.Top = 1; if (methodCallExpr.Arguments.Count == 2) { if (_predicates.Count > 1) { CombineTwoPredicatesOnStack(); } } break; case "Type": var typeExpr = GetArgumentAsConstant(methodCallExpr, 0); BuildTextPredicate("Type", (string)typeExpr.Value); break; case "TypeIs": var typeIsExpr = GetArgumentAsConstant(methodCallExpr, 0); BuildTextPredicate("TypeIs", (string)(typeIsExpr).Value); break; case "get_Item": if (!(methodCallExpr.Object is ParameterExpression)) { throw new NotSupportedException("#get_Item"); } break; case "startswith": { var fieldName = GetPropertyName(methodCallExpr.Arguments[0]); var startswithExpr = GetArgumentAsConstant(methodCallExpr, 1); var arg = (string)startswithExpr.Value; BuildWildcardPredicate(fieldName, WildcardPosition.AtEnd, arg); break; } case "endswith": { var fieldName = GetPropertyName(methodCallExpr.Arguments[0]); var endswithExpr = GetArgumentAsConstant(methodCallExpr, 1); var arg = (string)endswithExpr.Value; BuildWildcardPredicate(fieldName, WildcardPosition.AtStart, arg); break; } case "substringof": { var fieldName = GetPropertyName(methodCallExpr.Arguments[1]); var substringofExpr = GetArgumentAsConstant(methodCallExpr, 0); var arg = (string)substringofExpr.Value; BuildWildcardPredicate(fieldName, WildcardPosition.AtStartAndEnd, arg); break; } case "isof": { var isofExpr = GetArgumentAsConstant(methodCallExpr, 1); BuildTextPredicate("TypeIs", (string)(isofExpr).Value); break; } case "InFolder": { var infolderexpr = GetArgumentAsConstant(methodCallExpr, 0); var folder = infolderexpr.Value; BuildTextPredicate("InFolder", GetPath(folder, "InFolder")); break; } case "InTree": { var intreeexpr = GetArgumentAsConstant(methodCallExpr, 0); var folder = intreeexpr.Value; BuildTextPredicate("InTree", GetPath(folder, "InTree")); break; } case "GetType": { if (methodCallExpr.Object is MemberExpression member && member.Member == typeof(Content).GetProperty("ContentHandler")) { _predicates.Push(new ContentHandlerGetTypePredicate()); }
/// <summary>Gets all hooks.</summary> /// <param name="pagination">Pagination.</param> /// <param name="sort">Sort.</param> /// <returns>List of Hook instances returned from API.</returns> public ListPaginated<HookDTO> GetAll(Pagination pagination, Sort sort = null) { return this.GetList<HookDTO>(MethodKey.HooksAll, pagination, sort); }
/// <summary> /// Return a sorted view of <paramref name="reader"/> according to the order /// defined by <paramref name="sort"/>. If the reader is already sorted, this /// method might return the reader as-is. /// </summary> public static AtomicReader Wrap(AtomicReader reader, Sort sort) { return(Wrap(reader, new Sorter(sort).Sort(reader))); }
/// <summary> /// Utility method, to search and also collect all hits /// into the provided <see cref="ICollector"/>. /// </summary> public static TopFieldDocs Search(IndexSearcher searcher, Query q, Filter filter, int n, Sort sort, ICollector fc) { if (sort == null) { throw new ArgumentException("sort must not be null"); } return((TopFieldDocs)DoSearch(searcher, null, q, filter, n, sort, false, false, fc)); }
/// <summary> /// Get a listing of posts from the user sorted by <paramref name="sorting"/>, from time <paramref name="fromTime"/> /// and limited to <paramref name="limit"/>. /// </summary> /// <param name="sorting">How to sort the posts (hot, new, top, controversial).</param> /// <param name="limit">How many posts to fetch per request. Max is 100.</param> /// <param name="fromTime">What time frame of posts to show (hour, day, week, month, year, all).</param> /// <returns>The listing of posts requested.</returns> public Listing<Post> GetPosts(Sort sorting = Sort.New, int limit = 25, FromTime fromTime = FromTime.All) { if ((limit < 1) || (limit > 100)) throw new ArgumentOutOfRangeException("limit", "Valid range: [1,100]"); string linksUrl = string.Format(LinksUrl, Name); linksUrl += string.Format("?sort={0}&limit={1}&t={2}", Enum.GetName(typeof(Sort), sorting), limit, Enum.GetName(typeof(FromTime), fromTime)); return new Listing<Post>(Reddit, linksUrl, WebAgent); }
private int[] CreateExpectedGroupHeads(string searchTerm, GroupDoc[] groupDocs, Sort docSort, bool sortByScoreOnly, int[] fieldIdToDocID) { IDictionary <BytesRef, List <GroupDoc> > groupHeads = new JCG.Dictionary <BytesRef, List <GroupDoc> >(); foreach (GroupDoc groupDoc in groupDocs) { if (!groupDoc.content.StartsWith(searchTerm, StringComparison.Ordinal)) { continue; } if (!groupHeads.TryGetValue(groupDoc.group, out List <GroupDoc> grouphead)) { List <GroupDoc> list = new List <GroupDoc>(); list.Add(groupDoc); groupHeads[groupDoc.group] = list; continue; } grouphead.Add(groupDoc); } int[] allGroupHeads = new int[groupHeads.Count]; int i = 0; foreach (BytesRef groupValue in groupHeads.Keys) { List <GroupDoc> docs = groupHeads[groupValue]; // LUCENENET TODO: The original API Collections.Sort does not currently exist. // This call ultimately results in calling TimSort, which is why this line was replaced // with CollectionUtil.TimSort(IList<T>, IComparer<T>). // // NOTE: List.Sort(comparer) won't work in this case because it calls the comparer when the // values are the same, which results in this test failing. TimSort only calls the comparer // when the values differ. //Collections.Sort(docs, GetComparer(docSort, sortByScoreOnly, fieldIdToDocID)); CollectionUtil.TimSort(docs, GetComparer(docSort, sortByScoreOnly, fieldIdToDocID)); allGroupHeads[i++] = docs[0].id; } return(allGroupHeads); }
public static IOrderSpecification <TEntity> New(Expression <Func <TEntity, TResult> > expression, Sort sort = Sort.Ascending) { return(new OrderSpecification <TEntity, TResult>(expression, sort)); }
public void MergeSort_NullInputArray_ThrowsArgumentNullException() { Assert.Throws <ArgumentNullException>(() => Sort.MergeSort(null)); }
public object GetAll() { var queryValues = Request.RequestUri.ParseQueryString(); int page = Convert.ToInt32(queryValues["page"]); int start = Convert.ToInt32(queryValues["start"]); int limit = Convert.ToInt32(queryValues["limit"]); int id = Convert.ToInt32(queryValues["id"]); int orden = Convert.ToInt32(queryValues["orden"]); string strFieldFilters = queryValues["fieldFilters"]; FieldFilters fieldFilters = new FieldFilters(); if (!String.IsNullOrEmpty(strFieldFilters)) { fieldFilters = JsonConvert.DeserializeObject <FieldFilters>(strFieldFilters); } #region Configuramos el orden de la consulta si se obtuvo como parametro string strOrder = !string.IsNullOrWhiteSpace(queryValues["sort"]) ? queryValues["sort"] : ""; strOrder = strOrder.Replace('[', ' '); strOrder = strOrder.Replace(']', ' '); Sort sort; if (!string.IsNullOrWhiteSpace(strOrder)) { sort = JsonConvert.DeserializeObject <Sort>(strOrder); } else { sort = new Sort(); } #endregion string query = !string.IsNullOrWhiteSpace(queryValues["query"]) ? queryValues["query"] : ""; int totalRecords = 0; try { if (id == 0) { object json; var lista = repository.GetList(query, fieldFilters, sort, page, start, limit, ref totalRecords); json = new { total = totalRecords, data = lista, success = true }; return(json); } else { var model = repository.Get(id); object json = new { data = model, success = true }; return(json); } } catch (Exception ex) { LogManager.Write("ERROR:" + Environment.NewLine + "\tMETHOD = " + this.GetType().FullName + "." + MethodBase.GetCurrentMethod().Name + Environment.NewLine + "\tMESSAGE = " + ex.Message); object json = new { message = ex.Message, success = false }; return(json); } }
public void ScrollMode () { switch (mode) { case Sort.First: mode = Sort.Last; break; case Sort.Last: mode = Sort.Random; break; case Sort.Random: mode = Sort.First; break; } }
public void ArrayChecker_EmptyInputArray_ThrowsArgumentException() { Assert.Throws <ArgumentException>(() => Sort.ArrayChecker(new int[] { })); }
// Test using various international locales with accented characters (which // sort differently depending on locale) // // Copied (and slightly modified) from // Lucene.Net.Search.TestSort.testInternationalSort() // // TODO: this test is really fragile. there are already 3 different cases, // depending upon unicode version. public virtual void TestCollationKeySort(Analyzer usAnalyzer, Analyzer franceAnalyzer, Analyzer swedenAnalyzer, Analyzer denmarkAnalyzer, string usResult, string frResult, string svResult, string dkResult) { Directory indexStore = NewDirectory(); IndexWriter writer = new IndexWriter(indexStore, new IndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random(), MockTokenizer.WHITESPACE, false))); // document data: // the tracer field is used to determine which document was hit string[][] sortData = new string[][] { new string[] { "A", "x", "p\u00EAche", "p\u00EAche", "p\u00EAche", "p\u00EAche" }, new string[] { "B", "y", "HAT", "HAT", "HAT", "HAT" }, new string[] { "C", "x", "p\u00E9ch\u00E9", "p\u00E9ch\u00E9", "p\u00E9ch\u00E9", "p\u00E9ch\u00E9" }, new string[] { "D", "y", "HUT", "HUT", "HUT", "HUT" }, new string[] { "E", "x", "peach", "peach", "peach", "peach" }, new string[] { "F", "y", "H\u00C5T", "H\u00C5T", "H\u00C5T", "H\u00C5T" }, new string[] { "G", "x", "sin", "sin", "sin", "sin" }, new string[] { "H", "y", "H\u00D8T", "H\u00D8T", "H\u00D8T", "H\u00D8T" }, new string[] { "I", "x", "s\u00EDn", "s\u00EDn", "s\u00EDn", "s\u00EDn" }, new string[] { "J", "y", "HOT", "HOT", "HOT", "HOT" } }; FieldType customType = new FieldType(); customType.Stored = true; for (int i = 0; i < sortData.Length; ++i) { Document doc = new Document(); doc.Add(new Field("tracer", sortData[i][0], customType)); doc.Add(new TextField("contents", sortData[i][1], Field.Store.NO)); if (sortData[i][2] != null) { doc.Add(new TextField("US", usAnalyzer.TokenStream("US", new StringReader(sortData[i][2])))); } if (sortData[i][3] != null) { doc.Add(new TextField("France", franceAnalyzer.TokenStream("France", new StringReader(sortData[i][3])))); } if (sortData[i][4] != null) { doc.Add(new TextField("Sweden", swedenAnalyzer.TokenStream("Sweden", new StringReader(sortData[i][4])))); } if (sortData[i][5] != null) { doc.Add(new TextField("Denmark", denmarkAnalyzer.TokenStream("Denmark", new StringReader(sortData[i][5])))); } writer.AddDocument(doc); } writer.ForceMerge(1); writer.Dispose(); IndexReader reader = DirectoryReader.Open(indexStore); IndexSearcher searcher = new IndexSearcher(reader); Sort sort = new Sort(); Query queryX = new TermQuery(new Term("contents", "x")); Query queryY = new TermQuery(new Term("contents", "y")); sort.SetSort(new SortField("US", SortField.Type_e.STRING)); AssertMatches(searcher, queryY, sort, usResult); sort.SetSort(new SortField("France", SortField.Type_e.STRING)); AssertMatches(searcher, queryX, sort, frResult); sort.SetSort(new SortField("Sweden", SortField.Type_e.STRING)); AssertMatches(searcher, queryY, sort, svResult); sort.SetSort(new SortField("Denmark", SortField.Type_e.STRING)); AssertMatches(searcher, queryY, sort, dkResult); reader.Dispose(); indexStore.Dispose(); }
public void ArrayChecker_NullInputArray_ThrowsArgumentNullException() { Assert.Throws <ArgumentNullException>(() => Sort.ArrayChecker(null)); }
/// <summary>Gets the list of all the uploaded documents for all users.</summary> /// <param name="pagination">Pagination.</param> /// <param name="filter">Filter.</param> /// <param name="sort">Sort.</param> /// <returns>Collection of all users' uploaded documents.</returns> public ListPaginated<KycDocumentDTO> GetKycDocuments(Pagination pagination, FilterKycDocuments filter, Sort sort = null) { if (filter == null) filter = new FilterKycDocuments(); return this.GetList<KycDocumentDTO>(MethodKey.ClientGetKycDocuments, pagination, null, sort, filter.GetValues()); }
public OrderSpecification(Sort sort = Sort.Ascending) : this(entity => default, sort) { }
/// <summary> /// Get a listing of comments from the user sorted by <paramref name="sorting"/>, from time <paramref name="fromTime"/> /// and limited to <paramref name="limit"/>. /// </summary> /// <param name="sorting">How to sort the comments (hot, new, top, controversial).</param> /// <param name="limit">How many comments to fetch per request. Max is 100.</param> /// <param name="fromTime">What time frame of comments to show (hour, day, week, month, year, all).</param> /// <returns>The listing of comments requested.</returns> public Listing<Comment> GetComments(Sort sorting = Sort.New, int limit = 25, FromTime fromTime = FromTime.All) { if ((limit < 1) || (limit > MAX_LIMIT)) throw new ArgumentOutOfRangeException("limit", "Valid range: [1," + MAX_LIMIT + "]"); string commentsUrl = string.Format(CommentsUrl, Name); commentsUrl += string.Format("?sort={0}&limit={1}&t={2}", Enum.GetName(typeof(Sort), sorting), limit, Enum.GetName(typeof(FromTime), fromTime)); return new Listing<Comment>(Reddit, commentsUrl, WebAgent); }
public OrderSpecification(Expression <Func <TEntity, TResult> > expression, Sort sort = Sort.Ascending) { _expression = expression; _sort = sort; }
private IQueryable<Book> ApplyOrderBy(IQueryable<Book> booksQuery, Sort sort, bool sortAscending) { switch (sort) { case Sort.Title: return sortAscending ? booksQuery.OrderBy(book => book.Title) : booksQuery.OrderByDescending(book => book.Title); case Sort.Author: return sortAscending ? booksQuery.OrderBy(book => book.Author) : booksQuery.OrderByDescending(book => book.Author); case Sort.Rating: case Sort.MightRead: int flaggedBookWeight = sort == Sort.Rating ? 0 : 6; int authenticatedProfileId = 1; return from book in booksQuery let flaggedBook = book.FlaggedBooks.Where(p => p.ProfileId == authenticatedProfileId).FirstOrDefault() let weighting = flaggedBook == null ? -1 : (flaggedBook.IsFlaggedToRead != 0 ? flaggedBookWeight : flaggedBook.Rating) orderby sortAscending ? weighting : -weighting select book; case Sort.None: default: return booksQuery; } }
public static IOrderSpecification <TEntity> New(Sort sort = Sort.Ascending) { return(new OrderSpecification <TEntity, TResult>(sort)); }