private void PollMessages(object state)
        {
            var copyOfCachedMessages = new HashSet<Message>(_messageCache);
            var sinceId = copyOfCachedMessages.OrderByDescending(x => x.Created).First().IdValue;
            var messageService = CreateBaseMessageService.Invoke();
            var messages = messageService.GetMessagesSinceAsync(sinceId).Result.ToList();

            if (messages.Count == 0)
                return;

            foreach (var message in messages)
            {
                copyOfCachedMessages.Add(message);
            }

            if (copyOfCachedMessages.Count > MaxCacheCount)
            {
                var reducedCachedMessages = 
                    copyOfCachedMessages
                        .OrderByDescending(x => x.Created)
                        .Take(MaxCacheCount);

                copyOfCachedMessages.Clear();

                foreach (var message in reducedCachedMessages)
                {
                    copyOfCachedMessages.Add(message);
                }
            }

            lock (_padlock)
            {
                _messageCache = copyOfCachedMessages;
            }
        }
Example #2
0
        public void WriteListings()
        {
            HashSet<ArchiveListing> set = new HashSet<ArchiveListing>();
            foreach (ArchiveListing listing in _set)
            {
                ArchiveListing item = listing;
                while (item != null && set.Add(item))
                    item = item.Parent;
            }

            Action<ArchiveListing> writer;
            switch (InteractionService.GamePart)
            {
                case FFXIIIGamePart.Part1:
                    writer = ArchiveListingWriterV1.Write;
                    break;
                case FFXIIIGamePart.Part2:
                    writer = ArchiveListingWriterV2.Write;
                    break;
                default:
                    throw new NotSupportedException(InteractionService.GamePart.ToString());
            }

            foreach (ArchiveListing listing in set.OrderByDescending(l => l.Accessor.Level))
                writer(listing);
        }
Example #3
0
        public void WriteListings()
        {
            HashSet<ArchiveListing> set = new HashSet<ArchiveListing>();
            foreach (ArchiveListing listing in _set)
            {
                ArchiveListing item = listing;
                while (item != null && set.Add(item))
                    item = item.Parent;
            }

            foreach (ArchiveListing listing in set.OrderByDescending(l => l.Accessor.Level))
                ArchiveListingWriter.Write(listing);
        }
        internal IEnumerable<RepositoryCommitModel> GetTags(string name, int page, int p, out string referenceName, out int totalCount)
        {
            var commit = GetCommitByName(name, out referenceName);
            if (commit == null)
            {
                totalCount = 0;
                return Enumerable.Empty<RepositoryCommitModel>();
            }
            var tags = _repository.Tags;
            var commits = new HashSet<RepositoryCommitModel>(AnonymousComparer.Create<RepositoryCommitModel>((x, y) => x.ID == y.ID, obj => obj.ID.GetHashCode()));
            foreach (var tag in tags)
            {
                var c = _repository.Lookup(tag.Target.Id) as Commit;
                commits.Add(ToModel(c));

            }
            totalCount = commits.Count();

            return commits.OrderByDescending(x => x, (x, y) => x.Date.CompareTo(y.Date));
        }
        public List<LSHashTweet> GetNearestNeighbors(LSHashTweet tweet, int n)
        {
            if (_content.Count == 0)
                return new List<LSHashTweet>();

            HashSet<LSHashTweet> candidates = new HashSet<LSHashTweet>();
            List<long> wordIDs = tweet.Vector.GetItemIDs();
            foreach (long wordID in wordIDs)
            {
                if (_wordIndex.ContainsKey(wordID))
                {
                    foreach (LSHashTweet candidate in _wordIndex[wordID])
                        candidates.Add(candidate);
                }
            }

            if (candidates.Count == 0)
                return new List<LSHashTweet>();

            return candidates.OrderByDescending(t => t.Vector * tweet.Vector).Take(n).ToList();
        }
Example #6
0
 static void Main(string[] args)
 {
     Console.WriteLine(11111);
     //SortedSet<TestSort> s = new SortedSet<TestSort>(new TestSort[] {new TestSort {Name="bar", Age=1}});
     HashSet<TestSort> s = new HashSet<TestSort>();
     s.Add(  new TestSort {Name="foo6", Age=6} );
     s.Add(  new TestSort {Name="bar1", Age=1} );
     s.Add(  new TestSort {Name="hoge5", Age=5} );
     //SortedSet<TestSort> s = new SortedSet<TestSort>(new TestSort[] {
     //  new TestSort {Name="foo", Age=6},
     //  new TestSort {Name="bar", Age=1},
     //  new TestSort {Name="hoge", Age=5},
     //});
     Console.WriteLine(22222);
     Console.WriteLine(s);
     IEnumerable<TestSort>new_s = s.OrderByDescending(pet => pet.Age);
     foreach (TestSort ts in new_s)
     {
       Console.WriteLine(ts.Name);
     }
 }
		public static ulong[] GetScores()
		{
			var scores = new HashSet<ulong>();

			// row scores.
			for (var col = 0; col < 4; col++)
			{
				for (var row = 0; row < 6; row++)
				{
					ulong line = 0x0F;
					line <<= col + (row << 3);
					scores.Add(line);
				}
			}

			// column scores.
			for (var col = 0; col < 7; col++)
			{
				for (var row = 0; row < 3; row++)
				{
					ulong line = 0x01010101;
					line <<= col + (row << 3);
					scores.Add(line);
				}
			}
			// diagonal scores.
			for (var col = 0; col < 4; col++)
			{
				for (var row = 0; row < 3; row++)
				{
					ulong dig0 = 0x08040201;
					ulong dig1 = 0x01020408;
					dig0 <<= col + (row << 3);
					dig1 <<= col + (row << 3);
					scores.Add(dig0);
					scores.Add(dig1);
				}
			}
			return scores.OrderByDescending(s => s).ToArray();
		}
        /// <summary>
        /// Writes a player to the scoreboard database.
        /// </summary>
        /// <param name="player">PLayer to be written.</param>
        public void WriteToScoreBoard(IPlayer player)
        {
            ICollection<IPlayer> currentScoreBoard = new HashSet<IPlayer>();
            currentScoreBoard = this.ReadScoreboard();

            bool reorder = true;
            foreach (var currPlayer in currentScoreBoard.Where(cp => cp.Name == player.Name))
            {
                if (currPlayer.Score <= player.Score)
                {
                    currPlayer.Score = player.Score;
                    reorder = false;
                }
            }

            var sortedScoreBoard = currentScoreBoard;
            if (reorder)
            {
                currentScoreBoard.Add(player);
                sortedScoreBoard = currentScoreBoard.OrderByDescending(pl => Convert.ToInt32(pl.Score)).ThenBy(pl => pl.Name).ToList();
            }

            DataSerialization.WriteToFile(sortedScoreBoard, FileNames.scoreboard);
        }
 /// <summary>
 /// Finds the most common word
 /// </summary>
 /// <param name="rank">How far down the list you want to go. for example if you wanted the 4th equal words you's pass 3</param>
 /// <returns>a list of either one or more strings that represtent the word or words equally tied at that rank</returns>
 public List<string> FindMostCommonWord(int rank)
 {
     var groupedWords = Words.GroupBy(e => e.WordText) // this linq statement groups and counts words based on their length
         .Select(group => new { Value = group.Key, Count = group.Count() })
         .OrderByDescending(x => x.Count)
         .ToList();
     ISet<int> commoness = new HashSet<int>();
     foreach (var item in groupedWords)
     {
         commoness.Add(item.Count); // add the count of each word to the set
     }
     int i = commoness.OrderByDescending(e => e).ToList()[rank]; // this gets the number of times the most common word occured
     List<string> commonWords = new List<string>();
     foreach (var word in groupedWords.Where(e => e.Count == i)) // this filters for words that occured that many times
     {
         commonWords.Add(word.Value);
     }
     return commonWords;
 }
Example #10
0
 public void RemoveActivities(System.Collections.IList items)
 {
     var indexes = new HashSet<int>();
     foreach (Activity activity in items) {
         indexes.Add(this.Activities.IndexOf(activity));
     }
     foreach (int index in indexes.OrderByDescending(i=>i))
     {
         this.Activities.RemoveAt(index);
     }
 }
Example #11
0
        private void UpdateBehaviorTreeView()
        {
            behaviorTreeView.BeginUpdate();
            behaviorTreeView.Nodes.Clear();

            var rootKeys = new HashSet<string>(BT.Roots().Select(r => r.Key));
            foreach (var key in PublicRoots)
                rootKeys.Add(key);

            foreach (var key in rootKeys.OrderByDescending(k => PublicRoots.Contains(k)).ThenBy(k => k))
            {
                Behavior root;
                if (BT.Tree.TryGetValue(key, out root))
                {
                    var btPath = new BTPath { Path = new List<Behavior>() };
                    var newNode = AddNode(btPath, root, behaviorTreeView.Nodes);
                    btPath.Path.Add(root);
                    Expand(newNode, btPath);

                    if (expandedPaths.Contains(newNode.Tag.ToString()))
                        newNode.Expand();
                }
            }
            behaviorTreeView.EndUpdate();

            if (configParser.Errors.Count > 0 || analyzer.Errors.Count > 0)
            {
                errorListBox.BeginUpdate();
                errorListBox.Items.Clear();

                foreach (var error in configParser.Errors)
                    errorListBox.Items.Add(error);
                foreach (var error in analyzer.Errors)
                    errorListBox.Items.Add(error);

                errorListBox.EndUpdate();

                errorListBox.Show();
                errorLabel.Show();
            }
            else
            {
                errorListBox.Hide();
                errorLabel.Hide();
            }

            overviewTooltipStatuslabel.Text = string.Format("{0} files, {1} nodes", layers.Count(l => l.Enabled),
                BT.Tree.Count);

            expandedPaths.Clear();
        }
Example #12
0
 private void GetAllVariablesByDescending()
 {
     var variables = new HashSet<Variable>();
     foreach (var equation in _equationsList)
     {
         equation.MoveAllVarsToLeft();
         foreach (var expression in equation.LeftPart)
         {
             var variable = expression.Variable;
             if (!variable.Equals(Variable.NULL))
                 variables.Add(variable);
         }
     }
     _variablesList = variables.OrderByDescending(x => x.Name).ToList();
 }
 /// <summary>
 /// This gets the longest words excluding punctuation 
 /// </summary>
 /// <param name="rank">How far down the list you want to go. for example if you wanted the 4th equal words you's pass 3</param>
 /// <returns>a list of either one or more strings that represtent the word or words equally tied at that rank</returns>
 public List<string> FindLongestWord(int rank)
 {
     ISet<int> wordLengths = new HashSet<int>(); // a set is needed for this because we need to avoid duplication i.e. two words of length 13 should only be counted once
     foreach (Word word in Words)
     {
         wordLengths.Add(word.WordLength); // add the lengths of all words to the set
     }
     List<int> sortedWordLengths = wordLengths.OrderByDescending(e => e).ToList(); // sort them from highest to lowest so we can fetch highest, 3rd highest, etc
     List<string> longestWords = new List<string>();
     int wordLength = 0;
     try
     {
         wordLength = sortedWordLengths[rank]; // try to use what has been passed in with the rank parameter but it might be out of range
     }
     catch (IndexOutOfRangeException)
     {
         wordLength = sortedWordLengths.Last(); // if out of range just call the last one (this doesn't help if there's nothing in the list though)
     }
     foreach (Word word in Words.Where(e => e.WordLength == wordLength)) // filter words by their length, the length to use is calc using rank
     {
         longestWords.Add(word.WordText);
     }
     return longestWords;
 }
        private static IEnumerable<Obj_AI_Hero> TargetWeights(List<Obj_AI_Hero> targets)
        {
            try
            {
                foreach (var item in WeightedItems.Where(w => w.Weight > 0))
                {
                    item.UpdateMinMax(targets);
                }

                var targetsList = new HashSet<Target>();
                var multiplicator =
                    _menu.Item(_menu.Name + ".weights.heroes.weight-multiplicator").GetValue<Slider>().Value;
                foreach (var target in targets)
                {
                    var tmpWeight = WeightedItems.Where(w => w.Weight > 0).Sum(w => w.CalculatedWeight(target));
                    if (_menu != null)
                    {
                        tmpWeight +=
                            (_menu.Item(_menu.Name + ".weights.heroes." + target.ChampionName).GetValue<Slider>().Value *
                             _averageWeight + 0.1f) * multiplicator;
                    }

                    targetsList.Add(new Target(target, tmpWeight));
                }
                return targetsList.Count > 0 ? targetsList.OrderByDescending(t => t.Weight).Select(t => t.Hero) : null;
            }
            catch (Exception ex)
            {
                Global.Logger.AddItem(new LogItem(ex));
            }
            return null;
        }
        private static void ShowAchievementUnlocked(Achievement a)
        {
            var content = new GUIContent("ACHIEVEMENT UNLOCKED\n" + a.Title, GetIcon ());

            // Find the best window to display this on
            var allWindows = new HashSet<EditorWindow>((EditorWindow[])Resources.FindObjectsOfTypeAll(typeof(EditorWindow)));
            allWindows.RemoveWhere (IsEditorWindowHiddenTab);

            var targetWindow = allWindows.OrderByDescending(w => Mathf.Pow(w.position.width, WidthBias) * w.position.height).FirstOrDefault();
            if(targetWindow)
            {
            targetWindow.ShowNotification(content);
            }

            Debug.Log (string.Format("ACHIEVEMENT UNLOCKED: {0}\n{1}\n\n\n\n\n", a.Title, a.Description));
        }
        public Task<IEnumerable<Message>> GetMessagesAsync()
        {
            var copyOfCachedMessages = new HashSet<Message>(_messageCache);

            return Task.FromResult(
                copyOfCachedMessages
                    .OrderByDescending(x => x.Created)
                    .Take(Count));
        }
 /// <summary>
 /// Finds a list of sentances with the highest or highest equal word count
 /// </summary>
 /// <returns>Returns a list containing either a single or mulitple sentences</returns>
 public List<Sentence> FindSentenceWithMostWords(int rank)
 {
     ISet<int> sentenceWordCount = new HashSet<int>(); // a set is needed for this because we need to avoid duplication i.e. two sentances of count 13 should only be counted once
     foreach (Sentence sentence in Sentences) // this loop adds the word count of each sentence to the set
     {
         sentenceWordCount.Add(sentence.WordCount);// if a count already exists, say there has already been a count of 13, it trys to add a different sentence that has a count of 13, this statement will skip over that silently
     }
     List<int> sortedSentenceWordCount = sentenceWordCount.OrderByDescending(e => e).ToList(); // the set in order say { 16, 7, 13 } need to be sorted to { 16, 13, 7 }
     return Sentences.Where(e => e.WordCount == sortedSentenceWordCount[rank]).ToList(); // this gets all the sentances with the requird word count
 }