Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

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

@@ -0,0 +1,498 @@
+using System;
+using System.Collections;
+using System.Collections.Specialized;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.ComponentModel.Design;
+using System.ComponentModel.Design.Serialization;
+using System.Diagnostics;
+using System.Globalization;
+using System.Workflow.ComponentModel;
+using System.Workflow.ComponentModel.Design;
+using System.Workflow.ComponentModel.Compiler;
+using System.Workflow.ComponentModel.Serialization;
+
+namespace System.Workflow.Activities.Rules
+{
+    #region ConditionChangeAction
+    [DesignerSerializer(typeof(WorkflowMarkupSerializer), typeof(WorkflowMarkupSerializer))]
+    public abstract class RuleConditionChangeAction : WorkflowChangeAction
+    {
+        public abstract string ConditionName { get; }
+
+        protected override ValidationErrorCollection ValidateChanges(Activity activity)
+        {
+            // No validations required.
+            return new ValidationErrorCollection();
+        }
+    }
+    #endregion
+
+    #region RuleSetChangeAction
+    [DesignerSerializer(typeof(WorkflowMarkupSerializer), typeof(WorkflowMarkupSerializer))]
+    public abstract class RuleSetChangeAction : WorkflowChangeAction
+    {
+        public abstract string RuleSetName { get; }
+
+        protected override ValidationErrorCollection ValidateChanges(Activity activity)
+        {
+            // No validations can be done since we don't know the context the policy 
+            // will execute in (i.e. no idea what the "this" object will be)
+            return new ValidationErrorCollection();
+        }
+    }
+    #endregion
+
+    #region AddedConditionAction
+    public sealed class AddedConditionAction : RuleConditionChangeAction
+    {
+        private RuleCondition _conditionDefinition;
+
+        public AddedConditionAction(RuleCondition addedConditionDefinition)
+        {
+            if (null == addedConditionDefinition)
+                throw new ArgumentNullException("addedConditionDefinition");
+
+            _conditionDefinition = addedConditionDefinition;
+        }
+
+        public AddedConditionAction()
+        {
+        }
+
+        public override string ConditionName
+        {
+            get { return _conditionDefinition.Name; }
+        }
+
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
+        public RuleCondition ConditionDefinition
+        {
+            get
+            {
+                return this._conditionDefinition;
+            }
+            set
+            {
+                if (null == value)
+                    throw new ArgumentNullException("value");
+
+                this._conditionDefinition = value;
+            }
+        }
+
+        protected override bool ApplyTo(Activity rootActivity)
+        {
+            if (rootActivity == null)
+                return false;
+
+            RuleDefinitions rules = rootActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
+            if (rules == null)
+            {
+                rules = new RuleDefinitions();
+                ((Activity)rootActivity).SetValue(RuleDefinitions.RuleDefinitionsProperty, rules);
+            }
+
+            // 
+            bool setRuntimeMode = false;
+            if (rules.Conditions.RuntimeMode)
+            {
+                rules.Conditions.RuntimeMode = false;
+                setRuntimeMode = true;
+            }
+            try
+            {
+                rules.Conditions.Add(this.ConditionDefinition);
+            }
+            finally
+            {
+                if (setRuntimeMode)
+                    rules.Conditions.RuntimeMode = true;
+            }
+            return true;
+        }
+    }
+    #endregion
+
+    #region RemovedConditionAction
+    public sealed class RemovedConditionAction : RuleConditionChangeAction
+    {
+        private RuleCondition _conditionDefinition;
+
+        public RemovedConditionAction(RuleCondition removedConditionDefinition)
+        {
+            if (null == removedConditionDefinition)
+                throw new ArgumentNullException("removedConditionDefinition");
+
+            _conditionDefinition = removedConditionDefinition;
+        }
+        public RemovedConditionAction()
+        {
+        }
+
+        public override string ConditionName
+        {
+            get { return _conditionDefinition.Name; }
+        }
+
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
+        public RuleCondition ConditionDefinition
+        {
+            get
+            {
+                return this._conditionDefinition;
+            }
+            set
+            {
+                if (null == value)
+                    throw new ArgumentNullException("value");
+
+                this._conditionDefinition = value;
+            }
+        }
+
+        protected override bool ApplyTo(Activity rootActivity)
+        {
+
+            if (rootActivity == null)
+                return false;
+
+            RuleDefinitions rules = rootActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
+            if (rules == null || rules.Conditions == null)
+                return false;
+
+            // 
+            bool setRuntimeMode = false;
+            if (rules.Conditions.RuntimeMode)
+            {
+                rules.Conditions.RuntimeMode = false;
+                setRuntimeMode = true;
+            }
+            try
+            {
+                return rules.Conditions.Remove(this.ConditionDefinition.Name);
+            }
+            finally
+            {
+                if (setRuntimeMode)
+                    rules.Conditions.RuntimeMode = true;
+            }
+        }
+    }
+    #endregion
+
+    #region UpdatedConditionAction
+    public sealed class UpdatedConditionAction : RuleConditionChangeAction
+    {
+        private RuleCondition _conditionDefinition;
+        private RuleCondition _newConditionDefinition;
+
+        public UpdatedConditionAction(RuleCondition conditionDefinition, RuleCondition newConditionDefinition)
+        {
+            if (null == conditionDefinition)
+                throw new ArgumentNullException("conditionDefinition");
+            if (null == newConditionDefinition)
+                throw new ArgumentNullException("newConditionDefinition");
+
+            if (newConditionDefinition.Name != conditionDefinition.Name)
+            {
+                string message = string.Format(CultureInfo.CurrentCulture, Messages.ConditionNameNotIdentical, newConditionDefinition.Name, conditionDefinition.Name);
+                throw new ArgumentException(message);
+            }
+
+            _conditionDefinition = conditionDefinition;
+            _newConditionDefinition = newConditionDefinition;
+        }
+        public UpdatedConditionAction()
+        {
+        }
+
+        public override string ConditionName
+        {
+            get { return _conditionDefinition.Name; }
+        }
+
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
+        public RuleCondition ConditionDefinition
+        {
+            get
+            {
+                return this._conditionDefinition;
+            }
+            set
+            {
+                if (null == value)
+                    throw new ArgumentNullException("value");
+
+                this._conditionDefinition = value;
+            }
+        }
+
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
+        public RuleCondition NewConditionDefinition
+        {
+            get
+            {
+                return this._newConditionDefinition;
+            }
+            set
+            {
+                if (null == value)
+                    throw new ArgumentNullException("value");
+
+                this._newConditionDefinition = value;
+            }
+        }
+
+        protected override bool ApplyTo(Activity rootActivity)
+        {
+            if (rootActivity == null)
+                return false;
+
+            RuleDefinitions rules = rootActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
+            if (rules == null || rules.Conditions == null)
+                return false;
+
+            if (rules.Conditions[this.ConditionDefinition.Name] == null)
+                return false;
+
+            // 
+            bool setRuntimeMode = false;
+            if (rules.Conditions.RuntimeMode)
+            {
+                rules.Conditions.RuntimeMode = false;
+                setRuntimeMode = true;
+            }
+            try
+            {
+                rules.Conditions.Remove(this.ConditionDefinition.Name);
+                rules.Conditions.Add(this.NewConditionDefinition);
+            }
+            finally
+            {
+                if (setRuntimeMode)
+                    rules.Conditions.RuntimeMode = true;
+            }
+            return true;
+        }
+    }
+    #endregion
+
+    #region AddedRuleSetAction
+    public sealed class AddedRuleSetAction : RuleSetChangeAction
+    {
+        private RuleSet ruleset;
+
+        public AddedRuleSetAction(RuleSet addedRuleSetDefinition)
+        {
+            if (addedRuleSetDefinition == null)
+                throw new ArgumentNullException("addedRuleSetDefinition");
+            ruleset = addedRuleSetDefinition;
+        }
+
+        public AddedRuleSetAction()
+        {
+        }
+
+        public override string RuleSetName
+        {
+            get { return ruleset.Name; }
+        }
+
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
+        public RuleSet RuleSetDefinition
+        {
+            get { return ruleset; }
+            set
+            {
+                if (null == value)
+                    throw new ArgumentNullException("value");
+                ruleset = value;
+            }
+        }
+
+        protected override bool ApplyTo(Activity rootActivity)
+        {
+            if (rootActivity == null)
+                return false;
+
+            RuleDefinitions rules = rootActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
+            if (rules == null)
+            {
+                rules = new RuleDefinitions();
+                ((Activity)rootActivity).SetValue(RuleDefinitions.RuleDefinitionsProperty, rules);
+            }
+
+            // 
+            bool setRuntimeMode = false;
+            if (rules.RuleSets.RuntimeMode)
+            {
+                rules.RuleSets.RuntimeMode = false;
+                setRuntimeMode = true;
+            }
+            try
+            {
+                rules.RuleSets.Add(ruleset);
+            }
+            finally
+            {
+                if (setRuntimeMode)
+                    rules.RuleSets.RuntimeMode = true;
+            }
+            return true;
+        }
+    }
+    #endregion
+
+    #region RemovedRuleSetAction
+    public sealed class RemovedRuleSetAction : RuleSetChangeAction
+    {
+        private RuleSet ruleset;
+
+        public RemovedRuleSetAction(RuleSet removedRuleSetDefinition)
+        {
+            if (removedRuleSetDefinition == null)
+                throw new ArgumentNullException("removedRuleSetDefinition");
+            ruleset = removedRuleSetDefinition;
+        }
+
+        public RemovedRuleSetAction()
+        {
+        }
+
+        public override string RuleSetName
+        {
+            get { return ruleset.Name; }
+        }
+
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
+        public RuleSet RuleSetDefinition
+        {
+            get { return ruleset; }
+            set
+            {
+                if (null == value)
+                    throw new ArgumentNullException("value");
+                ruleset = value;
+            }
+        }
+
+        protected override bool ApplyTo(Activity rootActivity)
+        {
+
+            if (rootActivity == null)
+                return false;
+
+            RuleDefinitions rules = rootActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
+            if (rules == null || rules.RuleSets == null)
+                return false;
+
+            // 
+            bool setRuntimeMode = false;
+            if (rules.RuleSets.RuntimeMode)
+            {
+                rules.RuleSets.RuntimeMode = false;
+                setRuntimeMode = true;
+            }
+            try
+            {
+                return rules.RuleSets.Remove(ruleset.Name);
+            }
+            finally
+            {
+                if (setRuntimeMode)
+                    rules.RuleSets.RuntimeMode = true;
+            }
+        }
+    }
+    #endregion
+
+    #region UpdatedRuleSetAction
+    public sealed class UpdatedRuleSetAction : RuleSetChangeAction
+    {
+        private RuleSet original;
+        private RuleSet updated;
+
+        public UpdatedRuleSetAction(RuleSet originalRuleSetDefinition, RuleSet updatedRuleSetDefinition)
+        {
+            if (originalRuleSetDefinition == null)
+                throw new ArgumentNullException("originalRuleSetDefinition");
+            if (updatedRuleSetDefinition == null)
+                throw new ArgumentNullException("updatedRuleSetDefinition");
+
+            if (originalRuleSetDefinition.Name != updatedRuleSetDefinition.Name)
+            {
+                string message = string.Format(CultureInfo.CurrentCulture, Messages.ConditionNameNotIdentical, originalRuleSetDefinition.Name, updatedRuleSetDefinition.Name);
+                throw new ArgumentException(message);
+            }
+            original = originalRuleSetDefinition;
+            updated = updatedRuleSetDefinition;
+        }
+
+        public UpdatedRuleSetAction()
+        {
+        }
+
+        public override string RuleSetName
+        {
+            get { return original.Name; }
+        }
+
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
+        public RuleSet OriginalRuleSetDefinition
+        {
+            get { return original; }
+            set
+            {
+                if (null == value)
+                    throw new ArgumentNullException("value");
+                original = value;
+            }
+        }
+
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
+        public RuleSet UpdatedRuleSetDefinition
+        {
+            get { return updated; }
+            set
+            {
+                if (null == value)
+                    throw new ArgumentNullException("value");
+                updated = value;
+            }
+        }
+
+        protected override bool ApplyTo(Activity rootActivity)
+        {
+            if (rootActivity == null)
+                return false;
+
+            RuleDefinitions rules = rootActivity.GetValue(RuleDefinitions.RuleDefinitionsProperty) as RuleDefinitions;
+            if (rules == null || rules.RuleSets == null)
+                return false;
+
+            if (rules.RuleSets[RuleSetName] == null)
+                return false;
+
+            // 
+            bool setRuntimeMode = false;
+            if (rules.Conditions.RuntimeMode)
+            {
+                rules.Conditions.RuntimeMode = false;
+                setRuntimeMode = true;
+            }
+            try
+            {
+                rules.RuleSets.Remove(RuleSetName);
+                rules.RuleSets.Add(updated);
+            }
+            finally
+            {
+                if (setRuntimeMode)
+                    rules.RuleSets.RuntimeMode = true;
+            }
+            return true;
+        }
+    }
+    #endregion
+}