public void Dictionary_GetOrAdd_Adds_Unexisting_Key()
        {
            var dictionary = new Dictionary<int, string>();

            Assert.Equal("test", dictionary.GetOrAdd(1, v => "test"));
            Assert.Equal("test", dictionary.GetOrAdd(1, v => "test2"));
        }
Example #2
0
        public static void DebugIfNeeded(List<IObject> displayList)
        {
            string behindThis = _behindThis;
            if (behindThis == null) return;
            string whyIsThis = _whyIsThis;
            bool renderDebug = _renderDebug;
            _behindThis = null;

            Dictionary<string, List<string>> map = new Dictionary<string, List<string>>();
            const string sortWord = "Sort ";
            const string backwardsWord = "backwards ";
            foreach (var obj in displayList)
            {                
                foreach (var property in obj.Properties.Ints.AllProperties())
                {
                    if (!property.Key.Contains(sortWord)) continue;
                    if (renderDebug && property.Key.Contains(backwardsWord)) continue;
                    if (!renderDebug && !property.Key.Contains(backwardsWord)) continue;

                    string comparedId = property.Key.Substring(renderDebug ? property.Key.IndexOf(sortWord) + sortWord.Length : 
                        property.Key.IndexOf(backwardsWord) + backwardsWord.Length);

                    if (property.Value > 0) map.GetOrAdd(comparedId, () => new List<string>()).Add(obj.ID);
                    else map.GetOrAdd(obj.ID, () => new List<string>()).Add(comparedId);
                }
            }
            string chain = getChain(whyIsThis, behindThis, map, new HashSet<string>());
            Debug.WriteLine(chain == null ? string.Format("{0} is not behind {1}", whyIsThis, behindThis) :
                string.Format("{0}{1}", whyIsThis, chain));
        }
        public void TestGetOrAdd()
        {
            var dict = new Dictionary<string, string>();
            dict.GetOrAdd("x", () => "a");
            dict.GetOrAdd("x", () => { throw new Exception("Should not be reached."); });

            dict.Should().Equal(new Dictionary<string, string> {["x"] = "a"});
        }
	public void WhenGettingTwice_ThenGetsExisting()
	{
		var dictionary = new Dictionary<string, Guid>();

		var value = dictionary.GetOrAdd("foo", key => Guid.NewGuid());
		var value2 = dictionary.GetOrAdd("foo", key => Guid.NewGuid());
		
		Assert.Equal(value, value2);
	}
        public void GetOrAdd()
        {
            var dictionary = new Dictionary<int, string> { { 0, "Zero" } };

            dictionary.GetOrAdd(0, "0").ShouldBe("Zero");
            dictionary.GetOrAdd(1, "One").ShouldBe("One");
            dictionary.GetOrAdd(2, () => "Two").ShouldBe("Two");
            dictionary.GetOrAdd(3, i => i.ToString()).ShouldBe("3");
        }
Example #6
0
        public void TestMiscDictionaryGetOrAdd()
        {
            string key0 = "Blinky";

            var dict = new Dictionary<string, int>();

            int value0 = 0;
            dict.GetOrAdd(key0, v => value0 = v, () => 42);
            Assert.Equal(0, value0);
            dict.GetOrAdd(key0, v => value0 = v, () => 42);
            Assert.Equal(42, value0);
        }
        public void GetOrAddTest()
        {
            var stringValues = new Dictionary<string, string>
            {
                ["key1"] = "Hoge"
            };

            Assert.AreEqual("Hoge", stringValues.GetOrAdd("key1", key => "Fuga"));
            Assert.AreEqual("Hoge", stringValues["key1"]);

            Assert.AreEqual("key2_Piyo", stringValues.GetOrAdd("key2", key => key + "_Piyo"));
            Assert.AreEqual("key2_Piyo", stringValues["key2"]);
        }
Example #8
0
        public void GetOrAdd()
        {
            var d = new Dictionary<string, StockStatus>() {
                {"AAPL", new StockStatus { Price = 530.12m, Position = "Sell" }},
                {"GOOG", new StockStatus { Price = 123.5m, Position = "Buy" }}
            };

            d.GetOrAdd("AAPL").Position = "Buy";
            d.GetOrAdd("YHOO").Price = 1.99m;
            Console.Out.WriteLine(d.ToString<string, StockStatus>());

            Assert.That(d["AAPL"].Position, Is.EqualTo("Buy"), "Incorrect position.");
            Assert.That(d.Keys, Has.Count.EqualTo(3), "Incorrect number of keys.");
            Assert.That(d["YHOO"].Price, Is.EqualTo(1.99m), "Incorrect price.");
        }
        public void GetOrAdd()
        {
            // Type
            var @this = new Dictionary<string, string>();

            // Examples
            string value1 = @this.GetOrAdd("Fizz", "Buzz"); // return "Buzz";
            string value2 = @this.GetOrAdd("Fizz", "Buzz2"); // return "Buzz"; // The Dictionary already contains the key
            string value3 = @this.GetOrAdd("Fizz2", s => "Buzz"); // return "Buzz";

            // Unit Test
            Assert.AreEqual("Buzz", value1);
            Assert.AreEqual("Buzz", value2);
            Assert.AreEqual("Buzz", value3);
        }
Example #10
0
 public IEnumerable<RemoteInfo> Load(IEnumerable<ConfigurationEntry> config)
 {
     var remotes = new Dictionary<string, RemoteInfo>();
     foreach (var entry in config)
     {
         var keyParts = entry.Key.Split('.');
         if (keyParts.Length == 3 && keyParts[0] == "tfs-remote")
         {
             var id = keyParts[1];
             var key = keyParts[2];
             var remote = remotes.GetOrAdd(id);
             remote.Id = id;
             if (key == "url")
                 remote.Url = entry.Value;
             else if (key == "repository")
                 remote.Repository = entry.Value;
             else if (key == "username")
                 remote.Username = entry.Value;
             else if (key == "password")
                 remote.Password = entry.Value;
             else if (key == "ignore-paths")
                 remote.IgnoreRegex = entry.Value;
             else if (key == "legacy-urls")
                 remote.Aliases = entry.Value.Split(',');
             else if (key == "autotag")
                 remote.Autotag = bool.Parse(entry.Value);
         }
     }
     return remotes.Values;
 }
        public int AddNewErrors(IVsEnumExternalErrors pErrors)
        {
            var projectErrors = new HashSet<DiagnosticData>();
            var documentErrorsMap = new Dictionary<DocumentId, HashSet<DiagnosticData>>();

            var errors = new ExternalError[1];
            uint fetched;
            while (pErrors.Next(1, errors, out fetched) == VSConstants.S_OK && fetched == 1)
            {
                var error = errors[0];

                DiagnosticData diagnostic;
                if (error.bstrFileName != null)
                {
                    diagnostic = CreateDocumentDiagnosticItem(error);
                    if (diagnostic != null)
                    {
                        var diagnostics = documentErrorsMap.GetOrAdd(diagnostic.DocumentId, _ => new HashSet<DiagnosticData>());
                        diagnostics.Add(diagnostic);
                        continue;
                    }

                    projectErrors.Add(CreateProjectDiagnosticItem(error));
                }
                else
                {
                    projectErrors.Add(CreateProjectDiagnosticItem(error));
                }
            }

            _diagnosticProvider.AddNewErrors(_projectId, projectErrors, documentErrorsMap);
            return VSConstants.S_OK;
        }
            public GlobalCache(Dictionary<IAdapter, Consumer> consumers, int version)
            {
                GlobalSignalLookup = new Dictionary<Guid, List<Consumer>>();
                GlobalDestinationLookup = consumers;
                BroadcastConsumers = new List<Consumer>();
                Version = version;

                // Generate routes for all signals received by each consumer adapter
                foreach (var kvp in consumers)
                {
                    var consumerAdapter = kvp.Key;
                    var consumer = kvp.Value;

                    if ((object)consumerAdapter.InputMeasurementKeys != null)
                    {
                        // Create routes for each of the consumer's input signals
                        foreach (Guid signalID in consumerAdapter.InputMeasurementKeys.Select(key => key.SignalID))
                        {
                            GlobalSignalLookup.GetOrAdd(signalID, id => new List<Consumer>()).Add(consumer);
                        }
                    }
                    else
                    {
                        // Add this consumer to the broadcast routes to begin receiving all measurements
                        BroadcastConsumers.Add(consumer);
                    }
                }

                // Broadcast consumers receive all measurements, so add them to every signal route
                foreach (List<Consumer> consumerList in GlobalSignalLookup.Values)
                {
                    consumerList.AddRange(BroadcastConsumers);
                }
            }
Example #13
0
 public IEnumerable<RemoteInfo> Load(IEnumerable<ConfigurationEntry<string>> config)
 {
     var remotes = new Dictionary<string, RemoteInfo>();
     foreach (var entry in config)
     {
         var keyParts = entry.Key.Split('.');
         if (keyParts.Length >= 3 && keyParts[0] == "tfs-remote")
         {
             // The branch name may contain dots ("maint-1.0.0") which must be considered since split on "."
             var id = string.Join(".", keyParts, 1, keyParts.Length - 2);
             var key = keyParts.Last();
             var remote = remotes.GetOrAdd(id);
             remote.Id = id;
             if (key == "url")
                 remote.Url = entry.Value;
             else if (key == "repository")
                 remote.Repository = entry.Value;
             else if (key == "username")
                 remote.Username = entry.Value;
             else if (key == "password")
                 remote.Password = entry.Value;
             else if (key == "ignore-paths")
                 remote.IgnoreRegex = entry.Value;
             else if (key == "legacy-urls")
                 remote.Aliases = entry.Value.Split(',');
             else if (key == "autotag")
                 remote.Autotag = bool.Parse(entry.Value);
         }
     }
     return remotes.Values;
 }
        public void Dictionary_GetOrAdd_Gets_An_Existing_Value()
        {
            var dictionary = new Dictionary<int, string>();
            dictionary.Add(1, "1");

            Assert.Equal("1", dictionary.GetOrAdd(1, v => "test"));
        }
            private Dictionary<SyntaxToken, SyntaxToken> CreateOldToNewTokensMap(
                Dictionary<TriviaLocation, PreviousNextTokenPair> tokenPairs,
                Dictionary<TriviaLocation, LeadingTrailingTriviaPair> triviaPairs)
            {
                var map = new Dictionary<SyntaxToken, SyntaxToken>();
                foreach (var pair in CreateUniqueTokenTriviaPairs(tokenPairs, triviaPairs))
                {
                    var localCopy = pair;
                    var previousToken = map.GetOrAdd(localCopy.Item1.PreviousToken, _ => localCopy.Item1.PreviousToken);
                    map[localCopy.Item1.PreviousToken] = previousToken.WithTrailingTrivia(localCopy.Item2.TrailingTrivia);

                    var nextToken = map.GetOrAdd(localCopy.Item1.NextToken, _ => localCopy.Item1.NextToken);
                    map[localCopy.Item1.NextToken] = nextToken.WithLeadingTrivia(localCopy.Item2.LeadingTrivia);
                }

                return map;
            }
	public void WhenGettingNonExisting_ThenCreatesValue()
	{
		var id = Guid.NewGuid();
		var dictionary = new Dictionary<string, Guid>();

		var value = dictionary.GetOrAdd("foo", key => id);

		Assert.Equal(id, value);
	}
Example #17
0
        public UpgradeManager(ActorInitializer init)
        {
            upgrades = Exts.Lazy(() =>
            {
                var ret = new Dictionary<string, UpgradeState>();
                foreach (var up in init.Self.TraitsImplementing<IUpgradable>())
                    foreach (var t in up.UpgradeTypes)
                        ret.GetOrAdd(t).Traits.Add(up);

                return ret;
            });
        }
        private Dictionary<SyntaxToken, SyntaxToken> CreateOldToNewTokensMap(
            Dictionary<TriviaLocation, SyntaxToken> tokens,
            Dictionary<TriviaLocation, SyntaxAnnotation> annotations)
        {
            var token = default(SyntaxToken);
            var map = new Dictionary<SyntaxToken, SyntaxToken>();
			var emptyList = SpecializedCollections.EmptyEnumerable<SyntaxTrivia>();

			token = map.GetOrAdd(tokens[TriviaLocation.BeforeBeginningOfSpan], _ => tokens[TriviaLocation.BeforeBeginningOfSpan]);
            map[tokens[TriviaLocation.BeforeBeginningOfSpan]] = token.WithTrailingTrivia(emptyList).WithAdditionalAnnotations(annotations[TriviaLocation.BeforeBeginningOfSpan]);

            token = map.GetOrAdd(tokens[TriviaLocation.AfterBeginningOfSpan], _ => tokens[TriviaLocation.AfterBeginningOfSpan]);
            map[tokens[TriviaLocation.AfterBeginningOfSpan]] = token.WithLeadingTrivia(emptyList).WithAdditionalAnnotations(annotations[TriviaLocation.AfterBeginningOfSpan]);

            token = map.GetOrAdd(tokens[TriviaLocation.BeforeEndOfSpan], _ => tokens[TriviaLocation.BeforeEndOfSpan]);
            map[tokens[TriviaLocation.BeforeEndOfSpan]] = token.WithTrailingTrivia(emptyList).WithAdditionalAnnotations(annotations[TriviaLocation.BeforeEndOfSpan]);

            token = map.GetOrAdd(tokens[TriviaLocation.AfterEndOfSpan], _ => tokens[TriviaLocation.AfterEndOfSpan]);
            map[tokens[TriviaLocation.AfterEndOfSpan]] = token.WithLeadingTrivia(emptyList).WithAdditionalAnnotations(annotations[TriviaLocation.AfterEndOfSpan]);

            return map;
        }
        private static Dictionary<string, List<PropertyInfo>> GetPropertiesDependencies([NotNull]Type type)
        {
            var properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
            var dependencies = new Dictionary<string, List<PropertyInfo>>(properties.Length);

            foreach (var property in properties)
            {
                var dependsOnAttributes = property.GetCustomAttributes<DependsOnAttribute>();
                foreach (var dependsOnAttribute in dependsOnAttributes)
                {
                    var propertyInfos = dependencies.GetOrAdd(dependsOnAttribute.PropertyName, () => new List<PropertyInfo>());
                    propertyInfos.Add(property);
                }
            }

            return dependencies;
        }
        protected async Task<IDictionary<SyntaxNode, ISet<INamedTypeSymbol>>> GetAllReferencedDefinitionsAsync(
            Compilation compilation,
            IEnumerable<ISymbol> members,
            CancellationToken cancellationToken)
        {
            var namespaceScopeToReferencedDefinitions = new Dictionary<SyntaxNode, ISet<INamedTypeSymbol>>();
            var root = await Document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
            Func<SyntaxNode, ISet<INamedTypeSymbol>> createSet = _ => new HashSet<INamedTypeSymbol>();

            var annotatedNodes = root.GetAnnotatedNodesAndTokens(SymbolAnnotation.Kind);
            foreach (var annotatedNode in annotatedNodes)
            {
                cancellationToken.ThrowIfCancellationRequested();

                SyntaxNode namespaceScope = null;
                var annotations = annotatedNode.GetAnnotations(SymbolAnnotation.Kind);
                foreach (var annotation in annotations)
                {
                    cancellationToken.ThrowIfCancellationRequested();

                    foreach (var namedType in SymbolAnnotation.GetSymbols(annotation, compilation).OfType<INamedTypeSymbol>())
                    {
                        cancellationToken.ThrowIfCancellationRequested();
                        if (!IsBuiltIn(namedType))
                        {
                            namespaceScope = namespaceScope ?? this.GetInnermostNamespaceScope(annotatedNode);
                            var referencedDefinitions = namespaceScopeToReferencedDefinitions.GetOrAdd(
                                namespaceScope, createSet);
                            referencedDefinitions.Add(namedType);
                        }
                    }
                }
            }

            return namespaceScopeToReferencedDefinitions;
        }
    private void PrepareForImport(Options[] options, Action<string> logger)
    {
      var folderIdsByName = new Dictionary<string, List<Tuple<string, string>>>();
      AddFoldersRecusive(_session.Folders, folderIdsByName);

      foreach (var profile in options)
      {
        var ids = folderIdsByName.GetOrAdd(profile.OutlookFolderEntryId).FirstOrDefault();
        if (ids != null)
        {
          profile.OutlookFolderEntryId = ids.Item1;
          profile.OutlookFolderStoreId = ids.Item2;

          profile.OutlookFolderAccountName = _optionTasks.GetFolderAccountNameOrNull(profile.OutlookFolderStoreId);
        }
        else
        {
          logger($"Warning: did not find Folder '{profile.OutlookFolderEntryId}'");
          profile.OutlookFolderEntryId = null;
          profile.OutlookFolderStoreId = null;
          profile.OutlookFolderAccountName = null;
        }
      }
    }
Example #22
0
        public Tiling CreateTiling(
            [NotNull] TilingDefinition tilingDefinition,
            [NotNull] ShapeSet shapes,
            [NotNull] StyleManager styleManager)
        {
            if (tilingDefinition == null) throw new ArgumentNullException(nameof(tilingDefinition));
            if (shapes == null) throw new ArgumentNullException(nameof(shapes));
            if (styleManager == null) throw new ArgumentNullException(nameof(styleManager));
            if (!Tilings.Values.Contains(tilingDefinition))
            {
                throw new ArgumentException(
                    Strings.Template_CreateTiling_UnknownTilingDefinition,
                    nameof(tilingDefinition));
            }

            HashSet<ShapeTemplate> templates = new HashSet<ShapeTemplate>(shapes.Select(s => s.Template));

            if (!templates.SetEquals(ShapeTemplates.Values))
                throw new ArgumentException(Strings.Template_CreateTiling_WrongShapes, nameof(shapes));

            Dictionary<int, ShapeLines> shapeLines = new Dictionary<int, ShapeLines>();

            List<Tile> tiles = new List<Tile>(shapes.Count);

            // TODO Order shapes so that the nth shape is adjacent to at least one of the previous shapes
            foreach (Shape shape in shapes)
            {
                Debug.Assert(shape != null, "shape != null");

                string label = null;
                Matrix3x2 transform = default(Matrix3x2);

                if (tiles.Count < 1)
                {
                    label = tilingDefinition.AdjacentParts
                        .Where(l => l.Value.ShapeTemplate == shape.Template)
                        .OrderBy(l => l.Label, StringComparer.InvariantCulture)
                        .First().Label;
                    transform = Matrix3x2.Identity;
                }
                else
                {
                    foreach (Tile t in tiles)
                    {
                        foreach (EdgePartShape partShape in t.PartShapes)
                        {
                            Debug.Assert(partShape != null, "partShape != null");

                            Labeled<EdgePart> adjacent;
                            if (!tilingDefinition.AdjacentParts.TryGetAdjacent(
                                partShape.Part.WithLabel(t.Label),
                                out adjacent))
                                continue;

                            Debug.Assert(adjacent.Value != null, "adjacent.Value != null");
                            if (adjacent.Value.ShapeTemplate != shape.Template)
                                continue;

                            label = adjacent.Label;
                            transform = EdgePartPosition.Create(adjacent.Value, shape)
                                .GetTransformTo(t.GetEdgePartPosition(partShape.Part));
                        }

                        if (label != null) break;
                    }

                    if (label == null) throw new InvalidDataException();
                }

                EdgePartShape[] partShapes = shape.Template.EdgeParts[tilingDefinition]
                    .Select(
                        ep => new EdgePartShape(
                            ep,
                            shapes.GetEdge(ep.EdgePattern.EdgeName),
                            shapeLines.GetOrAdd(ep.PartShapeID, _ => ShapeLines.CreateDefault())))
                    .ToArray();

                Tile tile = new Tile(label, shape, transform, partShapes);
                tile.Style = styleManager.GetStyle(tile);
                tiles.Add(tile);
            }

            return new Tiling(this, tilingDefinition, tiles, styleManager);
        }
        /// <summary>
        /// Given a list of symbols, determine which are not recommended at the same position in linked documents.
        /// </summary>
        /// <param name="expectedSymbols">The symbols recommended in the active context.</param>
        /// <param name="linkedContextSymbolLists">The symbols recommended in linked documents</param>
        /// <returns>The list of projects each recommended symbol did NOT appear in.</returns>
        protected Dictionary<ISymbol, List<ProjectId>> FindSymbolsMissingInLinkedContexts(HashSet<ISymbol> expectedSymbols, IEnumerable<Tuple<DocumentId, AbstractSyntaxContext, IEnumerable<ISymbol>>> linkedContextSymbolLists)
        {
            var missingSymbols = new Dictionary<ISymbol, List<ProjectId>>(LinkedFilesSymbolEquivalenceComparer.IgnoreAssembliesInstance);

            foreach (var linkedContextSymbolList in linkedContextSymbolLists)
            {
                var symbolsMissingInLinkedContext = expectedSymbols.Except(linkedContextSymbolList.Item3, LinkedFilesSymbolEquivalenceComparer.IgnoreAssembliesInstance);
                foreach (var missingSymbol in symbolsMissingInLinkedContext)
                {
                    missingSymbols.GetOrAdd(missingSymbol, (m) => new List<ProjectId>()).Add(linkedContextSymbolList.Item1.ProjectId);
                }
            }

            return missingSymbols;
        }
Example #24
0
        // Reads statistics from the archive and stores them in a format that can
        // be easily manipulated to determine which devices belong in which levels.
        private void ReadStatistics()
        {
            ArchiveLocator locator;
            DateTime startTime;
            DateTime endTime;

            Dictionary<int, Aggregate> aggregateLookup;
            Aggregate currentAggregate;
            int currentHistorianID;

            Dictionary<string, DeviceStats> deviceStatsLookup;
            DeviceStats deviceStats;
            SignalStats signalStats;
            string signalName;
            int index;

            deviceStatsLookup = new Dictionary<string, DeviceStats>();

            // Create the statistics reader for reading statistics from the archive
            using (StatisticsReader statisticsReader = new StatisticsReader())
            {
                // Create the archive locator to
                // determine the location of the archive
                locator = new ArchiveLocator()
                {
                    ArchiveLocation = m_archiveLocation,
                    ArchiveLocationName = "Statistics",
                    ArchiveName = "STAT"
                };

                endTime = m_reportDate.ToUniversalTime() + TimeSpan.FromDays(1);
                startTime = endTime - TimeSpan.FromDays(ReportDays);

                // Set up and open the statistics reader
                statisticsReader.StartTime = startTime;
                statisticsReader.EndTime = endTime;
                statisticsReader.ArchiveFilePath = locator.ArchiveFilePath;
                statisticsReader.Open();

                // Create lookup tables for each
                aggregateLookup = new Dictionary<int, Aggregate>();

                foreach (MetadataRecord record in statisticsReader.MetadataRecords)
                {
                    if (IsDesiredDeviceStat(record.Synonym1))
                    {
                        deviceStats = deviceStatsLookup.GetOrAdd(GetDeviceNameForStat(record.Synonym1), name => new DeviceStats()
                        {
                            Name = name,
                            MeasurementsExpected = new Aggregate(ReportDays),
                            MeasurementsReceived = new Aggregate(ReportDays),
                            SignalStatsLookup = new Dictionary<string, SignalStats>()
                        });

                        if (record.Synonym1.EndsWith("!PMU-ST5", StringComparison.Ordinal))
                            aggregateLookup[record.HistorianID] = deviceStats.MeasurementsExpected;
                        else if (record.Synonym1.EndsWith("!PMU-ST4", StringComparison.Ordinal))
                            aggregateLookup[record.HistorianID] = deviceStats.MeasurementsReceived;
                    }
                    else if (IsDesiredSignalStat(record.Synonym1))
                    {
                        signalName = GetSignalName(record.Synonym1);

                        deviceStats = deviceStatsLookup.GetOrAdd(GetDeviceNameForSignal(signalName), name => new DeviceStats()
                        {
                            Name = name,
                            MeasurementsExpected = new Aggregate(ReportDays),
                            MeasurementsReceived = new Aggregate(ReportDays),
                            SignalStatsLookup = new Dictionary<string, SignalStats>()
                        });

                        signalStats = deviceStats.SignalStatsLookup.GetOrAdd(signalName, name => new SignalStats()
                        {
                            Name = name,
                            MeasurementsLatched = new Aggregate(ReportDays),
                            MeasurementsUnreasonable = new Aggregate(ReportDays)
                        });

                        if (record.Synonym1.StartsWith("980!"))
                            aggregateLookup[record.HistorianID] = signalStats.MeasurementsLatched;
                        else if (record.Synonym1.StartsWith("900!"))
                            aggregateLookup[record.HistorianID] = signalStats.MeasurementsUnreasonable;
                    }
                }

                currentAggregate = null;
                currentHistorianID = -1;

                foreach (IDataPoint dataPoint in statisticsReader.Read(aggregateLookup.Keys))
                {
                    index = (dataPoint.Time.ToDateTime() - startTime).Days;

                    if (index < 0 || index >= ReportDays)
                        continue;

                    if (dataPoint.HistorianID != currentHistorianID)
                    {
                        aggregateLookup.TryGetValue(dataPoint.HistorianID, out currentAggregate);
                        currentHistorianID = dataPoint.HistorianID;
                    }

                    if ((object)currentAggregate != null)
                        currentAggregate.Add(index, dataPoint.Value);
                }
            }

            // Store the statistics data to be used in the report
            m_deviceStatsList = deviceStatsLookup.Values.ToList();
        }
            private Dictionary<SyntaxToken, LeadingTrailingTriviaPair> CreateTokenLeadingTrailingTriviaMap(
                Dictionary<TriviaLocation, SyntaxToken> tokens)
            {
                var tuple = default(LeadingTrailingTriviaPair);
                var map = new Dictionary<SyntaxToken, LeadingTrailingTriviaPair>();

                tuple = map.GetOrAdd(tokens[TriviaLocation.BeforeBeginningOfSpan], _ => default(LeadingTrailingTriviaPair));
                map[tokens[TriviaLocation.BeforeBeginningOfSpan]] = new LeadingTrailingTriviaPair
                {
                    LeadingTrivia = tuple.LeadingTrivia,
                    TrailingTrivia = _triviaList[TriviaLocation.BeforeBeginningOfSpan]
                };

                tuple = map.GetOrAdd(tokens[TriviaLocation.AfterBeginningOfSpan], _ => default(LeadingTrailingTriviaPair));
                map[tokens[TriviaLocation.AfterBeginningOfSpan]] = new LeadingTrailingTriviaPair
                {
                    LeadingTrivia = _triviaList[TriviaLocation.AfterBeginningOfSpan],
                    TrailingTrivia = tuple.TrailingTrivia
                };

                tuple = map.GetOrAdd(tokens[TriviaLocation.BeforeEndOfSpan], _ => default(LeadingTrailingTriviaPair));
                map[tokens[TriviaLocation.BeforeEndOfSpan]] = new LeadingTrailingTriviaPair
                {
                    LeadingTrivia = tuple.LeadingTrivia,
                    TrailingTrivia = _triviaList[TriviaLocation.BeforeEndOfSpan]
                };

                tuple = map.GetOrAdd(tokens[TriviaLocation.AfterEndOfSpan], _ => default(LeadingTrailingTriviaPair));
                map[tokens[TriviaLocation.AfterEndOfSpan]] = new LeadingTrailingTriviaPair
                {
                    LeadingTrivia = _triviaList[TriviaLocation.AfterEndOfSpan],
                    TrailingTrivia = tuple.TrailingTrivia
                };

                return map;
            }
        private static Dictionary<Project, Dictionary<Document, List<ValueTuple<ISymbol, IReferenceFinder>>>> CreateProjectMap(
            ConcurrentDictionary<Document, ConcurrentQueue<ValueTuple<ISymbol, IReferenceFinder>>> map)
        {
            Contract.Requires(map.Count > 0);

            var projectMap = new Dictionary<Project, Dictionary<Document, List<ValueTuple<ISymbol, IReferenceFinder>>>>();
            foreach (var kv in map)
            {
                var documentMap = projectMap.GetOrAdd(kv.Key.Project, s_documentMapGetter);
                var queue = documentMap.GetOrAdd(kv.Key, s_queueGetter);

                queue.AddRange(kv.Value);
            }

            ValidateProjectMap(projectMap);
            return projectMap;
        }
Example #27
0
            public void Execute()
            {
                ValidateFacets();

                //We only want to run the base query once, so we capture all of the facet-ing terms then run the query
                //	once through the collector and pull out all of the terms in one shot
                var allCollector = new GatherAllCollector();
                var facetsByName = new Dictionary<string, Dictionary<string, FacetValue>>();


                using (var currentState = Database.IndexStorage.GetCurrentStateHolder(Index))
                {
                    var currentIndexSearcher = currentState.IndexSearcher;

                    var baseQuery = Database.IndexStorage.GetDocumentQuery(Index, IndexQuery, Database.IndexQueryTriggers);
                    currentIndexSearcher.Search(baseQuery, allCollector);
                    var fields = Facets.Values.Select(x => x.Name)
                            .Concat(Ranges.Select(x => x.Key));
                    var fieldsToRead = new HashSet<string>(fields);
                    IndexedTerms.ReadEntriesForFields(currentState,
                        fieldsToRead,
                        allCollector.Documents,
                        (term, doc) =>
                        {
                            var facets = Facets.Values.Where(facet => facet.Name == term.Field);
                            foreach (var facet in facets)
                            {
                                switch (facet.Mode)
                                {
                                    case FacetMode.Default:
                                        var facetValues = facetsByName.GetOrAdd(facet.DisplayName);
                                        FacetValue existing;
                                        if (facetValues.TryGetValue(term.Text, out existing) == false)
                                        {
                                            existing = new FacetValue
                                            {
                                                Range = GetRangeName(term)
                                            };
                                            facetValues[term.Text] = existing;
                                        }
                                        ApplyFacetValueHit(existing, facet, doc, null);
                                        break;
                                    case FacetMode.Ranges:
                                        List<ParsedRange> list;
                                        if (Ranges.TryGetValue(term.Field, out list))
                                        {
                                            for (int i = 0; i < list.Count; i++)
                                            {
                                                var parsedRange = list[i];
                                                if (parsedRange.IsMatch(term.Text))
                                                {
                                                    var facetValue = Results.Results[term.Field].Values[i];
                                                    ApplyFacetValueHit(facetValue, facet, doc, parsedRange);
                                                }
                                            }
                                        }
                                        break;
                                    default:
                                        throw new ArgumentOutOfRangeException();
                                }
                            }

                        });
                    UpdateFacetResults(facetsByName);

                    CompleteFacetCalculationsStage1(currentState);
                    CompleteFacetCalculationsStage2();
                }
            }
        public ExcelImportResult Import(string file, int projectColumn, int taskColumn,
                                        int dateColumn, int fromColumn, int toColumn, int rateColumn,
                                        int descriptionColumn)
        {
            var excelPackage = new ExcelPackage(new FileInfo(file));
            var worksheet = excelPackage.Workbook.Worksheets.First();
            var clients = new Dictionary<Guid, Domain.Client>();
            var projects = new Dictionary<Guid, Domain.Project>();
            var result = new ExcelImportResult();
            var toAdd = new List<TimeRegistration>();

            for (int r = 2; r <= worksheet.Dimension.End.Row; r++)
            {
                try
                {
                    Guid projectId;

                    Guid.TryParse(worksheet.Cells[r, projectColumn].Text, out projectId);

                    var project = projects.GetOrAdd(projectId, key => _aggregateRootRepository.GetById<Domain.Project>(key));
                    var client = clients.GetOrAdd(project.ClientId, key => _aggregateRootRepository.GetById<Domain.Client>(key));

                    if (project == null)
                    {
                        result.Errors.Add(r, "Project not found.");
                        continue;
                    }

                    DateTime date;
                    DateTime from;
                    DateTime to;
                    decimal rate;

                    if (!DateTime.TryParseExact(worksheet.Cells[r, dateColumn].Text, "yyyy-M-d", CultureInfo.InvariantCulture, DateTimeStyles.None, out date))
                    {
                        result.Errors.Add(r, "Date does not contain a valid date.");
                        continue;
                    }

                    if (!DateTime.TryParseExact(worksheet.Cells[r, fromColumn].Text, "H:mm", CultureInfo.InvariantCulture, DateTimeStyles.None, out from))
                    {
                        result.Errors.Add(r, "From does not contain a valid time.");
                        continue;
                    }

                    if (!DateTime.TryParseExact(worksheet.Cells[r, toColumn].Text, "H:mm", CultureInfo.InvariantCulture, DateTimeStyles.None, out to))
                    {
                        result.Errors.Add(r, "To does not contain a valid time.");
                        continue;
                    }

                    if (!decimal.TryParse(worksheet.Cells[r, rateColumn].Text, out rate))
                    {
                        result.Errors.Add(r, "Rate does not contain a valid number.");
                        continue;
                    }

                    toAdd.Add(new Domain.TimeRegistration(_idGenerator.NextGuid(),
                        client, project, new Domain.ValueObjects.Task
                        {
                            Name = worksheet.Cells[r, taskColumn].Text,
                            Rate = rate
                        },
                        worksheet.Cells[r, descriptionColumn].Text,
                        new Date(date.Year, date.Month, date.Day),
                        new Time(from.Hour, from.Minute),
                        new Time(to.Hour, to.Minute)));
                }
                catch (Exception ex)
                {
                    result.Errors.Add(r, ex.Message);
                }
            }

            if (!result.Errors.Any())
            {
                foreach (var timeRegistration in toAdd)
                {
                    _aggregateRootRepository.Save(timeRegistration);
                    result.Success++;
                }
            }

            return result;
        }
        public void GetOrAdd()
        {
            var dictionary = new Dictionary<string, string>();
            dictionary.GetOrAdd("fookey", "bar").Should().Be("bar");
            dictionary.GetOrAdd("fookey", "foo").Should().Be("bar");

            Action action = () => dictionary.GetOrAdd(null, "");
            action.ShouldThrow<ArgumentNullException>()
                .And.ParamName.Should().Be("key");

            dictionary = null;
            action.ShouldThrow<ArgumentNullException>()
                .And.ParamName.Should().Be("source");
        }
        public void GetOrAddOverload()
        {
            var dictionary = new Dictionary<string, string>();

            Func<string, string> adder = (key) =>
            {
                key.Should().Be("fookey");
                return "bar";
            };

            dictionary.GetOrAdd("fookey", adder).Should().Be("bar");
            dictionary.GetOrAdd("fookey", adder).Should().Be("bar");

            Action action = () => dictionary.GetOrAdd(null, addValueFactory: adder);
            action.ShouldThrow<ArgumentNullException>()
                .And.ParamName.Should().Be("key");

            action = () => dictionary.GetOrAdd("fookey", addValueFactory: null);
            action.ShouldThrow<ArgumentNullException>()
                .And.ParamName.Should().Be("addValueFactory");

            dictionary = null;
            action.ShouldThrow<ArgumentNullException>()
                .And.ParamName.Should().Be("source");
        }