示例#1
0
        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);
        }
示例#2
0
		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;
		}
示例#3
0
    /// <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>();
    }
示例#4
0
 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);
 }
示例#5
0
        /// <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);
 }
示例#10
0
 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;
 }
示例#11
0
        public void BubbleSortSlowest_Fail_EmptyArray()
        {
            // ARRANGE
            Sort sortAlgos = new Sort();
            int[] testNums = { };

            // ACT
            sortAlgos.BubbleSlowest(testNums);

            // ASSERT
            // ExpectedException attribute
        }
示例#12
0
 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);
     }
 }
示例#14
0
 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);
 }
示例#15
0
        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]);
            }
        }
示例#16
0
        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
 }
示例#18
0
        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);
        }
示例#19
0
 /// <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;
 }
示例#20
0
        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);
        }
示例#21
0
        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);
        }
示例#22
0
文件: compare.cs 项目: ExiaHan/z3test
 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));
     }
 }
示例#23
0
        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();
            }
        }
示例#24
0
        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();
        }
示例#25
0
 public IActionResult Edit(Sort tog)
 {
     db.Entry(tog).State = EntityState.Modified;
     db.SaveChanges();
     return(RedirectToAction("Index"));
 }
示例#26
0
 /// <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));
 }
示例#27
0
 public Task <SearchResult> SearchAsync(int channelId, int pageNo, int pageSize, Sort sort)
 {
     throw new NotImplementedException();
 }
示例#28
0
        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");
        }
示例#29
0
 /// <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;
 }
示例#30
0
        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);
        }
示例#31
0
 public void MergeSort_EmptyInputArray_ThrowsArgumentException()
 {
     Assert.Throws <ArgumentException>(() => Sort.MergeSort(new int[] { }));
 }
示例#32
0
 public void MergeSort_CorrectInputArray_PositiveTest(int[] array, int[] sortedArray)
 {
     Sort.MergeSort(array);
     Assert.AreEqual(array, sortedArray);
 }
示例#33
0
 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);
            }
        }
示例#35
0
        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);
        }
示例#36
0
 // 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());
 }
示例#37
0
        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());
        }
示例#38
0
 /// <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;
 }
示例#39
0
        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());
            }
        }
示例#40
0
        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
                }
            });
        }
示例#41
0
        /// <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);
        }
示例#42
0
        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());
                }
示例#43
0
 /// <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);
 }
示例#44
0
 /// <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)));
 }
示例#45
0
 /// <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));
 }
示例#46
0
        /// <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);
        }
示例#47
0
        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);
        }
示例#48
0
 public static IOrderSpecification <TEntity> New(Expression <Func <TEntity, TResult> > expression, Sort sort = Sort.Ascending)
 {
     return(new OrderSpecification <TEntity, TResult>(expression, sort));
 }
示例#49
0
 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);
            }
        }
示例#51
0
	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;			
		}
	}
示例#52
0
 public void ArrayChecker_EmptyInputArray_ThrowsArgumentException()
 {
     Assert.Throws <ArgumentException>(() => Sort.ArrayChecker(new int[] { }));
 }
示例#53
0
        // 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();
        }
示例#54
0
 public void ArrayChecker_NullInputArray_ThrowsArgumentNullException()
 {
     Assert.Throws <ArgumentNullException>(() => Sort.ArrayChecker(null));
 }
示例#55
0
        /// <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());
        }
示例#56
0
 public OrderSpecification(Sort sort = Sort.Ascending) : this(entity => default, sort)
 {
 }
示例#57
0
        /// <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);
        }
示例#58
0
 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;
            }
        }
示例#60
0
 public static IOrderSpecification <TEntity> New(Sort sort = Sort.Ascending)
 {
     return(new OrderSpecification <TEntity, TResult>(sort));
 }