// <copyright>
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
namespace System.Activities.DynamicUpdate
{
using System;
using System.Activities.DynamicUpdate;
using System.Activities.Validation;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Runtime;
using System.Runtime.CompilerServices;
public class DynamicUpdateMapBuilder
{
private HashSet<Activity> disallowUpdateInside;
public DynamicUpdateMapBuilder()
{
}
public bool ForImplementation
{
get;
set;
}
public ISet<Activity> DisallowUpdateInside
{
get
{
if (this.disallowUpdateInside == null)
{
this.disallowUpdateInside = new HashSet<Activity>(ReferenceEqualityComparer.Instance);
}
return this.disallowUpdateInside;
}
}
public Func<object, DynamicUpdateMapItem> LookupMapItem
{
get;
set;
}
public Func<Activity, DynamicUpdateMap> LookupImplementationMap
{
get;
set;
}
public LocationReferenceEnvironment UpdatedEnvironment
{
get;
set;
}
public Activity UpdatedWorkflowDefinition
{
get;
set;
}
public LocationReferenceEnvironment OriginalEnvironment
{
get;
set;
}
public Activity OriginalWorkflowDefinition
{
get;
set;
}
// Internal hook to allow DynamicUpdateServices to surface a customized error message when
// there is an invalid activity in the disallowUpdateInsideActivities list
internal Func<Activity, Exception> OnInvalidActivityToBlockUpdate
{
get;
set;
}
// Internal hook to allow DynamicUpdateServices to surface a customized error message when
// there is an invalid activity in the disallowUpdateInsideActivities list
internal Func<Activity, Exception> OnInvalidImplementationMapAssociation
{
get;
set;
}
public DynamicUpdateMap CreateMap()
{
IList<ActivityBlockingUpdate> activitiesBlockingUpdate;
return CreateMap(out activitiesBlockingUpdate);
}
[SuppressMessage(FxCop.Category.Design, FxCop.Rule.AvoidOutParameters, Justification = "Approved Design. Need to return the map and the block list.")]
public DynamicUpdateMap CreateMap(out IList<ActivityBlockingUpdate> activitiesBlockingUpdate)
{
RequireProperty(this.LookupMapItem, "LookupMapItem");
RequireProperty(this.UpdatedWorkflowDefinition, "UpdatedWorkflowDefinition");
RequireProperty(this.OriginalWorkflowDefinition, "OriginalWorkflowDefinition");
Finalizer finalizer = new Finalizer(this);
DynamicUpdateMap result = finalizer.FinalizeUpdate(out activitiesBlockingUpdate);
return result;
}
private static void CacheMetadata(Activity workflowDefinition, LocationReferenceEnvironment environment, ActivityUtilities.ProcessActivityCallback callback, bool forImplementation)
{
IList<ValidationError> validationErrors = null;
ActivityUtilities.CacheRootMetadata(workflowDefinition, environment, ProcessTreeOptions(forImplementation), callback, ref validationErrors);
ActivityValidationServices.ThrowIfViolationsExist(validationErrors);
}
static DynamicUpdateMapEntry GetParentEntry(Activity originalActivity, DynamicUpdateMap updateMap)
{
if (originalActivity.Parent != null && originalActivity.Parent.MemberOf == originalActivity.MemberOf)
{
DynamicUpdateMapEntry parentEntry;
updateMap.TryGetUpdateEntry(originalActivity.Parent.InternalId, out parentEntry);
Fx.Assert(parentEntry != null, "We process in IdSpace order, so we always process parents before their children");
return parentEntry;
}
return null;
}
static IEnumerable<Activity> GetPublicDeclaredChildren(Activity activity, bool includeExpressions)
{
IEnumerable<Activity> result = activity.Children.Concat(
activity.ImportedChildren).Concat(
activity.Delegates.Select(d => d.Handler)).Concat(
activity.ImportedDelegates.Select(d => d.Handler));
if (includeExpressions)
{
result = result.Concat(
activity.RuntimeVariables.Select(v => v.Default)).Concat(
activity.RuntimeArguments.Select(a => a.IsBound ? a.BoundArgument.Expression : null));
}
return result.Where(a => a != null && a.Parent == activity);
}
private static ProcessActivityTreeOptions ProcessTreeOptions(bool forImplementation)
{
return forImplementation ? ProcessActivityTreeOptions.DynamicUpdateOptionsForImplementation : ProcessActivityTreeOptions.DynamicUpdateOptions;
}
private static void RequireProperty(object value, string name)
{
if (value == null)
{
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.UpdateMapBuilderRequiredProperty(name)));
}
}
internal class ReferenceEqualityComparer : IEqualityComparer<object>
{
public static readonly IEqualityComparer<object> Instance = new ReferenceEqualityComparer();
ReferenceEqualityComparer()
{
}
public new bool Equals(object x, object y)
{
return object.ReferenceEquals(x, y);
}
public int GetHashCode(object obj)
{
return RuntimeHelpers.GetHashCode(obj);
}
}
// Preparer walks the tree and identifies, for each object in the tree, an ID that can be
// attached to an object in the new definition to match it to the equivalent object in the
// old definition.
internal class Preparer
{
private Dictionary<object, DynamicUpdateMapItem> updateableObjects;
private Activity originalProgram;
private LocationReferenceEnvironment originalEnvironment;
private bool forImplementation;
public Preparer(Activity originalProgram, LocationReferenceEnvironment originalEnvironment, bool forImplementation)
{
this.originalProgram = originalProgram;
this.originalEnvironment = originalEnvironment;
this.forImplementation = forImplementation;
}
public Dictionary<object, DynamicUpdateMapItem> Prepare()
{
this.updateableObjects = new Dictionary<object, DynamicUpdateMapItem>(ReferenceEqualityComparer.Instance);
CacheMetadata(this.originalProgram, this.originalEnvironment, null, this.forImplementation);
IdSpace idSpace = GetIdSpace();
if (idSpace != null)
{
for (int i = 1; i <= idSpace.MemberCount; i++)
{
ProcessElement(idSpace[i]);
}
}
return this.updateableObjects;
}
IdSpace GetIdSpace()
{
return this.forImplementation ? this.originalProgram.ParentOf : this.originalProgram.MemberOf;
}
void ProcessElement(Activity currentElement)
{
// Attach the original Activity ID to the activity
// The origin of a variable default is the same as the origin of the variable itself.
// So we don't attach match info for the default, since that would conflict with
// the match info for the variable.
if (currentElement.RelationshipToParent != Activity.RelationshipType.VariableDefault || currentElement.Origin == null)
{
ValidateOrigin(currentElement.Origin, currentElement);
this.updateableObjects[currentElement.Origin ?? currentElement] = new DynamicUpdateMapItem(currentElement.InternalId);
}
// Attach the original variable index to the variable
IList<Variable> variables = currentElement.RuntimeVariables;
for (int i = 0; i < variables.Count; i++)
{
Variable variable = variables[i];
if (string.IsNullOrEmpty(variable.Name))
{
ValidateOrigin(variable.Origin, variable);
this.updateableObjects[variable.Origin ?? variable] = new DynamicUpdateMapItem(currentElement.InternalId, i);
}
}
}
void ValidateOrigin(object origin, object element)
{
if (origin != null)
{
DynamicUpdateMapItem mapItem;
if (this.updateableObjects.TryGetValue(origin, out mapItem))
{
string error = null;
if (mapItem.IsVariableMapItem)
{
Variable dupe = GetVariable(mapItem);
Variable elementVar = element as Variable;
if (elementVar != null)
{
error = SR.DuplicateOriginVariableVariable(origin, dupe.Name, elementVar.Name);
}
else
{
error = SR.DuplicateOriginActivityVariable(origin, element, dupe.Name);
}
}
else
{
Activity dupe = GetActivity(mapItem);
Variable elementVar = element as Variable;
if (elementVar != null)
{
error = SR.DuplicateOriginActivityVariable(origin, dupe, elementVar.Name);
}
else
{
error = SR.DuplicateOriginActivityActivity(origin, dupe, element);
}
}
throw FxTrace.Exception.AsError(new InvalidWorkflowException(error));
}
}
}
Activity GetActivity(DynamicUpdateMapItem mapItem)
{
return GetIdSpace()[mapItem.OriginalId];
}
Variable GetVariable(DynamicUpdateMapItem mapItem)
{
return GetIdSpace()[mapItem.OriginalVariableOwnerId].RuntimeVariables[mapItem.OriginalId];
}
}
// Builds an Update Map given an old and new definition, and matches between them
internal class Finalizer
{
BitArray foundOriginalElements;
DynamicUpdateMapBuilder builder;
DynamicUpdateMap updateMap;
Dictionary<Activity, object> savedOriginalValues;
bool savedOriginalValuesForReferencedChildren;
IList<ActivityBlockingUpdate> blockList;
// dictionary from expression root to the activity that can make it go idle
Dictionary<Activity, Activity> expressionRootsThatCanInduceIdle;
public Finalizer(DynamicUpdateMapBuilder builder)
{
this.builder = builder;
this.savedOriginalValues = new Dictionary<Activity, object>(ReferenceEqualityComparer.Instance);
this.Matcher = new DefinitionMatcher(builder.LookupMapItem);
}
public DynamicUpdateMap FinalizeUpdate(out IList<ActivityBlockingUpdate> blockList)
{
this.updateMap = new DynamicUpdateMap();
this.blockList = new List<ActivityBlockingUpdate>();
// cache metadata of originalProgram
CacheMetadata(this.builder.OriginalWorkflowDefinition, this.builder.OriginalEnvironment, null, this.builder.ForImplementation);
IdSpace originalIdSpace = this.builder.ForImplementation ? this.builder.OriginalWorkflowDefinition.ParentOf : this.builder.OriginalWorkflowDefinition.MemberOf;
if (originalIdSpace == null)
{
Fx.Assert(this.builder.ForImplementation, "An activity must be a member of an IdSpace");
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.InvalidOriginalWorkflowDefinitionForImplementationMapCreation));
}
this.Matcher.OldIdSpace = originalIdSpace;
this.foundOriginalElements = new BitArray(originalIdSpace.MemberCount);
// cache metadata of modifiedProgram before iterative ProcessElement()
CacheMetadata(this.builder.UpdatedWorkflowDefinition, this.builder.UpdatedEnvironment, CheckCanArgumentOrVariableDefaultInduceIdle, this.builder.ForImplementation);
IdSpace idSpace = this.builder.ForImplementation ? this.builder.UpdatedWorkflowDefinition.ParentOf : this.builder.UpdatedWorkflowDefinition.MemberOf;
if (idSpace == null)
{
Fx.Assert(this.builder.ForImplementation, "An activity must be a member of an IdSpace");
throw FxTrace.Exception.AsError(new InvalidOperationException(SR.InvalidUpdatedWorkflowDefinitionForImplementationMapCreation));
}
this.Matcher.NewIdSpace = idSpace;
// check if any of the activities or variables from the original definition
// were reused in the updated definition
for (int i = 1; i < originalIdSpace.MemberCount + 1; i++)
{
CheckForReusedActivity(originalIdSpace[i]);
}
// most of the updatemap construction processing
for (int i = 1; i < idSpace.MemberCount + 1; i++)
{
ProcessElement(idSpace[i]);
}
// if an activity doesn't have an entry by this point, that means it was removed
for (int i = 0; i < this.foundOriginalElements.Count; i++)
{
if (!this.foundOriginalElements[i])
{
DynamicUpdateMapEntry removalEntry = new DynamicUpdateMapEntry(i + 1, 0);
Activity originalActivity = originalIdSpace[i + 1];
removalEntry.Parent = GetParentEntry(originalActivity, this.updateMap);
if (!removalEntry.IsParentRemovedOrBlocked)
{
removalEntry.DisplayName = originalActivity.DisplayName;
}
this.updateMap.AddEntry(removalEntry);
}
}
if (this.builder.ForImplementation)
{
this.updateMap.IsForImplementation = true;
// gather arguments diff between new and old activity definitions
this.updateMap.OldArguments = ArgumentInfo.List(builder.OriginalWorkflowDefinition);
this.updateMap.NewArguments = ArgumentInfo.List(builder.UpdatedWorkflowDefinition);
}
// Validate the Disallow entries
foreach (Activity disallowActivity in this.builder.DisallowUpdateInside)
{
if (disallowActivity == null)
{
continue;
}
if (disallowActivity.MemberOf != idSpace)
{
ThrowInvalidActivityToBlockUpdate(disallowActivity);
}
}
this.updateMap.NewDefinitionMemberCount = idSpace.MemberCount;
blockList = this.blockList;
return this.updateMap;
}
internal bool? AllowUpdateInsideCurrentActivity
{
get;
set;
}
internal string UpdateDisallowedReason
{
get;
set;
}
internal Dictionary<string, object> SavedOriginalValuesForCurrentActivity
{
get;
set;
}
internal DefinitionMatcher Matcher
{
get;
private set;
}
internal Dictionary<Activity, Activity> ExpressionRootsThatCanInduceIdle
{
get
{
return this.expressionRootsThatCanInduceIdle;
}
}
void BlockUpdate(Activity activity, UpdateBlockedReason reason, DynamicUpdateMapEntry entry, string message = null)
{
Fx.Assert(activity.MemberOf == (this.builder.ForImplementation ? activity.RootActivity.ParentOf : activity.RootActivity.MemberOf), "Should have called other overload of BlockUpdate");
BlockUpdate(activity, entry.OldActivityId.ToString(CultureInfo.InvariantCulture), reason, entry, message);
}
internal void BlockUpdate(Activity activity, string originalActivityId, UpdateBlockedReason reason, DynamicUpdateMapEntry entry, string message = null)
{
Fx.Assert(reason != UpdateBlockedReason.NotBlocked, "Invalid block reason");
if (!entry.IsRuntimeUpdateBlocked)
{
entry.BlockReason = reason;
if (reason == UpdateBlockedReason.Custom)
{
entry.BlockReasonMessage = message;
}
entry.ImplementationUpdateMap = null;
this.blockList.Add(new ActivityBlockingUpdate(activity, originalActivityId, message ?? UpdateBlockedReasonMessages.Get(reason)));
}
}
internal void SetOriginalValue(Activity key, object value, bool isReferencedChild)
{
if (isReferencedChild)
{
this.savedOriginalValuesForReferencedChildren = true;
}
else
{
this.savedOriginalValues[key] = value;
}
}
internal object GetSavedOriginalValueFromParent(Activity key)
{
object result = null;
this.savedOriginalValues.TryGetValue(key, out result);
return result;
}
void ProcessElement(Activity currentElement)
{
Activity originalElement = this.Matcher.GetMatch(currentElement);
if (originalElement != null)
{
// this means it's an existing one
DynamicUpdateMapEntry mapEntry = this.CreateMapEntry(currentElement, originalElement);
mapEntry.Parent = GetParentEntry(originalElement, this.updateMap);
if (this.builder.DisallowUpdateInside.Contains(currentElement))
{
mapEntry.IsUpdateBlockedByUpdateAuthor = true;
}
if (originalElement.GetType() != currentElement.GetType())
{
// returned matching activity's type doesn't really match the currentElement
BlockUpdate(currentElement, UpdateBlockedReason.TypeChange, mapEntry,
SR.DUActivityTypeMismatch(currentElement.GetType(), originalElement.GetType()));
}
if (this.DelegateArgumentsChanged(currentElement, originalElement))
{
this.BlockUpdate(currentElement, UpdateBlockedReason.DelegateArgumentChange, mapEntry);
}
DynamicUpdateMap implementationMap = null;
if (this.builder.LookupImplementationMap != null)
{
implementationMap = this.builder.LookupImplementationMap(currentElement);
}
// fill ArgumentEntries
// get arguments diff info from implementation map if it exists
// we do this before user participation, so that we don't call into user code
// if the update is invalid
IList<ArgumentInfo> oldArguments = GetOriginalArguments(mapEntry, implementationMap, currentElement, originalElement);
if (oldArguments != null)
{
CreateArgumentEntries(mapEntry, currentElement.RuntimeArguments, oldArguments);
}
// Capture any saved original value associated with this activity by its parent
mapEntry.SavedOriginalValueFromParent = GetSavedOriginalValueFromParent(currentElement);
if (mapEntry.IsRuntimeUpdateBlocked)
{
// don't allow activity to participate if update isn't possible anyway
mapEntry.EnvironmentUpdateMap = null;
return;
}
OnCreateDynamicUpdateMap(currentElement, originalElement, mapEntry, this.Matcher);
if (mapEntry.IsRuntimeUpdateBlocked)
{
// if the activity disabled update, we can't rely on the variable matches,
// so no point in proceeding
mapEntry.EnvironmentUpdateMap = null;
return;
}
// variable entries need to be calculated after activity participation, since
// the activity can participate in matching them
CreateVariableEntries(false, mapEntry, currentElement.RuntimeVariables, originalElement.RuntimeVariables, originalElement);
CreateVariableEntries(true, mapEntry, currentElement.ImplementationVariables, originalElement.ImplementationVariables, originalElement);
if (mapEntry.HasEnvironmentUpdates)
{
FillEnvironmentMapMemberCounts(mapEntry.EnvironmentUpdateMap, currentElement, originalElement, oldArguments);
}
else
{
Fx.Assert(originalElement.SymbolCount == currentElement.SymbolCount ||
originalElement.ImplementationVariables.Count != currentElement.ImplementationVariables.Count,
"Should have environment update if symbol count changed");
}
if (!mapEntry.IsParentRemovedOrBlocked && !mapEntry.IsUpdateBlockedByUpdateAuthor)
{
NestedIdSpaceFinalizer nestedFinalizer = new NestedIdSpaceFinalizer(this, implementationMap, currentElement, originalElement, null);
nestedFinalizer.ValidateOrCreateImplementationMap(mapEntry);
}
}
}
internal static void FillEnvironmentMapMemberCounts(EnvironmentUpdateMap envMap, Activity currentElement, Activity originalElement, IList<ArgumentInfo> oldArguments)
{
envMap.NewVariableCount = currentElement.RuntimeVariables != null ? currentElement.RuntimeVariables.Count : 0;
envMap.NewPrivateVariableCount = currentElement.ImplementationVariables != null ? currentElement.ImplementationVariables.Count : 0;
envMap.NewArgumentCount = currentElement.RuntimeArguments != null ? currentElement.RuntimeArguments.Count : 0;
envMap.OldVariableCount = originalElement.RuntimeVariables.Count;
envMap.OldPrivateVariableCount = originalElement.ImplementationVariables.Count;
envMap.OldArgumentCount = oldArguments != null ? oldArguments.Count : 0;
Fx.Assert((originalElement.HandlerOf == null && currentElement.HandlerOf == null)
|| (originalElement.HandlerOf.RuntimeDelegateArguments.Count == currentElement.HandlerOf.RuntimeDelegateArguments.Count),
"RuntimeDelegateArguments count must not have changed.");
envMap.RuntimeDelegateArgumentCount = originalElement.HandlerOf == null ? 0 : originalElement.HandlerOf.RuntimeDelegateArguments.Count;
}
DynamicUpdateMapEntry CreateMapEntry(Activity currentActivity, Activity matchin----ginal)
{
Fx.Assert(currentActivity != null && matchin----ginal != null, "this entry creation is only for existing activity's ID change.");
this.foundOriginalElements[matchin----ginal.InternalId - 1] = true;
DynamicUpdateMapEntry entry = new DynamicUpdateMapEntry(matchin----ginal.InternalId, currentActivity.InternalId);
this.updateMap.AddEntry(entry);
return entry;
}
internal void OnCreateDynamicUpdateMap(Activity currentElement, Activity originalElement,
DynamicUpdateMapEntry mapEntry, IDefinitionMatcher matcher)
{
this.AllowUpdateInsideCurrentActivity = null;
this.UpdateDisallowedReason = null;
this.SavedOriginalValuesForCurrentActivity = null;
this.savedOriginalValuesForReferencedChildren = false;
currentElement.OnInternalCreateDynamicUpdateMap(this, matcher, originalElement);
if (this.AllowUpdateInsideCurrentActivity == false)
{
this.BlockUpdate(currentElement, originalElement.Id, UpdateBlockedReason.Custom, mapEntry, this.UpdateDisallowedReason);
}
if (this.SavedOriginalValuesForCurrentActivity != null && this.SavedOriginalValuesForCurrentActivity.Count > 0)
{
mapEntry.SavedOriginalValues = this.SavedOriginalValuesForCurrentActivity;
}
if (this.savedOriginalValuesForReferencedChildren)
{
this.BlockUpdate(currentElement, originalElement.Id, UpdateBlockedReason.SavedOriginalValuesForReferencedChildren, mapEntry);
}
}
void CreateVariableEntries(bool forImplementationVariables, DynamicUpdateMapEntry mapEntry, IList<Variable> newVariables, IList<Variable> oldVariables, Activity originalElement)
{
if (newVariables != null && newVariables.Count > 0)
{
for (int i = 0; i < newVariables.Count; i++)
{
Variable newVariable = newVariables[i];
int originalIndex = this.Matcher.GetMatchIndex(newVariable, originalElement, forImplementationVariables);
if (originalIndex != i)
{
EnsureEnvironmentUpdateMap(mapEntry);
EnvironmentUpdateMapEntry environmentEntry = new EnvironmentUpdateMapEntry
{
OldOffset = originalIndex,
NewOffset = i,
};
if (forImplementationVariables)
{
mapEntry.EnvironmentUpdateMap.PrivateVariableEntries.Add(environmentEntry);
}
else
{
mapEntry.EnvironmentUpdateMap.VariableEntries.Add(environmentEntry);
}
if (originalIndex == EnvironmentUpdateMapEntry.NonExistent)
{
Activity idleActivity = GetIdleActivity(newVariable.Default);
if (idleActivity != null)
{
// If an variable default expression goes idle, the activity it is declared on can potentially
// resume execution before the default expression is evaluated. We can't allow that.
this.BlockUpdate(newVariable.Owner, UpdateBlockedReason.AddedIdleExpression, mapEntry,
SR.AddedIdleVariableDefaultBlockDU(newVariable.Name, idleActivity));
}
else if (newVariable.IsHandle)
{
this.BlockUpdate(newVariable.Owner, UpdateBlockedReason.NewHandle, mapEntry);
}
environmentEntry.IsNewHandle = newVariable.IsHandle;
}
}
}
}
// We don't normally create entries for removals, but we need to ensure that
// environment update happens if there are only removals.
if (oldVariables != null && (newVariables == null || newVariables.Count < oldVariables.Count))
{
EnsureEnvironmentUpdateMap(mapEntry);
}
}
internal void CreateArgumentEntries(DynamicUpdateMapEntry mapEntry, IList<RuntimeArgument> newArguments, IList<ArgumentInfo> oldArguments)
{
RuntimeArgument newIdleArgument;
Activity idleActivity;
if (!CreateArgumentEntries(mapEntry, newArguments, oldArguments, this.expressionRootsThatCanInduceIdle, out newIdleArgument, out idleActivity))
{
// If an argument expression goes idle, the activity it is declared on can potentially
// resume execution before the argument is evaluated. We can't allow that.
this.BlockUpdate(newIdleArgument.Owner, UpdateBlockedReason.AddedIdleExpression, mapEntry,
SR.AddedIdleArgumentBlockDU(newIdleArgument.Name, idleActivity));
return;
}
}
// if it detects any added argument whose Expression can induce idle, it returns FALSE along with newIdleArgument and idleActivity. Return true otherwise.
internal static bool CreateArgumentEntries(DynamicUpdateMapEntry mapEntry, IList<RuntimeArgument> newArguments, IList<ArgumentInfo> oldArguments, Dictionary<Activity, Activity> expressionRootsThatCanInduceIdle, out RuntimeArgument newIdleArgument, out Activity idleActivity)
{
newIdleArgument = null;
idleActivity = null;
if (newArguments != null && newArguments.Count > 0)
{
for (int i = 0; i < newArguments.Count; i++)
{
RuntimeArgument newArgument = newArguments[i];
int oldIndex = oldArguments.IndexOf(new ArgumentInfo(newArgument));
Fx.Assert(oldIndex >= 0 || oldIndex == EnvironmentUpdateMapEntry.NonExistent, "NonExistent constant should be consistent with IndexOf");
if (oldIndex != i)
{
EnsureEnvironmentUpdateMap(mapEntry);
mapEntry.EnvironmentUpdateMap.ArgumentEntries.Add(new EnvironmentUpdateMapEntry
{
OldOffset = oldIndex,
NewOffset = i
});
if (oldIndex == EnvironmentUpdateMapEntry.NonExistent && newArgument.IsBound)
{
Activity expressionRoot = newArgument.BoundArgument.Expression;
if (expressionRoot != null && expressionRootsThatCanInduceIdle != null && expressionRootsThatCanInduceIdle.TryGetValue(expressionRoot, out idleActivity))
{
newIdleArgument = newArgument;
return false;
}
}
}
}
}
// We don't normally create entries for removals, but we need to ensure that
// environment update happens if there are only removals.
if (oldArguments != null && (newArguments == null || newArguments.Count < oldArguments.Count))
{
EnsureEnvironmentUpdateMap(mapEntry);
}
return true;
}
IList<ArgumentInfo> GetOriginalArguments(DynamicUpdateMapEntry mapEntry, DynamicUpdateMap implementationMap, Activity updatedActivity, Activity originalActivity)
{
bool argumentsChangedFromImplementationMap = false;
if (implementationMap != null && !implementationMap.ArgumentsAreUnknown)
{
argumentsChangedFromImplementationMap = !ActivityComparer.ListEquals(implementationMap.NewArguments, implementationMap.OldArguments);
bool dynamicArgumentsDetected = !ActivityComparer.ListEquals(ArgumentInfo.List(updatedActivity), implementationMap.NewArguments);
if (argumentsChangedFromImplementationMap && dynamicArgumentsDetected)
{
// this is to ensure no dynamic arguments were added, removed or rearranged as the arguments owning activity was being consumed
// at the same time the activity has arguments changed from its implementation map.
// the list of RuntimeArguments obtained from the configured activity and the list of ArgumentInfos obtained from
// the implementation map must match exactly. Otherwise this activity is blocked for update.
this.BlockUpdate(updatedActivity, UpdateBlockedReason.DynamicArguments, mapEntry, SR.NoDynamicArgumentsInActivityDefinitionChange);
return null;
}
}
return argumentsChangedFromImplementationMap ? implementationMap.OldArguments : ArgumentInfo.List(originalActivity);
}
Activity GetIdleActivity(Activity expressionRoot)
{
Activity result = null;
if (expressionRoot != null && this.expressionRootsThatCanInduceIdle != null)
{
this.expressionRootsThatCanInduceIdle.TryGetValue(expressionRoot, out result);
}
return result;
}
static void EnsureEnvironmentUpdateMap(DynamicUpdateMapEntry mapEntry)
{
if (!mapEntry.HasEnvironmentUpdates)
{
mapEntry.EnvironmentUpdateMap = new EnvironmentUpdateMap();
}
}
void CheckForReusedActivity(Activity activity)
{
if (activity.RootActivity != this.builder.OriginalWorkflowDefinition)
{
throw FxTrace.Exception.AsError(new InvalidWorkflowException(SR.OriginalActivityReusedInModifiedDefinition(activity)));
}
IList<Variable> variables = activity.RuntimeVariables;
for (int i = 0; i < variables.Count; i++)
{
if (variables[i].Owner.RootActivity != this.builder.OriginalWorkflowDefinition)
{
throw FxTrace.Exception.AsError(new InvalidWorkflowException(SR.OriginalVariableReusedInModifiedDefinition(variables[i].Name)));
}
}
}
void CheckCanArgumentOrVariableDefaultInduceIdle(ActivityUtilities.ChildActivity childActivity, ActivityUtilities.ActivityCallStack parentChain)
{
Activity activity = childActivity.Activity;
if (!(activity.IsExpressionRoot || activity.RelationshipToParent == Activity.RelationshipType.VariableDefault))
{
return;
}
if (activity.HasNonEmptySubtree)
{
ActivityUtilities.FinishCachingSubtree(
childActivity, parentChain, ProcessTreeOptions(this.builder.ForImplementation),
(a, c) => CheckCanActivityInduceIdle(activity, a.Activity));
}
else
{
CheckCanActivityInduceIdle(activity, activity);
}
}
void CheckCanActivityInduceIdle(Activity activity, Activity expressionRoot)
{
if (activity.InternalCanInduceIdle)
{
if (this.expressionRootsThatCanInduceIdle == null)
{
this.expressionRootsThatCanInduceIdle = new Dictionary<Activity, Activity>(ReferenceEqualityComparer.Instance);
}
if (!this.expressionRootsThatCanInduceIdle.ContainsKey(expressionRoot))
{
this.expressionRootsThatCanInduceIdle.Add(expressionRoot, activity);
}
}
}
bool DelegateArgumentsChanged(Activity newActivity, Activity oldActivity)
{
// check DelegateArguments of ActivityDelegate owning the handler
if (newActivity.HandlerOf == null)
{
Fx.Assert(oldActivity.HandlerOf == null, "Once two activities have been matched, either both must be handlers or both must not be handlers.");
return false;
}
Fx.Assert(oldActivity.HandlerOf != null, "Once two activities have been matched, either both must be handlers or both must not be handlers.");
return !ActivityComparer.ListEquals(newActivity.HandlerOf.RuntimeDelegateArguments, oldActivity.HandlerOf.RuntimeDelegateArguments);
}
void ThrowInvalidActivityToBlockUpdate(Activity activity)
{
Exception exception;
if (builder.OnInvalidActivityToBlockUpdate != null)
{
exception = builder.OnInvalidActivityToBlockUpdate(activity);
}
else
{
exception = new InvalidOperationException(SR.InvalidActivityToBlockUpdate(activity));
}
throw FxTrace.Exception.AsError(exception);
}
internal void ThrowInvalidImplementationMapAssociation(Activity activity)
{
Exception exception;
if (builder.OnInvalidImplementationMapAssociation != null)
{
exception = builder.OnInvalidImplementationMapAssociation(activity);
}
else
{
exception = new InvalidOperationException(SR.InvalidImplementationMapAssociation(activity));
}
throw FxTrace.Exception.AsError(exception);
}
}
internal interface IDefinitionMatcher
{
void AddMatch(Activity newChild, Activity oldChild, Activity source);
void AddMatch(Variable newVariable, Variable oldVariable, Activity source);
Activity GetMatch(Activity newActivity);
Variable GetMatch(Variable newVariable);
}
internal class DefinitionMatcher : IDefinitionMatcher
{
Dictionary<object, object> newToOldMatches;
Func<object, DynamicUpdateMapItem> matchInfoLookup;
internal DefinitionMatcher(Func<object, DynamicUpdateMapItem> matchInfoLookup)
{
this.matchInfoLookup = matchInfoLookup;
this.newToOldMatches = new Dictionary<object, object>(ReferenceEqualityComparer.Instance);
}
internal IdSpace NewIdSpace
{
get;
set;
}
internal IdSpace OldIdSpace
{
get;
set;
}
// The following methods are intended to be called by the activity author
// (via UpdateMapMetadata), and should validate accordingly
public void AddMatch(Activity newChild, Activity oldChild, Activity source)
{
Fx.Assert(source != null, "source cannot be null.");
if (newChild.Parent != source)
{
throw FxTrace.Exception.Argument("newChild", SR.AddMatchActivityNewParentMismatch(
source, newChild, newChild.Parent));
}
if (newChild.MemberOf != newChild.Parent.MemberOf)
{
throw FxTrace.Exception.Argument("newChild", SR.AddMatchActivityPrivateChild(newChild));
}
if (oldChild.Parent != null && oldChild.MemberOf != oldChild.Parent.MemberOf)
{
throw FxTrace.Exception.Argument("oldChild", SR.AddMatchActivityPrivateChild(oldChild));
}
if (!ParentsMatch(newChild, oldChild))
{
throw FxTrace.Exception.Argument("oldChild", SR.AddMatchActivityNewAndOldParentMismatch(
newChild, oldChild, newChild.Parent, oldChild.Parent));
}
// Only one updated activity can match a given original activity
foreach (Activity newSibling in GetPublicDeclaredChildren(newChild.Parent, true))
{
if (GetMatch(newSibling) == oldChild)
{
this.newToOldMatches[newSibling] = null;
break;
}
}
this.newToOldMatches[newChild] = oldChild;
}
public void AddMatch(Variable newVariable, Variable oldVariable, Activity source)
{
if (!ActivityComparer.SignatureEquals(newVariable, oldVariable))
{
throw FxTrace.Exception.Argument("newVariable", SR.AddMatchVariableSignatureMismatch(
source, newVariable.Name, newVariable.Type, newVariable.Modifiers, oldVariable.Name, oldVariable.Type, oldVariable.Modifiers));
}
if (newVariable.Owner != source)
{
throw FxTrace.Exception.Argument("newVariable", SR.AddMatchVariableNewParentMismatch(
source, newVariable.Name, newVariable.Owner));
}
if (GetMatch(newVariable.Owner) != oldVariable.Owner)
{
throw FxTrace.Exception.Argument("oldVariable", SR.AddMatchVariableNewAndOldParentMismatch(
newVariable.Name, oldVariable.Name, newVariable.Owner, oldVariable.Owner));
}
if (!newVariable.IsPublic)
{
throw FxTrace.Exception.Argument("newVariable", SR.AddMatchVariablePrivateChild(newVariable.Name));
}
if (!oldVariable.IsPublic)
{
throw FxTrace.Exception.Argument("oldVariable", SR.AddMatchVariablePrivateChild(oldVariable.Name));
}
// Only one updated variable can match a given original variable
foreach (Variable newSibling in newVariable.Owner.RuntimeVariables)
{
if (GetMatch(newSibling) == oldVariable)
{
this.newToOldMatches[newSibling] = EnvironmentUpdateMapEntry.NonExistent;
break;
}
}
this.newToOldMatches[newVariable] = oldVariable.Owner.RuntimeVariables.IndexOf(oldVariable);
}
public Activity GetMatch(Activity newChild)
{
object result;
if (this.newToOldMatches.TryGetValue(newChild, out result))
{
return (Activity)result;
}
if (newChild.MemberOf != this.NewIdSpace)
{
// We can only match the IdSpace being updated.
return null;
}
if (newChild.Origin != null && newChild.RelationshipToParent == Activity.RelationshipType.VariableDefault)
{
// Auto-generated variable defaults have the same origin as the variable itself,
// so the match info comes from the variable.
foreach (Variable variable in newChild.Parent.RuntimeVariables)
{
if (variable.Default == newChild)
{
Variable originalVariable = GetMatch(variable);
if (originalVariable != null && originalVariable.Origin != null)
{
return originalVariable.Default;
}
}
}
return null;
}
DynamicUpdateMapItem matchInfo = this.matchInfoLookup(newChild.Origin ?? newChild);
if (matchInfo == null || matchInfo.IsVariableMapItem)
{
return null;
}
Activity originalActivity = this.OldIdSpace[matchInfo.OriginalId];
if (originalActivity != null && ParentsMatch(newChild, originalActivity))
{
this.newToOldMatches.Add(newChild, originalActivity);
return originalActivity;
}
else
{
return null;
}
}
public Variable GetMatch(Variable newVariable)
{
Activity matchingOwner = GetMatch(newVariable.Owner);
if (matchingOwner == null)
{
return null;
}
int index = GetMatchIndex(newVariable, matchingOwner, false);
if (index >= 0)
{
return matchingOwner.RuntimeVariables[index];
}
return null;
}
// return -1 if there is no match
internal int GetMatchIndex(Variable newVariable, Activity matchingOwner, bool forImplementation)
{
object result;
if (this.newToOldMatches.TryGetValue(newVariable, out result))
{
return (int)result;
}
IList<Variable> originalVariables;
if (forImplementation)
{
originalVariables = matchingOwner.ImplementationVariables;
}
else
{
originalVariables = matchingOwner.RuntimeVariables;
}
int oldIndex = -1;
if (String.IsNullOrEmpty(newVariable.Name))
{
if (forImplementation)
{
// HasPrivateMemberChanged must have detected any presence of nameless private variable in advance.
oldIndex = newVariable.Owner.ImplementationVariables.IndexOf(newVariable);
}
else
{
// only for those variables without names, we attempt to match by MapItem tag
DynamicUpdateMapItem matchInfo = this.matchInfoLookup(newVariable.Origin ?? newVariable);
if (matchInfo != null && matchInfo.IsVariableMapItem && matchingOwner.InternalId == matchInfo.OriginalVariableOwnerId)
{
// "matchingOwner.InternalId != matchInfo.OriginalVariableOwnerId" means the variable has been moved to a different owner,
// and it is treated as a new variable addition.
oldIndex = matchInfo.OriginalId;
}
}
}
else
{
// named variables are matched by their Name, Type and Modifiers
for (int i = 0; i < originalVariables.Count; i++)
{
if (ActivityComparer.SignatureEquals(newVariable, originalVariables[i]))
{
// match by sig----ure(Name, Type, Modifier) found
oldIndex = i;
break;
}
}
}
if (oldIndex >= 0 && oldIndex < originalVariables.Count)
{
this.newToOldMatches.Add(newVariable, oldIndex);
return oldIndex;
}
return EnvironmentUpdateMapEntry.NonExistent;
}
bool ParentsMatch(Activity currentActivity, Activity originalActivity)
{
if (currentActivity.Parent == null)
{
return originalActivity.Parent == null;
}
else
{
if (currentActivity.RelationshipToParent != originalActivity.RelationshipToParent ||
(currentActivity.HandlerOf != null && currentActivity.HandlerOf.ParentCollectionType != originalActivity.HandlerOf.ParentCollectionType))
{
return false;
}
if (currentActivity.Parent == currentActivity.MemberOf.Owner)
{
return originalActivity.Parent == this.OldIdSpace.Owner;
}
return originalActivity.Parent != null &&
GetMatch(currentActivity.Parent) == originalActivity.Parent;
}
}
}
internal class NestedIdSpaceFinalizer : IDefinitionMatcher
{
Finalizer finalizer;
DynamicUpdateMap userProvidedMap;
DynamicUpdateMap generatedMap;
Activity updatedActivity;
Activity originalActivity;
bool invalidMatchInCurrentActivity;
NestedIdSpaceFinalizer parent;
public NestedIdSpaceFinalizer(Finalizer finalizer, DynamicUpdateMap implementationMap, Activity updatedActivity, Activity originalActivity, NestedIdSpaceFinalizer parent)
{
this.finalizer = finalizer;
this.userProvidedMap = implementationMap;
this.updatedActivity = updatedActivity;
this.originalActivity = originalActivity;
this.parent = parent;
}
public void ValidateOrCreateImplementationMap(DynamicUpdateMapEntry mapEntry)
{
// check applicability of the provided implementation map
if (this.userProvidedMap != null)
{
IdSpace privateIdSpace = updatedActivity.ParentOf;
if (privateIdSpace == null)
{
this.finalizer.ThrowInvalidImplementationMapAssociation(updatedActivity);
}
if (!this.userProvidedMap.IsNoChanges && privateIdSpace.MemberCount != this.userProvidedMap.NewDefinitionMemberCount)
{
BlockUpdate(updatedActivity, UpdateBlockedReason.InvalidImplementationMap, mapEntry,
SR.InvalidImplementationMap(this.userProvidedMap.NewDefinitionMemberCount, privateIdSpace.MemberCount));
return;
}
}
// The only difference between updatedActivity and originalActivity is changes in the outer IdSpace.
// The implementation IdSpace should never change in response to outer IdSpace changes.
// The only exception is addition/removal/rearrangement of RuntimeArguments and their Expressions in the private IdSpace for the sake of supporting Receive Content Parameter change.
// If any argument change is detected and nothing else changed in the private IdSpace,
// HasPrivateMemberOtherThanArgumentsChanged will return FALSE as well as returning a generated implementation Map.
// Also, when userProvidedMap exists, we don't allow changes to arguments inside the private IdSpace
DynamicUpdateMap argumentChangesMap;
if (ActivityComparer.HasPrivateMemberOtherThanArgumentsChanged(this, updatedActivity, originalActivity, this.parent == null, out argumentChangesMap) ||
(argumentChangesMap != null && this.userProvidedMap != null))
{
// either of the following two must have occured here.
// A.
// members in the private IdSpace(or nested IdSpaces) must have changed.
// addition/removal/rearrangement of arguments and their expressions in the private IdSpace are not considered as change.
//
// B.
// addition/removal/rearrangement of arguments or their expressions in the private IdSpace occured and no other members in the private IdSpace(or nested IdSpaces) changed except their id shift.
// Due to the id shift caused by argument change, an implementation map("argumentChangesMap") was created.
// In addition to "argumentChangesMap", there is also a user provided map. This blocks DU.
// generate a warning and block update inside this activity
BlockUpdate(updatedActivity, UpdateBlockedReason.PrivateMembersHaveChanged, mapEntry);
return;
}
if (updatedActivity.ParentOf != null)
{
GenerateMap(argumentChangesMap);
if (this.generatedMap == null)
{
mapEntry.ImplementationUpdateMap = this.userProvidedMap;
}
else
{
if (this.userProvidedMap == null || this.userProvidedMap.IsNoChanges)
{
FillGeneratedMap();
}
else
{
MergeProvidedMapIntoGeneratedMap();
}
mapEntry.ImplementationUpdateMap = this.generatedMap;
}
}
}
// AddMatch is a no-op, since any matches come from the provided implementation map.
// However an invalid match can still cause us to disallow update
public void AddMatch(Activity newChild, Activity oldChild, Activity source)
{
if (newChild.Parent != source || newChild.MemberOf != source.MemberOf || GetMatch(newChild) != oldChild)
{
this.invalidMatchInCurrentActivity = true;
}
}
public void AddMatch(Variable newVariable, Variable oldVariable, Activity source)
{
if (newVariable.Owner != source || !newVariable.IsPublic || GetMatch(newVariable) != oldVariable)
{
this.invalidMatchInCurrentActivity = true;
}
}
public Activity GetMatch(Activity newActivity)
{
NestedIdSpaceFinalizer owningFinalizer = this;
do
{
// The original definition being updated still needs to reference the updated implementation.
// So even if we have a provided impl map, there should be no ID changes between updatedActivity and original activity.
if (newActivity.MemberOf == owningFinalizer.updatedActivity.ParentOf)
{
return owningFinalizer.originalActivity.ParentOf[newActivity.InternalId];
}
owningFinalizer = owningFinalizer.parent;
}
while (owningFinalizer != null);
return this.finalizer.Matcher.GetMatch(newActivity);
}
public Variable GetMatch(Variable newVariable)
{
Fx.Assert(newVariable.Owner.MemberOf == this.updatedActivity.ParentOf, "Should only call GetMatch for variables owned by the participating activity");
int index = newVariable.Owner.RuntimeVariables.IndexOf(newVariable);
if (index >= 0)
{
Activity matchingOwner = GetMatch(newVariable.Owner);
if (matchingOwner != null && matchingOwner.RuntimeVariables.Count > index)
{
return matchingOwner.RuntimeVariables[index];
}
}
return null;
}
public void CreateArgumentEntries(DynamicUpdateMapEntry mapEntry, IList<RuntimeArgument> newArguments, IList<ArgumentInfo> oldArguments)
{
RuntimeArgument newIdleArgument;
Activity idleActivity;
if (!DynamicUpdateMapBuilder.Finalizer.CreateArgumentEntries(mapEntry, newArguments, oldArguments, this.finalizer.ExpressionRootsThatCanInduceIdle, out newIdleArgument, out idleActivity))
{
// If an argument expression goes idle, the activity it is declared on can potentially
// resume execution before the argument is evaluated. We can't allow that.
this.BlockUpdate(newIdleArgument.Owner, UpdateBlockedReason.AddedIdleExpression, mapEntry,
SR.AddedIdleArgumentBlockDU(newIdleArgument.Name, idleActivity));
return;
}
}
void BlockUpdate(Activity updatedActivity, UpdateBlockedReason reason, DynamicUpdateMapEntry entry, string message = null)
{
Activity originalActivity = GetMatch(updatedActivity);
Fx.Assert(originalActivity != null, "Cannot block update inside an added activity");
this.finalizer.BlockUpdate(updatedActivity, originalActivity.Id, reason, entry, message);
}
// This method allows activities in the implementation IdSpace to participate in map creation.
// This is necessary because they may need to save original values for properties whose value
// may be set by referencing activity properties. (E.g. <Receive OperationName='{PropertyReference OpName}' />)
// They may also disable update based on observed property values. However they are not allowed
// to change or add any matches, because the implementation IdSpace should not be changing
// based on public property changes.
// if argumentChangesMap is non-null, it will be used as the initial generatedMap onto which original values are saved.
void GenerateMap(DynamicUpdateMap argumentChangesMap)
{
IdSpace updatedIdSpace = this.updatedActivity.ParentOf;
IdSpace originalIdSpace = this.originalActivity.ParentOf;
for (int i = 1; i <= updatedIdSpace.MemberCount; i++)
{
DynamicUpdateMapEntry providedEntry = null;
if (this.userProvidedMap != null && !this.userProvidedMap.IsNoChanges)
{
bool isNewlyAdded = !this.userProvidedMap.TryGetUpdateEntryByNewId(i, out providedEntry);
if (isNewlyAdded || providedEntry.IsRuntimeUpdateBlocked ||
providedEntry.IsUpdateBlockedByUpdateAuthor || providedEntry.IsParentRemovedOrBlocked)
{
// No need to save original values or block update
continue;
}
}
DynamicUpdateMapEntry argumentChangesMapEntry = null;
if (argumentChangesMap != null)
{
Fx.Assert(!argumentChangesMap.IsNoChanges, "argumentChangesMap will never be NoChanges map because it is automatically created only when there is argument changes.");
bool isNewlyAdded = !argumentChangesMap.TryGetUpdateEntryByNewId(i, out argumentChangesMapEntry);
if (isNewlyAdded)
{
// No need to save original values or block update
continue;
}
}
// We only need to save this map entry if it has some non-default value.
DynamicUpdateMapEntry generatedEntry = GenerateEntry(argumentChangesMapEntry, providedEntry, i);
DynamicUpdateMap providedImplementationMap = providedEntry != null ? providedEntry.ImplementationUpdateMap : null;
if (generatedEntry.IsRuntimeUpdateBlocked ||
generatedEntry.SavedOriginalValues != null ||
generatedEntry.SavedOriginalValueFromParent != null ||
generatedEntry.ImplementationUpdateMap != providedImplementationMap ||
generatedEntry.IsIdChange ||
generatedEntry.HasEnvironmentUpdates)
{
EnsureGeneratedMap();
this.generatedMap.AddEntry(generatedEntry);
}
}
if (argumentChangesMap != null && argumentChangesMap.entries != null)
{
// add all IsRemoved entries
foreach (DynamicUpdateMapEntry entry in argumentChangesMap.entries)
{
if (entry.IsRemoval)
{
EnsureGeneratedMap();
this.generatedMap.AddEntry(entry);
}
}
}
}
void EnsureGeneratedMap()
{
if (this.generatedMap == null)
{
this.generatedMap = new DynamicUpdateMap
{
IsForImplementation = true,
NewDefinitionMemberCount = this.updatedActivity.ParentOf.MemberCount
};
}
}
DynamicUpdateMapEntry GenerateEntry(DynamicUpdateMapEntry argumentChangesMapEntry, DynamicUpdateMapEntry providedEntry, int id)
{
DynamicUpdateMapEntry generatedEntry;
Activity updatedChild;
Activity originalChild;
// argumentChangesMapEntry and providedEntry are mutually exclusive.
// both cannot be non-null at the same time although both may be null at the same time.
if (argumentChangesMapEntry == null)
{
int originalIndex = providedEntry != null ? providedEntry.OldActivityId : id;
generatedEntry = new DynamicUpdateMapEntry(originalIndex, id);
// we assume nothing has changed in the private IdSpace
updatedChild = this.updatedActivity.ParentOf[id];
originalChild = this.originalActivity.ParentOf[id];
}
else
{
generatedEntry = argumentChangesMapEntry;
// activity IDs in the private IdSpace has changed due to arguments change inside the private IdSpace
updatedChild = this.updatedActivity.ParentOf[argumentChangesMapEntry.NewActivityId];
originalChild = this.originalActivity.ParentOf[argumentChangesMapEntry.OldActivityId];
}
// Allow the activity to participate
this.invalidMatchInCurrentActivity = false;
this.finalizer.OnCreateDynamicUpdateMap(updatedChild, originalChild, generatedEntry, this);
if (this.invalidMatchInCurrentActivity && !generatedEntry.IsRuntimeUpdateBlocked)
{
BlockUpdate(updatedChild, UpdateBlockedReason.ChangeMatchesInImplementation, generatedEntry);
}
// Fill in the rest of the map entry;
generatedEntry.SavedOriginalValueFromParent = this.finalizer.GetSavedOriginalValueFromParent(updatedChild);
DynamicUpdateMap childImplementationMap = providedEntry != null ? providedEntry.ImplementationUpdateMap : null;
if (!generatedEntry.IsRuntimeUpdateBlocked)
{
NestedIdSpaceFinalizer nestedFinalizer = new NestedIdSpaceFinalizer(this.finalizer, childImplementationMap, updatedChild, originalChild, this);
nestedFinalizer.ValidateOrCreateImplementationMap(generatedEntry);
}
return generatedEntry;
}
// The generated map only contains entries that have some non-default value. For it to be a valid
// implementation map, we need to fill in all the unchanged entries.
void FillGeneratedMap()
{
Fx.Assert(this.generatedMap != null, "If there were no generated entries then we don't need a generated map.");
this.generatedMap.ArgumentsAreUnknown = true;
for (int i = 1; i <= this.originalActivity.ParentOf.MemberCount; i++)
{
DynamicUpdateMapEntry entry;
if (!this.generatedMap.TryGetUpdateEntry(i, out entry))
{
entry = new DynamicUpdateMapEntry(i, i);
this.generatedMap.AddEntry(entry);
}
entry.Parent = GetParentEntry(this.originalActivity.ParentOf[i], this.generatedMap);
}
}
void MergeProvidedMapIntoGeneratedMap()
{
this.generatedMap.OldArguments = this.userProvidedMap.OldArguments;
this.generatedMap.NewArguments = this.userProvidedMap.NewArguments;
for (int i = 1; i <= this.userProvidedMap.OldDefinitionMemberCount; i++)
{
// Get/create the matching generated entry
DynamicUpdateMapEntry providedEntry;
this.userProvidedMap.TryGetUpdateEntry(i, out providedEntry);
DynamicUpdateMapEntry generatedEntry = GetOrCreateGeneratedEntry(providedEntry);
if (generatedEntry.IsRemoval || generatedEntry.IsRuntimeUpdateBlocked || generatedEntry.IsUpdateBlockedByUpdateAuthor || generatedEntry.IsParentRemovedOrBlocked)
{
continue;
}
// Disable update if there's a conflict
int newActivityId = providedEntry.NewActivityId;
if (HasOverlap(providedEntry.SavedOriginalValues, generatedEntry.SavedOriginalValues) ||
(HasSavedOriginalValuesForChildren(newActivityId, this.userProvidedMap) && HasSavedOriginalValuesForChildren(newActivityId, this.generatedMap)))
{
Activity updatedChild = this.updatedActivity.ParentOf[generatedEntry.NewActivityId];
BlockUpdate(updatedChild, UpdateBlockedReason.GeneratedAndProvidedMapConflict, generatedEntry, SR.GeneratedAndProvidedMapConflict);
}
else
{
generatedEntry.SavedOriginalValues = DynamicUpdateMapEntry.Merge(generatedEntry.SavedOriginalValues, providedEntry.SavedOriginalValues);
}
}
}
DynamicUpdateMapEntry GetOrCreateGeneratedEntry(DynamicUpdateMapEntry providedEntry)
{
// Get or create the matching entry
DynamicUpdateMapEntry generatedEntry;
if (!this.generatedMap.TryGetUpdateEntry(providedEntry.OldActivityId, out generatedEntry))
{
generatedEntry = new DynamicUpdateMapEntry(providedEntry.OldActivityId, providedEntry.NewActivityId)
{
DisplayName = providedEntry.DisplayName,
BlockReason = providedEntry.BlockReason,
BlockReasonMessage = providedEntry.BlockReasonMessage,
IsUpdateBlockedByUpdateAuthor = providedEntry.IsUpdateBlockedByUpdateAuthor,
};
this.generatedMap.AddEntry(generatedEntry);
}
else
{
Fx.Assert(providedEntry.NewActivityId == generatedEntry.NewActivityId &&
providedEntry.DisplayName == generatedEntry.DisplayName &&
!providedEntry.IsRuntimeUpdateBlocked && !providedEntry.IsUpdateBlockedByUpdateAuthor,
"GeneratedEntry should be created with correct ID, and should not be created for an entry that has blocked update");
}
// Copy/fill additional values
generatedEntry.EnvironmentUpdateMap = providedEntry.EnvironmentUpdateMap;
if (providedEntry.Parent != null)
{
DynamicUpdateMapEntry parentEntry;
this.generatedMap.TryGetUpdateEntry(providedEntry.Parent.OldActivityId, out parentEntry);
Fx.Assert(parentEntry != null, "We process in IdSpace order, so we always process parents before their children");
generatedEntry.Parent = parentEntry;
}
if (generatedEntry.SavedOriginalValueFromParent == null)
{
generatedEntry.SavedOriginalValueFromParent = providedEntry.SavedOriginalValueFromParent;
}
if (generatedEntry.ImplementationUpdateMap == null)
{
generatedEntry.ImplementationUpdateMap = providedEntry.ImplementationUpdateMap;
}
return generatedEntry;
}
bool HasOverlap(IDictionary<string, object> providedValues, IDictionary<string, object> generatedValues)
{
return providedValues != null && generatedValues != null &&
providedValues.Keys.Any(k => generatedValues.ContainsKey(k));
}
bool HasSavedOriginalValuesForChildren(int parentNewActivityId, DynamicUpdateMap map)
{
foreach (Activity child in GetPublicDeclaredChildren(this.updatedActivity.ParentOf[parentNewActivityId], false))
{
DynamicUpdateMapEntry childEntry;
if (map.TryGetUpdateEntryByNewId(child.InternalId, out childEntry) &&
childEntry.SavedOriginalValueFromParent != null)
{
return true;
}
}
return false;
}
}
}
}