1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
|
// <copyright>
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
namespace System.Activities.DynamicUpdate
{
using System;
using System.Activities.Validation;
using System.Collections.Generic;
using System.Linq;
public class UpdateMapMetadata
{
private DynamicUpdateMapBuilder.Finalizer finalizer;
DynamicUpdateMapBuilder.IDefinitionMatcher matcher;
private Activity targetActivity;
private bool isDisposed;
internal UpdateMapMetadata(DynamicUpdateMapBuilder.Finalizer finalizer,
DynamicUpdateMapBuilder.IDefinitionMatcher matcher, Activity targetActivity)
{
this.finalizer = finalizer;
this.matcher = matcher;
this.targetActivity = targetActivity;
this.isDisposed = false;
}
public void AllowUpdateInsideThisActivity()
{
this.ThrowIfDisposed();
this.finalizer.AllowUpdateInsideCurrentActivity = true;
this.finalizer.UpdateDisallowedReason = null;
}
public void DisallowUpdateInsideThisActivity(string reason)
{
this.ThrowIfDisposed();
this.finalizer.AllowUpdateInsideCurrentActivity = false;
this.finalizer.UpdateDisallowedReason = reason;
}
public void AddMatch(Activity updatedChild, Activity originalChild)
{
this.ThrowIfDisposed();
if (updatedChild != null && originalChild != null)
{
this.matcher.AddMatch(updatedChild, originalChild, this.targetActivity);
}
}
public void AddMatch(Variable updatedVariable, Variable originalVariable)
{
this.ThrowIfDisposed();
if (updatedVariable != null && originalVariable != null)
{
this.matcher.AddMatch(updatedVariable, originalVariable, this.targetActivity);
}
}
public Activity GetMatch(Activity updatedChild)
{
this.ThrowIfDisposed();
if (updatedChild != null)
{
Activity result = this.matcher.GetMatch(updatedChild);
if (updatedChild.MemberOf == this.targetActivity.MemberOf)
{
return result;
}
else if (result != null)
{
// GetMatch checks that the activities have the same relationship to declaring parent.
// But for referenced children, we also need to check whether they have the same relationship
// to referencing parent.
// In case of multiple references from the same parent, we'll compare the first one we find.
bool updatedIsImport;
bool updatedIsReferenced = IsChild(this.TargetActivity, updatedChild, out updatedIsImport);
bool updatedIsDelegate = updatedChild.HandlerOf != null;
bool originalIsImport;
bool originalIsReferenced = IsChild(GetMatch(this.TargetActivity), result, out originalIsImport);
bool originalIsDelegate = result.HandlerOf != null;
if (updatedIsReferenced && originalIsReferenced && updatedIsImport == originalIsImport && updatedIsDelegate == originalIsDelegate)
{
return result;
}
}
}
return null;
}
public Variable GetMatch(Variable updatedVariable)
{
this.ThrowIfDisposed();
if (updatedVariable != null && updatedVariable.Owner == this.TargetActivity)
{
Variable result = this.matcher.GetMatch(updatedVariable);
return result;
}
return null;
}
public bool IsReferenceToImportedChild(Activity childActivity)
{
this.ThrowIfDisposed();
if (childActivity == null)
{
return false;
}
Activity parent = (childActivity.RootActivity == this.TargetActivity.RootActivity) ? this.TargetActivity : GetMatch(this.TargetActivity);
return IsReferenceToImportedChild(parent, childActivity);
}
internal bool IsUpdateExplicitlyAllowedOrDisallowed
{
get
{
return this.finalizer.AllowUpdateInsideCurrentActivity.HasValue;
}
}
internal void Dispose()
{
this.isDisposed = true;
}
internal bool AreMatch(Activity updatedActivity, Activity originalActivity)
{
return this.matcher.GetMatch(updatedActivity) == originalActivity;
}
internal bool AreMatch(ActivityDelegate updatedDelegate, ActivityDelegate originalDelegate)
{
if (updatedDelegate.Handler != null && originalDelegate.Handler != null)
{
return this.matcher.GetMatch(updatedDelegate.Handler) == originalDelegate.Handler;
}
else
{
return updatedDelegate.Handler == null && originalDelegate.Handler == null;
}
}
internal DynamicUpdateMapBuilder.Finalizer Finalizer
{
get
{
return this.finalizer;
}
}
internal Activity TargetActivity
{
get
{
return this.targetActivity;
}
}
internal void ThrowIfDisposed()
{
if (this.isDisposed)
{
throw FxTrace.Exception.AsError(new ObjectDisposedException(ToString()));
}
}
internal static bool IsChild(Activity parent, Activity child, out bool isImport)
{
if (child.HandlerOf == null)
{
isImport = parent.ImportedChildren.Contains(child);
return isImport || parent.Children.Contains(child);
}
else
{
isImport = parent.ImportedDelegates.Contains(child.HandlerOf);
return isImport || parent.Delegates.Contains(child.HandlerOf);
}
}
static bool IsReferenceToImportedChild(Activity parent, Activity child)
{
if (child != null && child.MemberOf != parent.MemberOf)
{
IdSpace idSpace = parent.MemberOf.Parent;
while (idSpace != null)
{
if (idSpace == child.MemberOf)
{
return true;
}
else
{
idSpace = idSpace.Parent;
}
}
}
return false;
}
}
}
|
