Exemple #1
0
 public override void _Backward(INode fromNode, IGraphData errorSignal, IContext context, IReadOnlyList <INode> parents)
 {
     Debug.Assert(_source._children.Contains(fromNode));
     _signalTable[fromNode] = errorSignal;
     if (_signalTable.All(s => s.Value != null) && parents?.Any() == true)
     {
         var firstSignal  = _signalTable[_source._children.First()];
         var otherSignals = _signalTable
                            .Where(s => s.Value != firstSignal && s.Value.Columns == firstSignal.Columns && s.Value.Rows == firstSignal.Rows)
                            .ToList()
         ;
         if (otherSignals.Any())
         {
             var matrix = firstSignal.GetMatrix();
             foreach (var item in otherSignals)
             {
                 matrix.AddInPlace(item.Value.GetMatrix());
             }
             firstSignal = firstSignal.ReplaceWith(matrix);
         }
         foreach (var parent in parents)
         {
             context.AddBackward(firstSignal, parent, _source);
         }
         _source._onBackpropagation?.Invoke(_signalTable);
     }
 }
        public IBusControl CreateServiceBus(MassTransitOptions options, IReadOnlyList<Action<IReceiveEndpointConfigurator>> commandSubscriptions, IReadOnlyList<Action<IReceiveEndpointConfigurator>> eventSubscriptions)
        {
            return Bus.Factory.CreateUsingInMemory(cfg =>
            {
                cfg.UseJsonSerializer();
                cfg.UseConcurrencyLimit(options.ConcurrencyLimit);

                if (commandSubscriptions.Any())
                {
                    cfg.ReceiveEndpoint(options.CommandQueueNameStrategy.GetQueueName(), endpoint =>
                    {
                        endpoint.UseRetry(options.CommandErrorPolicy);

                        foreach (var subscription in commandSubscriptions)
                            subscription(endpoint);
                    });
                }

                if (eventSubscriptions.Any())
                {
                    cfg.ReceiveEndpoint(options.EventQueueNameStrategy.GetQueueName(), endpoint =>
                    {
                        endpoint.UseRetry(options.EventErrorPolicy);

                        foreach (var subscription in eventSubscriptions)
                            subscription(endpoint);
                    });
                }
            });
        }
Exemple #3
0
        public override async Task <IEnumerable <Models.Geoposition> > CalculateRoute(Models.Geoposition from, Models.Geoposition to)
        {
            Geopoint nativeFrom = CoordinateConverter.ConvertToNative(from);
            Geopoint nativeTo   = CoordinateConverter.ConvertToNative(to);

            MapRouteFinderResult routeResult = await MapRouteFinder.GetDrivingRouteAsync(
                nativeFrom,
                nativeTo,
                MapRouteOptimization.Time,
                MapRouteRestrictions.None);

            List <Models.Geoposition>        result         = new List <Models.Geoposition>();
            IReadOnlyList <BasicGeoposition> routePositions = routeResult?.Route?.Path?.Positions;

            if (routePositions?.Any() == true)
            {
                foreach (BasicGeoposition position in routePositions)
                {
                    result.Add(new Models.Geoposition
                    {
                        Latitude  = position.Latitude,
                        Longitude = position.Longitude
                    });
                }
            }

            return(result);
        }
Exemple #4
0
        public void Load(IReadOnlyList <string> args)
        {
            try
            {
                if (args?.Any() != true)
                {
                    return;
                }

                string exportPath = Path.Combine("F:", "Projects", "Progamming", "utinyTest", "Ripped");

                PrepareExportDirectory(exportPath);

                var exportSttings = new ExportSettings {
                    ExportScripts             = false,
                    GUIDByContent             = true,
                    ExportDir                 = exportPath,
                    GameDir                   = args.First(),
                    DumpInfo                  = true,
                    ScriptByName              = false,
                    ShaderByName              = true,
                    ShaderExportMode          = ShaderExportMode.Asm,
                    CondenseShaderSubprograms = true,
                };
                GameStructureExporter.ExportGameStructure(exportSttings);


                Logger.Log(LogType.Info, LogCategory.General, "Finished");
            }
            catch (Exception ex)
            {
                Logger.Log(LogType.Error, LogCategory.General, ex.ToString());
            }
        }
Exemple #5
0
        public Observation(IReadOnlyList<int> currentQuoteCount, DateTime date)
        {
            if (currentQuoteCount == null) throw new ArgumentNullException("quoteCount");
            if (!currentQuoteCount.Any()) throw new ArgumentException("Collection must containt at least one item.");

            this.CurrentQuoteCount = currentQuoteCount;
            this.Date = date;
        }
 /// <summary>
 /// Sends a backpropagation signal further up the graph
 /// </summary>
 /// <param name="errorSignal">The backpropagating error</param>
 /// <param name="context">Graph context</param>
 /// <param name="parents">Parents of the current node</param>
 protected void _SendErrorTo(IGraphData errorSignal, IContext context, IReadOnlyList <INode> parents)
 {
     if (parents?.Any() == true)
     {
         foreach (var parent in parents)
         {
             context.AddBackward(errorSignal, parent, _source);
         }
     }
 }
        public override void OnExtractionSuccess(string filePath, IReadOnlyList<Directory> directories, string relativePath, TextWriter log)
        {
            base.OnExtractionSuccess(filePath, directories, relativePath, log);

            try
            {
                using (var writer = OpenWriter(filePath))
                {
                    try
                    {
                        // Write any errors
                        if (directories.Any(d => d.HasError))
                        {
                            foreach (var directory in directories)
                            {
                                if (!directory.HasError)
                                    continue;
                                foreach (var error in directory.Errors)
                                    writer.Write("[ERROR: {0}] {1}\n", directory.Name, error);
                            }
                            writer.Write('\n');
                        }

                        // Write tag values for each directory
                        foreach (var directory in directories)
                        {
                            var directoryName = directory.Name;
                            foreach (var tag in directory.Tags)
                            {
                                var tagName = tag.TagName;
                                var description = tag.Description;

                                if (directory is FileMetadataDirectory && tag.TagType == FileMetadataDirectory.TagFileModifiedDate)
                                    description = "<omitted for regression testing as checkout dependent>";

                                writer.Write("[{0} - 0x{1:x4}] {2} = {3}\n",
                                    directoryName, tag.TagType, tagName, description);
                            }

                            if (directory.TagCount != 0)
                                writer.Write('\n');
                        }
                    }
                    finally
                    {
                        writer.Write("Generated using metadata-extractor\n");
                        writer.Write("https://drewnoakes.com/code/exif/\n");
                    }
                }
            }
            catch (Exception e)
            {
                log.Write("Exception after extraction: {0}\n", e.Message);
            }
        }
        public static IReadOnlyList<string> GetStringContents(string textBeforeCollapse, string textAfterCollapse, IReadOnlyList<string> collapsedContent) {
            var contents = new List<string> {
                textBeforeCollapse + (collapsedContent.Any() ? collapsedContent[0] : string.Empty)
            };

            contents.AddRange(from text in collapsedContent.Skip(1).Take(collapsedContent.Count - 1)
                              select text);
            contents[contents.Count - 1] += textAfterCollapse;

            return contents;
        } 
        public void CalculateWeights(IReadOnlyList <BuildingDto> buildings, string originalSearchQuery, IReadOnlyList <string> separateSearchTerms)
        {
            if (!(buildings?.Any() ?? false))
            {
                return;
            }

            foreach (var building in buildings)
            {
                var fullyMatchedProperties = CalculateFullMatch(building, originalSearchQuery);
                CalculatePartialMatches(building, separateSearchTerms, fullyMatchedProperties);
            }
        }
Exemple #10
0
        /// <summary>
        /// Default Constructor
        /// </summary>
        /// <param name="arguments">Arguments</param>
        public Parameters(IReadOnlyList<string> arguments)
        {
            if (null == arguments)
            {
                throw new ArgumentNullException("arguments");
            }
            if (!arguments.Any() || arguments.Count() > 4)
            {
                throw new ArgumentException("Invalid parameter count.");
            }

            this.arguments = arguments;
        }
        public void CalculateWeights(IReadOnlyList <GroupDto> groups, string originalSearchQuery, IReadOnlyList <string> separateSearchTerms)
        {
            if (!(groups?.Any() ?? false))
            {
                return;
            }

            foreach (var groupDto in groups)
            {
                var fullyMatchedProperties = CalculateFullMatch(groupDto, originalSearchQuery);
                CalculatePartialMatches(groupDto, separateSearchTerms, fullyMatchedProperties);
            }
        }
        /// <summary>
        /// Composes the given projection lambdas into a single projection which only references the
        /// necessary selected colums. Thus, if you have something like
        /// <code>
        ///     query.Select(c => new { CompanyName = c.Company.Name, c.Name })
        ///         .Where(t => t.CompanyName != null &gt;&gt; t.CompanyName.Length > 0)
        ///         .Select(t => t.Name);
        /// </code>
        /// we might naively generate a projection like c => new { CompanyName = c.Company.Name, c.Name }.Name.
        /// This will fail when executed, because we will not have selected any columns from Company.
        /// </summary>
        public static LambdaExpression CreateProjection(IReadOnlyList<LambdaExpression> projections)
        {
            Throw.If(projections.Count == 0, "projections: at least one projection is required");
            Throw.If(projections.Any(e => e == null || e.Parameters.Count != 1), "projections: all expressions must be projections");

            // first, create a composition of the lambdas with all parameters inlined
            var composedProjection = ComposeWithInlining(projections, indexToMerge: projections.Count - 1);

            // next, replace constructs like
            // x = new { a = p.Foo.Bar, b = 2 * p.Name.Length }.b with x = 2 * p.Name.Length
            var simplifiedProjection = (LambdaExpression)Visitor.Visit(composedProjection);

            return simplifiedProjection;
        }
        public static void Save(string fileName, IReadOnlyList<Bookmark> bookmarks)
        {
            if (!bookmarks.Any())
            {
                File.Delete(fileName);
                return;
            }

            var bookmarksFile = new BookmarksFile { Bookmarks = bookmarks.OrderBy(x => x.Time).ToList() };
            using (var stream = new FileStream(fileName, FileMode.Create))
            {
                Serializer.Serialize(stream, bookmarksFile);
            }
        }
        private async Task <IReadOnlyList <VSInternalDiagnosticReport> > RemapDocumentDiagnosticsAsync(
            IReadOnlyList <VSInternalDiagnosticReport> unmappedDiagnosticReports,
            Uri razorDocumentUri,
            CancellationToken cancellationToken)
        {
            if (unmappedDiagnosticReports?.Any() != true)
            {
                return(unmappedDiagnosticReports);
            }

            var mappedDiagnosticReports = new List <VSInternalDiagnosticReport>(unmappedDiagnosticReports.Count);

            foreach (var diagnosticReport in unmappedDiagnosticReports)
            {
                // Check if there are any diagnostics in this report
                if (diagnosticReport?.Diagnostics?.Any() != true)
                {
                    _logger.LogInformation("Diagnostic report contained no diagnostics.");
                    mappedDiagnosticReports.Add(diagnosticReport);
                    continue;
                }

                _logger.LogInformation($"Requesting processing of {diagnosticReport.Diagnostics.Length} diagnostics.");

                var processedDiagnostics = await _diagnosticsProvider.TranslateAsync(
                    RazorLanguageKind.CSharp,
                    razorDocumentUri,
                    diagnosticReport.Diagnostics,
                    cancellationToken
                    ).ConfigureAwait(false);

                if (!_documentManager.TryGetDocument(razorDocumentUri, out var documentSnapshot) ||
                    documentSnapshot.Version != processedDiagnostics.HostDocumentVersion)
                {
                    _logger.LogInformation($"Document version mismatch, discarding {diagnosticReport.Diagnostics.Length} diagnostics.");

                    // We choose to discard diagnostics in this case & report nothing changed.
                    diagnosticReport.Diagnostics = null;
                    mappedDiagnosticReports.Add(diagnosticReport);
                    continue;
                }

                _logger.LogInformation($"Returning {processedDiagnostics.Diagnostics.Length} diagnostics.");
                diagnosticReport.Diagnostics = processedDiagnostics.Diagnostics;

                mappedDiagnosticReports.Add(diagnosticReport);
            }

            return(mappedDiagnosticReports.ToArray());
        }
Exemple #15
0
        public void CalculateWeights(IReadOnlyList <MediumDto> mediums, IReadOnlyList <GroupDto> groups, string originalSearchTerms, IReadOnlyList <string> separateSearchTerms)
        {
            if (!(mediums?.Any() ?? false))
            {
                return;
            }

            foreach (var mediumDto in mediums)
            {
                var fullyMatchedProperties = CalculateFullMatch(mediumDto, originalSearchTerms);
                CalculatePartialMatches(mediumDto, separateSearchTerms, fullyMatchedProperties);
                CalculateTypeWeight(mediumDto, separateSearchTerms);
                mediumDto.Weight += groups.FirstOrDefault(x => x.Id == mediumDto.GroupId)?.TransitoryWeight ?? 0;
            }
        }
Exemple #16
0
        public void CalculateWeights(IReadOnlyList <LockDto> locks, IReadOnlyList <BuildingDto> buildings, string originalSearchTerms, IReadOnlyList <string> separateSearchTerms)
        {
            if (!(locks?.Any() ?? false))
            {
                return;
            }

            foreach (var lockDto in locks)
            {
                var fullyMatchedProperties = CalculateFullMatch(lockDto, originalSearchTerms);
                CalculateTypeWeight(lockDto, separateSearchTerms);
                CalculatePartialMatches(lockDto, separateSearchTerms, fullyMatchedProperties);
                lockDto.Weight += buildings.SingleOrDefault(x => x.Id == lockDto.BuildingId)?.TransitoryWeight ?? 0;
            }
        }
        protected virtual Uri PickNewServer(Uri lastServer, IReadOnlyList<Uri> serverPool)
        {
            if (!serverPool.Any())
            {
                throw new NoServersAvailableException();
            }

            if (serverPool.Count == 1)
            {
                return serverPool[0];
            }

            if (lastServer != null)
            {
                serverPool = serverPool.Except(new[] { lastServer }).ToList();
            }

            if (!serverPool.Any())
            {
                if (lastServer == null)
                {
                    throw new NoServersAvailableException();
                }

                return lastServer;
            }

            if (serverPool.Count == 1)
            {
                return serverPool[0];
            }

            _server++;
            int index = _server;
            return serverPool[index % serverPool.Count];
        }
        private static IReadOnlyList<Issue> FilterByKompetenz(IReadOnlyList<Issue> issues, IReadOnlyList<string> kompetenzen)
        {
            if (!kompetenzen.Any())
            {
                return issues;
            }

            issues = issues
                .Where(i => 
                    i.Kompetenzen
                        .Select(x => x.ToLowerInvariant())
                        .Intersect(
                            kompetenzen.Select(x => x.ToLowerInvariant()))
                    .Any())
                .ToList();
            return issues;
        }
Exemple #19
0
        private static void InvokeCallbackCommand( OpenFileInteraction openFile, IReadOnlyList<IFile> files )
        {
            Contract.Requires( openFile != null );
            Contract.Requires( files != null );

            if ( files.Any() )
            {
                // set file and execute accept
                openFile.Files.ReplaceAll( files );
                openFile.ExecuteDefaultCommand();
            }
            else
            {
                // execute cancel
                openFile.ExecuteCancelCommand();
            }
        }
        private static bool IsTransformRequired(
            string propertyName,
            DisplayMetadata modelMetadata,
            IReadOnlyList<object> propertyAttributes)
        {
            if (!string.IsNullOrEmpty(modelMetadata.SimpleDisplayProperty))
            {
                return false;
            }

            if (propertyAttributes.Any(a => a is DisplayAttribute))
            {
                return false;
            }

            return !string.IsNullOrEmpty(propertyName);
        }
        private IReadOnlyDictionary<int, string> CharacterEntered(IReadOnlyList<string> lines, string text, TextPosition startingTextPosition) {
            var currentTextLine = new StringBuilder();

            if (lines.Any()) {
                if (startingTextPosition.Column >= lines[startingTextPosition.Line].Length) {
                    currentTextLine.Append(lines[startingTextPosition.Line]).Append(text);
                } else {
                    currentTextLine.Append(lines[startingTextPosition.Line]).Insert(startingTextPosition.Column, text);
                }
            } else {
                currentTextLine.Append(text);
            }

            return new Dictionary<int, string> {
                [startingTextPosition.Line] = currentTextLine.ToString()
            };
        }
        public virtual void OnExtractionSuccess(string filePath, IReadOnlyList<Directory> directories, string relativePath, TextWriter log)
        {
            if (!directories.Any(d => d.HasError))
                return;

            log.WriteLine(filePath);
            foreach (var directory in directories)
            {
                if (!directory.HasError)
                    continue;
                foreach (var error in directory.Errors)
                {
                    log.Write("\t[{0}] {1}\n", directory.Name, error);
                    _errorCount++;
                }
            }
        }
Exemple #23
0
        public static async Task <ContentSearchResult> GetRandomContentsAsync(IPictureparkService client, string searchString, int limit, IReadOnlyList <ContentType> contentTypes = null)
        {
            var request = new ContentSearchRequest {
                SearchString = searchString, Limit = limit
            };

            if (contentTypes?.Any() == true)
            {
                request.Filter = new TermsFilter
                {
                    Field = nameof(ContentDetail.ContentType).ToLowerCamelCase(),
                    Terms = contentTypes.Select(ct => ct.ToString()).ToArray()
                };
            }

            return(await client.Content.SearchAsync(request));
        }
 /// <summary>
 /// Called when backpropagating
 /// </summary>
 /// <param name="fromNode">The node that sent the backpropagation signal</param>
 /// <param name="errorSignal">The backpropagating error</param>
 /// <param name="context">Graph context</param>
 /// <param name="parents">Parents of the current node</param>
 public void Backward(INode fromNode, IGraphData errorSignal, IContext context, IReadOnlyList <INode> parents)
 {
     if (errorSignal == null)
     {
         if (parents?.Any() == true)
         {
             foreach (var parent in parents)
             {
                 context.AddBackward(errorSignal, parent, _source);
             }
         }
     }
     else
     {
         _Backward(fromNode, errorSignal, context, parents);
     }
 }
        public override async Task <IEnumerable <Position> > CalculateRoute(RouteModel route)
        {
            Geopoint nativeFrom = CoordinateConverter.ConvertToNative(route.From);
            Geopoint nativeTo   = CoordinateConverter.ConvertToNative(route.To);

            // add route starts
            List <Geopoint> routeWaypoints = new List <Geopoint>()
            {
                nativeFrom
            };

            // add route waypoints if any
            if (route.WayPoints != null && route.WayPoints.Any())
            {
                foreach (var point in route.WayPoints)
                {
                    routeWaypoints.Add(CoordinateConverter.ConvertToNative(point));
                }
            }

            // add route ends
            routeWaypoints.Add(nativeTo);

            MapRouteFinderResult routeResult = await MapRouteFinder.GetDrivingRouteFromWaypointsAsync(
                routeWaypoints,
                MapRouteOptimization.Time,
                MapRouteRestrictions.None);

            List <Position> result = new List <Position>();
            IReadOnlyList <BasicGeoposition> routePositions = routeResult?.Route?.Path?.Positions;

            route.Distance = routeResult?.Route?.LengthInMeters ?? 0;
            route.Duration = routeResult?.Route?.EstimatedDuration.TotalMinutes ?? 0;

            if (routePositions?.Any() == true)
            {
                foreach (BasicGeoposition position in routePositions)
                {
                    result.Add(new Position(position.Latitude, position.Longitude));
                }
            }

            return(result);
        }
Exemple #26
0
        public LiquidRenderer(string tag, IReadOnlyList<Category> categories, IEnumerable<Issue> issues)
        {
            if (categories == null || !categories.Any())
                categories = Defaults.Categories;

            var issuesVariable = categories.ToDictionary(
                cat => cat.Id,
                cat => issues.Where(issue => issue.Labels.Any(label => label.MatchesAny(cat.Labels)))
                    .Select(issue => new IssueDrop(issue, cat.Labels)));
            var categoriesVariable = categories.Select(category => new CategoryDrop(category.Id, category.Title,
                issuesVariable.ContainsKey(category.Id) && issuesVariable[category.Id].Any()));

            _variables = new Hash
            {
                {"tag", tag},
                {"categories", categoriesVariable},
                {"issues", issuesVariable}
            };
        }
        public static IEnumerable <T> SortDynamically <T>(this IEnumerable <T> items, IReadOnlyList <ISortOrderField> sortArgs)
        {
            if (items == null || !items.Any())
            {
                return(new List <T>());
            }

            if (sortArgs?.Any() == false)
            {
                return(items);
            }

            //Map the Sort by property string names to actual Property Descriptors
            //for dynamic processing...
            var propCollection = TypeDescriptor.GetProperties(typeof(T));
            var sortGetters    = sortArgs?.Select(s => new {
                SortArg = s,
                Getter  = propCollection.Find(s.FieldName, true)
            });


            IOrderedEnumerable <T> orderedItems = null;

            foreach (var sort in sortGetters)
            {
                if (orderedItems == null)
                {
                    orderedItems = sort.SortArg.IsAscending()
                        ? items.OrderBy(c => sort.Getter.GetValue(c))
                        : items.OrderByDescending(c => sort.Getter.GetValue(c));
                }
                else
                {
                    orderedItems = sort.SortArg.IsAscending()
                        ? orderedItems.ThenBy(c => sort.Getter.GetValue(c))
                        : orderedItems.ThenByDescending(c => sort.Getter.GetValue(c));
                }
            }

            //NOTE: To Finish the sorting, we materialize the Results!
            return(orderedItems?.ToList() ?? items);
        }
Exemple #28
0
        public IReadOnlyList <GroupDto> Search(string originalSearchQuery, IReadOnlyList <string> searchTerms)
        {
            if (!(searchTerms?.Any() ?? false))
            {
                return(new List <GroupDto>());
            }

            var groupEntities = _groupRepository.GetGroupsMatchingTerms(searchTerms);

            if (!groupEntities.Any())
            {
                return(new List <GroupDto>());
            }

            var groupDtos = groupEntities.Select(ToGroupDto).ToList();

            _groupWeightCalculator.CalculateWeights(groupDtos, originalSearchQuery, searchTerms);

            return(groupDtos);
        }
Exemple #29
0
            public override void ApplyState()
            {
                base.ApplyState();

                shader     = Source.shader;
                texture    = Source.texture;
                drawSize   = Source.DrawSize;
                points     = Source.ResampledWaveform?.GetPoints();
                channels   = Source.ResampledWaveform?.GetChannels() ?? 0;
                lowColour  = Source.lowColour ?? DrawColourInfo.Colour;
                midColour  = Source.midColour ?? DrawColourInfo.Colour;
                highColour = Source.highColour ?? DrawColourInfo.Colour;

                if (points?.Any() == true)
                {
                    highMax = points.Max(p => p.HighIntensity);
                    midMax  = points.Max(p => p.MidIntensity);
                    lowMax  = points.Max(p => p.LowIntensity);
                }
            }
Exemple #30
0
        public IReadOnlyList <BuildingDto> Search(string originalSearchQuery, IReadOnlyList <string> searchTerms)
        {
            if (!(searchTerms?.Any() ?? false))
            {
                return(new List <BuildingDto>());
            }

            var buildingEntities = _buildingRepository.GetBuildingsMatchingTerms(searchTerms);

            if (!buildingEntities.Any())
            {
                return(new List <BuildingDto>());
            }

            var buildingDtos = buildingEntities.Select(ToBuildingDto).ToList();

            _buildingWeightCalculator.CalculateWeights(buildingDtos, originalSearchQuery, searchTerms);

            return(buildingDtos);
        }
        public IBusControl CreateServiceBus(MassTransitOptions options, IReadOnlyList<Action<IReceiveEndpointConfigurator>> commandSubscriptions, IReadOnlyList<Action<IReceiveEndpointConfigurator>> eventSubscriptions)
        {
            var bus = Bus.Factory.CreateUsingRabbitMq(cfg =>
            {
                var host = cfg.Host(_connectionDescriptor.Host, h =>
                {
                    h.Username(_connectionDescriptor.UserName);
                    h.Password(_connectionDescriptor.Password);
                });

                cfg.UseJsonSerializer();
                cfg.UseConcurrencyLimit(options.ConcurrencyLimit);

                if (commandSubscriptions.Any())
                {
                    cfg.ReceiveEndpoint(host, options.CommandQueueNameStrategy.GetQueueName(), endpoint =>
                    {
                        endpoint.UseRetry(options.CommandErrorPolicy);
                        _rabbitMqOptions.CommandQueuePolicy.ApplyPolicy(endpoint);

                        foreach (var subscription in commandSubscriptions)
                            subscription(endpoint);
                    });
                }

                if (eventSubscriptions.Any())
                {
                    cfg.ReceiveEndpoint(host, options.EventQueueNameStrategy.GetQueueName(), endpoint =>
                    {
                        endpoint.UseRetry(options.EventErrorPolicy);
                        _rabbitMqOptions.EventQueuePolicy.ApplyPolicy(endpoint);

                        foreach (var subscription in eventSubscriptions)
                            subscription(endpoint);
                    });
                }

            });

            return bus;
        }
        public async Task <bool> DeleteNotes(IReadOnlyList <long> noteIds)
        {
            if (noteIds?.Any() == false)
            {
                throw new ArgumentNullException(nameof(noteIds));
            }

            var notes = await _context
                        .Notes
                        .Where(n => noteIds !.Contains(n.Id))
                        .ToListAsync();

            if (notes?.Any() == false)
            {
                return(false);
            }

            _context.Notes.RemoveRange(notes);

            return(await _context.SaveChangesAsync() > 0);
        }
        /// <summary>
        /// The viewmodel for the song metadata editor.
        /// </summary>
        /// <param name="songs">The metadata for the songs to edit.</param>
        /// <param name="multipleSongSaveWarning">
        /// A warning that is displayed when an attempt is made to save the metadata for more than
        /// one song.
        /// </param>
        public TagEditorViewModel(IReadOnlyList<LocalSong> songs, Func<Task<bool>> multipleSongSaveWarning)
        {
            if (songs == null)
                throw new ArgumentNullException("songs");

            if (!songs.Any())
                throw new ArgumentException("Tag editor requires at least 1 song");

            this.songs = songs;

            this.Save = ReactiveCommand.CreateAsyncTask(async _ =>
            {
                bool shouldSave = true;

                if (songs.Count > 1)
                {
                    shouldSave = await multipleSongSaveWarning();
                }

                if (shouldSave)
                {
                    await this.SaveTags();
                }
            });
            this.isSaving = this.Save.IsExecuting
                .ToProperty(this, x => x.IsSaving);

            this.DismissFailure = ReactiveCommand.Create();

            this.saveFailed = this.Save.ThrownExceptions.Select(_ => true)
                .Merge(this.DismissFailure.Select(_ => false))
                .ToProperty(this, x => x.SaveFailed);

            this.Cancel = ReactiveCommand.Create();

            this.Finished = this.Save.Merge(this.Cancel.ToUnit())
                .FirstAsync()
                .PublishLast()
                .PermaRef();
        }
Exemple #34
0
        public IReadOnlyList <LockDto> Search(string originalSearchQuery, IReadOnlyList <string> searchTerms, IReadOnlyList <BuildingDto> buildings)
        {
            if (string.IsNullOrWhiteSpace(originalSearchQuery) || !(searchTerms?.Any() ?? false))
            {
                return(new List <LockDto>());
            }

            var maybeLockTypes = TryGetLockTypesOnSearchTerms(searchTerms);

            var lockEntities = _lockRepository.GetLocksMatchingTerms(searchTerms, maybeLockTypes);

            if (!lockEntities.Any())
            {
                return(new List <LockDto>());
            }

            var lockDtos = lockEntities.Select(ToLockDto).ToList();

            _lockWeightCalculator.CalculateWeights(lockDtos, buildings, originalSearchQuery, searchTerms);

            return(lockDtos);
        }
Exemple #35
0
        public IReadOnlyList <MediumDto> Search(string originalSearchQuery, IReadOnlyList <string> searchTerms, IReadOnlyList <GroupDto> groups)
        {
            if (!(searchTerms?.Any() ?? false))
            {
                return(new List <MediumDto>());
            }

            var maybeMediumTypes = TryGetMediumTypesOnSearchTerms(searchTerms);

            var mediumEntities = _mediumRepository.GetMediumsMatchingTerms(searchTerms, maybeMediumTypes);

            if (!mediumEntities.Any())
            {
                return(new List <MediumDto>());
            }

            var mediumDtos = mediumEntities.Select(ToMediumDto).ToList();

            _mediumWeightCalculator.CalculateWeights(mediumDtos, groups, originalSearchQuery, searchTerms);

            return(mediumDtos);
        }
        public async void ContinueFileOpenPicker(IReadOnlyList<StorageFile> files)
        {
            if (files == null || !files.Any()) return;
            IsLoading = true;
            using (var stream = (FileRandomAccessStream)await files[0].OpenAsync(FileAccessMode.Read))
            {
                var newImageBytes = new byte[stream.Size];
                using (var dataReader = new DataReader(stream))
                {
                    await dataReader.LoadAsync((uint)stream.Size);
                    dataReader.ReadBytes(newImageBytes);
                }

                var contentHelper = new ContentClientHelper(QuickbloxClient);
                var blobUploadInfo = await contentHelper.UploadImage(newImageBytes, false);
                if (blobUploadInfo != null)
                {
                    SendAttachment(blobUploadInfo);
                }
            }
            IsLoading = false;
        }
 private static Uri AsRelativeUri(this string @this, IReadOnlyList<string> queryParameters)
     => queryParameters.Any()
         ? AsRelativeUri(@this + (@this.Contains("?") ? "&" : "?") + string.Join("&", queryParameters))
         : AsRelativeUri(@this);
        private bool IsTypeExcludedFromValidation(IReadOnlyList<IExcludeTypeValidationFilter> filters, Type type)
        {
            // This can be set to null in ModelBinding scenarios which does not flow through this path.
            if (filters == null)
            {
                return false;
            }

            return filters.Any(filter => filter.IsTypeExcluded(type));
        }
        /// <summary>
        /// Returns a string representation of the settings.
        /// </summary>
        /// <returns>A string representation of the settings.</returns>
        public override string ToString()
        {
            if (_isFrozen)
            {
                return(_frozenStringRepresentation);
            }

            var sb = new StringBuilder();

            if (_applicationName != null)
            {
                sb.AppendFormat("ApplicationName={0};", _applicationName);
            }
            if (_autoEncryptionOptions != null)
            {
                sb.AppendFormat("AutoEncryptionOptions={0};", _autoEncryptionOptions);
            }
            if (_compressors?.Any() ?? false)
            {
                sb.AppendFormat("Compressors=[{0}];", string.Join(",", _compressors));
            }
            sb.AppendFormat("ConnectionMode={0};", _connectionMode);
            sb.AppendFormat("ConnectTimeout={0};", _connectTimeout);
            sb.AppendFormat("Credentials={{{0}}};", _credentials);
            sb.AppendFormat("GuidRepresentation={0};", _guidRepresentation);
            sb.AppendFormat("HeartbeatInterval={0};", _heartbeatInterval);
            sb.AppendFormat("HeartbeatTimeout={0};", _heartbeatTimeout);
            sb.AppendFormat("IPv6={0};", _ipv6);
            sb.AppendFormat("MaxConnectionIdleTime={0};", _maxConnectionIdleTime);
            sb.AppendFormat("MaxConnectionLifeTime={0};", _maxConnectionLifeTime);
            sb.AppendFormat("MaxConnectionPoolSize={0};", _maxConnectionPoolSize);
            sb.AppendFormat("MinConnectionPoolSize={0};", _minConnectionPoolSize);
            if (_readEncoding != null)
            {
                sb.Append("ReadEncoding=UTF8Encoding;");
            }
            sb.AppendFormat("ReadConcern={0};", _readConcern);
            sb.AppendFormat("ReadPreference={0};", _readPreference);
            sb.AppendFormat("ReplicaSetName={0};", _replicaSetName);
            sb.AppendFormat("RetryReads={0}", _retryReads);
            sb.AppendFormat("RetryWrites={0}", _retryWrites);
            sb.AppendFormat("LocalThreshold={0};", _localThreshold);
            if (_scheme != ConnectionStringScheme.MongoDB)
            {
                sb.AppendFormat("Scheme={0};", _scheme);
            }
            if (_sdamLogFilename != null)
            {
                sb.AppendFormat("SDAMLogFileName={0};", _sdamLogFilename);
            }
            sb.AppendFormat("Servers={0};", string.Join(",", _servers.Select(s => s.ToString()).ToArray()));
            sb.AppendFormat("ServerSelectionTimeout={0};", _serverSelectionTimeout);
            sb.AppendFormat("SocketTimeout={0};", _socketTimeout);
            if (_sslSettings != null)
            {
                sb.AppendFormat("SslSettings={0};", _sslSettings);
            }
            sb.AppendFormat("Tls={0};", _useTls);
            sb.AppendFormat("TlsInsecure={0};", _allowInsecureTls);
            sb.AppendFormat("WaitQueueSize={0};", _waitQueueSize);
            sb.AppendFormat("WaitQueueTimeout={0}", _waitQueueTimeout);
            sb.AppendFormat("WriteConcern={0};", _writeConcern);
            if (_writeEncoding != null)
            {
                sb.Append("WriteEncoding=UTF8Encoding;");
            }
            return(sb.ToString());
        }
        public async Task<IReadOnlyList<TenantResource>> FindTenants(IReadOnlyList<string> tenantNames, IReadOnlyList<string> tenantTags)
        {
            if (!tenantNames.Any() && !tenantTags.Any())
            {
                return new List<TenantResource>(0);
            }

            if (!repository.SupportsTenants())
            {
                throw new CommandException(
                    "Your Octopus server does not support tenants, which was introduced in Octopus 3.4. Please upgrade your Octopus server, enable the multi-tenancy feature or remove the --tenant and --tenanttag arguments.");
            }

            var tenantsByName = FindTenantsByName(tenantNames).ConfigureAwait(false);
            var tenantsByTags = FindTenantsByTags(tenantTags).ConfigureAwait(false);

            var distinctTenants = (await tenantsByTags)
                .Concat(await tenantsByName)
                .GroupBy(t => t.Id)
                .Select(g => g.First())
                .ToList();

            return distinctTenants;
        }
Exemple #41
0
 private bool CanSaveCurrentSearch() => _currentSearchTags?.Any() == true;
Exemple #42
0
        public void MainMethodCode()
        {
            // Opening a Non-Versioned SQL Server instance.

            DatabaseConnectionProperties connectionProperties = new DatabaseConnectionProperties(EnterpriseDatabaseType.SQLServer)
            {
                AuthenticationMode = AuthenticationMode.DBMS,

                // Where testMachine is the machine where the instance is running and testInstance is the name of the SqlServer instance.
                Instance = @"testMachine\testInstance",

                // Provided that a database called LocalGovernment has been created on the testInstance and geodatabase has been enabled on the database.
                Database = "LocalGovernment",

                // Provided that a login called gdb has been created and corresponding schema has been created with the required permissions.
                User     = "******",
                Password = "******",
                Version  = "dbo.DEFAULT"
            };

            using (Geodatabase geodatabase = new Geodatabase(connectionProperties))
                using (RelationshipClass relationshipClass = geodatabase.OpenDataset <RelationshipClass>("LocalGovernment.GDB.luCodeViolationHasInspections"))
                    using (FeatureClass violationsFeatureClass = geodatabase.OpenDataset <FeatureClass>("LocalGovernment.GDB.luCodeViolation"))
                        using (Table inspectionTable = geodatabase.OpenDataset <Table>("LocalGovernment.GDB.luCodeInspection"))
                        {
                            List <Row>  jeffersonAveViolations = new List <Row>();
                            QueryFilter queryFilter            = new QueryFilter {
                                WhereClause = "LOCDESC LIKE '///%Jefferson///%'"
                            };

                            // If you need to *cache* the rows retrieved from the cursor for processing later, it is important that you don't use recycling in
                            // the Search() method (i.e., useRecyclingCursor must be set to *false*).  Also, the returned rows/features cached in the list
                            // should be disposed when no longer in use so that unmanaged resources are not held on to longer than necessary.

                            using (RowCursor rowCursor = violationsFeatureClass.Search(queryFilter, false))
                            {
                                while (rowCursor.MoveNext())
                                {
                                    jeffersonAveViolations.Add(rowCursor.Current);
                                }
                            }

                            IReadOnlyList <Row> relatedOriginRows      = null;
                            IReadOnlyList <Row> relatedDestinationRows = null;

                            try
                            {
                                QueryFilter filter = new QueryFilter {
                                    WhereClause = "ACTION = '1st Notice'"
                                };
                                Selection selection = inspectionTable.Select(filter, SelectionType.ObjectID, SelectionOption.Normal);

                                relatedOriginRows = relationshipClass.GetRowsRelatedToDestinationRows(selection.GetObjectIDs());

                                // Find out if any of 1st Notice inspections were from Jefferson Avenue.
                                FeatureClassDefinition featureClassDefinition = violationsFeatureClass.GetDefinition();
                                int  locationDescriptionIndex = featureClassDefinition.FindField("LOCDESC");
                                bool containsJeffersonAve     = relatedOriginRows.Any(row => Convert.ToString(row[locationDescriptionIndex]).Contains("Jefferson"));

                                List <long> jeffersonAveViolationObjectIds = jeffersonAveViolations.Select(row => row.GetObjectID()).ToList();

                                relatedDestinationRows = relationshipClass.GetRowsRelatedToOriginRows(jeffersonAveViolationObjectIds);

                                //Find out if any Jefferson Ave Violations have 1st Notice Inspections
                                TableDefinition tableDefinition           = inspectionTable.GetDefinition();
                                int             actionFieldIndex          = tableDefinition.FindField("ACTION");
                                bool            hasFirstNoticeInspections = relatedDestinationRows.Any(row => Convert.ToString(row[actionFieldIndex]).Contains("1st Notice"));
                            }
                            finally
                            {
                                Dispose(jeffersonAveViolations);
                                Dispose(relatedOriginRows);
                                Dispose(relatedDestinationRows);
                            }
                        }
        }
Exemple #43
0
 public bool Has <T>() => Chunks?.Any(x => x.GetType() == typeof(T)) ?? false;
        /// <summary>
        /// Returns a string representation of the settings.
        /// </summary>
        /// <returns>A string representation of the settings.</returns>
        public override string ToString()
        {
            if (_isFrozen)
            {
                return(_frozenStringRepresentation);
            }

            var parts = new List <string>();

            if (_applicationName != null)
            {
                parts.Add(string.Format("ApplicationName={0}", _applicationName));
            }

            if (_compressors?.Any() ?? false)
            {
                parts.Add($"Compressors={string.Join(",", _compressors)}");
            }

            parts.Add(string.Format("ConnectionMode={0}", _connectionMode));
            parts.Add(string.Format("ConnectTimeout={0}", _connectTimeout));
            parts.Add(string.Format("Credentials={{{0}}}", _credentials));
            parts.Add(string.Format("GuidRepresentation={0}", _guidRepresentation));
            parts.Add(string.Format("HeartbeatInterval={0}", _heartbeatInterval));
            parts.Add(string.Format("HeartbeatTimeout={0}", _heartbeatTimeout));
            parts.Add(string.Format("IPv6={0}", _ipv6));
            parts.Add(string.Format("MaxConnectionIdleTime={0}", _maxConnectionIdleTime));
            parts.Add(string.Format("MaxConnectionLifeTime={0}", _maxConnectionLifeTime));
            parts.Add(string.Format("MaxConnectionPoolSize={0}", _maxConnectionPoolSize));
            parts.Add(string.Format("MinConnectionPoolSize={0}", _minConnectionPoolSize));
            parts.Add(string.Format("OperationTimeout={0}", _operationTimeout));
            parts.Add(string.Format("ReadConcern={0}", _readConcern));
            if (_readEncoding != null)
            {
                parts.Add("ReadEncoding=UTF8Encoding");
            }
            parts.Add(string.Format("ReadPreference={0}", _readPreference));
            parts.Add(string.Format("ReplicaSetName={0}", _replicaSetName));
            parts.Add(string.Format("RetryReads={0}", _retryReads));
            parts.Add(string.Format("RetryWrites={0}", _retryWrites));
            parts.Add(string.Format("LocalThreshold={0}", _localThreshold));
            if (_scheme != ConnectionStringScheme.MongoDB)
            {
                parts.Add(string.Format("Scheme={0}", _scheme));
            }
            if (_sdamLogFilename != null)
            {
                parts.Add($"SDAMLogFilename={_sdamLogFilename}");
            }
            parts.Add(string.Format("Servers={0}", string.Join(",", _servers.Select(s => s.ToString()).ToArray())));
            parts.Add(string.Format("ServerSelectionTimeout={0}", _serverSelectionTimeout));
            parts.Add(string.Format("SocketTimeout={0}", _socketTimeout));
            if (_sslSettings != null)
            {
                parts.Add(string.Format("SslSettings={0}", _sslSettings));
            }
            parts.Add(string.Format("Tls={0}", _useTls));
            parts.Add(string.Format("TlsInsecure={0}", _allowInsecureTls));
            parts.Add(string.Format("WaitQueueSize={0}", _waitQueueSize));
            parts.Add(string.Format("WaitQueueTimeout={0}", _waitQueueTimeout));
            parts.Add(string.Format("WriteConcern={0}", _writeConcern));
            if (_writeEncoding != null)
            {
                parts.Add("WriteEncoding=UTF8Encoding");
            }
            return(string.Join(",", parts.ToArray()));
        }
Exemple #45
0
        /// <summary>
        /// Returns the canonical URL based on the settings in this MongoUrlBuilder.
        /// </summary>
        /// <returns>The canonical URL.</returns>
        public override string ToString()
        {
            StringBuilder url = new StringBuilder();

            if (_scheme == ConnectionStringScheme.MongoDB)
            {
                url.Append("mongodb://");
            }
            else
            {
                url.Append("mongodb+srv://");
            }
            if (!string.IsNullOrEmpty(_username))
            {
                url.Append(Uri.EscapeDataString(_username));
                if (_password != null)
                {
                    url.AppendFormat(":{0}", Uri.EscapeDataString(_password));
                }
                url.Append("@");
            }
            else if (_password != null)
            {
                // this would be weird and we really shouldn't be here...
                url.AppendFormat(":{0}@", _password);
            }
            if (_servers != null)
            {
                bool firstServer = true;
                foreach (MongoServerAddress server in _servers)
                {
                    if (!firstServer)
                    {
                        url.Append(",");
                    }
                    if (server.Port == 27017 || _scheme == ConnectionStringScheme.MongoDBPlusSrv)
                    {
                        url.Append(server.Host);
                    }
                    else
                    {
                        url.AppendFormat("{0}:{1}", server.Host, server.Port);
                    }
                    firstServer = false;
                }
            }
            if (_databaseName != null)
            {
                url.Append("/");
                url.Append(_databaseName);
            }
            var query = new StringBuilder();

            if (_authenticationMechanism != null)
            {
                query.AppendFormat("authMechanism={0};", _authenticationMechanism);
            }
            if (_authenticationMechanismProperties.Any())
            {
                query.AppendFormat(
                    "authMechanismProperties={0};",
                    string.Join(",", _authenticationMechanismProperties
                                .Select(x => string.Format("{0}:{1}", x.Key, x.Value)).ToArray()));
            }
            if (_authenticationSource != null)
            {
                query.AppendFormat("authSource={0};", _authenticationSource);
            }
            if (_applicationName != null)
            {
                query.AppendFormat("appname={0};", _applicationName);
            }
            if (_ipv6)
            {
                query.AppendFormat("ipv6=true;");
            }
            if (_scheme == ConnectionStringScheme.MongoDBPlusSrv)
            {
                if (!_useSsl)
                {
                    query.AppendFormat("ssl=false;");
                }
            }
            else
            {
                if (_useSsl)
                {
                    query.AppendFormat("ssl=true;");
                }
            }
            if (!_verifySslCertificate)
            {
                query.AppendFormat("sslVerifyCertificate=false;");
            }

            if (_compressors?.Any() ?? false)
            {
                query.AppendFormat("compressors={0};", string.Join(",", _compressors.Select(x => x.Type.ToString().ToLowerInvariant())));
                foreach (var compressor in _compressors)
                {
                    ParseAndAppendCompressorOptions(query, compressor);
                }
            }
            if (_connectionMode != ConnectionMode.Automatic)
            {
                query.AppendFormat("connect={0};", MongoUtils.ToCamelCase(_connectionMode.ToString()));
            }
            if (!string.IsNullOrEmpty(_replicaSetName))
            {
                query.AppendFormat("replicaSet={0};", _replicaSetName);
            }
            if (_readConcernLevel != null)
            {
                query.AppendFormat("readConcernLevel={0};", MongoUtils.ToCamelCase(_readConcernLevel.Value.ToString()));
            }
            if (_readPreference != null)
            {
                query.AppendFormat("readPreference={0};", MongoUtils.ToCamelCase(_readPreference.ReadPreferenceMode.ToString()));
                if (_readPreference.TagSets != null)
                {
                    foreach (var tagSet in _readPreference.TagSets)
                    {
                        query.AppendFormat("readPreferenceTags={0};", string.Join(",", tagSet.Tags.Select(t => string.Format("{0}:{1}", t.Name, t.Value)).ToArray()));
                    }
                }
                if (_readPreference.MaxStaleness.HasValue)
                {
                    query.AppendFormat("maxStaleness={0};", FormatTimeSpan(_readPreference.MaxStaleness.Value));
                }
            }
            if (_fsync != null)
            {
                query.AppendFormat("fsync={0};", JsonConvert.ToString(_fsync.Value));
            }
            if (_journal != null)
            {
                query.AppendFormat("journal={0};", JsonConvert.ToString(_journal.Value));
            }
            if (_w != null)
            {
                query.AppendFormat("w={0};", _w);
            }
            if (_wTimeout != null)
            {
                query.AppendFormat("wtimeout={0};", FormatTimeSpan(_wTimeout.Value));
            }
            if (_connectTimeout != MongoDefaults.ConnectTimeout)
            {
                query.AppendFormat("connectTimeout={0};", FormatTimeSpan(_connectTimeout));
            }
            if (_heartbeatInterval != ServerSettings.DefaultHeartbeatInterval)
            {
                query.AppendFormat("heartbeatInterval={0};", FormatTimeSpan(_heartbeatInterval));
            }
            if (_heartbeatTimeout != ServerSettings.DefaultHeartbeatTimeout)
            {
                query.AppendFormat("heartbeatTimeout={0};", FormatTimeSpan(_heartbeatTimeout));
            }
            if (_maxConnectionIdleTime != MongoDefaults.MaxConnectionIdleTime)
            {
                query.AppendFormat("maxIdleTime={0};", FormatTimeSpan(_maxConnectionIdleTime));
            }
            if (_maxConnectionLifeTime != MongoDefaults.MaxConnectionLifeTime)
            {
                query.AppendFormat("maxLifeTime={0};", FormatTimeSpan(_maxConnectionLifeTime));
            }
            if (_maxConnectionPoolSize != MongoDefaults.MaxConnectionPoolSize)
            {
                query.AppendFormat("maxPoolSize={0};", _maxConnectionPoolSize);
            }
            if (_minConnectionPoolSize != MongoDefaults.MinConnectionPoolSize)
            {
                query.AppendFormat("minPoolSize={0};", _minConnectionPoolSize);
            }
            if (_localThreshold != MongoDefaults.LocalThreshold)
            {
                query.AppendFormat("localThreshold={0};", FormatTimeSpan(_localThreshold));
            }
            if (_serverSelectionTimeout != MongoDefaults.ServerSelectionTimeout)
            {
                query.AppendFormat("serverSelectionTimeout={0};", FormatTimeSpan(_serverSelectionTimeout));
            }
            if (_socketTimeout != MongoDefaults.SocketTimeout)
            {
                query.AppendFormat("socketTimeout={0};", FormatTimeSpan(_socketTimeout));
            }
            if (_waitQueueMultiple != 0.0 && _waitQueueMultiple != MongoDefaults.WaitQueueMultiple)
            {
                query.AppendFormat("waitQueueMultiple={0};", _waitQueueMultiple);
            }
            if (_waitQueueSize != 0 && _waitQueueSize != MongoDefaults.WaitQueueSize)
            {
                query.AppendFormat("waitQueueSize={0};", _waitQueueSize);
            }
            if (_waitQueueTimeout != MongoDefaults.WaitQueueTimeout)
            {
                query.AppendFormat("waitQueueTimeout={0};", FormatTimeSpan(WaitQueueTimeout));
            }
            if (_guidRepresentation != MongoDefaults.GuidRepresentation)
            {
                query.AppendFormat("uuidRepresentation={0};", (_guidRepresentation == GuidRepresentation.CSharpLegacy) ? "csharpLegacy" : MongoUtils.ToCamelCase(_guidRepresentation.ToString()));
            }
            if (!_retryReads.GetValueOrDefault(true))
            {
                query.AppendFormat("retryReads=false;");
            }
            if (_retryWrites.HasValue)
            {
                query.AppendFormat("retryWrites={0};", JsonConvert.ToString(_retryWrites.Value));
            }
            if (query.Length != 0)
            {
                query.Length = query.Length - 1; // remove trailing ";"
                if (_databaseName == null)
                {
                    url.Append("/");
                }
                url.Append("?");
                url.Append(query.ToString());
            }
            return(url.ToString());
        }
Exemple #46
0
        private IEnumerable<Func<IReadOnlyList<IRelationalCommand>>> GetMigrationCommands(
            IReadOnlyList<HistoryRow> appliedMigrationEntries,
            string targetMigration = null)
        {
            var appliedMigrations = new Dictionary<string, TypeInfo>();
            var unappliedMigrations = new Dictionary<string, TypeInfo>();
            foreach (var migration in _migrationsAssembly.Migrations)
            {
                if (appliedMigrationEntries.Any(
                    e => string.Equals(e.MigrationId, migration.Key, StringComparison.OrdinalIgnoreCase)))
                {
                    appliedMigrations.Add(migration.Key, migration.Value);
                }
                else
                {
                    unappliedMigrations.Add(migration.Key, migration.Value);
                }
            }

            IReadOnlyList<Migration> migrationsToApply;
            IReadOnlyList<Migration> migrationsToRevert;
            if (string.IsNullOrEmpty(targetMigration))
            {
                migrationsToApply = unappliedMigrations
                    .Select(p => _migrationsAssembly.CreateMigration(p.Value, _activeProvider))
                    .ToList();
                migrationsToRevert = new Migration[0];
            }
            else if (targetMigration == Migration.InitialDatabase)
            {
                migrationsToApply = new Migration[0];
                migrationsToRevert = appliedMigrations
                    .OrderByDescending(m => m.Key)
                    .Select(p => _migrationsAssembly.CreateMigration(p.Value, _activeProvider))
                    .ToList();
            }
            else
            {
                targetMigration = _migrationsAssembly.GetMigrationId(targetMigration);
                migrationsToApply = unappliedMigrations
                    .Where(m => string.Compare(m.Key, targetMigration, StringComparison.OrdinalIgnoreCase) <= 0)
                    .Select(p => _migrationsAssembly.CreateMigration(p.Value, _activeProvider))
                    .ToList();
                migrationsToRevert = appliedMigrations
                    .Where(m => string.Compare(m.Key, targetMigration, StringComparison.OrdinalIgnoreCase) > 0)
                    .OrderByDescending(m => m.Key)
                    .Select(p => _migrationsAssembly.CreateMigration(p.Value, _activeProvider))
                    .ToList();
            }

            for (var i = 0; i < migrationsToRevert.Count; i++)
            {
                var migration = migrationsToRevert[i];

                yield return () =>
                {
                    _logger.LogInformation(RelationalStrings.RevertingMigration(migration.GetId()));

                    return GenerateDownSql(
                        migration,
                        i != migrationsToRevert.Count - 1
                            ? migrationsToRevert[i + 1]
                            : null);
                };
            }

            foreach (var migration in migrationsToApply)
            {
                yield return () =>
                {
                    _logger.LogInformation(RelationalStrings.ApplyingMigration(migration.GetId()));

                    return GenerateUpSql(migration);
                };
            }
        }
Exemple #47
0
        // The assembly info must be in the last minus 1 position because:
        // - assemblyInfo should be in the end to override attributes
        // - assemblyInfo cannot be in the last position, because last file contains the main
        private static IEnumerable<string> GetSourceFiles(IReadOnlyList<string> sourceFiles, string assemblyInfo)
        {
            if (!sourceFiles.Any())
            {
                yield return assemblyInfo;
                yield break;
            }

            foreach (var s in sourceFiles.Take(sourceFiles.Count() - 1))
                yield return s;

            yield return assemblyInfo;

            yield return sourceFiles.Last();
        }
 public static ICompleteEventStreamMutator Create(IReadOnlyList<IEventMigration> eventMigrationFactories)
 {
     return eventMigrationFactories.Any()
                ? new RealMutator(eventMigrationFactories)
                : (ICompleteEventStreamMutator)new OnlySerializeVersionsMutator();
 }
 protected ResultListViewModel()
 {
     OpenResult             = new Command <T>(async(x) => await OnOpenResultAsync(x).ConfigureAwait(false));
     CopyToClipboardCommand = new Command(CopyAllToClipboard, () => displayResults?.Any() ?? false);
 }
        public static Type CreateType(string typeName, IReadOnlyList<IMemberDefinition> nodes, bool serializable = false, bool @sealed = false, Type parent = null, IEnumerable<Type> interfaces = null)
        {
            Type type;
            if (_typeCache.TryGetValue(typeName, out type))
                return type;

            var typeAttributes = ClassTypeAttributes;

            if (@sealed)
                typeAttributes |= TypeAttributes.Sealed;

            if (serializable)
                typeAttributes |= TypeAttributes.Serializable;

            var typeBuilder = _HorizonModule.DefineType(typeName, typeAttributes);

            List<IMemberDefinition> members;

            if (parent == null)
            {
                members = nodes.ToList();
            }
            else
            {
                typeBuilder.SetParent(parent);

                var properties = Info.Extended.Properties(parent);
                var fields = Info.Extended.Fields(parent);

                var names = properties.Select(x => x.Name).Union(fields.Select(x => x.Name)).ToList();
                members = nodes.Where(x => !names.Contains(x.Name)).ToList();

                if (parent.IsAbstract)
                {
                    //We need to implement these ourselves
                    var abstractProperties = properties.Where(x => (x.PropertyInfo.CanRead && x.PropertyInfo.GetGetMethod().IsAbstract) || (x.PropertyInfo.CanWrite && x.PropertyInfo.GetSetMethod().IsAbstract))
                                                       .Select(x => MemberDefinition.Property(x, isVirtual: true));

                    members.AddRange(abstractProperties);

                    var abstractMethods = Info.Extended.Methods(parent)
                                              .Where(x => x.MethodInfo.IsAbstract)
                                              .Where(x => !nodes.Any(n => n.Name == x.Name))
                                              .Select(x => MemberDefinition.EmptyMethod(x, isVirtual: true));

                    members.AddRange(abstractMethods);
                }
            }

            var notifyChanges = false;
            MethodBuilder raisePropertyChanged = null;
            
            if (interfaces != null)
            {
                var interfaceSet = new HashSet<Type>();
                
                foreach (var @interface in interfaces.Where(interfaceSet.Add).SelectMany(x => x.GetInterfaces()))
                    interfaceSet.Add(@interface);

                foreach (var @interface in interfaceSet)
                {
                    typeBuilder.AddInterfaceImplementation(@interface);

                    var properties = Info.Extended.Properties(@interface).Select(x => MemberDefinition.Property(x.Name, x.MemberType));
                    members = members.Union(properties).ToList();


                    var events = Info.Extended.Events(@interface);

                    if (!notifyChanges &&
                        (notifyChanges = typeof(INotifyPropertyChanged).IsAssignableFrom(@interface)))
                    {
                        foreach (var @event in events)
                        {
                            var tuple = GenerateEvent(typeBuilder, @event);

                            if (@event.Name != "PropertyChanged")
                                continue;

                            var eventBuilder = tuple.Item1;
                            var eventBackingField = tuple.Item2;

                            raisePropertyChanged = BuildOnPropertyChanged(typeBuilder, eventBuilder, eventBackingField);
                        }
                    }
                    else
                    {
                        members.AddRange(events.Select(x => new EventMemberDefinition(x.Name, x.EventHandlerType)));
                    }


                    var emptyMethods = Info.Extended.Methods(@interface).Select(method => MemberDefinition.EmptyMethod(method));
                    members.AddRange(emptyMethods);
                }
            }

            if (raisePropertyChanged != null)
            {
                foreach (var propertyDefinition in members.OfType<PropertyMemberDefinition>())
                    propertyDefinition.RaisePropertyChanged = raisePropertyChanged;
            }

            foreach (var member in members)
                member.Build(typeBuilder);

            if (parent != null)
            {
                if (raisePropertyChanged != null)
                    OverrideParentPropertiesForPropertyChanged(typeBuilder, parent, raisePropertyChanged);
            }

            // Generate our type and cache it.
            _typeCache[typeName] = type = typeBuilder.CreateType();
            return type;
        }
        private double SimulateOpponentWithPrediction(double lowerTimeBound, double timePerLeaf, POGame oppGame, Controller opponent,
                                                      IReadOnlyList <Prediction> predicitionMap, ref Dictionary <POGame, List <MctsNode> > newSimulations)
        {
            double predictionScore = 0;

            if (!(predicitionMap?.Any() ?? false))
            {
                return(predictionScore);
            }
            int denominator = predicitionMap.Count;
            var scorings    = predicitionMap.GroupBy(p => p.Deck.Scoring)
                              .Select(c => new MctsNode.ScoreExt(((double)c.Count() / denominator), c.Key))
                              .OrderByDescending(s => s.Value).ToList();

            // the simulation time for one prediction
            double timePerPrediction = timePerLeaf / predicitionMap.Count;

            // use prediction for each game
            for (int i = 0; i < predicitionMap.Count; i++)
            {
                Prediction   prediction = predicitionMap[i];
                SetasideZone setasideZone;
                setasideZone = new SetasideZone(opponent);

                // create deck zone
                List <Card> deckCards = prediction.Deck.Cards;
                DeckZone    deckZone;
                deckZone = new DeckZone(opponent);
                createZone(opponent, deckCards, deckZone, ref setasideZone);
                deckZone.Shuffle();

                // create hand zone
                List <Card> handCards = prediction.Hand.Cards;
                HandZone    handZone;
                handZone = new HandZone(opponent);
                createZone(opponent, handCards, handZone, ref setasideZone);

                var oppLeafNodes = new List <MctsNode>();

                // forward game
                POGame forwardGame = oppGame.getCopy();

                // upper time bound for simulation the opponent using the current prediction
                double oppSimulationTime = lowerTimeBound + (i + 1) * timePerPrediction / 2;

                // simulate opponent's moves
                while (forwardGame != null &&
                       forwardGame.State == SabberStoneCore.Enums.State.RUNNING &&
                       forwardGame.CurrentPlayer.Id == opponent.Id)
                {
                    // simulate
                    var      oppRoot     = new MctsNode(opponent.Id, scorings, forwardGame, null, null);
                    MctsNode bestOppNode = Simulate(oppSimulationTime, oppRoot, ref oppLeafNodes);
                    // get solution
                    List <PlayerTask> solutions = bestOppNode.GetSolution();
                    for (int j = 0; j < solutions.Count && (forwardGame != null); j++)
                    {
                        PlayerTask oppTask = solutions[j];
                        Dictionary <PlayerTask, POGame> dir = forwardGame.Simulate(new List <PlayerTask> {
                            oppTask
                        });
                        forwardGame = dir[oppTask];

                        if (forwardGame != null && forwardGame.CurrentPlayer.Choice != null)
                        {
                            break;
                        }
                    }
                }

                // upper time bound for simulation the player using the forwarded game
                double simulationTime = oppSimulationTime + timePerPrediction / 2;
                double score          = 0;
                var    leafs          = new List <MctsNode>();

                // simulate player using forwarded opponent game
                while (forwardGame != null &&
                       forwardGame.State == SabberStoneCore.Enums.State.RUNNING &&
                       forwardGame.CurrentPlayer.Id == _playerId)
                {
                    // simulate
                    var root = new MctsNode(_playerId, new List <MctsNode.ScoreExt> {
                        new MctsNode.ScoreExt(1.0, _scoring)
                    }, forwardGame, null, null);
                    MctsNode bestNode = Simulate(simulationTime, root, ref leafs);
                    // get solution
                    List <PlayerTask> solutions = bestNode.GetSolution();
                    for (int j = 0; j < solutions.Count && (forwardGame != null); j++)
                    {
                        PlayerTask task = solutions[j];
                        Dictionary <PlayerTask, POGame> dir = forwardGame.Simulate(new List <PlayerTask> {
                            task
                        });
                        forwardGame = dir[task];

                        if (forwardGame != null && forwardGame.CurrentPlayer.Choice != null)
                        {
                            break;
                        }
                    }
                    // TODO: maybe penalty forwardGame == null
                    score = bestNode.TotalScore;
                }
                predictionScore += score;

                if (forwardGame != null)
                {
                    newSimulations.Add(forwardGame, leafs);
                }
            }
            return(predictionScore);
        }
Exemple #52
0
        public static void Run(string[] args)
        {
            IReadOnlyList <string> input             = Array.Empty <string>();
            IReadOnlyList <string> resources         = null;
            IReadOnlyList <string> additionalFormats = null;
            string output            = null;
            string manifest          = null;
            bool   allConfigurations = false;

            // Preview options
            bool   autosize      = false;
            double imgWidth      = 640;
            double imgHeight     = 480;
            string configuration = null;

            bool recursive = false;
            bool silent    = false;
            bool verbose   = false;

            var cliOptions = ArgumentSyntax.Parse(args, options =>
            {
                options.ApplicationName = "cdcli component";

                options.DefineOption("o|output", ref output,
                                     "Output file (the format will be inferred from the extension). Cannot be used for directory inputs or in combination with specific output format options.");
                var manifestOption = options.DefineOption("manifest", ref manifest, false, "Writes a manifest file listing the compiled components.");
                if (manifestOption.IsSpecified && manifest == null)
                {
                    manifest = "manifest.xml";
                }
                options.DefineOption("autosize", ref autosize, "Automatically sizes the output image to fit the rendered preview.");
                options.DefineOption("w|width", ref imgWidth, double.Parse, "Width of output images to generate (default=640).");
                options.DefineOption("h|height", ref imgHeight, double.Parse, "Height of output images to generate (default=480).");
                options.DefineOption("r|recursive", ref recursive, "Recursively searches sub-directories of the input directory.");
                options.DefineOption("s|silent", ref silent, "Does not output anything to the console on successful operation.");
                options.DefineOption("v|verbose", ref verbose, "Outputs extra information to the console.");
                options.DefineOption("c|configuration", ref configuration, "Name of component configuration to use.");
                options.DefineOption("all-configurations", ref allConfigurations, "Produce an output for every component configuration (supported output formats only).");
                options.DefineOptionList("resources", ref resources, "Resources to use in generating the output. Either a directory, or a space-separated list of [key] [filename] pairs.");
                options.DefineOptionList("format", ref additionalFormats, "Output formats to write.");
                options.DefineParameterList("input", ref input, "Components to compile.");
            });

            var loggerFactory = new LoggerFactory();

            if (!silent)
            {
                loggerFactory.AddProvider(new BasicConsoleLogger(LogLevel.Information));
            }

            var logger = loggerFactory.CreateLogger(typeof(ComponentApp));

            if (!input.Any())
            {
                logger.LogError("At least one input file must be specified.");
                Environment.Exit(1);
            }

            var  generators        = new Dictionary <IOutputGenerator, string>();
            var  outputGenerators  = new OutputGeneratorRepository();
            bool outputIsDirectory = Directory.Exists(output);

            if (output != null && !outputIsDirectory)
            {
                if (outputGenerators.TryGetGeneratorByFileExtension(Path.GetExtension(output), out var generator))
                {
                    // Use the generator implied by the file extension
                    generators.Add(generator, output);
                }
                else if (additionalFormats?.Any() != true)
                {
                    logger.LogError("Unable to infer format from output file extension." + Environment.NewLine +
                                    "Specify a known file extension or specify explicitly using --format");
                    Environment.Exit(1);
                }
                else
                {
                    logger.LogInformation("Unable to infer format from output file extension. Using formats only.");
                }
            }

            if (additionalFormats?.Any() == true)
            {
                foreach (var format in additionalFormats)
                {
                    if (outputGenerators.TryGetGeneratorByFormat(format, out var generator))
                    {
                        generators.Add(generator, outputIsDirectory ? output : null);
                    }
                    else
                    {
                        logger.LogError($"Unknown format: {format}");
                        Environment.Exit(1);
                    }
                }
            }

            var previewOptions = new PreviewGenerationOptions
            {
                Center        = true,
                Crop          = autosize,
                Width         = imgWidth,
                Height        = imgHeight,
                Configuration = configuration,
                Properties    = new Dictionary <string, string>(),
            };

            DirectoryComponentDescriptionLookup componentDescriptionLookup;

            if (input.Count == 1 && Directory.Exists(input.Single()))
            {
                componentDescriptionLookup = new DirectoryComponentDescriptionLookup(input.Single(), true);
            }
            else
            {
                componentDescriptionLookup = new DirectoryComponentDescriptionLookup(input.ToArray());
            }

            var resourceProvider = ResourceProviderFactory.Create(loggerFactory.CreateLogger(typeof(ResourceProviderFactory)), resources);
            var outputRunner     = new OutputRunner(loggerFactory.CreateLogger <OutputRunner>(), resourceProvider);
            var compileRunner    = new ComponentDescriptionRunner(loggerFactory.CreateLogger <ComponentDescriptionRunner>(), outputRunner);
            var configurationDefinitionRunner = new ConfigurationDefinitionRunner(loggerFactory.CreateLogger <ConfigurationDefinitionRunner>(), componentDescriptionLookup, outputRunner);
            var results = new List <IManifestEntry>();

            var inputs = new List <string>();

            foreach (var i in input)
            {
                if (File.Exists(i))
                {
                    inputs.Add(i);
                }
                else if (Directory.Exists(i))
                {
                    foreach (var generator in generators)
                    {
                        if (generator.Value != null && !Directory.Exists(generator.Value))
                        {
                            logger.LogError("Outputs must be directories when the input is a directory.");
                            Environment.Exit(1);
                        }
                    }

                    foreach (var file in Directory.GetFiles(i, "*.xml",
                                                            recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly))
                    {
                        inputs.Add(file);
                    }

                    foreach (var file in Directory.GetFiles(i, "*.yaml",
                                                            recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly))
                    {
                        inputs.Add(file);
                    }
                }
                else
                {
                    logger.LogError($"Input is not a valid file or directory: {i}");
                    Environment.Exit(1);
                }
            }

            foreach (var file in inputs.OrderBy(x => x))
            {
                IManifestEntry result;

                switch (Path.GetExtension(file))
                {
                case ".xml":
                    result = compileRunner.CompileOne(file, previewOptions, allConfigurations, generators);
                    break;

                case ".yaml":
                    result = configurationDefinitionRunner.CompileOne(file, previewOptions, generators);
                    break;

                default:
                    throw new NotSupportedException($"File type '{Path.GetExtension(file)}' not supported.");
                }

                results.Add(result);
            }

            if (manifest != null)
            {
                using (var manifestFs = File.Open(manifest, FileMode.Create))
                {
                    logger.LogInformation($"Writing manifest to {manifest}");
                    ManifestWriter.WriteManifest(results, manifestFs);
                }
            }
        }
 /// <summary>
 /// Maps from a list of one type TK to a list of a another type T using a mapper function designated while calling the method.
 /// </summary>
 /// <typeparam name="TIn">A type that we map from.</typeparam>
 /// <typeparam name="TOut">A type that we map to.</typeparam>
 /// <param name="items">The inventory item objects or models to be mapped.</param>
 /// <param name="mapper">The function used for mapping.</param>
 /// <returns></returns>
 public IReadOnlyList <TIn> Map <TIn, TOut>(IReadOnlyList <TOut> items, Func <TOut, TIn> mapper)
 {
     // If the input collection is empty, return a new empty list of the target type.
     // Otherwise, preform the individual mapping.
     return(items?.Any() == true?items.Select(mapper).ToList() : new List <TIn>());
 }
Exemple #54
0
        private void WriteLocations(Location location, IReadOnlyList<Location> additionalLocations)
        {
            if (HasPath(location))
            {
                _writer.WriteArrayStart("locations");
                _writer.WriteObjectStart(); // location
                _writer.WriteKey("resultFile");

                WritePhysicalLocation(location);

                _writer.WriteObjectEnd(); // location
                _writer.WriteArrayEnd(); // locations
            }

            // See https://github.com/dotnet/roslyn/issues/11228 for discussion around
            // whether this is the correct treatment of Diagnostic.AdditionalLocations
            // as SARIF relatedLocations.
            if (additionalLocations != null &&
                additionalLocations.Count > 0 &&
                additionalLocations.Any(l => HasPath(l)))
            {
                _writer.WriteArrayStart("relatedLocations");

                foreach (var additionalLocation in additionalLocations)
                {
                    if (HasPath(additionalLocation))
                    {
                        _writer.WriteObjectStart(); // annotatedCodeLocation
                        _writer.WriteKey("physicalLocation");

                        WritePhysicalLocation(additionalLocation);

                        _writer.WriteObjectEnd(); // annotatedCodeLocation
                    }
                }

                _writer.WriteArrayEnd(); // relatedLocations
            }
        }
        private void LoadNavigationProperties(
            object entity,
            IReadOnlyList<INavigation> navigationPath,
            int currentNavigationIndex,
            IReadOnlyList<object> relatedEntities)
        {
            if (navigationPath[currentNavigationIndex].PointsToPrincipal()
                && relatedEntities.Any())
            {
                _clrPropertySetterSource
                    .GetAccessor(navigationPath[currentNavigationIndex])
                    .SetClrValue(entity, relatedEntities[0]);

                var inverseNavigation = navigationPath[currentNavigationIndex].FindInverse();

                if (inverseNavigation != null)
                {
                    if (inverseNavigation.IsCollection())
                    {
                        _clrCollectionAccessorSource
                            .GetAccessor(inverseNavigation)
                            .AddRange(relatedEntities[0], new[] { entity });
                    }
                    else
                    {
                        _clrPropertySetterSource
                            .GetAccessor(inverseNavigation)
                            .SetClrValue(relatedEntities[0], entity);
                    }
                }
            }
            else
            {
                if (navigationPath[currentNavigationIndex].IsCollection())
                {
                    _clrCollectionAccessorSource
                        .GetAccessor(navigationPath[currentNavigationIndex])
                        .AddRange(entity, relatedEntities);

                    var inverseNavigation = navigationPath[currentNavigationIndex].FindInverse();

                    if (inverseNavigation != null)
                    {
                        var clrPropertySetter
                            = _clrPropertySetterSource
                                .GetAccessor(inverseNavigation);

                        foreach (var relatedEntity in relatedEntities)
                        {
                            clrPropertySetter.SetClrValue(relatedEntity, entity);
                        }
                    }
                }
                else if (relatedEntities.Any())
                {
                    _clrPropertySetterSource
                        .GetAccessor(navigationPath[currentNavigationIndex])
                        .SetClrValue(entity, relatedEntities[0]);

                    var inverseNavigation = navigationPath[currentNavigationIndex].FindInverse();

                    if (inverseNavigation != null)
                    {
                        _clrPropertySetterSource
                            .GetAccessor(inverseNavigation)
                            .SetClrValue(relatedEntities[0], entity);
                    }
                }
            }
        }
 private static bool ContainsCitiesFile(IReadOnlyList<StorageFile> files)
 {
     return files.Any(f => f.Name == SETTING_KEY);
 }
        /// <summary>
        /// Creates graph from the given items.
        /// Contains implementation of INSERT(hnsw, q, M, Mmax, efConstruction, mL) algorithm.
        /// Article: Section 4. Algorithm 1.
        /// </summary>
        /// <param name="items">The items to insert.</param>
        /// <param name="generator">The random number generator to distribute nodes across layers.</param>
        internal void Build(IReadOnlyList <TItem> items, Random generator)
        {
            if (!items?.Any() ?? false)
            {
                return;
            }

            var core = new Core(this.distance, this.Parameters, items);

            core.AllocateNodes(generator);

            var entryPoint = core.Nodes[0];
            var searcher   = new Searcher(core);
            Func <int, int, TDistance> nodeDistance = core.GetDistance;
            var neighboursIdsBuffer = new List <int>(core.Algorithm.GetM(0) + 1);

            for (int nodeId = 1; nodeId < core.Nodes.Count; ++nodeId)
            {
                using (new ScopeLatencyTracker(GraphBuildEventSource.Instance?.GraphInsertNodeLatencyReporter))
                {
                    /*
                     * W ← ∅ // list for the currently found nearest elements
                     * ep ← get enter point for hnsw
                     * L ← level of ep // top layer for hnsw
                     * l ← ⌊-ln(unif(0..1))∙mL⌋ // new element’s level
                     * for lc ← L … l+1
                     *   W ← SEARCH-LAYER(q, ep, ef=1, lc)
                     *   ep ← get the nearest element from W to q
                     * for lc ← min(L, l) … 0
                     *   W ← SEARCH-LAYER(q, ep, efConstruction, lc)
                     *   neighbors ← SELECT-NEIGHBORS(q, W, M, lc) // alg. 3 or alg. 4
                     *     for each e ∈ neighbors // shrink connections if needed
                     *       eConn ← neighbourhood(e) at layer lc
                     *       if │eConn│ > Mmax // shrink connections of e if lc = 0 then Mmax = Mmax0
                     *         eNewConn ← SELECT-NEIGHBORS(e, eConn, Mmax, lc) // alg. 3 or alg. 4
                     *         set neighbourhood(e) at layer lc to eNewConn
                     *   ep ← W
                     * if l > L
                     *   set enter point for hnsw to q
                     */

                    // zoom in and find the best peer on the same level as newNode
                    var bestPeer    = entryPoint;
                    var currentNode = core.Nodes[nodeId];
                    var currentNodeTravelingCosts = new TravelingCosts <int, TDistance>(nodeDistance, nodeId);
                    for (int layer = bestPeer.MaxLayer; layer > currentNode.MaxLayer; --layer)
                    {
                        searcher.RunKnnAtLayer(bestPeer.Id, currentNodeTravelingCosts, neighboursIdsBuffer, layer, 1);
                        bestPeer = core.Nodes[neighboursIdsBuffer[0]];
                        neighboursIdsBuffer.Clear();
                    }

                    // connecting new node to the small world
                    for (int layer = Math.Min(currentNode.MaxLayer, entryPoint.MaxLayer); layer >= 0; --layer)
                    {
                        searcher.RunKnnAtLayer(bestPeer.Id, currentNodeTravelingCosts, neighboursIdsBuffer, layer, this.Parameters.ConstructionPruning);
                        var bestNeighboursIds = core.Algorithm.SelectBestForConnecting(neighboursIdsBuffer, currentNodeTravelingCosts, layer);

                        for (int i = 0; i < bestNeighboursIds.Count; ++i)
                        {
                            int newNeighbourId = bestNeighboursIds[i];
                            core.Algorithm.Connect(currentNode, core.Nodes[newNeighbourId], layer);
                            core.Algorithm.Connect(core.Nodes[newNeighbourId], currentNode, layer);

                            // if distance from newNode to newNeighbour is better than to bestPeer => update bestPeer
                            if (DistanceUtils.Lt(currentNodeTravelingCosts.From(newNeighbourId), currentNodeTravelingCosts.From(bestPeer.Id)))
                            {
                                bestPeer = core.Nodes[newNeighbourId];
                            }
                        }

                        neighboursIdsBuffer.Clear();
                    }

                    // zoom out to the highest level
                    if (currentNode.MaxLayer > entryPoint.MaxLayer)
                    {
                        entryPoint = currentNode;
                    }

                    // report distance cache hit rate
                    GraphBuildEventSource.Instance?.CoreGetDistanceCacheHitRateReporter?.Invoke(core.DistanceCacheHitRate);
                }
            }

            // construction is done
            this.core       = core;
            this.entryPoint = entryPoint;
        }
            private void AugmentCompletionsBasedOnLinesBefore(IReadOnlyList<RobotsTxtLineSyntax> before, IList<Completion> completions)
            {
                // first line
                if (!before.Any())
                {
                    completions.Add(ToCompletion("User-agent"));
                }

                // right after User-agent
                else if (before.All(l => l.NameToken.Value.Equals("User-agent", StringComparison.InvariantCultureIgnoreCase)))
                {
                    completions.Add(ToCompletion("User-agent"));
                    completions.Add(ToCompletion("Allow"));
                    completions.Add(ToCompletion("Disallow"));
                    completions.Add(ToCompletion("Sitemap"));
                    completions.Add(ToCompletion("Host"));
                    completions.Add(ToCompletion("Crawl-delay"));
                }

                // any other case
                else
                {
                    completions.Add(ToCompletion("Allow"));
                    completions.Add(ToCompletion("Disallow"));
                    completions.Add(ToCompletion("Sitemap"));

                    if (!before.Any(l => l.NameToken.Value.Equals("Host", StringComparison.InvariantCultureIgnoreCase)))
                        completions.Add(ToCompletion("Host"));

                    if (!before.Any(l => l.NameToken.Value.Equals("Crawl-delay", StringComparison.InvariantCultureIgnoreCase)))
                        completions.Add(ToCompletion("Crawl-delay"));
                }
            }
        private void SetupWallSideActuators(IEnumerable<GrabableItemData> items, IReadOnlyList<ActuatorItemData> actuators)
        {
            if (actuators.Any())
            {
                CurrentGrabableItems = items;

                var factory = parser.TryMatchFactory(actuators, items.Any());
                if (factory != null)
                {
                    CurrentTile.SubItems.Add(factory.CreateItem(builder, CurrentTile, actuators));
                }
                else
                {
                    if(actuators.All(x => x.ActuatorType != 5 && x.ActuatorType != 6))
                    {
                        foreach (var i in actuators)
                        {
                            Point? absolutePosition = null;
                            if (i.ActionLocation is RemoteTarget)
                                absolutePosition = ((RemoteTarget) i.ActionLocation).Position.Position.ToAbsolutePosition(builder.CurrentMap);

                            CurrentTile.SubItems.Add(new Actuator(builder.GetWallPosition(i.TilePosition, CurrentTile), $"{absolutePosition} {i.DumpString()}"));
                        }
                    }
                    else
                    {
                        
                    }
                }
            }
        }
        public async void ContinueFileOpenPicker(IReadOnlyList<StorageFile> files)
        {
            if (files != null && files.Any())
            {
                var stream = (FileRandomAccessStream)await files[0].OpenAsync(FileAccessMode.Read);
                using (var streamForImage = stream.CloneStream())
                {
                    newImageBytes = new byte[stream.Size];
                    using (var dataReader = new DataReader(stream))
                    {
                        await dataReader.LoadAsync((uint)stream.Size);
                        dataReader.ReadBytes(newImageBytes);
                    }

                    UserImage = ImageHelper.CreateBitmapImage(streamForImage, 100);
                }
            }
        }