public ResolvedTraitSet ReplaceTraitParameterValue(ResolveOptions resOpt, string toTrait, string paramName, dynamic valueWhen, dynamic valueNew)
{
ResolvedTraitSet traitSetResult = this as ResolvedTraitSet;
for (int i = 0; i < traitSetResult.Set.Count; i++)
{
ResolvedTrait rt = traitSetResult.Set[i];
if (rt?.Trait.IsDerivedFrom(toTrait, resOpt) == true)
{
if (rt.ParameterValues != null)
{
ParameterCollection pc = rt.ParameterValues.PC;
List <dynamic> av = rt.ParameterValues.Values;
int idx = pc.FetchParameterIndex(paramName);
if (idx >= 0 && Equals(av[idx], valueWhen))
{
// copy the set and make a deep copy of the trait being set
traitSetResult = this.ShallowCopyWithException(rt.Trait);
// assume these are all still true for this copy
rt = traitSetResult.Set[i];
av = rt.ParameterValues.Values;
av[idx] = ParameterValue.FetchReplacementValue(resOpt, av[idx], valueNew, true);
break;
}
}
}
}
return(traitSetResult);
}
public ResolvedTraitSet DeepCopy()
{
ResolvedTraitSet copy = new ResolvedTraitSet(this.ResOpt);
for (int i = 0; i < this.Set.Count; i++)
{
ResolvedTrait rt = this.Set[i].Copy();
copy.Set.Add(rt);
copy.LookupByTrait.Add(rt.Trait, rt);
}
copy.HasElevated = this.HasElevated;
return(copy);
}
internal bool Remove(ResolveOptions resOpt, string traitName)
{
ResolvedTrait rt = this.Find(resOpt, traitName);
if (rt != null)
{
this.LookupByTrait.Remove(rt.Trait);
this.Set.Remove(rt);
return(true);
}
return(false);
}
public void SetParameterValueFromArgument(CdmTraitDefinition trait, CdmArgumentDefinition arg)
{
ResolvedTrait resTrait = this.Get(trait);
if (resTrait?.ParameterValues != null)
{
List <dynamic> av = resTrait.ParameterValues.Values;
dynamic newVal = arg.Value;
// get the value index from the parameter collection given the parameter that this argument is setting
int iParam = resTrait.ParameterValues.IndexOf(arg.GetParameterDef());
av[iParam] = ParameterValue.FetchReplacementValue(this.ResOpt, av[iParam], newVal, true);
resTrait.ParameterValues.WasSet[iParam] = true;
}
}
public ResolvedTrait Find(ResolveOptions resOpt, string traitName)
{
int l = this.Set.Count;
for (int i = 0; i < l; i++)
{
ResolvedTrait rt = this.Set[i];
if (rt.Trait.IsDerivedFrom(traitName, resOpt))
{
return(rt);
}
}
return(null);
}
public ISet <string> CollectTraitNames()
{
ISet <string> collection = new HashSet <string>();
if (this.Set != null)
{
int l = this.Set.Count;
for (int i = 0; i < l; i++)
{
ResolvedTrait rt = this.Set[i];
rt.CollectTraitNames(this.ResOpt, collection);
}
}
return(collection);
}
public ResolvedTraitSet ShallowCopy()
{
ResolvedTraitSet copy = new ResolvedTraitSet(this.ResOpt);
if (this.Set != null)
{
int l = this.Set.Count;
for (int i = 0; i < l; i++)
{
ResolvedTrait rt = this.Set[i];
copy.Set.Add(rt);
copy.LookupByTrait.Add(rt.Trait, rt);
}
}
copy.HasElevated = this.HasElevated;
return(copy);
}
public ResolvedTraitSet ShallowCopyWithException(CdmTraitDefinition just)
{
ResolvedTraitSet copy = new ResolvedTraitSet(this.ResOpt);
int l = this.Set.Count;
for (int i = 0; i < l; i++)
{
ResolvedTrait rt = this.Set[i];
if (rt.Trait == just)
{
rt = rt.Copy();
}
copy.Set.Add(rt);
copy.LookupByTrait.Add(rt.Trait, rt);
}
copy.HasElevated = this.HasElevated;
return(copy);
}
public void SetParameterValueFromArgument(CdmTraitDefinition trait, CdmArgumentDefinition arg)
{
ResolvedTrait resTrait = this.Get(trait);
if (resTrait?.ParameterValues != null)
{
List <dynamic> av = resTrait.ParameterValues.Values;
dynamic newVal = arg.Value;
// get the value index from the parameter collection given the parameter that this argument is setting
var paramDef = arg.GetParameterDef();
if (paramDef != null)
{
resTrait.ParameterValues.SetParameterValue(this.ResOpt, paramDef.GetName(), newVal);
}
else
{
// debug
paramDef = arg.GetParameterDef();
}
}
}
public ResolvedTraitSet MergeSet(ResolvedTraitSet toMerge, bool elevatedOnly = false)
{
bool copyOnWrite = true;
ResolvedTraitSet traitSetResult = this;
if (toMerge != null)
{
int l = toMerge.Set.Count;
for (int i = 0; i < l; i++)
{
ResolvedTrait rt = toMerge.Set[i];
if (!elevatedOnly || rt.Trait.Elevated == true)
{
ResolvedTraitSet traitSetMerge = traitSetResult.Merge(rt, copyOnWrite);
if (traitSetMerge != traitSetResult)
{
traitSetResult = traitSetMerge;
copyOnWrite = false;
}
}
}
}
return(traitSetResult);
}
public void OwnOne(ResolvedTrait rt, ResolveOptions resOpt)
{
this.ResolvedTraitSet = new ResolvedTraitSet(resOpt);
this.ResolvedTraitSet.Merge(rt, false);
}
public ResolvedTraitSet Merge(ResolvedTrait toMerge, bool copyOnWrite)
{
ResolvedTraitSet traitSetResult = this;
var trait = toMerge.Trait;
List <dynamic> av = null;
List <bool> wasSet = null;
if (toMerge.ParameterValues != null)
{
av = toMerge.ParameterValues.Values;
wasSet = toMerge.ParameterValues.WasSet;
}
if (this.HasElevated != true)
{
this.HasElevated = trait.Elevated;
}
if (traitSetResult.LookupByTrait.ContainsKey(trait))
{
ResolvedTrait rtOld = traitSetResult.LookupByTrait[trait];
List <dynamic> avOld = null;
if (rtOld.ParameterValues != null)
{
avOld = rtOld.ParameterValues.Values;
}
if (av != null && avOld != null)
{
// the new values take precedence
for (int i = 0; i < av.Count; i++)
{
if (avOld[i]?.GetType() == typeof(JValue))
{
avOld[i] = (string)avOld[i];
}
try
{
if (av[i] != avOld[i])
{
if (copyOnWrite)
{
traitSetResult = traitSetResult.ShallowCopyWithException(trait);
rtOld = traitSetResult.LookupByTrait[trait];
avOld = rtOld.ParameterValues.Values;
copyOnWrite = false;
}
avOld[i] = ParameterValue.FetchReplacementValue(this.ResOpt, avOld[i], av[i], wasSet[i]);
}
}
catch
{
}
}
}
}
else
{
if (copyOnWrite)
{
traitSetResult = traitSetResult.ShallowCopy();
}
toMerge = toMerge.Copy();
traitSetResult.Set.Add(toMerge);
traitSetResult.LookupByTrait.Add(trait, toMerge);
}
return(traitSetResult);
}
