internal override void ConstructResolvedTraits(ResolvedTraitSetBuilder rtsb, ResolveOptions resOpt)
{
// base traits then add any elevated from attributes then add things exhibited by the att.
CdmObjectReference baseClass = this.ExtendsEntityRef;
if (baseClass != null)
{
// merge in all from base class
rtsb.MergeTraits((baseClass as CdmObjectReferenceBase).FetchResolvedTraits(resOpt));
}
if (this.Attributes != null)
{
ResolvedTraitSet rtsElevated = new ResolvedTraitSet(resOpt);
for (int i = 0; i < this.Attributes.Count; i++)
{
dynamic att = this.Attributes.AllItems[i];
dynamic rtsAtt = att.FetchResolvedTraits(resOpt);
if (rtsAtt?.HasElevated == true)
{
rtsElevated = rtsElevated.MergeSet(rtsAtt, true);
}
}
rtsb.MergeTraits(rtsElevated);
}
this.ConstructResolvedTraitsDef(null, rtsb, resOpt);
}
internal override void ConstructResolvedTraits(ResolvedTraitSetBuilder rtsb, ResolveOptions resOpt)
{
// // get from datatype
if (this.DataType != null)
{
rtsb.TakeReference(this.DataType.FetchResolvedTraits(resOpt));
}
// // get from purpose
if (this.Purpose != null)
{
rtsb.MergeTraits(this.Purpose.FetchResolvedTraits(resOpt));
}
this.AddResolvedTraitsApplied(rtsb, resOpt);
// special case for attributes, replace a default "this.attribute" with this attribute on traits that elevate attribute
if (rtsb.ResolvedTraitSet?.HasElevated == true)
{
CdmAttributeReference replacement = new CdmAttributeReference(this.Ctx, this.Name, true)
{
Ctx = this.Ctx,
ExplicitReference = this,
InDocument = this.InDocument,
Owner = this,
};
rtsb.ReplaceTraitParameterValue(resOpt, "does.elevateAttribute", "attribute", "this.attribute", replacement);
}
//rtsb.CleanUp();
}
internal override void ConstructResolvedTraits(ResolvedTraitSetBuilder rtsb, ResolveOptions resOpt)
{
CdmObjectDefinition objDef = this.FetchObjectDefinition <CdmObjectDefinition>(resOpt);
if (objDef != null)
{
ResolvedTraitSet rtsInh = (objDef as CdmObjectDefinitionBase).FetchResolvedTraits(resOpt);
if (rtsInh != null)
{
rtsInh = rtsInh.DeepCopy();
}
rtsb.TakeReference(rtsInh);
}
else
{
string defName = this.FetchObjectDefinitionName();
Logger.Warning(defName, this.Ctx, $"unable to resolve an object from the reference '{defName}'");
}
if (this.AppliedTraits != null)
{
foreach (CdmTraitReference at in this.AppliedTraits)
{
rtsb.MergeTraits(at.FetchResolvedTraits(resOpt));
}
}
}
internal ResolvedTraitSet AddResolvedTraitsApplied(ResolvedTraitSetBuilder rtsb, ResolveOptions resOpt)
{
AppliedTraits.AllItems.ForEach(item => rtsb.MergeTraits(item.FetchResolvedTraits(resOpt)));
// dynamic applied on use
return(rtsb.ResolvedTraitSet);
}
internal override void ConstructResolvedTraits(ResolvedTraitSetBuilder rtsb, ResolveOptions resOpt)
{
// // get from purpose
if (this.Purpose != null)
rtsb.TakeReference(this.Purpose.FetchResolvedTraits(resOpt));
this.AddResolvedTraitsApplied(rtsb, resOpt);
//rtsb.CleanUp();
}
internal ResolvedTraitSet AddResolvedTraitsApplied(ResolvedTraitSetBuilder rtsb, ResolveOptions resOpt)
{
int l = this.AppliedTraits.Count;
for (int i = 0; i < l; i++)
{
rtsb.MergeTraits(this.AppliedTraits[i].FetchResolvedTraits(resOpt));
}
// dynamic applied on use
return(rtsb.ResolvedTraitSet);
}
internal ResolvedTraitSet AddResolvedTraitsApplied(ResolvedTraitSetBuilder rtsb, ResolveOptions resOpt)
{
Action <CdmTraitCollection> addAppliedTraits = (ats) =>
{
if (ats != null)
{
int l = ats.Count;
for (int i = 0; i < l; i++)
{
rtsb.MergeTraits(ats.AllItems[i].FetchResolvedTraits(resOpt));
}
}
};
addAppliedTraits(this.AppliedTraits);
// dynamic applied on use
return(rtsb.ResolvedTraitSet);
}
internal override void ConstructResolvedTraits(ResolvedTraitSetBuilder rtsb, ResolveOptions resOpt)
{
// get only the elevated traits from attribute first, then add in all traits from this definition
if (this.Members != null)
{
ResolvedTraitSet rtsElevated = new ResolvedTraitSet(resOpt);
for (int i = 0; i < this.Members.Count; i++)
{
dynamic att = this.Members.AllItems[i];
ResolvedTraitSet rtsAtt = att.FetchResolvedTraits(resOpt);
if (rtsAtt?.HasElevated == true)
{
rtsElevated = rtsElevated.MergeSet(rtsAtt, true);
}
}
rtsb.MergeTraits(rtsElevated);
}
this.ConstructResolvedTraitsDef(null, rtsb, resOpt);
}
internal override void ConstructResolvedTraits(ResolvedTraitSetBuilder rtsb, ResolveOptions resOpt)
{
return;
}
internal override void ConstructResolvedTraits(ResolvedTraitSetBuilder rtsb, ResolveOptions resOpt)
{
this.ConstructResolvedTraitsDef(this.ExtendsDataTypeRef, rtsb, resOpt);
//rtsb.CleanUp();
}
/// <inheritdoc />
internal override void ConstructResolvedTraits(ResolvedTraitSetBuilder rtsb, ResolveOptions resOpt)
{
this.ConstructResolvedTraitsDef(null, rtsb, resOpt);
}
internal virtual ResolvedTraitSet FetchResolvedTraits(ResolveOptions resOpt = null)
{
bool wasPreviouslyResolving = this.Ctx.Corpus.isCurrentlyResolving;
this.Ctx.Corpus.isCurrentlyResolving = true;
if (resOpt == null)
{
resOpt = new ResolveOptions(this, this.Ctx.Corpus.DefaultResolutionDirectives);
}
const string kind = "rtsb";
ResolveContext ctx = this.Ctx as ResolveContext;
string cacheTagA = ctx.Corpus.CreateDefinitionCacheTag(resOpt, this, kind);
ResolvedTraitSetBuilder rtsbAll = null;
if (this.TraitCache == null)
{
this.TraitCache = new Dictionary <string, ResolvedTraitSetBuilder>();
}
else if (!string.IsNullOrWhiteSpace(cacheTagA))
{
this.TraitCache.TryGetValue(cacheTagA, out rtsbAll);
}
// store the previous document set, we will need to add it with
// children found from the constructResolvedTraits call
SymbolSet currDocRefSet = resOpt.SymbolRefSet;
if (currDocRefSet == null)
{
currDocRefSet = new SymbolSet();
}
resOpt.SymbolRefSet = new SymbolSet();
if (rtsbAll == null)
{
rtsbAll = new ResolvedTraitSetBuilder();
if (!resolvingTraits)
{
resolvingTraits = true;
this.ConstructResolvedTraits(rtsbAll, resOpt);
resolvingTraits = false;
}
CdmObjectDefinitionBase objDef = this.FetchObjectDefinition <CdmObjectDefinitionBase>(resOpt);
if (objDef != null)
{
// register set of possible docs
ctx.Corpus.RegisterDefinitionReferenceSymbols(objDef, kind, resOpt.SymbolRefSet);
if (rtsbAll.ResolvedTraitSet == null)
{
// nothing came back, but others will assume there is a set in this builder
rtsbAll.ResolvedTraitSet = new ResolvedTraitSet(resOpt);
}
// get the new cache tag now that we have the list of docs
cacheTagA = ctx.Corpus.CreateDefinitionCacheTag(resOpt, this, kind);
if (!string.IsNullOrWhiteSpace(cacheTagA))
{
this.TraitCache[cacheTagA] = rtsbAll;
}
}
}
else
{
// cache was found
// get the SymbolSet for this cached object
string key = CdmCorpusDefinition.CreateCacheKeyFromObject(this, kind);
((CdmCorpusDefinition)ctx.Corpus).DefinitionReferenceSymbols.TryGetValue(key, out SymbolSet tempDocRefSet);
resOpt.SymbolRefSet = tempDocRefSet;
}
// merge child document set with current
currDocRefSet.Merge(resOpt.SymbolRefSet);
resOpt.SymbolRefSet = currDocRefSet;
this.Ctx.Corpus.isCurrentlyResolving = wasPreviouslyResolving;
return(rtsbAll.ResolvedTraitSet);
}
internal void ConstructResolvedTraitsDef(CdmObjectReference baseCdmObjectRef, ResolvedTraitSetBuilder rtsb, ResolveOptions resOpt)
{
// get from base public class first, then see if some are applied to base public class on ref then add dynamic traits exhibited by this def
if (baseCdmObjectRef != null)
{
// merge in all from base class
rtsb.MergeTraits((baseCdmObjectRef as CdmObjectReferenceBase).FetchResolvedTraits(resOpt));
}
// merge in dynamic that are exhibited by this class
if (this.ExhibitsTraits != null)
{
foreach (CdmTraitReference exhibitsTrait in this.ExhibitsTraits)
{
rtsb.MergeTraits(exhibitsTrait.FetchResolvedTraits(resOpt));
}
}
}
