/// <summary>
        /// Logs out various data on the child-parent relationships.
        ///
        /// </summary>
        /// <param name="sender"></param>
        public static void Log(object sender)
        {
            if (!(sender is DependencyObject))
            {
                return;
            }
            var       edgesOfGraph      = new HashSet <Relationship>();
            var       branchPoints      = new List <DependencyObject>();
            Stopwatch startNew          = Stopwatch.StartNew();
            var       longestUnbranched = new List <List <Relationship> >();

            longestUnbranched.Add(new List <Relationship>());
            var  timesEncountered = new Dictionary <DependencyObject, int>();
            bool success          = Inspect(0, (DependencyObject)sender, branchPoints, edgesOfGraph, longestUnbranched, timesEncountered);

            TimeSpan startNewElapsed = startNew.Elapsed;

            startNew.Stop();

            var getParent = edgesOfGraph.ToLookup(r => r.Child);

            var branchPointsCounted = branchPoints
                                      .GroupBy(bp => bp, (key, group) => new { key, count = group.Count() })
                                      .ToDictionary(x => x.key, x => x.count);

            Func <DependencyObject, string> toString = dob => {
                if (dob == null)
                {
                    return("<null>");
                }

                string result = $"{dob.GetType()}@{dob.GetHashCode()}[times({timesEncountered[dob]})]";
                result += branchPointsCounted.ContainsKey(dob)
                    ? $"[isBranchPoint({branchPointsCounted[dob]})]"
                    : "";
                return(result);
            };
            Func <Relationship, string> relationshipToString = e => $"Parent: {toString(e.Parent)}, Child: {toString(e.Child)}, RelationshipType: {e.Type}, RecursionDepth: {e.RecursionDepth}";

            Console.WriteLine($"{sender}: branchPoints.Length={edgesOfGraph.Count}");
            Console.WriteLine($"Branchpoints: {Environment.NewLine}{string.Join(Environment.NewLine, branchPointsCounted.OrderBy(bpc => bpc.Value).Select(bp => toString(bp.Key)))}");
            Console.WriteLine($"Time taken {startNewElapsed}");
            string parentChain = string.Join(
                Environment.NewLine,
                (sender as DependencyObject).Traverse(o => getParent[o].FirstOrDefault()?.Parent).Select(o => toString(o)));

            Console.WriteLine("Parentchain:" + Environment.NewLine + parentChain);
            if (!success)
            {
                Console.WriteLine("Exceeded maximum recursion: ");
                string relationshipsList = string.Join(Environment.NewLine + Environment.NewLine,
                                                       longestUnbranched.Skip(longestUnbranched.Count - 100).Select(subList => "Count: " + subList.Count + Environment.NewLine + string.Join(Environment.NewLine, subList.Select(r => $"    {relationshipToString(r)}"))));
                Console.WriteLine(relationshipsList);
            }
            Console.WriteLine("Edges of graph: ");
            Console.WriteLine(
                string.Join(
                    Environment.NewLine,
                    edgesOfGraph.Select(e => relationshipToString(e))));
        }
Example #2
0
        public void Remove(bool prompt)
        {
            var selectedViewNames = new HashSet <ViewName>(chooseViewsControl1.SelectedViews);

            if (selectedViewNames.Count == 0)
            {
                return;
            }
            string message;

            if (selectedViewNames.Count == 1)
            {
                message = string.Format(Resources.ManageViewsForm_BtnRemoveOnClick_Are_you_sure_you_want_to_delete_the_view___0___, selectedViewNames.First().Name);
            }
            else
            {
                message = string.Format(Resources.ManageViewsForm_BtnRemoveOnClick_Are_you_sure_you_want_to_delete_these__0__views_, selectedViewNames.Count);
            }
            if (prompt && ViewContext.ShowMessageBox(this, message, MessageBoxButtons.OKCancel) == DialogResult.Cancel)
            {
                return;
            }
            var namesByGroup = selectedViewNames.ToLookup(name => name.GroupId, name => name.Name);

            foreach (var grouping in namesByGroup)
            {
                ViewContext.DeleteViews(grouping.Key, grouping);
            }
        }
        /// <summary>
        /// Updates all dependencies with version ranges to the version it was resolved to.
        /// </summary>
        private static void ResolveDependecyVersionRanges(HashSet <NugetPackage> runtimePackages)
        {
            var runtimePackagesLookup = runtimePackages.ToLookup(x => x.Name.ToLowerInvariant());

            foreach (var runtimePackage in runtimePackages)
            {
                foreach (var dependency in runtimePackage.Dependencies.ToList())
                {
                    if (!NuGetVersion.TryParse(dependency.Value, out _) && VersionRange.TryParse(dependency.Value, out VersionRange versionRange))
                    {
                        var normalizedDependencyKey = dependency.Key.ToLowerInvariant();
                        var package = runtimePackagesLookup[normalizedDependencyKey].FirstOrDefault(pkg => versionRange.Satisfies(NuGetVersion.Parse(pkg.Version)));
                        if (package != default)
                        {
                            runtimePackage.Dependencies[dependency.Key] = package.Version;
                        }
                        else
                        {
                            // This should not happen, since all dependencies are resolved to a specific version.
                            Console.Error.WriteLine($"Dependency ({dependency.Value}) with version range ({dependency.Value}) did not resolve to a specific version.");
                        }
                    }
                }
            }
        }
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var links = new HashSet<Link>((IList<Link>)value, new LinkEqualityComparer());

            writer.WriteStartObject();

            var lookup = links.ToLookup(l => l.Rel);

            foreach (var rel in lookup)
            {
                writer.WritePropertyName(rel.Key);
                if (rel.Count() > 1)
                    writer.WriteStartArray();
                foreach (var link in rel)
                {
                    writer.WriteStartObject();
                    writer.WritePropertyName("href");
                    writer.WriteValue(ResolveUri(link.Href));

                    if (link.IsTemplated)
                    {
                        writer.WritePropertyName("templated");
                        writer.WriteValue(true);
                    }

                    writer.WriteEndObject();
                }
                if (rel.Count() > 1)
                    writer.WriteEndArray();
            }
            writer.WriteEndObject();
        }
        protected void FillReportsTree()
        {
            var currentLanguage = LanguageUtil.GetLanguage();

            var allEntitiesLp = (from n in DataContext.LP_Categories
                                 where n.DateDeleted == null && (n.Language == currentLanguage || n.Language == null || n.Language == "")
                                 select n).ToLookup(n => n.ParentID);

            var entitiesList = CategoryUtil.GetAllCategories(null, allEntitiesLp).ToList();

            CategoryUtil.Sort(entitiesList);

            var categories = (from n in entitiesList
                              where n.DateDeleted == null
                              orderby n.OrderIndex, n.Number, n.DateCreated
                              select new ParentChildEntity
            {
                ID = n.ID,
                ParentID = n.ParentID,
                Type = "Category",
                Name = n.Name
            }).ToList();

            var reports = (from n in DataContext.LP_Reports
                           where n.DateDeleted == null && (n.Language == currentLanguage || n.Language == null || n.Language == "")
                           select new ParentChildEntity
            {
                ID = n.ID,
                ParentID = n.CategoryID,
                Type = "Report",
                Name = n.Name
            }).ToList();

            var itemsSet = new HashSet <ParentChildEntity>();

            itemsSet.UnionWith(categories);
            itemsSet.UnionWith(reports);

            var itemsLp = itemsSet.ToLookup(n => n.ParentID);
            var parents = itemsSet.Where(n => n.ParentID == null);

            foreach (var entity in parents)
            {
                var node = new TreeNode
                {
                    Text         = GetEntityText(entity),
                    Value        = Convert.ToString(entity.ID),
                    ShowCheckBox = (entity.Type == "Report")
                };

                FillNode(node, entity.ID, itemsLp);

                tvReports.Nodes.Add(node);
            }

            tvReports.CollapseAll();
        }
Example #6
0
        public TargetResolver(IEnumerable <Target> targetsEnum)
        {
            var targets = targetsEnum.ToArray();

            // For molecules allow lookup by formula, InChIKey etc in addition to display name
            var accessions = new HashSet <Tuple <string, Target> >();

            foreach (var target in targets.Where(t => !t.IsProteomic))
            {
                var accessionNumbers = target.Molecule.AccessionNumbers;
                if (accessionNumbers != null)
                {
                    // Allow lookup by InChiKey, HMDB etc
                    foreach (var name in accessionNumbers.GetAllKeys())
                    {
                        var key = name.Substring(name.IndexOf(':') + 1); // e.g. drop the "InChikey:" from ""InChiKey:ZXPLRDFHBYIQOX-BTBVOZEKSA-N"
                        if (!string.IsNullOrEmpty(key))
                        {
                            accessions.Add(new Tuple <string, Target>(key, target));
                        }
                    }
                }

                // Allow lookup by formula
                var formula = target.Molecule.Formula;
                if (!string.IsNullOrEmpty(formula))
                {
                    accessions.Add(new Tuple <string, Target>(formula, target));
                }
            }

            if (accessions.Any())
            {
                foreach (var target in targets)
                {
                    // Also lookup by name
                    accessions.Add(new Tuple <string, Target>(GetTargetDisplayName(target), target));

                    // And by small molecule encoding string
                    var encoded = target.ToSerializableString();
                    if (!string.IsNullOrEmpty(encoded))
                    {
                        accessions.Add(new Tuple <string, Target>(encoded, target));
                    }
                }

                _targetsByName = accessions.ToLookup(a => a.Item1, a => a.Item2);
            }
            else
            {
                _targetsByName = targets.Select(t => t.ToSerializableString())
                                 .Distinct()
                                 .Select(Target.FromSerializableString).ToLookup(GetTargetDisplayName);
            }
        }
        public async Task Initialize(Project project, IProjectConfiguration configuration, Compilation compilation)
        {
            var extProject = project.Solution.Projects.First(o => o.Name == _projectName);
            var doc        = extProject.Documents.First(o => o.Name == _fileName);
            var rootNode   = await doc.GetSyntaxRootAsync().ConfigureAwait(false);

            var semanticModel = await doc.GetSemanticModelAsync().ConfigureAwait(false);

            _extensionMethods = new HashSet <IMethodSymbol>(rootNode.DescendantNodes()
                                                            .OfType <MethodDeclarationSyntax>()
                                                            .Where(o => o.Identifier.ValueText.EndsWith("Async"))
                                                            .Select(o => semanticModel.GetDeclaredSymbol(o)));
            _extensionMethodsLookup = _extensionMethods.ToLookup(o => o.Name);
        }
Example #8
0
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var links  = new HashSet <Link>((IList <Link>)value, new LinkEqualityComparer());
            var lookup = links.ToLookup(l => l.Rel);

            if (lookup.Count == 0)
            {
                return;
            }

            writer.WriteStartObject();

            foreach (var rel in lookup)
            {
                writer.WritePropertyName(rel.Key);
                if (rel.Count() > 1)
                {
                    writer.WriteStartArray();
                }
                foreach (var link in rel)
                {
                    writer.WriteStartObject();
                    writer.WritePropertyName("href");
                    writer.WriteValue(ResolveUri(link.Href));

                    if (link.IsTemplated)
                    {
                        writer.WritePropertyName("templated");
                        writer.WriteValue(true);
                    }
                    if (!string.IsNullOrEmpty(link.Title))
                    {
                        writer.WritePropertyName("title");
                        writer.WriteValue(link.Title);
                    }

                    writer.WriteEndObject();
                }
                if (rel.Count() > 1)
                {
                    writer.WriteEndArray();
                }
            }
            writer.WriteEndObject();
        }
Example #9
0
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var links  = new HashSet <Link>((IList <Link>)value, Link.EqualityComparer);
            var lookup = links.ToLookup(l => l.Rel);

            if (lookup.Count == 0)
            {
                return;
            }

            writer.WriteStartObject();

            foreach (var rel in lookup)
            {
                var count = rel.Count();

                writer.WritePropertyName(rel.Key);

                bool serializeAsArray = (count > 1) || (rel.Any(l => l.IsMultiLink)) || (rel.Key == Link.RelForCuries);

                if (serializeAsArray)
                {
                    writer.WriteStartArray();
                }

                foreach (var link in rel)
                {
                    WriteLink(writer, link);
                }

                if ((count > 1) || (rel.Any(l => l.IsMultiLink)) || (rel.Key == Link.RelForCuries))
                {
                    writer.WriteEndArray();
                }
            }

            writer.WriteEndObject();
        }
Example #10
0
        public void NamespaceCasingConsistent()
        {
            var nameSpaces = new HashSet <string>();

            foreach (var type in Types)
            {
                nameSpaces.Add(type.Namespace);
                for (int i = 0; i < type.Namespace.Length; i++)
                {
                    if (type.Namespace[i] == '.')
                    {
                        nameSpaces.Add(type.Namespace.Substring(0, i));
                    }
                }

                foreach (var g in nameSpaces.ToLookup(s => s.ToUpperInvariant()))
                {
                    if (g.Count() > 1)
                    {
                        throw new Exception(string.Format("Found many casings {0}: {1}", g.Key, string.Join(",", g)));
                    }
                }
            }
        }
Example #11
0
        /// <summary>
        /// Generates the lookup used by recalculate. takes the solved cells as a parameter
        /// returns a function for all mappings name to value found so far with.
        /// </summary>
        /// <param name="cellsSolved">The cells solved.</param>
        /// <returns></returns>
        private Lookup generateLookup(HashSet <Cell> cellsSolved)
        {
            var lookup = cellsSolved.ToLookup(c => c.name, c => (double)c.value);

            return(s => lookup[s].First());
        }
        // Report evil twins if found. Assumes the initMapAsync method has been called. Exception caught
        // and logged in %LOCALAPPDATA%\AcTools\Logs\EvilTwins-YYYY-MM-DD.log on operation failure.
        private static async Task <bool> reportAsync()
        {
            bool ret = false; // assume failure

            try
            {
                foreach (KeyValuePair <AcDepot, HashSet <Tuple <string, int> > > pair in _map.OrderBy(n => n.Key)) // order by AcDepot
                {
                    AcDepot depot = pair.Key;                                                                      // depot
                    HashSet <Tuple <string, int> > hset = pair.Value;                                              // [element, EID] from all dynamic streams in depot
                    // from our hashset create a collection of elements mapped to their EID's
                    Lookup <string, Tuple <string, int> > col = (Lookup <string, Tuple <string, int> >)hset.ToLookup(n => n.Item1);
                    // where more than one EID exists for the element, order by element
                    foreach (var ii in col.Where(n => n.Count() > 1).OrderBy(n => n.Key))
                    {
                        string element = ii.Key;
                        if (_excludeList != null && _excludeList.Contains(element))
                        {
                            continue; // ignore if in TwinsExcludeFile
                        }
                        log(element);
                        IEnumerable <AcStream> filter = from n in depot.Streams
                                                        where n.IsDynamic && !n.Hidden
                                                        select n;
                        List <Task <XElement> > tasks = new List <Task <XElement> >(filter.Count());
                        foreach (AcStream stream in filter)
                        {
                            tasks.Add(getElementInfoAsync(stream, element));
                        }

                        XElement[] arr = await Task.WhenAll(tasks);                      // finish running stat commands in parallel

                        if (arr != null && arr.All(n => n != null))                      // true if all ran successfully
                        {
                            foreach (Tuple <string, int> jj in ii.OrderBy(n => n.Item2)) // order twins by EID
                            {
                                int eid = jj.Item2;
                                log($"\tEID: {eid} on {DateTime.Now.ToString("ddd MMM d h:mm tt")}");
                                // C# language short-circuit: the test for id equals eid isn't evaluated if status equals "(no such elem)",
                                // otherwise an exception would be thrown since the id attribute doesn't exist in this case
                                foreach (XElement e in arr.Where(n => (string)n.Attribute("status") != "(no such elem)" &&
                                                                 (int)n.Attribute("id") == eid).OrderBy(n => n.Annotation <AcStream>()))
                                {
                                    log($"\t\t{e.Annotation<AcStream>()} {(string)e.Attribute("status")}");
                                    string      namedVersion = (string)e.Attribute("namedVersion"); // virtual stream name and version number
                                    string      temp         = (string)e.Attribute("Real");
                                    string[]    real         = temp.Split('\\');                    // workspace stream and version numbers
                                    AcStream    wkspace      = depot.getStream(int.Parse(real[0])); // workspace stream
                                    ElementType elemType     = e.acxType("elemType");
                                    string      twin;
                                    if ((long?)e.Attribute("size") != null)
                                    {
                                        twin = $"\t\t\tSize: {(long)e.Attribute("size")}, ModTime: {e.acxTime("modTime")} {{{elemType}}}" +
                                               $"{Environment.NewLine}\t\t\tReal: {wkspace}\\{real[1]}, Virtual: {namedVersion}";
                                    }
                                    else // a folder or link
                                    {
                                        twin = $"\t\t\tReal: {wkspace}\\{real[1]}, Virtual: {namedVersion} {{{elemType}}}";
                                    }

                                    log(twin);
                                }

                                log("");
                            }
                        }
                    }
                }

                ret = true; // operation succeeded
            }

            catch (Exception ecx)
            {
                AcDebug.Log($"Exception caught and logged in Program.reportAsync{Environment.NewLine}{ecx.Message}");
            }

            return(ret);
        }
		private void Initialize()
		{
			if (null == _consumingMethod)
				throw new InvalidOperationException("Consuming method has not been defined");

			if (!_assemblies.Any())
				throw new InvalidOperationException("There are no assemblies to scan");

			var types = _assemblies
				.SelectMany(a => {
				    try
				    {
				        return a.GetExportedTypes();
				    } catch{}
				    return new Type[0];
				}).Where(x=>x!=null)
				.ToList();

			var messageTypes = types.Where(x => !x.IsInterface && typeof(IMessage).IsAssignableFrom(x)).ToArray();
			var consumerTypes = types.Where(x => typeof(IConsume).IsAssignableFrom(x)).ToArray();

			var consumingDirectly = consumerTypes
				.SelectMany(consumerType =>
					GetConsumedMessages(consumerType)
						.Select(messageType => new MessageMapping(consumerType, messageType, true)))
				.ToArray();

			var result = new HashSet<MessageMapping>();

			foreach (var m in consumingDirectly)
			{
				result.Add(m);
			}
			var allMessages = result.Select(m => m.Message).ToList();
			foreach (var messageType in messageTypes)
			{
				if (!allMessages.Contains(messageType))
				{
					allMessages.Add(messageType);
					result.Add(new MessageMapping(typeof(MessageMapping.BusNull), messageType, true));
				}
			}

			_consumerInfos = result
				.GroupBy(x => x.Consumer)
				.Select(x =>
				{
					var directs = x
						.Where(m => m.Direct)
						.Select(m => m.Message)
						.Distinct();

					var assignables = x
						.Select(m => m.Message)
						.Where(t => directs.Any(d => d.IsAssignableFrom(t)))
						.Distinct();

					return new ConsumerInfo(x.Key, assignables.ToArray());
				}).ToList();


			_messageInfos = result
				.ToLookup(x => x.Message)
				.Select(x =>
				{
					var domainConsumers = x
						.Where(t => t.Consumer != typeof(MessageMapping.BusNull))
						.ToArray();

					return new MessageInfo
					{
						MessageType = x.Key,
						AllConsumers = domainConsumers.Select(m => m.Consumer).Distinct().ToArray(),
						DerivedConsumers = domainConsumers.Where(m => !m.Direct).Select(m => m.Consumer).Distinct().ToArray(),
						DirectConsumers = domainConsumers.Where(m => m.Direct).Select(m => m.Consumer).Distinct().ToArray(),
					};
				}).ToList();

			var includedTypes = _messageInfos
				.Select(m => m.MessageType).ToList();

			// message directory should still include all messages for the serializers
			var orphanedMessages = result
				.Where(m => !includedTypes.Contains(m.Message))
				.Select(m => new MessageInfo
				{
					MessageType = m.Message,
					AllConsumers = Type.EmptyTypes,
					DerivedConsumers = Type.EmptyTypes,
					DirectConsumers = Type.EmptyTypes
				});

			_messageInfos.AddRange(orphanedMessages);


		}
Example #14
0
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var pureLinks   = ((IList <Link>)value).Where(q => q.GetType() != typeof(Curie)).ToList();
            var curies      = ((IList <Link>)value).Where(q => q.GetType() == typeof(Curie)).ToList();
            var links       = new HashSet <Link>(pureLinks, new LinkEqualityComparer());
            var curiedLinks = new HashSet <Link>(curies, new LinkEqualityComparer());
            var lookup      = links.ToLookup(l => l.Rel);

            if (lookup.Count == 0)
            {
                return;
            }


            writer.WriteStartObject();
            bool hasCuries = curiedLinks.Count > 0;

            if (hasCuries && !EmbeddedResourceConverter.IsEmbeddedResourceConverterContext(serializer.Context))
            {
                writer.WritePropertyName("curies");
                writer.WriteStartArray();

                foreach (var rel in curiedLinks)
                {
                    var curie = rel as Curie;
                    WriteCurie(writer, curie);
                }

                writer.WriteEndArray();
            }

            foreach (var rel in lookup)
            {
                writer.WritePropertyName(rel.Key);
                if (rel.Count() > 1)
                {
                    writer.WriteStartArray();
                }
                foreach (var link in rel)
                {
                    writer.WriteStartObject();
                    writer.WritePropertyName("href");
                    writer.WriteValue(ResolveUri(link.Href));

                    if (link.IsTemplated)
                    {
                        writer.WritePropertyName("templated");
                        writer.WriteValue(true);
                    }
                    WriteIfNotNullOrEmpty(writer, link.Title, "title");
                    WriteIfNotNullOrEmpty(writer, link.Profile, "profile");
                    WriteIfNotNullOrEmpty(writer, link.Type, "type");


                    writer.WriteEndObject();
                }
                if (rel.Count() > 1)
                {
                    writer.WriteEndArray();
                }
            }
            writer.WriteEndObject();
        }
        public void NamespaceCasingConsistent()
        {
            var nameSpaces = new HashSet<string>();

            foreach (var type in Types)
            {
                nameSpaces.Add(type.Namespace);
                for (int i = 0; i < type.Namespace.Length; i++)
                {
                    if (type.Namespace[i] == '.')
                    {
                        nameSpaces.Add(type.Namespace.Substring(0, i));
                    }
                }

                foreach (var g in nameSpaces.ToLookup(s => s.ToUpperInvariant()))
                {
                    if (g.Count() > 1)
                    {
                        throw new Exception(string.Format("Found many casings {0}: {1}", g.Key, string.Join(",", g)));
                    }
                }
            }
        }
Example #16
0
 public void Remove(bool prompt)
 {
     var selectedViewNames = new HashSet<ViewName>(chooseViewsControl1.SelectedViews);
     if (selectedViewNames.Count == 0)
     {
         return;
     }
     string message;
     if (selectedViewNames.Count == 1)
     {
         message = string.Format(Resources.ManageViewsForm_BtnRemoveOnClick_Are_you_sure_you_want_to_delete_the_view___0___, selectedViewNames.First().Name);
     }
     else
     {
         message = string.Format(Resources.ManageViewsForm_BtnRemoveOnClick_Are_you_sure_you_want_to_delete_these__0__views_, selectedViewNames.Count);
     }
     if (prompt && ViewContext.ShowMessageBox(this, message, MessageBoxButtons.OKCancel) == DialogResult.Cancel)
     {
         return;
     }
     var namesByGroup = selectedViewNames.ToLookup(name => name.GroupId, name => name.Name);
     foreach (var grouping in namesByGroup)
     {
         ViewContext.DeleteViews(grouping.Key, grouping);
     }
     
 }
Example #17
0
        private void Initialize()
        {
            if (null == _consumingMethod)
            {
                throw new InvalidOperationException("Consuming method has not been defined");
            }

            if (!_assemblies.Any())
            {
                throw new InvalidOperationException("There are no assemblies to scan");
            }

            var types = _assemblies
                        .SelectMany(a => {
                try
                {
                    return(a.GetExportedTypes());
                } catch {}
                return(new Type[0]);
            }).Where(x => x != null)
                        .ToList();

            var messageTypes  = types.Where(x => !x.IsInterface && typeof(IMessage).IsAssignableFrom(x)).ToArray();
            var consumerTypes = types.Where(x => typeof(IConsume).IsAssignableFrom(x)).ToArray();

            var consumingDirectly = consumerTypes
                                    .SelectMany(consumerType =>
                                                GetConsumedMessages(consumerType)
                                                .Select(messageType => new MessageMapping(consumerType, messageType, true)))
                                    .ToArray();

            var result = new HashSet <MessageMapping>();

            foreach (var m in consumingDirectly)
            {
                result.Add(m);
            }
            var allMessages = result.Select(m => m.Message).ToList();

            foreach (var messageType in messageTypes)
            {
                if (!allMessages.Contains(messageType))
                {
                    allMessages.Add(messageType);
                    result.Add(new MessageMapping(typeof(MessageMapping.BusNull), messageType, true));
                }
            }

            _consumerInfos = result
                             .GroupBy(x => x.Consumer)
                             .Select(x =>
            {
                var directs = x
                              .Where(m => m.Direct)
                              .Select(m => m.Message)
                              .Distinct();

                var assignables = x
                                  .Select(m => m.Message)
                                  .Where(t => directs.Any(d => d.IsAssignableFrom(t)))
                                  .Distinct();

                return(new ConsumerInfo(x.Key, assignables.ToArray()));
            }).ToList();


            _messageInfos = result
                            .ToLookup(x => x.Message)
                            .Select(x =>
            {
                var domainConsumers = x
                                      .Where(t => t.Consumer != typeof(MessageMapping.BusNull))
                                      .ToArray();

                return(new MessageInfo
                {
                    MessageType = x.Key,
                    AllConsumers = domainConsumers.Select(m => m.Consumer).Distinct().ToArray(),
                    DerivedConsumers = domainConsumers.Where(m => !m.Direct).Select(m => m.Consumer).Distinct().ToArray(),
                    DirectConsumers = domainConsumers.Where(m => m.Direct).Select(m => m.Consumer).Distinct().ToArray(),
                });
            }).ToList();

            var includedTypes = _messageInfos
                                .Select(m => m.MessageType).ToList();

            // message directory should still include all messages for the serializers
            var orphanedMessages = result
                                   .Where(m => !includedTypes.Contains(m.Message))
                                   .Select(m => new MessageInfo
            {
                MessageType      = m.Message,
                AllConsumers     = Type.EmptyTypes,
                DerivedConsumers = Type.EmptyTypes,
                DirectConsumers  = Type.EmptyTypes
            });

            _messageInfos.AddRange(orphanedMessages);
        }
Example #18
-1
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            var links = new HashSet<Link>((IList<Link>)value, Link.EqualityComparer);
            var lookup = links.ToLookup(l => l.Rel);
            
            if (lookup.Count == 0) 
                return;

            writer.WriteStartObject();

            foreach (var rel in lookup)
            {
                var count = rel.Count();

                writer.WritePropertyName(rel.Key);
                
                if ((count > 1) || (rel.Key == Link.RelForCuries))
                    writer.WriteStartArray();

                foreach (var link in rel)
                    WriteLink(writer, link);

                if ((count > 1) || (rel.Key == Link.RelForCuries))
                    writer.WriteEndArray();
            }

            writer.WriteEndObject();
        }