Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Workflow.Activities/Rules/RuleDefinitions.cs

@@ -0,0 +1,127 @@
+// ---------------------------------------------------------------------------
+// Copyright (C) 2006 Microsoft Corporation All Rights Reserved
+// ---------------------------------------------------------------------------
+
+#define CODE_ANALYSIS
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Workflow.ComponentModel;
+
+namespace System.Workflow.Activities.Rules
+{
+    #region class RuleDefinitions
+
+    public sealed class RuleDefinitions : IWorkflowChangeDiff
+    {
+
+        [SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]
+        public static readonly DependencyProperty RuleDefinitionsProperty = DependencyProperty.RegisterAttached("RuleDefinitions", typeof(RuleDefinitions), typeof(RuleDefinitions), new PropertyMetadata(null, DependencyPropertyOptions.Metadata, new GetValueOverride(OnGetRuleConditions), null, new Attribute[] { new DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden) }));
+
+        private RuleConditionCollection conditions;
+        private RuleSetCollection ruleSets;
+        private bool runtimeInitialized;
+        [NonSerialized]
+        private object syncLock = new object();
+
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
+        public RuleConditionCollection Conditions
+        {
+            get
+            {
+                if (this.conditions == null)
+                    this.conditions = new RuleConditionCollection();
+                return conditions;
+            }
+        }
+
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
+        public RuleSetCollection RuleSets
+        {
+            get
+            {
+                if (this.ruleSets == null)
+                    this.ruleSets = new RuleSetCollection();
+                return this.ruleSets;
+            }
+        }
+
+        internal static object OnGetRuleConditions(DependencyObject dependencyObject)
+        {
+            if (dependencyObject == null)
+                throw new ArgumentNullException("dependencyObject");
+
+            RuleDefinitions rules = dependencyObject.GetValueBase(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
+            if (rules != null)
+                return rules;
+
+            Activity rootActivity = dependencyObject as Activity;
+            if (rootActivity.Parent == null)
+            {
+                rules = ConditionHelper.GetRuleDefinitionsFromManifest(rootActivity.GetType());
+                if (rules != null)
+                    dependencyObject.SetValue(RuleDefinitions.RuleDefinitionsProperty, rules);
+            }
+            return rules;
+        }
+
+        internal void OnRuntimeInitialized()
+        {
+            lock (syncLock)
+            {
+                if (runtimeInitialized)
+                    return;
+                Conditions.OnRuntimeInitialized();
+                RuleSets.OnRuntimeInitialized();
+                runtimeInitialized = true;
+            }
+        }
+
+        #region IWorkflowChangeDiff Members
+
+        public IList<WorkflowChangeAction> Diff(object originalDefinition, object changedDefinition)
+        {
+            RuleDefinitions originalRules = originalDefinition as RuleDefinitions;
+            RuleDefinitions changedRules = changedDefinition as RuleDefinitions;
+            if ((originalRules == null) || (changedRules == null))
+                return new List<WorkflowChangeAction>();
+
+            IList<WorkflowChangeAction> cdiff = Conditions.Diff(originalRules.Conditions, changedRules.Conditions);
+            IList<WorkflowChangeAction> rdiff = RuleSets.Diff(originalRules.RuleSets, changedRules.RuleSets);
+
+            // quick optimization -- if no condition changes, simply return the ruleset changes
+            if (cdiff.Count == 0)
+                return rdiff;
+
+            // merge ruleset changes into condition changes
+            for (int i = 0; i < rdiff.Count; ++i)
+            {
+                cdiff.Add(rdiff[i]);
+            }
+            return cdiff;
+        }
+        #endregion
+
+        internal RuleDefinitions Clone()
+        {
+            RuleDefinitions newRuleDefinitions = new RuleDefinitions();
+
+            if (this.ruleSets != null)
+            {
+                newRuleDefinitions.ruleSets = new RuleSetCollection();
+                foreach (RuleSet r in this.ruleSets)
+                    newRuleDefinitions.ruleSets.Add(r.Clone());
+            }
+
+            if (this.conditions != null)
+            {
+                newRuleDefinitions.conditions = new RuleConditionCollection();
+                foreach (RuleCondition r in this.conditions)
+                    newRuleDefinitions.conditions.Add(r.Clone());
+            }
+
+            return newRuleDefinitions;
+        }
+    }
+    #endregion
+}