ResultList

Namespace: SMBLibrary
We found 10 examples in language CSharp for this search. You will see 55 fragments of code.

Other methods


        public CompletionDataProviderKeyResult ProcessKey(char key)
        {
            if (char.IsLetterOrDigit(key) || key == '\"' || key == '.' || key == '(' || key == '_' || key == '$')
            {
                return CompletionDataProviderKeyResult.NormalKey;
            }
            // key triggers insertion of selected items
            return CompletionDataProviderKeyResult.InsertionKey;
        }

        /// <summary>
        /// Called when entry should be inserted. Forward to the insertion action of the completion data.
        /// </summary>
        public bool InsertAction(ICompletionData data, TextArea textArea, int insertionOffset, char key)
        {
            textArea.Caret.Position = textArea.Document.OffsetToPosition(insertionOffset);
            bool temp = data.InsertAction(textArea, key);
            textArea.Refresh();
            return temp;
        }

        private void AddParserData(List<ICompletionData> resultList)
        {
            var data = _parserService.GetAllParserData().Where(s => (s is ILabel && !((ILabel) s).IsReusable) || s is IDefine);
            resultList.AddRange(data.Select(parserData => new CodeCompletionData(parserData.Name, CodeCompletionType.Label, parserData.Description)));
        }

        #region Predefined Data

        private void Add16BitRegs(List<ICompletionData> resultList)
        {
            resultList.Add(new CodeCompletionData("bc", CodeCompletionType.Register));
            resultList.Add(new CodeCompletionData("de", CodeCompletionType.Register));
            resultList.Add(new CodeCompletionData("hl", CodeCompletionType.Register));
            resultList.Add(new CodeCompletionData("ix", CodeCompletionType.Register));
            resultList.Add(new CodeCompletionData("iy", CodeCompletionType.Register));
        }

        private void Add8BitRegs(List<ICompletionData> resultList)
        {
            resultList.Add(new CodeCompletionData("a", CodeCompletionType.Register));
            resultList.Add(new CodeCompletionData("b", CodeCompletionType.Register));
            resultList.Add(new CodeCompletionData("d", CodeCompletionType.Register));
            resultList.Add(new CodeCompletionData("h", CodeCompletionType.Register));
            resultList.Add(new CodeCompletionData("ixl", CodeCompletionType.Register));
            resultList.Add(new CodeCompletionData("iyl", CodeCompletionType.Register));
            resultList.Add(new CodeCompletionData("c", CodeCompletionType.Register));
            resultList.Add(new CodeCompletionData("e", CodeCompletionType.Register));
            resultList.Add(new CodeCompletionData("l", CodeCompletionType.Register));
            resultList.Add(new CodeCompletionData("ixh", CodeCompletionType.Register));
            resultList.Add(new CodeCompletionData("iyh", CodeCompletionType.Register));
            resultList.Add(new CodeCompletionData("(hl)", CodeCompletionType.Register));
            resultList.Add(new CodeCompletionData("(ix+", CodeCompletionType.Register));
            resultList.Add(new CodeCompletionData("(iy+", CodeCompletionType.Register));
        }

        #endregion

        public ICompletionData[] GenerateCompletionData(string fileName, TextArea textArea, char charTyped)
        {
            List<ICompletionData> resultList = new List<ICompletionData>();
            string command = string.Empty;
            string firstArg = string.Empty;
            int col = 0;
            var lineSegment = textArea.Document.GetLineSegment(textArea.Caret.Line);
            while (col < textArea.Caret.Column)
            {
                var word = lineSegment.GetWord(col);

                col += word.Length;
            }

            switch (charTyped)
            {
                default:
                {
                    switch (command.ToLower())
                    {
                        case "ld":
                            if (string.IsNullOrEmpty(firstArg))
                            {
                                Add16BitRegs(resultList);
                                resultList.Add(new CodeCompletionData("sp", CodeCompletionType.Register));
                                Add8BitRegs(resultList);
                                return resultList.ToArray();
                            }
                            switch (firstArg.ToLower())
                            {
                                case "hl":
                                case "de":
                                case "bc":
                                case "iy":
                                case "ix":
                                    AddParserData(resultList);
                                    break;
                                case "sp":
                                    resultList.Add(new CodeCompletionData("hl", CodeCompletionType.Register));
                                    resultList.Add(new CodeCompletionData("ix", CodeCompletionType.Register));
                                    resultList.Add(new CodeCompletionData("iy", CodeCompletionType.Register));
                                    return resultList.ToArray();
                                case "a":
                                case "b":
                                case "c":
                                case "d":
                                case "e":
                                case "h":
                                case "l":
                                case "(hl)":
                                    if (firstArg == "a")
                                    {
                                        resultList.Add(new CodeCompletionData("i", CodeCompletionType.Register));
                                        resultList.Add(new CodeCompletionData("r", CodeCompletionType.Register));
                                    }
                                    Add8BitRegs(resultList);
                                    break;
                                case "i":
                                case "r":
                                    resultList.Add(new CodeCompletionData("a", CodeCompletionType.Register));
                                    break;
                            }
                            return resultList.ToArray();
                        case "in":
                        case "out":
                            int temp;
                            if (string.IsNullOrEmpty(firstArg))
                            {
                                resultList.Add(new CodeCompletionData("a", CodeCompletionType.Register));
                                resultList.Add(new CodeCompletionData("(C)", CodeCompletionType.Register));
                            }
                            else if (int.TryParse(firstArg, out temp))
                            {
                                resultList.Add(new CodeCompletionData("(C)", CodeCompletionType.Register));
                            }
                            /*else
                            {
                                return _portsList;
                            }*/
                            return resultList.ToArray();
                        case "bit":
                        case "set":
                        case "res":
                            if (string.IsNullOrEmpty(firstArg))
                            {
                                resultList.Add(new CodeCompletionData("0", CodeCompletionType.Command));
                                resultList.Add(new CodeCompletionData("1", CodeCompletionType.Command));
                                resultList.Add(new CodeCompletionData("2", CodeCompletionType.Command));
                                resultList.Add(new CodeCompletionData("3", CodeCompletionType.Command));
                                resultList.Add(new CodeCompletionData("4", CodeCompletionType.Command));
                                resultList.Add(new CodeCompletionData("5", CodeCompletionType.Command));
                                resultList.Add(new CodeCompletionData("6", CodeCompletionType.Command));
                                resultList.Add(new CodeCompletionData("7", CodeCompletionType.Command));
                            }
                            else
                            {
                                Add8BitRegs(resultList);
                            }
                            return resultList.ToArray();
                        case "add":
                        case "adc":
                        case "sbc":
                            if (string.IsNullOrEmpty(firstArg))
                            {
                                resultList.Add(new CodeCompletionData("a", CodeCompletionType.Register));
                                resultList.Add(new CodeCompletionData("hl", CodeCompletionType.Register));
                                if (command == "add")
                                {
                                    resultList.Add(new CodeCompletionData("ix", CodeCompletionType.Register));
                                    resultList.Add(new CodeCompletionData("iy", CodeCompletionType.Register));
                                }
                            }
                            else
                            {
                                if (firstArg == "hl" || firstArg == "ix" || firstArg == "iy")
                                {
                                    resultList.Add(new CodeCompletionData("bc", CodeCompletionType.Register));
                                    resultList.Add(new CodeCompletionData("de", CodeCompletionType.Register));
                                    resultList.Add(new CodeCompletionData("hl", CodeCompletionType.Register));
                                    resultList.Add(new CodeCompletionData("sp", CodeCompletionType.Register));
                                }
                                else
                                {
                                    Add8BitRegs(resultList);
                                }
                            }
                            return resultList.ToArray();
                        case "dec":
                        case "inc":
                        case "rlc":
                        case "rl":
                        case "rr":
                        case "rrc":
                        case "sla":
                        case "sll":
                        case "sra":
                        case "srl":
                            // commands that take a register or a number
                        case "cp":
                        case "or":
                        case "xor":
                            Add8BitRegs(resultList);
                            return resultList.ToArray();
                        case "sub":
                            if (string.IsNullOrEmpty(firstArg))
                            {
                                resultList.Add(new CodeCompletionData("a", CodeCompletionType.Register));
                            }
                            else
                            {
                                Add8BitRegs(resultList);
                            }
                            return resultList.ToArray();
                            // 16 bit only
                        case "push":
                        case "pop":
                            resultList.Add(new CodeCompletionData("af", CodeCompletionType.Register));
                            Add16BitRegs(resultList);
                            return resultList.ToArray();
                            // labels/equates and conditions
                        case "call":
                        case "jp":
                        case "jr":
                        case "ret":
                        case "djnz":
                            // possible to have conditions
                            if (command != "djnz" && string.IsNullOrEmpty(firstArg))
                            {
                                resultList.Add(new CodeCompletionData("z", CodeCompletionType.Register));
                                resultList.Add(new CodeCompletionData("nz", CodeCompletionType.Register));
                                resultList.Add(new CodeCompletionData("c", CodeCompletionType.Register));
                                resultList.Add(new CodeCompletionData("nc", CodeCompletionType.Register));
                                if (command != "jr")
                                {
                                    resultList.Add(new CodeCompletionData("p", CodeCompletionType.Register));
                                    resultList.Add(new CodeCompletionData("m", CodeCompletionType.Register));
                                    resultList.Add(new CodeCompletionData("po", CodeCompletionType.Register));
                                    resultList.Add(new CodeCompletionData("pe", CodeCompletionType.Register));
                                }
                            }
                            if (command == "ret")
                            {
                                return resultList.ToArray();
                            }

                            AddParserData(resultList);
                            return resultList.ToArray();
                            //special cases
                        case "im":
                            resultList.Add(new CodeCompletionData("0", CodeCompletionType.Command));
                            resultList.Add(new CodeCompletionData("1", CodeCompletionType.Command));
                            resultList.Add(new CodeCompletionData("2", CodeCompletionType.Command));
                            return resultList.ToArray();
                        case "ex":
                            resultList.Add(new CodeCompletionData("de,hl", CodeCompletionType.Register));
                            resultList.Add(new CodeCompletionData("af,af'", CodeCompletionType.Register));
                            resultList.Add(new CodeCompletionData("(sp),hl", CodeCompletionType.Register));
                            resultList.Add(new CodeCompletionData("(sp),ix", CodeCompletionType.Register));
                            resultList.Add(new CodeCompletionData("(sp),iy", CodeCompletionType.Register));
                            return resultList.ToArray();
                        case "rst":
                            resultList.Add(new CodeCompletionData("08h", CodeCompletionType.Command));
                            resultList.Add(new CodeCompletionData("10h", CodeCompletionType.Command));
                            resultList.Add(new CodeCompletionData("18h", CodeCompletionType.Command));
                            resultList.Add(new CodeCompletionData("20h", CodeCompletionType.Command));
                            resultList.Add(new CodeCompletionData("28h", CodeCompletionType.Command));
                            resultList.Add(new CodeCompletionData("30h", CodeCompletionType.Command));
                            resultList.Add(new CodeCompletionData("38h", CodeCompletionType.Command));
                            return resultList.ToArray();

                            //all the no argument commands
                        case "ccf":
                        case "cpdr":
                        case "cpd":
                        case "cpir":
                        case "cpi":
                        case "cpl":
                        case "daa":
                        case "di":
                        case "ei":
                        case "exx":
                        case "halt":
                        case "indr":
                        case "ind":
                        case "inir":
                        case "ini":
                        case "lddr":
                        case "ldd":
                        case "ldir":
                        case "ldi":
                        case "neg":
                        case "nop":
                        case "otdr":
                        case "otir":
                        case "outd":
                        case "outi":
                        case "reti":
                        case "retn":
                        case "rla":
                        case "rlca":
                        case "rld":
                        case "rra":
                        case "rrca":
                        case "scf":
                            return resultList.ToArray();
                        default:
                        {
                            var macros = _parserService.GetAllParserData().Where(s => s is IMacro);
                            resultList = new List<ICompletionData>(macros.Select(m =>
                                new CodeCompletionData(m.Name, CodeCompletionType.Define, m.Description)));
                            return resultList.ToArray();
                        }
                    }
                }
            }
        }


        // Good Luck (random shit), Lord of the Rings, Custom game, Memes, Lande, Erhverv, Serier

        public List<string> GetItems(string categoryStringId)
        {
            switch (categoryStringId)
            {
                case "LeagueOfLegends":
                    return LeagueOfLegends();
                case "SportAthletes":
                    return SportAthletes();
                case "Marvel":
                    return Marvel();
                case "Disney":
                    return Disney();
                case "DisneyCharacters":
                    return DisneyCharacters();
                case "GameOfThrones":
                    return GameOfThrones();
                case "Movies":
                    return Movies();
                case "StarWars":
                    return StarWars();
                case "CustomCategory":
                    return CustomCategory();
                case "Professions":
                    return Professions();
                case "Brands":
                    return Brands();
                case "HarryPotter":
                    return HarryPotter();
                default:
                    return new List<string>();
            }
        }

        public List<string> LeagueOfLegends()
        {
            List<string> resultList = new List<string>();
            resultList.Add("Aatrox");
            resultList.Add("Ahri");
            resultList.Add("Akali");
            resultList.Add("Alistar");
            resultList.Add("Amumu");
            resultList.Add("Anivia");
            resultList.Add("Annie");
            resultList.Add("Ashe");
            resultList.Add("Aurelion Sol");
            resultList.Add("Azir");
            resultList.Add("Bard");
            resultList.Add("Blitzcrank");
            resultList.Add("Brand");
            resultList.Add("Braum");
            resultList.Add("Caitlyn");
            resultList.Add("Camille");
            resultList.Add("Cassiopeia");
            resultList.Add("Cho'Gath");
            resultList.Add("Corki");
            resultList.Add("Darius");
            resultList.Add("Diana");
            resultList.Add("Dr. Mundo");
            resultList.Add("Draven");
            resultList.Add("Ekko");
            resultList.Add("Elise");
            resultList.Add("Evelynn");
            resultList.Add("Ezreal");
            resultList.Add("Fiddlesticks");
            resultList.Add("Fiora");
            resultList.Add("Fizz");
            resultList.Add("Galio");
            resultList.Add("Gangplank");
            resultList.Add("Garen");
            resultList.Add("Gnar");
            resultList.Add("Gragas");
            resultList.Add("Graves");
            resultList.Add("Hecarim");
            resultList.Add("Heimerdinger");
            resultList.Add("Illaoi");
            resultList.Add("Irelia");
            resultList.Add("Ivern");
            resultList.Add("Janna");
            resultList.Add("Jarvan IV");
            resultList.Add("Jax");
            resultList.Add("Jayce");
            resultList.Add("Jhin");
            resultList.Add("Jinx");
            resultList.Add("Kai'Sa");
            resultList.Add("Kalista");
            resultList.Add("Karma");
            resultList.Add("Karthus");
            resultList.Add("Kassadin");
            resultList.Add("Katarina");
            resultList.Add("Kayle");
            resultList.Add("Kayn");
            resultList.Add("Kennen");
            resultList.Add("Kha'Zix");
            resultList.Add("Kindred");
            resultList.Add("Kled");
            resultList.Add("Kog'Maw");
            resultList.Add("LeBlanc");
            resultList.Add("Lee Sin");
            resultList.Add("Leona");
            resultList.Add("Lissandra");
            resultList.Add("Lucian");
            resultList.Add("Lulu");
            resultList.Add("Lux");
            resultList.Add("Malphite");
            resultList.Add("Malzahar");
            resultList.Add("Maokai");
            resultList.Add("Master Yi");
            resultList.Add("Miss Fortune");
            resultList.Add("Mordekaiser");
            resultList.Add("Morgana");
            resultList.Add("Nami");
            resultList.Add("Nasus");
            resultList.Add("Nautilus");
            resultList.Add("Neeko");
            resultList.Add("Nidalee");
            resultList.Add("Nocturne");
            resultList.Add("Nunu & Willump");
            resultList.Add("Olaf");
            resultList.Add("Orianna");
            resultList.Add("Ornn");
            resultList.Add("Pantheon");
            resultList.Add("Poppy");
            resultList.Add("Pyke");
            resultList.Add("Quinn");
            resultList.Add("Rakan");
            resultList.Add("Rammus");
            resultList.Add("Rek'Sai");
            resultList.Add("Renekton");
            resultList.Add("Rengar");
            resultList.Add("Riven");
            resultList.Add("Rumble");
            resultList.Add("Ryze");
            resultList.Add("Sejuani");
            resultList.Add("Shaco");
            resultList.Add("Shen");
            resultList.Add("Shyvana");
            resultList.Add("Singed");
            resultList.Add("Sion");
            resultList.Add("Sivir");
            resultList.Add("Skarner");
            resultList.Add("Sona");
            resultList.Add("Soraka");
            resultList.Add("Swain");
            resultList.Add("Syndra");
            resultList.Add("Tahm Kench");
            resultList.Add("Taliyah");
            resultList.Add("Talon");
            resultList.Add("Taric");
            resultList.Add("Teemo");
            resultList.Add("Thresh");
            resultList.Add("Tristana");
            resultList.Add("Trundle");
            resultList.Add("Tryndamere");
            resultList.Add("Twisted Fate");
            resultList.Add("Twitch");
            resultList.Add("Udyr");
            resultList.Add("Urgot");
            resultList.Add("Varus");
            resultList.Add("Vayne");
            resultList.Add("Veigar");
            resultList.Add("Vel'Koz");
            resultList.Add("Vi");
            resultList.Add("Viktor");
            resultList.Add("Vladimir");
            resultList.Add("Volibear");
            resultList.Add("Warwick");
            resultList.Add("Wukong");
            resultList.Add("Xayah");
            resultList.Add("Xerath");
            resultList.Add("Xin Zhao");
            resultList.Add("Yasuo");
            resultList.Add("Yorick");
            resultList.Add("Zac");
            resultList.Add("Zed");
            resultList.Add("Ziggs");
            resultList.Add("Zilean");
            resultList.Add("Zoe");
            resultList.Add("Sylas");
            resultList.Add("Yuumi");
            resultList.Add("Qiyana");
            resultList.Add("Senna");
            resultList.Add("Aphelios");
            resultList.Add("Sett");
            resultList.Add("Lillia");

            return resultList;
        }

        public int LeagueOfLegendsCount()
        {
            var lol = LeagueOfLegends();
            return lol.Count;
        }

        public List<string> SportAthletes()
        {
            List<string> resultList = new List<string>();

            resultList.Add("Christiano Ronaldo");
            resultList.Add("LeBron James");
            resultList.Add("Lionel Messi");
            resultList.Add("Roger Federer");
            resultList.Add("Neymar");
            resultList.Add("Usain Bolt");
            resultList.Add("Tiger Woods");
            resultList.Add("Mikkel Hansen");
            resultList.Add("Niklas Landin");
            resultList.Add("Tom Brady");
            resultList.Add("Serena Williams");
            resultList.Add("Caroline Wozniacki");
            resultList.Add("Zlatan Ibrahimovix");
            resultList.Add("Mike Tyson");
            resultList.Add("Gareth Bale");
            resultList.Add("Ronaldinho");
            resultList.Add("Luis Suárez");
            resultList.Add("Michael Laudrup");
            resultList.Add("Peter Schmeichel");
            resultList.Add("Eli Manning");
            resultList.Add("David Beckham");
            resultList.Add("Manuel Neuer");
            resultList.Add("Lewis Hamilton");
            resultList.Add("Michael Schumacher");
            resultList.Add("Michael Phelps");
            resultList.Add("Jeanette Ottesen");
            resultList.Add("Nicklas Bendtner");
            resultList.Add("Christian Eriksen");
            resultList.Add("Harry Kane");
            resultList.Add("Viktor Axelsen");
            resultList.Add("Zinedine Zidane");
            resultList.Add("Roberto Carlos");
            resultList.Add("Ronaldo Nazario");
            resultList.Add("Kylian Mbappé");

            return resultList;
        }

        public int SportAthletesCount()
        {
            var sa = SportAthletes();
            return sa.Count;
        }

        public List<string> Marvel()
        {
            List<string> resultList = new List<string>();

            resultList.Add("Iron Man");
            resultList.Add("Hulk");
            resultList.Add("Thor");
            resultList.Add("Ultron");
            resultList.Add("Ant-Man");
            resultList.Add("Captain America");
            resultList.Add("Doctor Strange");
            resultList.Add("Spider-Man");
            resultList.Add("Black Panther");
            resultList.Add("Daredevil");
            resultList.Add("Punisher");
            resultList.Add("Deadpool");
            resultList.Add("Nick Fury");
            resultList.Add("Colossus");
            resultList.Add("Bucky Barnes");
            resultList.Add("Hawkeye");
            resultList.Add("Luke Cage");
            resultList.Add("Iron Fist");
            resultList.Add("Scarlet Witch");
            resultList.Add("War Machine");
            resultList.Add("Captain Marvel");
            resultList.Add("Quicksilver");
            resultList.Add("Vision");
            resultList.Add("Black Widow");
            resultList.Add("Wasp");
            resultList.Add("Falcon");
            resultList.Add("Jessica Jones");
            resultList.Add("Rocket Raccoon");
            resultList.Add("Groot");
            resultList.Add("Drax");
            resultList.Add("Star-Lord");
            resultList.Add("Mantis");
            resultList.Add("Thanos");
            resultList.Add("Venom");
            resultList.Add("Loki");
            resultList.Add("Gamora");
            resultList.Add("Yondu");

            return resultList;
        }

        static void MainSample(string[] args)
        {
            string filePath = @"G:\RepositoryFiles\Effect of Inverted Index Partitioning Schemes on Performance of Query Processing in Parallel Text Retrieval Systems.pdf";

            PdfReader reader = new PdfReader(filePath);
            
            ZeFontSizeLocationTextExtractionStrategy S = new ZeFontSizeLocationTextExtractionStrategy();
            List<ZeChunkFontSize> resultList = ZePdfTextExtractor.GetTextFromPage(reader, 1, S);

            StringBuilder resultSb = new StringBuilder();

            for (int i = 0; i < resultList.Count; i++)
            {
                resultSb.AppendFormat(@"<span style=""font-family:{0};font-size:{1}"">", resultList[i].CurFont, resultList[i].CurFontSize);

                while ((i < resultList.Count) && (resultList[i].Text != "\n") && (resultList[i].Text != " ")  )
                {
                    resultSb.Append(resultList[i].Text);
                    i++;
                }

                if ((i < resultList.Count) && (resultList[i].Text == " "))
                {
                    resultSb.Append(resultList[i].Text);
                }

                if ((i < resultList.Count) && (resultList[i].Text == "\n"))
                {
                    resultSb.Append("<br />");

                }

                resultSb.AppendLine("</span>");
            }

            string F = resultSb.ToString();

            Console.WriteLine(F);

            string fileResult = F;
            System.IO.File.WriteAllText(@"G:\htmlextrac.html", fileResult);
            
            Console.ReadLine();
        }

        [TestMethod]
        [Owner("Trevor Williams-Ros")]
        [TestCategory("ResultList_Constructor")]
        public void ResultList_Constructor_Default_HasErrorsIsFalse()
        {
            //------------Setup for test--------------------------

            //------------Execute Test---------------------------
            var resultList = new ResultList<string>();

            //------------Assert Results-------------------------
            Assert.IsNotNull(resultList.Items);
            Assert.IsFalse(resultList.HasErrors);
            Assert.IsNull(resultList.Errors);
        }

        [TestMethod]
        [Owner("Trevor Williams-Ros")]
        [TestCategory("ResultList_Constructor")]
        public void ResultList_Constructor_ErrorFormatWithNoArgs_HasErrorsIsTrue()
        {
            //------------Setup for test--------------------------

            //------------Execute Test---------------------------
            var resultList = new ResultList<string>("Hello");

            //------------Assert Results-------------------------
            Assert.IsNotNull(resultList.Items);
            Assert.IsTrue(resultList.HasErrors);
            Assert.AreEqual("Hello", resultList.Errors);
        }

        [TestMethod]
        [Owner("Trevor Williams-Ros")]
        [TestCategory("ResultList_Constructor")]
        public void ResultList_Constructor_ErrorFormatWithArgs_HasErrorsIsTrue()
        {
            //------------Setup for test--------------------------

            //------------Execute Test---------------------------
            var resultList = new ResultList<string>("Hello {0}", "world");

            //------------Assert Results-------------------------
            Assert.IsNotNull(resultList.Items);
            Assert.IsTrue(resultList.HasErrors);
            Assert.AreEqual("Hello world", resultList.Errors);
        }

        [TestMethod]
        [Owner("Trevor Williams-Ros")]
        [TestCategory("ResultList_Constructor")]
        public void ResultList_Constructor_ExceptionIsNull_HasErrorsIsTrue()
        {
            //------------Setup for test--------------------------

            //------------Execute Test---------------------------
            var resultList = new ResultList<string>((Exception)null);

            //------------Assert Results-------------------------
            Assert.IsNotNull(resultList.Items);
            Assert.IsTrue(resultList.HasErrors);
            Assert.AreEqual("", resultList.Errors);
        }

        [TestMethod]
        [Owner("Trevor Williams-Ros")]
        [TestCategory("ResultList_Constructor")]
        public void ResultList_Constructor_ExceptionIsNotNull_HasErrorsIsTrue()
        {
            //------------Setup for test--------------------------
            var ex = new Exception("Error Occurred", new Exception("Inner Error"));

            //------------Execute Test---------------------------
            var resultList = new ResultList<string>(ex);

            //------------Assert Results-------------------------
            Assert.IsNotNull(resultList.Items);
            Assert.IsTrue(resultList.HasErrors);
            Assert.AreEqual("Error Occurred\r\nInner Error\r\n", resultList.Errors);
        }


        [TestMethod]
        [Owner("Trevor Williams-Ros")]
        [TestCategory("ResultList_ToString")]
        public void ResultList_ToString_Json()
        {
            //------------Setup for test--------------------------
            var resultList = new ResultList<string>("Hello");
            var expected = JsonConvert.SerializeObject(resultList);

            //------------Execute Test---------------------------
            var actual = resultList.ToString();

            //------------Assert Results-------------------------
            Assert.AreEqual(expected, actual);
        }

        public static List<ContentItem> BuilderContent(MomentEntity moment,bool displayContact=true)
        {
            var resultList = new List<ContentItem>();
            int index = 1;
            AddItem(resultList, index++, "发布时间", DateTimeHelper.GetDateDesc(moment.CreateTime, true));
            if (moment.StopTime.HasValue)
            {
                string stopStr = moment.StopTime.Value.ToString("yyyy-MM-dd HH:mm");
                if (IsOverTime(moment.StopTime))
                {
                    stopStr += "(已过期)";
                }
                AddItem(resultList, index++, "截止时间", stopStr);
            }
            AddItem(resultList, index++, "性别要求", GenderMap(moment.ExpectGender));
            AddItem(resultList, index++, "人数限制",string.Format("{0}人",moment.NeedCount));
            if (moment.IsOffLine)
            {
                AddItem(resultList, index++, "地点", moment.Place);
            }
            if (displayContact)
            {
                AddItem(resultList, index++, "联系方式", "通过申请后可查看", TagTypeEnum.Contact);
            }
            return resultList;
        }

        public static List<ContentItem> BuilderContent2Contact(MomentEntity moment, UserInfoEntity userInfo, bool displayContact)
        {
            var resultList = new List<ContentItem>();
            int index = 1;
            AddItem(resultList, index++, "发布时间", DateTimeHelper.GetDateDesc(moment.CreateTime, true), TagTypeEnum.PublishTime);
            if (moment.StopTime.HasValue)
            {
                string stopStr = moment.StopTime.Value.ToString(DateTimeHelper.yMdHm);
                if (IsOverTime(moment.StopTime))
                {
                    stopStr += "(已过期)";
                }
                AddItem(resultList, index++, "截止时间", stopStr);
            }
            AddItem(resultList, index++, "性别要求", GenderMap(moment.ExpectGender));
            AddItem(resultList, index++, "人数限制", string.Format("{0}人", moment.NeedCount));
            AddItem(resultList, index++, "地点", moment.Place);
            if (displayContact)
            {
                if (!string.IsNullOrEmpty(userInfo.Mobile))
                {
                    AddItem(resultList, index++, "手机号", userInfo.Mobile, TagTypeEnum.Contact);
                }
                if (!string.IsNullOrEmpty(userInfo.WeChatNo))
                {
                    AddItem(resultList, index++, "微信号", userInfo.WeChatNo, TagTypeEnum.Contact);
                }
                if (!string.IsNullOrEmpty(userInfo.QQNo))
                {
                    AddItem(resultList, index++, "QQ号", userInfo.QQNo, TagTypeEnum.Contact);
                }
            }
            return resultList;
        }

        public static string GetShareTitle(MomentEntity moment)
        {
            if (moment == null)
            {
                return null;
            }
            var stringBuilder = new StringBuilder();
            if (!string.IsNullOrEmpty(moment.Title))
            {
                stringBuilder.AppendFormat("{0}:",moment.Title);
            }
            if (!string.IsNullOrEmpty(moment.Content))
            {
                stringBuilder.Append(moment.Content);
            }
            return stringBuilder.ToString();
        }

        private static void AddItem(List<ContentItem> resultList,int index,string title, string content, TagTypeEnum type= TagTypeEnum.Default,string icon=null)
        {
            if (string.IsNullOrEmpty(content))
            {
                return;
            }
            resultList.Add(new ContentItem()
            {
                Type = type,
                Title = "",
                Content = string.Format("{0}:{1}", title, content),
                Icon = icon,
                Index = index
            });
        }

        private static string GenderMap(GenderEnum gender)
        {
            switch (gender)
            {
                case GenderEnum.Man:
                    return "只要男生";
                case GenderEnum.Woman:
                    return "只要女生";
                case GenderEnum.Default:
                case GenderEnum.All:
                default:
                    return "男女不限";
            }
        }


        public static string BtnTextMap(MomentStateEnum state, DateTime? stopTime,bool isApply, bool selfFlag, bool isOverCount)
        {
            if (isApply)
            {
                return "查看我的申请";
            }
            if (IsOverTime(stopTime) || isOverCount|| selfFlag)
            {
                return "";
            }
            if (state== MomentStateEnum.正常发布中)
            {
                return "申请参与";
            }

            return "";
        }


        private void ResultList_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
        {
            if (sender != ResultList) return;
            e.Handled = true;
            ResultSelected();
        }

        private void SearchText_KeyUp(object sender, KeyEventArgs e)
        {
            e.Handled = true;
            _changingResults = true;
            switch (e.Key)
            {
                case Key.Escape:
                    Hide();
                    break;
                case Key.Enter:
                    ResultSelected();
                    break;
                case Key.Down:
                    _selectionIndex++;
                    ResultList.SelectedIndex = Math.Min(ResultList.Items.Count - 1, _selectionIndex);
                    ResultList.ScrollIntoView(ResultList.SelectedItem);
                    break;
                case Key.Up:
                    _selectionIndex--;
                    ResultList.SelectedIndex = Math.Max(ResultList.Items.Count == 0 ? -1 : 0, _selectionIndex);
                    ResultList.ScrollIntoView(ResultList.SelectedItem);
                    break;
                default:
                {
                    // update results
                    string text = SearchText.Text;
                    var resultIssues = Vault.SearchIssues(text);

                    if (resultIssues.Count == 0)
                    {
                        if (ResultList.Items.Count == 0)
                        {
                            ResultList.Visibility = Visibility.Collapsed;
                            ResultEmptyText.Visibility = Visibility.Visible;
                        }
                        else
                        {
                            SearchText.Background = Brushes.LightPink;
                        }
                    }
                    else
                    {
                        SearchText.Background = Brushes.White;
                        ResultList.Items.Clear();
                        ResultList.Visibility = Visibility.Visible;
                        ResultEmptyText.Visibility = Visibility.Collapsed;

                        for (int i = 0; i < resultIssues.Count && i < 20; i++)
                        {
                            Issue issue = resultIssues[i];
                            string assigneeText = "(" + (issue.Assignee?.DisplayName ?? "Unassigned") + ")";
                            ResultEntry entry = new ResultEntry(issue.Key, issue.Summary, assigneeText, Vault.GetWrappedImage(issue.Type?.IconUrl));
                            ResultList.Items.Add(entry);
                        }
                        ResultList.SelectedIndex = Math.Clamp(_selectionIndex, 0, resultIssues.Count - 1);
                    }
                    break;
                }
            }
            _changingResults = false;
        }

        private void SearchWindow_GotFocus(object sender, RoutedEventArgs e)
        {
            if (e.Source != ResultList)
            {
                SearchText.Focus();
            }
        }

        private void ResultList_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            if (ResultList.SelectedIndex >= 0) {
                _selectionIndex = ResultList.SelectedIndex;
            }
            if (!_changingResults)
            {
                ResultSelected();
            }
        }

        private void ResultSelected()
        {
            if (ResultList.Items.Count > 0 && ResultList.SelectedItem is ResultEntry entry)
            {
                SearchResultSelected?.Invoke(entry.IssueKey);
                Hide();
            }
        }

        public void Display()
        {
            Show();
            Top = (Owner.Top + Owner.Height / 2) - Height / 2;
            Left = (Owner.Left + Owner.Width / 2) - Width / 2;

            SearchText.Focus();
            SearchText.SelectAll();
        }


        private void OpenFile_Click(object sender, EventArgs e)
        {
            pView.Clear();
            pList.Clear();

            //파일 오픈
            string path = SelectFilePath();
            if (path == null) return;

            readText = File.ReadAllLines(path);

            //토큰 분리
            for (int i = 0; i < readText.Length; i++)
            {
                string[] token = readText[i].Split(' ');
                Process p = new Process(int.Parse(token[1]), int.Parse(token[2]), int.Parse(token[3]), int.Parse(token[4]));
                pList.Add(p);
            }

            //Grid에 process 출력
            dataGridView1.Rows.Clear();
            string[] row = { "", "", "", "" };
            foreach (Process p in pList)
            {
                row[0] = p.processID.ToString();
                row[1] = p.arriveTime.ToString();
                row[2] = p.burstTime.ToString();
                row[3] = p.priority.ToString();

                dataGridView1.Rows.Add(row);
            }

            //arriveTime으로 정렬
          
            pList.Sort(delegate (Process x, Process y)
            {
                if (x.arriveTime > y.arriveTime) return 1;
                else if (x.arriveTime < y.arriveTime) return -1;
                else
                {
                    return x.processID.CompareTo(y.processID);
                }
                //return x.arriveTime.CompareTo(y.arriveTime);
            });
             
            
            readFile = true;
        }
        
        private string SelectFilePath()
        {
            openFileDialog1.Filter = "텍스트파일|*.txt";
            return (openFileDialog1.ShowDialog() == DialogResult.OK) ? openFileDialog1.FileName : null;
        }

        private void Run_Click(object sender, EventArgs e)
        {
            if (!readFile) return;

            if (menuCheck == 1) { resultList = FCFS.Run(pList, resultList); }
            else if (menuCheck == 2) { resultList = Non_Preemptive_SJF.Run(pList, resultList); }
            else if (menuCheck == 3) { resultList = Preemptive_SJF.Run(pList, resultList); }
            else if (menuCheck == 4) { resultList = Non_Preemptive_Priority.Run(pList, resultList); }
            else if (menuCheck == 5) { resultList = RR.Run(pList, resultList, timeQuantum); }

            //결과출력
            dataGridView2.Rows.Clear();



            //값을 받아 왔다 확인해주는 값;
            //값을 집어넣어두는 곳
            if (menuCheck == 3 || menuCheck == 5)
            {
                int[] turnaround = new int[resultList.Count + 1];
                int[] time = new int[resultList.Count + 1];
                for (int t = 0; t < resultList.Count; t++) turnaround[t] = -1;

                for (int t = resultList.Count - 1; t >= 0; t--)
                {
                    if (turnaround[resultList[t].processID] == -1)
                    {
                        turnaround[resultList[t].processID] = resultList[t].turnaroundTime;
                    }
                    else continue;
                }
                for (int t = 0; t < resultList.Count; t++)
                {
                    int tt;
                    for (tt = 0; tt != resultList[t].processID; tt++) ;
                    resultList[t].turnaroundTime = turnaround[tt];

                }
            }
            string[] row = { "", "", "", "","" };

            double waitingTime = 0.0;
            foreach (Result r in resultList)
            {
                row[0] = r.processID.ToString();
                row[1] = r.burstTime.ToString();
                row[2] = r.waitingTime.ToString();
                waitingTime += r.waitingTime;
                row[3] = r.responseTime.ToString();
                row[4] = r.turnaroundTime.ToString();
                dataGridView2.Rows.Add(row);
            }
            //////////////
            double avercount = 0.0;
            int[] j = new int[resultList.Count + 1];

            for (int i = 0; i < resultList.Count; i++)
            {
                j[resultList[i].processID] = -1;
            }
            for (int l = 0; l <= resultList.Count; l++)    
            {
                if (j[l] == -1)
                    ++avercount;
            }


            double responseTime = 0.0;          

            for (int i = 0; i < resultList.Count; i++)
            {
                responseTime += resultList[i].responseTime;
            }
            /////////////////
            TRTime.Text = "전체 실행시간: " + (resultList[resultList.Count - 1].startP + resultList[resultList.Count - 1].burstTime).ToString();
            avgRT.Text = "평균 대기시간: " + (waitingTime / avercount).ToString();//원래 resultList.Count
            resTime.Text = "평균 응답시간: " + (responseTime / avercount).ToString();
            panel1.Invalidate();
            
        }


        private void panel1_Paint(object sender, PaintEventArgs e)
        {
            int startPosition = 10;
            double waitingTime = 0.0;

            int resultListPosition = 0;
          
                foreach (Result r in resultList)
                {
                    e.Graphics.DrawString("p" + r.processID.ToString(), Font, Brushes.Black, startPosition + (r.startP * 10), resultListPosition);
                    e.Graphics.DrawRectangle(Pens.Red, startPosition + (r.startP * 10), resultListPosition + 20, r.burstTime * 10, 30);
                    e.Graphics.DrawString(r.burstTime.ToString(), Font, Brushes.Black, startPosition + (r.startP * 10), resultListPosition + 60);
                    e.Graphics.DrawString(r.waitingTime.ToString(), Font, Brushes.Black, startPosition + (r.startP * 10), resultListPosition + 80);
                    waitingTime += (double)r.waitingTime;

                }
            
           
        }

        private void sJF비선점ToolStripMenuItem_Click(object sender, EventArgs e)
        {
          
        }

        private void label3_Click(object sender, EventArgs e)
        {

        }


        #region 仅仅基于用户的 查询方法.




        /// <summary>
        /// 获取 指定 用户的 "可访问部门" 列表.
        /// 可访问部门包含 用户当前部门 与 用户当前部门的下属部门.
        /// </summary>
        /// <param name="userCode"> 用户代码 </param>
        /// <returns></returns>
        public List<MR_DEPT> GetUserAccessAbleDeptList(string userCode)
        {
            // 预期要返回的结果.
            List<MR_DEPT> resultList = new List<MR_DEPT>();

            // 开始查询处理.
            using (MyRuleEntities context = new MyRuleEntities())
            {
                // 首先查询用户.
                MR_USER mrUser = context.MR_USER.FirstOrDefault(p => p.USER_CODE == userCode);


                if (mrUser == null)
                {
                    // 用户不存在.
                    return resultList;
                }


                // 延迟查询 用户的 直属部门.
                foreach (MR_DEPT mrDept in mrUser.MR_DEPT)
                {
                    // 如果结果列表中没有数据, 那么加入结果列表.
                    if (resultList.Count(p => p.DEPT_CODE == mrDept.DEPT_CODE) == 0)
                    {
                        // 加入 用户的 直属部门.
                        resultList.Add(mrDept);

                        // 查询这个部门的下属部门.
                        List<MR_DEPT> allSubDeptList = mrDept.GetAllSubMrDeptList();

                        foreach (MR_DEPT subDept in allSubDeptList)
                        {
                             // 如果结果列表中没有数据, 那么加入结果列表.
                            if (resultList.Count(p => p.DEPT_CODE == subDept.DEPT_CODE) == 0)
                            {
                                // 加入 用户的 直属部门 的  下属部门.
                                resultList.Add(subDept);
                            }
                        }
                    }
                }
            }

            // 返回结果列表.
            return resultList;
        }




        /// <summary>
        /// 获取 指定 用户的 "可访问模块" 列表.
        /// 可访问模块包含 用户直接可访问模块 与 用户直接可访问模块的下属模块.
        /// </summary>
        /// <param name="userCode"> 用户代码 </param>
        /// <returns></returns>
        public List<MR_MODULE> GetUserAccessAbleModuleList(string userCode)
        {
            // 开始查询处理并返回.
            using (MyRuleEntities context = new MyRuleEntities())
            {
                return GetUserAccessAbleModuleList(context, userCode);
            }
        }



        /// <summary>
        /// 获取 指定用户 对指定模块 的 "可访问动作" 列表.
        /// 可访问动作,包含 当前模块的 默认可用动作 与 针对用户授权了的动作.
        /// </summary>
        /// <param name="userCode"> 用户代码 </param>
        /// <param name="moduleCode"> 模块代码 </param>
        /// <returns></returns>
        public List<MR_ACTION> GetUserAccessAbleActionList(string userCode, string moduleCode)
        {
            // 开始查询处理, 并返回.
            using (MyRuleEntities context = new MyRuleEntities())
            {
                return GetUserAccessAbleActionList(context, userCode, moduleCode);
            }


        }



        #endregion







        #region  仅仅基于 角色 的查询方法.


        /// <summary>
        /// 获取 指定 角色的 "可访问模块" 列表.
        /// 可访问模块包含 角色直接可访问模块 与 角色直接可访问模块的下属模块.
        /// </summary>
        /// <param name="roleCode"> 角色代码 </param>
        /// <returns></returns>
        public List<MR_MODULE> GetRoleAccessAbleModuleList(string roleCode)
        {
            // 开始查询处理 并返回.
            using (MyRuleEntities context = new MyRuleEntities())
            {
                return GetRoleAccessAbleModuleList(context, roleCode);
            }
        }



        /// <summary>
        /// 获取 指定角色 对指定模块 的 "可访问动作" 列表.
        /// 可访问动作,包含 当前模块的 默认可用动作 与 针对角色授权了的动作.
        /// </summary>
        /// <param name="roleCode"> 角色代码 </param>
        /// <param name="moduleCode"> 模块代码 </param>
        /// <returns></returns>
        public List<MR_ACTION> GetRoleAccessAbleActionList(string roleCode, string moduleCode)
        {
            // 开始查询处理. 并返回.
            using (MyRuleEntities context = new MyRuleEntities())
            {
                return GetRoleAccessAbleActionList(context, roleCode, moduleCode);
            }
        }





        #endregion









        #region 结合 用户与角色 的查询方法.



        /// <summary>
        /// 获取 指定 用户的 全部的 "可访问模块" 列表.
        /// 可访问模块包含 用户直接可访问模块 与 用户直接可访问模块的下属模块.
        /// 以及 用户的角色 直接可访问模块 与 用户的角色直接可访问模块的下属模块.
        /// </summary>
        /// <param name="userCode"> 用户代码 </param>
        /// <returns></returns>
        public List<MR_MODULE> GetAllUserAccessAbleModuleList(string userCode)
        {
            // 开始查询处理 并返回.
            using (MyRuleEntities context = new MyRuleEntities())
            {
                return GetAllUserAccessAbleModuleList(context, userCode);
            }
        }

      

        [HttpGet]
        //Show list of all students
        public List<Student> getStudents()
        {
            //Filling the list of students
            resultList = AddUser();
            //Sending back the list of students

            //Save process to Logging file
            logCls.CreateLog("Bütün öğrencilerin listesi görüntülendi");
            return resultList;

        
        }

        [HttpGet("{id}")]
        //Show only the student whose id is specified
        public Student getStudent(int id)
        {
            
            resultList = AddUser();
            Student student = new Student();
            //Find specified student with id
            student = resultList.FirstOrDefault(x => x.StudentId == id);
            //Save process to Logging file
            logCls.CreateLog(id + " nolu öğrencinin bilgileri görüntülendi");
            return student; 

      
        }
        
        [HttpPost]
        //Add student to list
        public Result PostStudents(Student ogr)
        {
            //Filling the list of students
            resultList = AddUser();

            //Is the student we want to add on the list?
            bool control = resultList.Select(x => x.StudentId == ogr.StudentId).FirstOrDefault();
            //if answer is "NO" add student to the list
            if(control==false)
            {
               
                resultList.Add(ogr);
                result.status = 1;
                result.message = "Listeye ogrenci basariyla eklendi";

                //Save process to Logging file
                logCls.CreateLog(ogr.StudentId + " nolu ogrenci listeye başarıyla eklendi");
            }
            // return failed message and all list of students
            else
            {
                result.status = 0;
                result.message = "Ekleme basarisiz";
                result.students = resultList;
            }
               

            return result;

        }

        [HttpPut("{id}")]
        //Update the information of the student whose id is specified in the list
        public Result UpdateStudent(Student newValue, int id)
        {
            //Filling the list of students
            resultList = AddUser();

            //Find student with specified id
            //student may not be on the list
            Student? oldValue=resultList.Find(y=>y.StudentId ==id);
            if(oldValue!=null)
            {
                //if student on the list update student's unformation 
                result.status = 1;
                result.message = "öğrenciler listesi basariyla guncellendi";
                result.students = resultList;

                //Save process to Logging file
                logCls.CreateLog(id + " nolu ogrencinin bilgileri ve " + result.message);
            }
            else
            {
                //else return failed message
                result.status = 0;
                result.message = "Bilgisini guncellemek istediginiz ogrenci listede bulunamadi";
            }
            return result;
           
        }

        [HttpDelete("{id}")]
        //Delete the information of the student whose id is specified in the list
        public Result DeleteStudent(int id)
        {
            //Filling the list of students
            resultList = AddUser();

            //Find student with specified id
            //student may not be on the list
            Student? deletedValue=resultList.Find(y=>y.StudentId==id);
            if (deletedValue != null)
            {
                //if student on the list delete student's information from list
                resultList.Remove(deletedValue);
                result.status = 1;
                result.message = "Ogrenci başarıyla silindi";
                result.students = resultList;
                logCls.CreateLog(id + " nolu " + result.message);
                
               

            }
            else
            {
                //else return failed message
                result.status = 0;
                result.message = "Bilgisini guncellemek istediginiz ogrenci listede bulunamadi";
            }
            return result;
            
        }
       
        //fuction which filling students' information
        //use this function if you don't have database 
        public List<Student> AddUser()
        {
            List<Student> lst = new List<Student>();
            lst.Add(new Model.Student { StudentId = 1, Name = "Aizat", Surname = "Esenbekova", Age = 20 });
            lst.Add(new Model.Student { StudentId = 2, Name = "Dilara", Surname = "Sahin", Age = 21 });
            lst.Add(new Model.Student { StudentId = 3, Name = "Duygu", Surname = "Koc", Age = 19 });
            lst.Add(new Model.Student { StudentId = 4, Name = "Selin", Surname = "Yilmaz", Age = 25 });
            return lst;
        }



        public ActionResult Index()
        {
            return RedirectToAction("Index", "Dashboard");
        }


        public ActionResult NoAccessPage(int id)
        {
            int storeId = id;
            Logger.Info("NoAccessPage. StoreId:" + storeId);
            return View();
        }

        //<li>
        //                           <a href="@url">Go to frontend <i class="glyphicon glyphicon-share-alt"></i></a>
        //                       </li>



        public ActionResult StoreName()
        {
            if (IsSuperAdmin)
            {
                return PartialView("StoreName", "Store Management Admin Panel");
            }
            else
            {
                if (LoginStore == null)
                {
                    return PartialView("StoreName", "Store is null");
                }
                else
                {
                    return PartialView("StoreName", this.LoginStore.Name);
                }

            }
        }
        //  [OutputCache(CacheProfile = "Cache20Minutes")]
        public ActionResult StoreSearch()
        {
            if (User.Identity.IsAuthenticated)
            {
                return PartialView("StoreSearch");
            }
            else
            {
                return new EmptyResult();
            }
        }
        public ActionResult ReturnFrontEndUrl()
        {
            if (IsSuperAdmin)
            {
                return new EmptyResult();
            }
            else
            {

                if (LoginStore == null)
                {
                    return PartialView("ReturnFrontEndUrl", "");
                }
                else
                {
                    return PartialView("ReturnFrontEndUrl", this.LoginStore);
                }

            }
        }

        public ActionResult AdminSearch(String adminsearchkey, int page = 1)
        {
            if (String.IsNullOrEmpty(adminsearchkey))
            {
                return View(new PagedList<BaseEntity>(new List<BaseEntity>(), page - 1, 20, 0));
            }
            ViewBag.SearchKey = adminsearchkey;
            adminsearchkey = adminsearchkey.Trim().ToLower();

            int storeId = this.LoginStore.Id;
            String key = String.Format("SearchEntireStore-{0}-{1}", storeId, adminsearchkey);
            List<BaseEntity> resultList = null;
            StoreSearchCache.TryGet(key, out resultList);

            if (resultList == null)
            {
                resultList = SearchEntireStoreAsync(adminsearchkey, storeId).Result;
                StoreSearchCache.Set(key, resultList, MemoryCacheHelper.CacheAbsoluteExpirationPolicy(ProjectAppSettings.GetWebConfigInt("SearchEntireStore_Minute", 10)));
            }

            var returnSearchModel = new PagedList<BaseEntity>(resultList, page - 1, 20, resultList.Count);
            return View(returnSearchModel);
        }

SMBLibrary.RPC.ResultList : IList

Fields :

public Byte Reserved
public UInt16 Reserved2

Constructors :

public ResultList()
public ResultList(Byte[] buffer = , Int32 offset = )

Methods :

public Void WriteBytes(Byte[] buffer = , Int32 offset = )
public Void WriteBytes(Byte[] buffer = , Int32& offset = )
public Int32 get_Length()
public Int32 get_Capacity()
public Void set_Capacity(Int32 value = )
public Int32 get_Count()
public ResultElement get_Item(Int32 index = )
public Void set_Item(Int32 index = , ResultElement value = )
public Void Add(ResultElement item = )
public Void AddRange(IEnumerable<ResultElement> collection = )
public ReadOnlyCollection<ResultElement> AsReadOnly()
public Int32 BinarySearch(Int32 index = , Int32 count = , ResultElement item = , IComparer<ResultElement> comparer = )
public Int32 BinarySearch(ResultElement item = )
public Int32 BinarySearch(ResultElement item = , IComparer<ResultElement> comparer = )
public Void Clear()
public Boolean Contains(ResultElement item = )
public List<TOutput> ConvertAll(Converter<ResultElement, TOutput> converter = )
public Void CopyTo(ResultElement[] array = )
public Void CopyTo(Int32 index = , ResultElement[] array = , Int32 arrayIndex = , Int32 count = )
public Void CopyTo(ResultElement[] array = , Int32 arrayIndex = )
public Int32 EnsureCapacity(Int32 capacity = )
public Boolean Exists(Predicate<ResultElement> match = )
public ResultElement Find(Predicate<ResultElement> match = )
public List<ResultElement> FindAll(Predicate<ResultElement> match = )
public Int32 FindIndex(Predicate<ResultElement> match = )
public Int32 FindIndex(Int32 startIndex = , Predicate<ResultElement> match = )
public Int32 FindIndex(Int32 startIndex = , Int32 count = , Predicate<ResultElement> match = )
public ResultElement FindLast(Predicate<ResultElement> match = )
public Int32 FindLastIndex(Predicate<ResultElement> match = )
public Int32 FindLastIndex(Int32 startIndex = , Predicate<ResultElement> match = )
public Int32 FindLastIndex(Int32 startIndex = , Int32 count = , Predicate<ResultElement> match = )
public Void ForEach(Action<ResultElement> action = )
public Enumerator<ResultElement> GetEnumerator()
public List<ResultElement> GetRange(Int32 index = , Int32 count = )
public Int32 IndexOf(ResultElement item = )
public Int32 IndexOf(ResultElement item = , Int32 index = )
public Int32 IndexOf(ResultElement item = , Int32 index = , Int32 count = )
public Void Insert(Int32 index = , ResultElement item = )
public Void InsertRange(Int32 index = , IEnumerable<ResultElement> collection = )
public Int32 LastIndexOf(ResultElement item = )
public Int32 LastIndexOf(ResultElement item = , Int32 index = )
public Int32 LastIndexOf(ResultElement item = , Int32 index = , Int32 count = )
public Boolean Remove(ResultElement item = )
public Int32 RemoveAll(Predicate<ResultElement> match = )
public Void RemoveAt(Int32 index = )
public Void RemoveRange(Int32 index = , Int32 count = )
public Void Reverse()
public Void Reverse(Int32 index = , Int32 count = )
public Void Sort()
public Void Sort(IComparer<ResultElement> comparer = )
public Void Sort(Int32 index = , Int32 count = , IComparer<ResultElement> comparer = )
public Void Sort(Comparison<ResultElement> comparison = )
public ResultElement[] ToArray()
public Void TrimExcess()
public Boolean TrueForAll(Predicate<ResultElement> match = )
public Type GetType()
public String ToString()
public Boolean Equals(Object obj = )
public Int32 GetHashCode()