/// <summary> /// Fetches the corresponding object definition for every object reference. /// </summary> /// <param name="objects"></param> /// <param name="resOpt"></param> internal void ResolveObjectDefinitions(ResolveOptions resOpt) { ResolveContext ctx = this.Ctx as ResolveContext; resOpt.IndexingDoc = this; foreach (var obj in this.InternalObjects) { switch (obj.ObjectType) { case CdmObjectType.AttributeRef: case CdmObjectType.AttributeGroupRef: case CdmObjectType.AttributeContextRef: case CdmObjectType.DataTypeRef: case CdmObjectType.EntityRef: case CdmObjectType.PurposeRef: case CdmObjectType.TraitRef: ctx.RelativePath = obj.DeclaredPath; CdmObjectReferenceBase reff = obj as CdmObjectReferenceBase; if (CdmObjectReferenceBase.offsetAttributePromise(reff.NamedReference) < 0) { CdmObjectDefinition resNew = reff.FetchObjectDefinition <CdmObjectDefinition>(resOpt); if (resNew == null) { // It's okay if references can't be resolved when shallow validation is enabled. if (resOpt.ShallowValidation) { Logger.Warning(ctx, Tag, nameof(ResolveObjectDefinitions), this.AtCorpusPath, CdmLogCode.WarnResolveReferenceFailure, reff.NamedReference); } else { Logger.Error(ctx, Tag, nameof(ResolveObjectDefinitions), this.AtCorpusPath, CdmLogCode.ErrResolveReferenceFailure, reff.NamedReference); // don't check in this file without both of these comments. handy for debug of failed lookups // CdmObjectDefinitionBase resTest = ref.FetchObjectDefinition(resOpt); } } else { Logger.Info(ctx, Tag, nameof(ResolveObjectDefinitions), this.AtCorpusPath, $"resolved '{reff.NamedReference}'"); } } break; case CdmObjectType.ParameterDef: // when a parameter has a datatype that is a cdm object, validate that any default value is the // right kind object CdmParameterDefinition parameter = obj as CdmParameterDefinition; parameter.ConstTypeCheck(resOpt, this, null); break; } } resOpt.IndexingDoc = null; }
/// <summary> /// Verifies if the trait argument data type matches what is specified on the trait definition. /// </summary> /// <param name="objects"></param> /// <param name="resOpt"></param> internal void ResolveTraitArguments(ResolveOptions resOpt) { ResolveContext ctx = this.Ctx as ResolveContext; foreach (var obj in this.InternalObjects) { if (obj is CdmTraitReference traitRef) { CdmTraitDefinition traitDef = traitRef.FetchObjectDefinition <CdmTraitDefinition>(resOpt); if (traitDef == null) { continue; } for (int argumentIndex = 0; argumentIndex < traitRef.Arguments.Count; ++argumentIndex) { CdmArgumentDefinition argument = traitRef.Arguments[argumentIndex]; try { ctx.RelativePath = argument.DeclaredPath; ParameterCollection paramCollection = traitDef.FetchAllParameters(resOpt); CdmParameterDefinition paramFound = paramCollection.ResolveParameter(argumentIndex, argument.Name); argument.ResolvedParameter = paramFound; // if parameter type is entity, then the value should be an entity or ref to one // same is true of 'dataType' dataType dynamic argumentValue = paramFound.ConstTypeCheck(resOpt, this, argument.Value); if (argumentValue != null) { argument.Value = argumentValue; } } catch (Exception e) { Logger.Error(ctx, Tag, nameof(ResolveTraitArguments), this.AtCorpusPath, CdmLogCode.ErrTraitResolutionFailure, traitDef.GetName(), e.ToString()); } } traitRef.ResolvedArguments = true; } } }
internal override ResolvedTraitSet FetchResolvedTraits(ResolveOptions resOpt = null) { if (resOpt == null) { resOpt = new ResolveOptions(this, this.Ctx.Corpus.DefaultResolutionDirectives); } const string kind = "rtsb"; var ctx = this.Ctx as ResolveContext; // get referenced trait var trait = this.FetchObjectDefinition <CdmTraitDefinition>(resOpt); ResolvedTraitSet rtsTrait = null; if (trait == null) { return(ctx.Corpus.CreateEmptyResolvedTraitSet(resOpt)); } // see if one is already cached // cache by name unless there are parameter if (trait.ThisIsKnownToHaveParameters == null) { // never been resolved, it will happen soon, so why not now? rtsTrait = trait.FetchResolvedTraits(resOpt); } ResolvedTraitSet rtsResult = null; // store the previous reference symbol set, we will need to add it with // children found from the constructResolvedTraits call SymbolSet currSymRefSet = resOpt.SymbolRefSet ?? new SymbolSet(); resOpt.SymbolRefSet = new SymbolSet(); // get the set of resolutions, should just be this one trait if (rtsTrait == null) { // store current symbol ref set SymbolSet newSymbolRefSet = resOpt.SymbolRefSet; resOpt.SymbolRefSet = new SymbolSet(); rtsTrait = trait.FetchResolvedTraits(resOpt); // bubble up symbol reference set from children if (newSymbolRefSet != null) { newSymbolRefSet.Merge(resOpt.SymbolRefSet); } resOpt.SymbolRefSet = newSymbolRefSet; } if (rtsTrait != null) { rtsResult = rtsTrait.DeepCopy(); } // now if there are argument for this application, set the values in the array if (this.Arguments != null && rtsResult != null) { // if never tried to line up arguments with parameters, do that if (!this.ResolvedArguments) { this.ResolvedArguments = true; ParameterCollection param = trait.FetchAllParameters(resOpt); int argumentIndex = 0; foreach (CdmArgumentDefinition argument in this.Arguments) { CdmParameterDefinition paramFound = param.ResolveParameter(argumentIndex, argument.Name); argument.ResolvedParameter = paramFound; argument.Value = paramFound.ConstTypeCheck(resOpt, this.InDocument, argument.Value); argumentIndex++; } } foreach (CdmArgumentDefinition argument in this.Arguments) { rtsResult.SetParameterValueFromArgument(trait, argument); } } // register set of possible symbols ctx.Corpus.RegisterDefinitionReferenceSymbols(this.FetchObjectDefinition <CdmObjectDefinition>(resOpt), kind, resOpt.SymbolRefSet); // merge child document set with current currSymRefSet.Merge(resOpt.SymbolRefSet); resOpt.SymbolRefSet = currSymRefSet; return(rtsResult); }