/// <summary>
 /// Initializes a new instance of the <see cref="SealedListCollectionSourceTemplate{TSource, TItem, TValue}"/> class.
 /// </summary>
 /// <param name="path">Path to the source object.</param>
 /// <param name="propertyName">The name of the <see cref="ISealableList{TValue}"/> property to check in each items of the list.</param>
 /// <param name="startingPoint">The starting point for the path.</param>
 public SealedListCollectionSourceTemplate(string path, string propertyName, ITemplatePathStart <TSource> startingPoint = null)
     : base(path, startingPoint)
 {
     ItemProperty = BaseNodeHelper.NodeTreeHelper.GetPropertyOf(typeof(TItem), propertyName);
     Debug.Assert(ItemProperty != null);
     Debug.Assert(ItemProperty.PropertyType.GetInterface(typeof(ISealableList).Name) != null);
 }
예제 #2
0
        /// <summary>
        /// Initializes a new instance of the <see cref="SourceTemplate{TSource, TValue}"/> class.
        /// </summary>
        /// <param name="path">Path to the source object.</param>
        /// <param name="startingPoint">The starting point for the path.</param>
        public SourceTemplate(string path, ITemplatePathStart <TSource> startingPoint = null)
        {
            Path          = path;
            StartingPoint = startingPoint ?? TemplateNodeStart <TSource> .Default;

            List <PropertyInfo> PropertyPath = new List <PropertyInfo>();

            TemplateHelper.BuildPropertyPath(StartingPoint.PropertyType, path, PropertyPath);

            this.PropertyPath = PropertyPath.AsReadOnly();
        }
예제 #3
0
        /// <summary>
        /// Gets the current value at the end of a property path.
        /// </summary>
        /// <typeparam name="TSource">Type of the source.</typeparam>
        /// <typeparam name="TValue">Type of the result.</typeparam>
        /// <param name="source">The node for which the value is requested.</param>
        /// <param name="startingPoint">The starting point to use.</param>
        /// <param name="propertyPath">Path from the starting point to the value to read.</param>
        /// <param name="isInterrupted">True is progressing through the path was interrupted.</param>
        public static TValue GetPropertyPathValue <TSource, TValue>(TSource source, ITemplatePathStart <TSource> startingPoint, IReadOnlyList <PropertyInfo> propertyPath, out bool isInterrupted)
            where TSource : ISource
        {
            isInterrupted = true;
            object IntermediateResult = startingPoint.GetStart(source);

#if DEBUG_ENGINE
            try
            {
#endif
            for (int i = 0; i < propertyPath.Count; i++)
            {
                if (IntermediateResult is IOnceReference AsOnceReference)
                {
                    if (!AsOnceReference.IsAssigned)
                    {
                        isInterrupted = true;
                        return(default);
예제 #4
0
 /// <summary>
 /// Initializes a new instance of the <see cref="ConditionallyAssignedSealedTableSourceTemplate{TSource, TRef, TKey, TValue}"/> class.
 /// </summary>
 /// <param name="path">Path to the <see cref="IOptionalReference{TRef}"/> in the source object.</param>
 /// <param name="propertyName">The name of the <see cref="ISealableDictionary{TKey, TValue}"/> property to check in the optional node.</param>
 /// <param name="startingPoint">The starting point for the path.</param>
 public ConditionallyAssignedSealedTableSourceTemplate(string path, string propertyName, ITemplatePathStart <TSource> startingPoint = null)
     : base(path, startingPoint)
 {
     ItemProperty = BaseNodeHelper.NodeTreeHelper.GetPropertyOf(typeof(TRef), propertyName);
     Debug.Assert(ItemProperty != null);
     Debug.Assert(ItemProperty.PropertyType.GetInterface(typeof(ISealableDictionary).Name) != null);
 }
예제 #5
0
        private bool FindRuleWithDestination(ICollection <IRuleTemplate> ruleTemplateList, IList <ISource> unresolvedSourceList, string path, Type type, ITemplatePathStart startingPoint, out IRuleTemplate matchingRule)
        {
            matchingRule = null;

            foreach (IRuleTemplate Rule in ruleTemplateList)
            {
                foreach (ISource Source in unresolvedSourceList)
                {
                    if (!Rule.NodeType.IsAssignableFrom(Source.GetType()))
                    {
                        continue;
                    }

                    IList <IDestinationTemplate> DestinationTemplateList = Rule.GetAllDestinationTemplatesNotSet(Source);
                    foreach (IDestinationTemplate DestinationTemplate in DestinationTemplateList)
                    {
                        if (DestinationTemplate.Path == path && DestinationTemplate.StartingPoint == startingPoint)
                        {
                            if (DestinationTemplate.DestinationType == type)
                            {
                                matchingRule = Rule;
                                return(true);
                            }
                        }
                    }
                }
            }

            return(false);
        }
예제 #6
0
        private void ListDependencies(IList <ISource> unresolvedSourceList)
        {
            Debug.WriteLine("Performing cyclic dependencies analysis...");

            Dictionary <IRuleTemplate, IList <ISource> > Analysis = new Dictionary <IRuleTemplate, IList <ISource> >();

            foreach (IRuleTemplate Rule in RuleTemplateList)
            {
                /*if (Rule is IConstraintRuleTemplate AsRuleTemplate)
                 * {
                 *
                 * }*/

                foreach (ISource Source in unresolvedSourceList)
                {
                    if (!Rule.NodeType.IsAssignableFrom(Source.GetType()))
                    {
                        continue;
                    }

                    bool IsNoDestinationSet = Rule.IsNoDestinationSet(Source);
                    if (IsNoDestinationSet)
                    {
                        bool AreAllSourcesReady = Rule.AreAllSourcesReady(Source, out IDictionary <ISourceTemplate, object> DataList);
                        if (!AreAllSourcesReady)
                        {
                            IList <ISourceTemplate> SourceTemplateList = Rule.GetAllSourceTemplatesNotReady(Source);
                            Debug.Assert(SourceTemplateList.Count > 0);

                            if (!Analysis.ContainsKey(Rule))
                            {
                                Analysis.Add(Rule, new List <ISource>());
                            }
                            Analysis[Rule].Add(Source);
                        }
                    }
                }
            }

            bool Exit;

            do
            {
                ICollection <IRuleTemplate> Rules    = Analysis.Keys;
                IList <IRuleTemplate>       ToRemove = new List <IRuleTemplate>();

                foreach (KeyValuePair <IRuleTemplate, IList <ISource> > Entry in Analysis)
                {
                    IRuleTemplate   Rule       = Entry.Key;
                    IList <ISource> SourceList = Entry.Value;
                    Debug.Assert(SourceList.Count > 0);

                    foreach (ISource Source in SourceList)
                    {
                        IList <ISourceTemplate> SourceTemplateList = Rule.GetAllSourceTemplatesNotReady(Source);
                        Debug.Assert(SourceTemplateList.Count > 0);

                        foreach (ISourceTemplate SourceTemplate in SourceTemplateList)
                        {
                            string             Path          = SourceTemplate.Path;
                            Type               SourceType    = SourceTemplate.SourceType;
                            ITemplatePathStart StartingPoint = SourceTemplate.StartingPoint;

                            if (FindRuleWithDestination(Rules, unresolvedSourceList, Path, SourceType, StartingPoint, out IRuleTemplate MatchingRule))
                            {
                                if (!ToRemove.Contains(Rule))
                                {
                                    ToRemove.Add(Rule);
                                }
                            }
                        }
                    }
                }

                foreach (IRuleTemplate Rule in ToRemove)
                {
                    Analysis.Remove(Rule);
                }

                Exit = ToRemove.Count == 0;
            }while (!Exit);

            Debug.WriteLine($"{Analysis.Count} rule(s) are waiting on a source template:");
            foreach (KeyValuePair <IRuleTemplate, IList <ISource> > Entry in Analysis)
            {
                Debug.WriteLine($"{Entry.Key} on {Entry.Value.Count} node(s)");
            }
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="SealedListSourceTemplate{TSource, TValue}"/> class.
 /// </summary>
 /// <param name="path">Path to the source object.</param>
 /// <param name="startingPoint">The starting point for the path.</param>
 public SealedListSourceTemplate(string path, ITemplatePathStart <TSource> startingPoint = null)
     : base(path, startingPoint)
 {
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="OnceReferenceTableSourceTemplate{TSource, TKey, TValue, TRef}"/> class.
 /// </summary>
 /// <param name="path">Path to the source object.</param>
 /// <param name="propertyName">The name of the <see cref="OnceReference{TRef}"/> property to check in each item of the list.</param>
 /// <param name="startingPoint">The starting point for the path.</param>
 public OnceReferenceTableSourceTemplate(string path, string propertyName, ITemplatePathStart <TSource> startingPoint = null)
     : base(path, startingPoint)
 {
     ItemProperty = BaseNodeHelper.NodeTreeHelper.GetPropertyOf(typeof(TValue), propertyName);
     Debug.Assert(ItemProperty != null);
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="UnsealedTableDestinationTemplate{TSource, TKey, TValue}"/> class.
 /// </summary>
 /// <param name="path">Path to the destination object.</param>
 /// <param name="startingPoint">The starting point for the path.</param>
 public UnsealedTableDestinationTemplate(string path, ITemplatePathStart <TSource> startingPoint = null)
     : base(path, startingPoint)
 {
 }
예제 #10
0
 /// <summary>
 /// Initializes a new instance of the <see cref="ResolvedPathSourceTemplate{TSource}"/> class.
 /// </summary>
 /// <param name="path">Path to the source object.</param>
 /// <param name="startingPoint">The starting point for the path.</param>
 public ResolvedPathSourceTemplate(string path, ITemplatePathStart <TSource> startingPoint = null)
     : base(path, startingPoint)
 {
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="OnceReferenceSourceTemplate{TSource, TRef}"/> class.
 /// </summary>
 /// <param name="path">Path to the source object.</param>
 /// <param name="startingPoint">The starting point for the path.</param>
 public OnceReferenceSourceTemplate(string path, ITemplatePathStart <TSource> startingPoint = null)
     : base(path, startingPoint)
 {
 }