public bool TryGetValue(TKey key, out TValue value)
{
SingleDependency single = _data as SingleDependency;
if (single != null)
{
if (EqualityComparer <TKey> .Default.Equals(single.Key, key))
{
value = single.Value;
return(true);
}
value = default(TValue);
return(false);
}
var dict = _data as AnalysisDictionary <TKey, TValue>;
if (dict != null)
{
return(dict.TryGetValue(key, out value));
}
value = default(TValue);
return(false);
}
internal bool TryGetValue(TKey fromModule, out TValue deps)
{
SingleDependency single = _data as SingleDependency;
if (single != null)
{
if (single.Key.Equals(fromModule))
{
deps = single.Value;
return(true);
}
deps = default(TValue);
return(false);
}
Dictionary <TKey, TValue> dict = _data as Dictionary <TKey, TValue>;
if (_data != null)
{
return(dict.TryGetValue(fromModule, out deps));
}
deps = default(TValue);
return(false);
}
public void SetUp(SingleDependency dependency)
{
idleUnitType = dependency.unitType;
for (int i = 0; i < valueText.Length; i++)
{
valueText[i].text = dependency.countToUnlock.ToString();
}
HideAll();
if (dependency.isComplete)
{
for (int i = 0; i < completeItems.Length; i++)
{
completeItems[i].Show();
}
}
else
{
for (int i = 0; i < incompleteItems.Length; i++)
{
incompleteItems[i].Show();
}
}
}
public static void CreateNonEqualFilter(this TreeContext context,
INode node1,
INode node2,
IFilterGroup parentGroup,
IDiagInfo diagInfo)
{
if (node1.Token.Type != node2.Token.Type)
{
return;
}
var tuple = new Tuple <IToken, IToken>(node1.Token, node2.Token);
var reverseTuple = new Tuple <IToken, IToken>(node2.Token, node1.Token);
if (context.NonEqualFilters.Contains(tuple) || context.NonEqualFilters.Contains(reverseTuple))
{
return;
}
context.NonEqualFilters.Add(tuple);
var dep1 = new SingleDependency(node1.Token);
var dep2 = new SingleDependency(node2.Token);
var newInfo = new FilterInfo(context.Store.NextId, diagInfo, parentGroup?.FilterInfo.FilterToken);
var filter = new Filter2 <IResolutionContext, IResolutionContext>(dep1, dep2, (x, y) => !x.Equals(y), newInfo);
context.Filters.Add(filter);
}
public static void CreateNonEqualFilter(this TreeContext context,
INode node1,
INode node2,
IFilterGroup parentGroup,
IDiagInfo diagInfo)
{
if (node1.Token.Type != node2.Token.Type)
{
return;
}
var tuple = new Tuple<IToken, IToken>(node1.Token, node2.Token);
var reverseTuple = new Tuple<IToken, IToken>(node2.Token, node1.Token);
if (context.NonEqualFilters.Contains(tuple) || context.NonEqualFilters.Contains(reverseTuple))
{
return;
}
context.NonEqualFilters.Add(tuple);
var dep1 = new SingleDependency(node1.Token);
var dep2 = new SingleDependency(node2.Token);
var newInfo = new FilterInfo(context.Store.NextId, diagInfo, parentGroup?.FilterInfo.FilterToken);
var filter = new Filter2<IResolutionContext, IResolutionContext>(dep1, dep2, (x, y) => !x.Equals(y), newInfo);
context.Filters.Add(filter);
}
static bool CheckDependencies(string s, UAPScript UAPScriptEnv, List <KeyValuePair <string, string> > parameters)
{
foreach (var item in parameters)
{
SingleDependency dependency = new SingleDependency(item.Key, item.Value);
if (!dependency.Check())
{
Host.SetForeground(ConsoleColor.Red);
Host.WriteLine("Missing dependency:" + item.Key);
Host.SetForeground(ConsoleColor.White);
}
}
return(true);
}
public Context RegisterFactory <T>(DependencyFactory <T> factory)
{
ThrowIfNull(factory, "factory");
Type dependencyType = typeof(T);
Type factoryType = factory.GetType();
SingleDependency selfDependency = new SingleDependency(factory);
InsertDependency(factoryType, selfDependency);
FactoryDependency <T> factoryDependency = new FactoryDependency <T>(selfDependency);
InsertDependency(dependencyType, factoryDependency);
return(this);
}
public IEnumerator <KeyValuePair <TKey, TValue> > GetEnumerator()
{
SingleDependency single = _data as SingleDependency;
if (single != null)
{
yield return(new KeyValuePair <TKey, TValue>(single.Key, single.Value));
}
AnalysisDictionary <TKey, TValue> dict = _data as AnalysisDictionary <TKey, TValue>;
if (dict != null)
{
foreach (var keyValue in dict)
{
yield return(keyValue);
}
}
}
internal void Remove(TKey fromModule)
{
SingleDependency single = _data as SingleDependency;
if (single != null)
{
if (single.Key.Equals(fromModule))
{
single = null;
}
return;
}
Dictionary <TKey, TValue> dict = _data as Dictionary <TKey, TValue>;
if (_data != null)
{
dict.Remove(fromModule);
}
}
public void InitTestContext()
{
ruleT1 = new TestRuleT1();
ruleDependent = new OtherRuleT1();
transformation = new MockTransformation(ruleT1, ruleDependent);
transformation.Initialize();
context = new MockContext(transformation);
dependency = new SingleDependency();
dependency.BaseTransformation = ruleT1;
dependency.DependencyTransformation = ruleDependent;
dependency.ExecuteBefore = true;
c_Test = new MockComputation(new object[] { "a" }, ruleT1, context, "b");
c_Dependent = new MockComputation(new object[] { new Dummy() }, ruleDependent, context, null);
context.Computations.Add(c_Test);
context.Computations.Add(c_Dependent);
}
public TValue this[TKey key] {
get {
TValue res;
if (TryGetValue(key, out res))
{
return(res);
}
throw new KeyNotFoundException();
}
set {
if (_data == null)
{
_data = new SingleDependency(key, value);
return;
}
SingleDependency single = _data as SingleDependency;
if (single != null)
{
if (single.Key.Equals(key))
{
single.Value = value;
return;
}
var data = new Dictionary <TKey, TValue>();
data[single.Key] = single.Value;
_data = data;
}
Dictionary <TKey, TValue> dict = _data as Dictionary <TKey, TValue>;
if (dict == null)
{
_data = dict = new Dictionary <TKey, TValue>();
}
dict[key] = value;
}
}
public bool TryGetSingleDependency(out SingleDependency dependency)
{
dependency = _data as SingleDependency;
return(dependency != null);
}
