public ResolvedAttributeSet Copy()
{
ResolvedAttributeSet copy = new ResolvedAttributeSet();
copy.AttributeContext = this.AttributeContext;
int l = this.Set.Count;
// save the mappings to overwrite
// maps from merge may not be correct
IDictionary <ResolvedAttribute, HashSet <CdmAttributeContext> > newRa2attCtxSet = new Dictionary <ResolvedAttribute, HashSet <CdmAttributeContext> >();
IDictionary <CdmAttributeContext, ResolvedAttribute> newAttCtx2ra = new Dictionary <CdmAttributeContext, ResolvedAttribute>();
for (int i = 0; i < l; i++)
{
ResolvedAttribute sourceRa = this.Set[i];
ResolvedAttribute copyRa = sourceRa.Copy();
this.CopyAttCtxMappingsInto(newRa2attCtxSet, newAttCtx2ra, sourceRa, copyRa);
copy.Merge(copyRa);
}
// reset mappings to the correct one
copy.Ra2attCtxSet = newRa2attCtxSet;
copy.AttCtx2ra = newAttCtx2ra;
return(copy);
}
public ResolvedAttributeSet Copy()
{
ResolvedAttributeSet copy = new ResolvedAttributeSet();
copy.AttributeContext = this.AttributeContext;
int l = this.Set.Count;
// save the mappings to overwrite
// maps from merge may not be correct
IDictionary <ResolvedAttribute, HashSet <CdmAttributeContext> > newRa2attCtxSet = new Dictionary <ResolvedAttribute, HashSet <CdmAttributeContext> >();
IDictionary <CdmAttributeContext, ResolvedAttribute> newAttCtx2ra = new Dictionary <CdmAttributeContext, ResolvedAttribute>();
for (int i = 0; i < l; i++)
{
ResolvedAttribute sourceRa = this.Set[i];
ResolvedAttribute copyRa = sourceRa.Copy();
copy.Merge(copyRa);
}
// copy the ownership map. new map will point at old att lists, but we never update these lists, only make new ones, so all is well
if (this.AttributeOwnershipMap != null)
{
copy.AttributeOwnershipMap = new Dictionary <string, HashSet <string> >(this.AttributeOwnershipMap);
}
copy.DepthTraveled = this.DepthTraveled;
return(copy);
}
public ResolvedAttributeSet Copy()
{
ResolvedAttributeSet copy = new ResolvedAttributeSet();
copy.AttributeContext = this.AttributeContext;
int l = this.Set.Count;
for (int i = 0; i < l; i++)
{
ResolvedAttribute sourceRa = this.Set[i];
ResolvedAttribute copyRa = sourceRa.Copy();
copy.Merge(copyRa);
}
// copy the ownership map. new map will point at old att lists, but we never update these lists, only make new ones, so all is well
if (this.AttributeOwnershipMap != null)
{
copy.AttributeOwnershipMap = new Dictionary <string, HashSet <string> >(this.AttributeOwnershipMap);
}
copy.DepthTraveled = this.DepthTraveled;
return(copy);
}
ResolvedAttributeSet Apply(ResolvedTraitSet traits, ResolveOptions resOpt, CdmAttributeResolutionGuidance resGuide, List <AttributeResolutionApplier> actions)
{
if (traits == null && actions.Count == 0)
{
// nothing can change
return(this);
}
// for every attribute in the set run any attribute appliers
ResolvedAttributeSet appliedAttSet = new ResolvedAttributeSet();
int l = this.Set.Count;
appliedAttSet.AttributeContext = this.AttributeContext;
// check to see if we need to make a copy of the attributes
// do this when building an attribute context and when we will modify the attributes (beyond traits)
// see if any of the appliers want to modify
bool makingCopy = false;
if (l > 0 && appliedAttSet.AttributeContext != null && actions != null && actions.Count > 0)
{
ResolvedAttribute resAttTest = this.Set[0];
foreach (AttributeResolutionApplier traitAction in actions)
{
ApplierContext ctx = new ApplierContext {
ResOpt = resOpt, ResAttSource = resAttTest, ResGuide = resGuide
};
if (traitAction.WillAttributeModify(ctx) == true)
{
makingCopy = true;
break;
}
}
}
if (makingCopy)
{
// fake up a generation round for these copies that are about to happen
AttributeContextParameters acp = new AttributeContextParameters
{
under = appliedAttSet.AttributeContext,
type = Enums.CdmAttributeContextType.GeneratedSet,
Name = "_generatedAttributeSet"
};
appliedAttSet.AttributeContext = CdmAttributeContext.CreateChildUnder(traits.ResOpt, acp);
acp = new AttributeContextParameters
{
under = appliedAttSet.AttributeContext,
type = Enums.CdmAttributeContextType.GeneratedRound,
Name = "_generatedAttributeRound0"
};
appliedAttSet.AttributeContext = CdmAttributeContext.CreateChildUnder(traits.ResOpt, acp);
}
for (int i = 0; i < l; i++)
{
ResolvedAttribute resAtt = this.Set[i];
CdmAttributeContext attCtxToMerge = null;
if (resAtt.Target is ResolvedAttributeSet subSet)
{
if (makingCopy)
{
resAtt = resAtt.Copy();
// making a copy of a subset (att group) also bring along the context tree for that whole group
attCtxToMerge = resAtt.AttCtx;
}
// the set contains another set. process those
resAtt.Target = subSet.Apply(traits, resOpt, resGuide, actions);
}
else
{
ResolvedTraitSet rtsMerge = resAtt.ResolvedTraits.MergeSet(traits);
resAtt.ResolvedTraits = rtsMerge;
if (actions != null)
{
foreach (AttributeResolutionApplier traitAction in actions)
{
ApplierContext ctx = new ApplierContext {
ResOpt = traits.ResOpt, ResAttSource = resAtt, ResGuide = resGuide
};
if (traitAction.WillAttributeModify(ctx) == true)
{
// make a context for this new copy
if (makingCopy)
{
AttributeContextParameters acp = new AttributeContextParameters
{
under = appliedAttSet.AttributeContext,
type = Enums.CdmAttributeContextType.AttributeDefinition,
Name = resAtt.ResolvedName,
Regarding = resAtt.Target
};
ctx.AttCtx = CdmAttributeContext.CreateChildUnder(traits.ResOpt, acp);
attCtxToMerge = ctx.AttCtx as CdmAttributeContext;
}
// make a copy of the resolved att
if (makingCopy)
{
resAtt = resAtt.Copy();
}
ctx.ResAttSource = resAtt;
// modify it
traitAction.DoAttributeModify(ctx);
}
}
}
}
appliedAttSet.Merge(resAtt, attCtxToMerge);
}
appliedAttSet.AttributeContext = this.AttributeContext;
if (!makingCopy)
{
// didn't copy the attributes or make any new context, so just take the old ones
appliedAttSet.Ra2attCtxSet = this.Ra2attCtxSet;
appliedAttSet.AttCtx2ra = this.AttCtx2ra;
}
return(appliedAttSet);
}