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); }