Пример #1
0
        public static HashSet <ArabicRomanNumeral> GetArabicRomanNumeralsMapping(int upToArabicNumber = DICTIONARY_PREPOPULATION_SIZE)
        {
            if (upToArabicNumber == DICTIONARY_PREPOPULATION_SIZE)
            {
                return(new HashSet <ArabicRomanNumeral>(_arabicRomanNumeralsMapping.Take(upToArabicNumber)));
            }

            if (upToArabicNumber < DICTIONARY_PREPOPULATION_SIZE)
            {
                return
                    ((HashSet <ArabicRomanNumeral>) new HashSet <ArabicRomanNumeral>(_arabicRomanNumeralsMapping).Take(upToArabicNumber));
            }

            if (upToArabicNumber >= DICTIONARY_PREPOPULATION_SIZE)
            {
                if (_arabicRomanNumeralsMapping.Count >= upToArabicNumber)
                {
                    return(new HashSet <ArabicRomanNumeral>(_arabicRomanNumeralsMapping.Take(upToArabicNumber)));
                }

                HashSet <ArabicRomanNumeral> largerMapping = GenerateAdditionalMappings(DICTIONARY_PREPOPULATION_SIZE + 1, upToArabicNumber);
                _arabicRomanNumeralsMapping = (HashSet <ArabicRomanNumeral>)_arabicRomanNumeralsMapping.Union(largerMapping);
            }

            return(_arabicRomanNumeralsMapping);
        }
Пример #2
0
        private void ConnectToPeersLoop()
        {
            while (!cancellationTokenSource.IsCancellationRequested)
            {
                int connectedCount   = connectedPeers.Count;
                int unconnectedCount = unconnectedPeers.Count;

                if (connectedCount < ConnectedMax)
                {
                    Task[] tasks = { };
                    if (unconnectedCount > 0)
                    {
                        IPEndPoint[] endpoints;
                        lock (unconnectedPeers)
                        {
                            endpoints = unconnectedPeers.Take(ConnectedMax - connectedCount).ToArray();
                        }
                        tasks = endpoints.Select(p => ConnectToPeerAsync(p)).ToArray();
                    }
                    else if (connectedCount > 0)
                    {
                        lock (connectedPeers)
                        {
                            foreach (RemotePeer node in connectedPeers)
                            {
                                node.RequestPeers();
                            }
                        }
                    }
                    else
                    {
                        tasks = Settings.Default.SeedList.OfType <string>().Select(p => p.Split(':')).Select(p => ConnectToPeerAsync(p[0], int.Parse(p[1]))).ToArray();
                    }

                    try
                    {
                        Task.WaitAll(tasks, cancellationTokenSource.Token);
                    }
                    catch (OperationCanceledException)
                    {
                        break;
                    }
                }
                for (int i = 0; i < 50 && !cancellationTokenSource.IsCancellationRequested; i++)
                {
                    Thread.Sleep(100);
                }
            }
        }
Пример #3
0
        private static bool SearchWordHelper(char[][] board, string word, int row, int col, HashSet <Tuple <int, int> > visitedCells)
        {
            bool success = false;

            if (word.Length == 0)
            {
                return(true);
            }

            Tuple <int, int>          matchingCell;
            Stack <Tuple <int, int> > matchingAdjcentCells = new Stack <Tuple <int, int> >();
            int visitedCellCount = visitedCells.Count;

            if (GetNextMatchingAdjecentCells(board, row, col, word[0], matchingAdjcentCells, visitedCells))
            {
                while (!success && matchingAdjcentCells.Count > 0)
                {
                    matchingCell = matchingAdjcentCells.Pop();
                    visitedCells.Add(matchingCell);
                    success = SearchWordHelper(board, word.Substring(1), matchingCell.Item1, matchingCell.Item2, visitedCells);

                    if (!success)
                    {
                        visitedCells = visitedCells.Take(visitedCellCount).ToHashSet();
                    }
                }
            }

            return(success);
        }
        private void TryRenderOrientationData()
        {
            int dataCount = Math.Min(RenderConfig.MaxParallelTerrainRefreshes, FreeBakerTriplets.Count);

            var dataToProcess = UnrenderedOrientationData.Take(dataCount).ToArray();

            for (int i = 0; i < dataToProcess.Length; i++)
            {
                var activeData = dataToProcess[i];

                activeData.BakerTriplet = FreeBakerTriplets.Dequeue();

                RenderOrientation(activeData.Chunk, activeData.BakerTriplet.Item1);
                RenderWeights(activeData.Chunk, activeData.BakerTriplet.Item2);
                RenderDuck(activeData.Chunk, activeData.BakerTriplet.Item3);
            }

            for (int i = 0; i < dataToProcess.Length; i++)
            {
                var activeData = dataToProcess[i];

                activeData.BakerTriplet.Item1.ReadPixels();
                activeData.BakerTriplet.Item2.ReadPixels();
                activeData.BakerTriplet.Item3.ReadPixels();

                UnrenderedOrientationData.Remove(activeData);
            }
        }
        private async Task <Action[]> MergeActionsAsync(ISourceBlock <Action[]> actionSource, int?take)
        {
            var result = new Action[0];

            while (await actionSource.OutputAvailableAsync())
            {
                Console.WriteLine($"[{DateTime.Now:T}] OutputAvailableAsync");

                var next = await actionSource.ReceiveAsync();

                Console.WriteLine($"[{DateTime.Now:T}] Merging next result {next.Length}. Total {result.Length}");

                if (next.Length == 0)
                {
                    continue;
                }

                IEnumerable <Action> current = new HashSet <Action>(result.Concat(next)).OrderByDescending(action => action.ActionDateTime);

                if (take.HasValue)
                {
                    current = current.Take(take.Value);
                }

                result = current.ToArray();

                Console.WriteLine($"[{DateTime.Now:T}] Merged with next result {next.Length}. Total {result.Length}");
            }

            return(result);
        }
        public async Task <string[]> Collect(string keyPhrase, int max)
        {
            if (max <= 0)
            {
                throw new AppException("Invalid 'max' value");
            }

            var collection = await GetCollection(Enumerable.Empty <Guid>(), keyPhrase);

            if (collection == null)
            {
                return(new string[0]);
            }
            var searched = new HashSet <Guid>();

            var result = new HashSet <string>();

            do
            {
                searched.Add(collection.Id);
                var phrases = await GetPhrases(collection);

                result.UnionWith(phrases);
                await _dbContext.SaveChangesAsync();
            } while (searched.Count < 5 && result.Count < max && (collection = await GetCollection(searched)) != null);

            return(result.Take(max).ToArray());
        }
Пример #7
0
        protected override void DoEndOfFile()
        {
            foreach (KeyValuePair <FieldIndex, HashSet <string> > entry in _incorrectDataFormat)
            {
                FieldIndex       fieldIndex          = entry.Key;
                HashSet <string> incorrectDataFormat = entry.Value;

                string errorsToShow = string.Join(", ", incorrectDataFormat
                                                  .Take(NumberOfShownErrors)
                                                  .Select(s => "'" + s + "'")
                                                  .ToList()
                                                  );

                string message = string.Format(Messages.ControlDataFormatMessage, errorsToShow);

                if (incorrectDataFormat.Count > NumberOfShownErrors)
                {
                    int remainingErrors = incorrectDataFormat.Count - NumberOfShownErrors;
                    message += string.Format(Messages.ControlDataFormatMessageExtension, remainingErrors);
                }

                _testResults.Add(new TestResult(ResultType.Error, AddmlLocation.FromFieldIndex(fieldIndex), message));
            }

            _incorrectDataFormat.Clear();
        }
Пример #8
0
        public List <Video> GetRelatedVideos([FromRoute] int[] videoIDS, [FromRoute] int limit = 5)
        {
            AssociationRuleMatcher <int> classifier = CreateAprioriClassifier();

            // Get the videos that appear most with the video who's ID is the given argument videoID
            int[][]       matches = classifier.Decide(videoIDS);
            List <Video>  videos  = new List <Video>();
            HashSet <int> ids     = new HashSet <int>();

            // Merge all the video IDs into a single HashSet, this will remove duplicates.
            foreach (int[] e in matches)
            {
                foreach (int f in e)
                {
                    ids.Add(f);
                }
            }

            // Take only the given amount of videos from the argument 'limit'.
            ids = ids.Take(limit).ToHashSet();

            // Get the full video model for each of the IDs.
            foreach (int id in ids)
            {
                videos.Add(_context.Video.FirstOrDefault(video => video.ID == id));
            }

            return(videos);
        }
Пример #9
0
        public void ClearOldPages()
        {
            if (!_viewedPages.Contains(CurrentPageNumber))
            {
                _viewedPages.Add(CurrentPageNumber);
            }

            if (_viewedPages.Count > MAX_PAGE_CACHE)
            {
                // First try to remove just the last item
                _viewedPages.Take(_viewedPages.Count - MAX_PAGE_CACHE)
                .Where(p => Math.Abs(p - CurrentPageNumber) > MAX_PAGE_CACHE);

                // Get furthest pages from current
                List <Tuple <int, int> > pageDistances = new List <Tuple <int, int> >();
                foreach (int page in _viewedPages)
                {
                    pageDistances.Add(new Tuple <int, int>(Math.Abs(page - CurrentPageNumber), page));
                }

                // Take extra pages and clean them
                foreach (var page in pageDistances.OrderByDescending(d => d.Item1)
                         .Take(pageDistances.Count - MAX_PAGE_CACHE)
                         .Select(d => d.Item2))
                {
                    int index = GetIndexFromPageNumber(page);
                    ClearPage(Pages[index]);
                    _viewedPages.Remove(page);
                }
            }
        }
Пример #10
0
        public void Trie_ScaleTest()
        {
            var allTypes      = new HashSet <string>();
            var allAssemblies = AppDomain.CurrentDomain.GetAssemblies();

            foreach (var assembly in allAssemblies)
            {
                var types = assembly.GetTypes();
                foreach (var type in types)
                {
                    allTypes.Add(type.Name.ToLowerInvariant());
                }
            }

            var step = allTypes.Count / 5;

            for (var length = step; length < allTypes.Count; length += step)
            {
                Measure.Method(() =>
                {
                    var t = new Trie(allTypes.Take(length));
                })
                .SampleGroup($"Indexing {length} / {allTypes.Count}")
                .WarmupCount(1)
                .MeasurementCount(5)
                .Run();
            }
        }
Пример #11
0
        public Card drawcard()
        {
            Card card = (Card)shuffledCards.Take(1).Single();

            shuffledCards.Remove(card);
            return(card);
        }
Пример #12
0
        public static IEnumerable <string> GetHives(string message, string hiveTargets)
        {
            var hives = new HashSet <string> {
                "hive"
            };

            if (!string.IsNullOrEmpty(hiveTargets))
            {
                foreach (var item in hiveTargets.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
                {
                    var hiveName = GetHiveName(item, true);
                    if (string.IsNullOrEmpty(hiveName))
                    {
                        continue;
                    }
                    hives.Add(hiveName);
                }
            }


            if (message.Contains("#"))
            {
                foreach (Match item in Regex.Matches(message, @"(?<!\w)#\w+"))
                {
                    var hiveName = GetHiveName(item.Value, false);
                    if (string.IsNullOrEmpty(hiveName))
                    {
                        continue;
                    }
                    hives.Add(hiveName);
                }
            }

            return(hives.Take(15));
        }
Пример #13
0
        private void DoUpgrade(HashSet <BuildingBlock> all_blocks, int targetGrade, bool increment, BasePlayer player)
        {
            var todo = all_blocks.Take(configData.BatchSize).ToArray();

            foreach (var building_block in todo)
            {
                all_blocks.Remove(building_block);
                var target_grade = NextBlockGrade(building_block, targetGrade, increment ? 1 : -1);
                if (!CanUpgrade(building_block, (BuildingGrade.Enum)target_grade))
                {
                    continue;
                }

                building_block.SetGrade((BuildingGrade.Enum)target_grade);
                building_block.SetHealthToMax();
                building_block.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
                building_block.UpdateSkin();
                Interface.CallHook("OnStructureUpgrade", building_block, player, (BuildingGrade.Enum)target_grade);
            }
            if (all_blocks.Count > 0)
            {
                NextTick(() => DoUpgrade(all_blocks, targetGrade, increment, player));
            }
            else
            {
                PrintMessage(player, increment ? "FinishedUp" : "FinishedDown");
                runningPlayers.Remove(player.userID);
            }
        }
Пример #14
0
        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();

            sb.Append('{');

            foreach (T element in _set.Take(50))
            {
                sb.Append(element.ToString());
                sb.Append(", ");
            }

            if (_set.Count <= 50)
            {
                if (sb[sb.Length - 1] == ' ')
                {
                    sb.Remove(sb.Length - 2, 2);
                }
            }
            else
            {
                sb.Append("...");
            }

            sb.Append('}');

            return(sb.ToString());
        }
Пример #15
0
        public virtual IList <Product> GetCrosssellProductsByShoppingCart(IList <OrganizedShoppingCartItem> cart, int numberOfProducts)
        {
            var result = new List <Product>();

            if (numberOfProducts == 0)
            {
                return(result);
            }

            if (cart == null || cart.Count == 0)
            {
                return(result);
            }

            var cartProductIds   = new HashSet <int>(cart.Select(x => x.Item.ProductId));
            var csItems          = GetCrossSellProductsByProductIds(cartProductIds);
            var productIdsToLoad = new HashSet <int>(csItems.Select(x => x.ProductId2).Except(cartProductIds));

            if (productIdsToLoad.Count > 0)
            {
                result.AddRange(GetProductsByIds(productIdsToLoad.Take(numberOfProducts).ToArray()));
            }

            return(result);
        }
Пример #16
0
        public string[] GetVocabulary(ITokenizer tokenizer, IEnumerable <Sms> smses)
        {
            var spamSmsmes = smses
                             .Where(x => x.Label == SmsLabel.Spam);

            var spamWords = spamSmsmes
                            .SelectMany(x => tokenizer.Tokenize(x.Text)).Distinct().ToArray();

            var tokenizedSpamSmses = spamSmsmes.Select((x => tokenizer.Tokenize(x.Text))).ToArray();

            var topSpamWords = new HashSet <string>(spamWords.OrderByDescending(x => tokenizedSpamSmses.Count(y => y.Contains(x))).Take(30));


            var hamSmsmes = smses
                            .Where(x => x.Label == SmsLabel.Ham);

            var hamWords = hamSmsmes
                           .SelectMany(x => tokenizer.Tokenize(x.Text)).Distinct().ToArray();

            var tokenizedHamSmses = hamSmsmes.Select((x => tokenizer.Tokenize(x.Text))).ToArray();

            var topHamWords = new HashSet <string> (hamWords.OrderByDescending(x => tokenizedHamSmses.Count(y => y.Contains(x))).Take(30));

            var intersection = new HashSet <string>(topHamWords);

            intersection.IntersectWith(topSpamWords);

            topHamWords.ExceptWith(intersection);
            topSpamWords.ExceptWith(intersection);

            return(topSpamWords.Take(10).Union(topHamWords.Take(10)).ToArray());
        }
Пример #17
0
                public IEnumerable <long> TakeFreeSectors(int count)
                {
                    if (_freeSectors.Count < count)
                    {
                        for (long i = 0; i < _bitmapManager.Length; i++)
                        {
                            if (!_bitmapManager.Get(i))
                            {
                                _freeSectors.Add(i);
                                if (_freeSectors.Count >= Math.Max(count, 1024 * 4))
                                {
                                    break;
                                }
                            }
                        }
                    }

                    var result = _freeSectors.Take(count).ToArray();

                    foreach (var sector in result)
                    {
                        _bitmapManager.Set(sector, true);

                        _usingSectorCount++;
                    }

                    _freeSectors.ExceptWith(result);

                    return(result);
                }
Пример #18
0
        public async Task <CommandResult> CleanAsync(ulong u, int quota, CleanType[] types)
        {
            if (quota > 300)
            {
                return(new QuiccbanFailResult(_responseService.Get("clean_amount_too_large")));
            }

            types = types ?? new CleanType[] { };

            var distinctedTypes = types.Distinct();

            var messages = new HashSet <IUserMessage>();

            int   attemptCount  = 0;
            ulong lastMessageId = 0;

grabMessages:
            int getAmount = quota - messages.Count;
            var unfilteredMessages = (lastMessageId == 0 ? await Context.Channel.GetMessagesAsync(Context.Message.Id, Direction.Before, getAmount).FlattenAsync() : await Context.Channel.GetMessagesAsync(lastMessageId, Direction.Before, getAmount).FlattenAsync());

            lastMessageId = unfilteredMessages.LastOrDefault() == null ? lastMessageId : unfilteredMessages.LastOrDefault().Id;
            var channelMessages = unfilteredMessages.Where(x => x is IUserMessage && (DateTimeOffset.UtcNow - x.CreatedAt).TotalDays < 14).Cast <IUserMessage>();

            if (u != 0)
            {
                channelMessages.Where(x => x.Author.Id == u);
            }

            _helperService.FilterCleaningCollection(ref channelMessages, types);
            foreach (var message in channelMessages)
            {
                if (!messages.Any(x => x.Id == message.Id))
                {
                    messages.Add(message);
                }
                else
                {
                    attemptCount = 5;
                    break;
                }
            }

            if (attemptCount < 5 && messages.Count < quota && channelMessages.Count() != 0)
            {
                attemptCount++;
                goto grabMessages;
            }


            if (messages.Count == 0)
            {
                return(new QuiccbanFailResult(_responseService.Get("clean_no_messages")));
            }


            await Context.Channel.DeleteMessagesAsync(messages.Take(quota));

            return(new QuiccbanSuccessResult(string.Format(_responseService.Get("clean_success"), messages.Take(quota).Count())));
        }
Пример #19
0
        /// <summary>
        /// This method looks for the requestedPackage and downloads it.
        /// If requested, it also installs the dependencies associated with the requestedPackage
        /// </summary>
        /// <param name="requestedPackage"></param>
        /// <param name="autoInstallDependencis"></param>
        /// <returns></returns>
        static async Task PerformPackageActionAsync(NugetPackage requestedPackage, bool autoInstallDependencis, List <NugetPackage> installedPackages, Func <NugetPackage, SourcePackageDependencyInfo, ISettings, SourceCacheContext, List <NugetPackage>, Task> action)
        {
            ServicePointManager.Expect100Continue = true;
            ServicePointManager.SecurityProtocol  = SecurityProtocolType.Tls12;

            var packageId                = requestedPackage.Id;
            var packageVersion           = requestedPackage.VersionRange.MinVersion;
            var nuGetFramework           = NuGetFramework.ParseFolder(requestedPackage.TargetFramework);
            var settings                 = Settings.LoadDefaultSettings(root: requestedPackage.RootPath);
            var providers                = Repository.Provider.GetCoreV3();
            var sourceRepositoryProvider = new SourceRepositoryProvider(settings, providers);
            var repositories             = new List <SourceRepository>();

            if (requestedPackage.Source != null)
            {
                repositories.Add(Repository.CreateSource(providers, new PackageSource(requestedPackage.Source.ToString())));
            }
            foreach (var depSource in requestedPackage.DependencySources)
            {
                repositories.Add(Repository.CreateSource(providers, new PackageSource(depSource.ToString())));
            }
            repositories.AddRange(sourceRepositoryProvider.GetRepositories());

            using (var cacheContext = new SourceCacheContext())
            {
                var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);

                var dependencyWalkLevel = autoInstallDependencis? -1 : 0;
                await GetPackageDependencyInfo(dependencyWalkLevel,
                                               new PackageIdentity(packageId, packageVersion),
                                               nuGetFramework, cacheContext, _logger, repositories, availablePackages, installedPackages);

                var resolverContext = new PackageResolverContext(
                    DependencyBehavior.Lowest,
                    new[] { packageId },
                    Enumerable.Empty <string>(),
                    Enumerable.Empty <PackageReference>(),
                    Enumerable.Empty <PackageIdentity>(),
                    availablePackages,
                    repositories.Select(s => s.PackageSource),
                    _logger);

                IEnumerable <SourcePackageDependencyInfo> packagesToInstall = null;
                if (autoInstallDependencis)
                {
                    packagesToInstall = availablePackages;
                }
                else
                {
                    packagesToInstall = availablePackages.Take(1);
                }

                foreach (var packageToInstall in packagesToInstall)
                {
                    await action(requestedPackage, packageToInstall, settings, cacheContext, installedPackages);
                }
            }
        }
Пример #20
0
        public override void Run(string[] args)
        {
            var filenames = string.Empty;
            var options = new OptionSet() { { "f=|files=", "Merges the specified split files.", f => filenames = f } };
            options.Parse(args);
            if (string.IsNullOrWhiteSpace(filenames))
            {
                throw new OptionSetException(options);
            }

            var splitFiles = new HashSet<string>(Directory.EnumerateFiles(@".\", filenames));
            var workFiles = new List<string>(splitFiles.Take(splitFiles.Count - Take >= Take ? Take : splitFiles.Count));
            splitFiles.RemoveWhere(s => workFiles.Contains(s));
            int splitId = 0;
            bool firstRun = true;
            var createdFiles = new HashSet<string>();

            while (workFiles.Count > 1 || firstRun)
            {
                int written = 0;
                var multiQueue = new MultiQueue(workFiles);
                using (var stream = Utils.FindFirstSplitFile("merge", ref splitId))
                {
                    createdFiles.Add(stream.Name);
                    Console.WriteLine("Merging {0} into {1}", string.Join(",", from f in workFiles
                                                                               select Path.GetFileName(f)),
                                                                               Path.GetFileName(stream.Name));
                    foreach (var item in multiQueue.Merge())
                    {
                        stream.Write(item.ToGuid().ToByteArray(), 0, 16);
                        if (++written % 1000000 == 0)
                        {
                            Console.WriteLine("Written {0} lines", written);
                        }
                    }
                }

                Console.WriteLine("Written {0} lines", written);
                Console.WriteLine("Excluded {0} duplicates.", multiQueue.Duplicates);
                if (!firstRun)
                {
                    workFiles.ForEach(f => File.Delete(f));
                }

                workFiles = new List<string>(splitFiles.Take(splitFiles.Count - Take >= Take ? Take : splitFiles.Count));
                splitFiles.RemoveWhere(s => workFiles.Contains(s));
                if (workFiles.Count < Take)
                {
                    splitFiles = createdFiles;
                    createdFiles = new HashSet<string>();
                    workFiles = new List<string>(splitFiles.Take(Take));
                    splitFiles.RemoveWhere(s => workFiles.Contains(s));
                    firstRun = false;
                }
            }
        }
Пример #21
0
 public List <BlobStoreData> GetTopN(int topN)
 {
     lock (Cache)
     {
         return(CacheKeys.Take(Math.Min(CacheKeys.Count, topN)).Select(k =>
         {
             return GetBlobByRef(k);
         }).ToList());
     }
 }
Пример #22
0
 private void ConnectToPeersLoop()
 {
     while (disposed == 0)
     {
         int connectedCount   = connectedPeers.Count;
         int pendingCount     = pendingPeers.Count;
         int unconnectedCount = unconnectedPeers.Count;
         int maxConnections   = Math.Max(CONNECTED_MAX + CONNECTED_MAX / 5, PENDING_MAX);
         if (connectedCount < CONNECTED_MAX && pendingCount < PENDING_MAX && (connectedCount + pendingCount) < maxConnections)
         {
             Task[] tasks = { };
             if (unconnectedCount > 0)
             {
                 IPEndPoint[] endpoints;
                 lock (unconnectedPeers)
                 {
                     endpoints = unconnectedPeers.Take(maxConnections - (connectedCount + pendingCount)).ToArray();
                 }
                 tasks = endpoints.Select(p => ConnectToPeerAsync(p)).ToArray();
             }
             else if (connectedCount > 0)
             {
                 lock (connectedPeers)
                 {
                     foreach (RemoteNode node in connectedPeers)
                     {
                         node.RequestPeers();
                     }
                 }
             }
             else
             {
                 tasks = Settings.Default.SeedList.OfType <string>().Select(p => p.Split(':')).Select(p => ConnectToPeerAsync(p[0], int.Parse(p[1]))).ToArray();
             }
             Task.WaitAll(tasks);
         }
         for (int i = 0; i < 50 && disposed == 0; i++)
         {
             Thread.Sleep(100);
         }
     }
 }
Пример #23
0
 private string GetPreview(HashSet <string> identities)
 {
     if (identities.Count <= 3)
     {
         return(string.Join(", ", identities));
     }
     else
     {
         return(string.Join(", ", identities.Take(3)) + "...");
     }
 }
Пример #24
0
 public HashSet <Student> GetStudents()
 {
     if (Students != null)
     {
         return(Students.Take(Students.Count).ToHashSet());
     }
     else
     {
         throw new NullReferenceException();
     }
 }
Пример #25
0
 private void ConnectToPeersLoop()
 {
     while (disposed == 0)
     {
         int connectedCount   = connectedPeers.Count;
         int unconnectedCount = unconnectedPeers.Count;
         if (connectedCount < ConnectedMax)
         {
             Task[] tasks = { };
             if (unconnectedCount > 0)
             {
                 IPEndPoint[] endpoints;
                 lock (unconnectedPeers)
                 {
                     endpoints = unconnectedPeers.Take(ConnectedMax - connectedCount).ToArray();
                 }
                 tasks = endpoints.Select(p => ConnectToPeerAsync(p)).ToArray();
             }
             else if (connectedCount > 0)
             {
                 lock (connectedPeers)
                 {
                     foreach (RemoteNode node in connectedPeers)
                     {
                         node.RequestPeers();
                     }
                 }
             }
             else
             {
                 tasks = Settings.Default.SeedList.OfType <string>().Select(p => p.Split(':')).Select(p => ConnectToPeerAsync(p[0], int.Parse(p[1]))).ToArray();
             }
             Task.WaitAll(tasks);
         }
         for (int i = 0; i < 50 && disposed == 0; i++)
         {
             Thread.Sleep(100);
         }
     }
 }
Пример #26
0
 private void ConnectToPeersLoop()
 {
     while (disposed == 0)
     {
         int connectedCount   = connectedPeers.Count;
         int pendingCount     = pendingPeers.Count;
         int unconnectedCount = unconnectedPeers.Count;
         int maxConnections   = Math.Max(CONNECTED_MAX + CONNECTED_MAX / 5, PENDING_MAX);
         if (connectedCount < CONNECTED_MAX && pendingCount < PENDING_MAX && (connectedCount + pendingCount) < maxConnections)
         {
             Task[] tasks;
             if (unconnectedCount > 0)
             {
                 IPEndPoint[] endpoints;
                 lock (unconnectedPeers)
                 {
                     endpoints = unconnectedPeers.Take(maxConnections - (connectedCount + pendingCount)).ToArray();
                 }
                 tasks = endpoints.Select(p => ConnectToPeerAsync(p)).ToArray();
             }
             else if (connectedCount > 0)
             {
                 lock (connectedPeers)
                 {
                     tasks = connectedPeers.Values.ToArray().Select(p => Task.Run(new Action(p.RequestPeers))).ToArray();
                 }
             }
             else
             {
                 tasks = SeedList.Select(p => ConnectToPeerAsync(p)).ToArray();
             }
             Task.WaitAll(tasks);
         }
         for (int i = 0; i < 50 && disposed == 0; i++)
         {
             Thread.Sleep(100);
         }
     }
 }
Пример #27
0
        private void SavePackagesToSettingsStore()
        {
            // only save if there are new package added
            if (_packagesCache.Count > 0)
            {
                // IMPORTANT: call ToList() here. Otherwise, we may read and write to the settings store at the same time
                var loadedPackagesMetadata = LoadPackageMetadataFromSettingsStore().ToList();

                _settingsManager.SavePackageMetadata(
                    _packagesCache.
                    Take(MaximumPackageCount).
                    Concat(loadedPackagesMetadata));
            }
        }
Пример #28
0
        void UpdateLights()
        {
            pointLightTargets.Take(MAX_LIGHTS).ForEachWithIndex((pointLight, idx) => {
                _lightPositions[idx]   = pointLight.position;
                _lightIntensities[idx] = pointLight.intensity;
                _lightRanges[idx]      = pointLight.range;
                _lightColors[idx]      = pointLight.color;
            });

            for (int idx = pointLightTargets.Count; idx < MAX_LIGHTS; idx++)
            {
                _lightIntensities[idx] = 0.0f;
            }
        }
Пример #29
0
        public static IEnumerable <string> GetMentions(string message)
        {
            var mentions = new HashSet <string> {
            };

            if (!string.IsNullOrEmpty(message))
            {
                foreach (Match item in Regex.Matches(message, @"(?<!\w)@\w+"))
                {
                    mentions.Add(item.Value.TrimStart('@'));
                }
            }
            return(mentions.Take(15));
        }
Пример #30
0
    private HashSet <Vector3Int> CalculateZoneCost(HashSet <Vector3Int> newPositionsSet)
    {
        resourceManager.AddMoney(structuresOldQuantity * structureData.placementCost);

        int numberToPlace = resourceManager.HowManyStructuresCanIPlace(structureData.placementCost, newPositionsSet.Count);

        if (numberToPlace < newPositionsSet.Count)
        {
            newPositionsSet = new HashSet <Vector3Int>(newPositionsSet.Take(numberToPlace).ToList());
        }
        structuresOldQuantity = newPositionsSet.Count;
        resourceManager.SpendMoney(structuresOldQuantity * structureData.placementCost);
        Debug.Log(structuresOldQuantity);
        return(newPositionsSet);
    }
Пример #31
0
        public IEnumerable <object> GetPropertyValues()
        {
            yield return(Name);

            yield return(TimesUsed);

            yield return(FileSize);

            yield return(string.Join(", ", UsedInWallsets));

            yield return(string.Join(", ", UsedInstancesSamples.Take(3)));

            foreach (string s in GetPropertyValuesSpecific())
            {
                yield return(s);
            }
        }
Пример #32
0
        protected async Task FetchUrlInfos(Status[] ses)
        {
            if (ses == null || ses.Length == 0)
                return;
            var mem = MemoryCache.Default;

            var urls = new HashSet<string>();
            foreach (var s in ses)
            {
                var us = Utils.ExtractUrlFromWeibo(s.text);
                foreach(var url in us)
                {
                    if (mem.Get("http://t.cn/" + url) == null)
                        urls.Add(url);
                }
                //urls.Add(us);
                if (s.retweeted_status != null)
                {
                    var rus = Utils.ExtractUrlFromWeibo(s.retweeted_status.text);
                    foreach (var url in rus)
                    {
                        if (mem.Get("http://t.cn/" + url) == null)
                            urls.Add(url);
                    }
                }
            }
            if(urls.Count >= 20)
            {
                var tasks = new Task[2];
                var u1 = urls.Take(20);
                tasks[0] = FetchUrlInfosImp(u1);
                var u2 = urls.Skip(20);
                tasks[1] = FetchUrlInfosImp(u2);
                await Task.WhenAll(tasks);
            }else
            {
                await FetchUrlInfosImp(urls);
            }

        }