private static CodeTypeReference CreateTypeReference(ITypedElement typedElement, System.Action<CodeAttributeDeclaration> attributePersistor, System.Func<ITypedElement, CodeTypeReference, ITransformationContext, CodeTypeReference> getCollectionType, ITransformationContext context)
{
if (typedElement == null) return new CodeTypeReference(typeof(void));
CodeTypeReference elementType;
var systemType = typedElement.Type as IPrimitiveType;
if (systemType != null)
{
elementType = new CodeTypeReference(systemType.SystemType);
}
else
{
var type = typedElement.Type;
bool isReference;
if (type != null)
{
isReference = type is IReferenceType;
}
else
{
isReference = typedElement is IReference;
}
elementType = CreateReference(typedElement.Type, isReference, context);
}
if (typedElement.UpperBound == 1)
{
return elementType;
}
else
{
if (attributePersistor != null)
{
if (typedElement.LowerBound > 0) attributePersistor(new CodeAttributeDeclaration(new CodeTypeReference(typeof(LowerBoundAttribute).Name), new CodeAttributeArgument(new CodePrimitiveExpression(typedElement.LowerBound))));
if (typedElement.UpperBound > 1) attributePersistor(new CodeAttributeDeclaration(new CodeTypeReference(typeof(UpperBoundAttribute).Name), new CodeAttributeArgument(new CodePrimitiveExpression(typedElement.UpperBound))));
}
if (getCollectionType == null)
{
return new CodeTypeReference(typeof(IEnumerable<>).Name, elementType);
}
else
{
return getCollectionType(typedElement, elementType, context);
}
}
}
public static void VisitAll(this ITypedElement nav) => nav.Visit((_, n) => { var dummy = n.Value; });
public static void Visit(this ITypedElement root, Action <int, ITypedElement> visitor) => root.visit(visitor, 0);
/// <summary> /// Provides the statement which modifies the variable /// </summary> /// <param name="variable"></param> /// <returns>null if no statement modifies the element</returns> public abstract VariableUpdateStatement Modifies(ITypedElement variable);
public bool Reads(ITypedElement variable)
{
bool retVal = false;
foreach (Case cas in Cases)
{
if (cas.Read(variable))
{
retVal = true;
break;
}
}
return retVal;
}
/// <summary>
/// Indicates whether this statement reads the element
/// </summary>
/// <param name="variable"></param>
/// <returns></returns>
public override bool Reads(ITypedElement variable)
{
foreach (Action action in Actions)
{
if (action.Reads(variable))
{
return true;
}
}
return false;
}
/// <summary>
/// Provides the mode for the typed element provided
/// </summary>
/// <param name="element"></param>
/// <returns></returns>
public Usage.ModeEnum GetModeForTypedElement(ITypedElement element)
{
Usage.ModeEnum retVal = Usage.ModeEnum.Read;
foreach (Action action in Actions)
{
Usage.ModeEnum mode = action.GetModeForTypedElement(element);
if (mode != Usage.ModeEnum.Read)
{
retVal = mode;
break;
}
}
return retVal;
}
/// <summary>
/// Indicates whether this call may read a given variable
/// </summary>
/// <param name="variable"></param>
/// <returns></returns>
public bool Reads(ITypedElement variable)
{
bool retVal = false;
Function function = Called.getStaticCallable() as Function;
if (function != null)
{
retVal = function.Reads(variable);
}
return retVal;
}
public static bool IsEqualTo(this ITypedElement left, ITypedElement right, bool compareNames = false)
{
if (compareNames && (left.Name != right.Name))
{
return(false);
}
var l = left.Value;
var r = right.Value;
// Compare primitives (or extended primitives)
if (l != null && r != null)
{
if (l.GetType() == typeof(string) && r.GetType() == typeof(string))
{
return((string)l == (string)r);
}
else if (l.GetType() == typeof(bool) && r.GetType() == typeof(bool))
{
return((bool)l == (bool)r);
}
else if (l.GetType() == typeof(long) && r.GetType() == typeof(long))
{
return((long)l == (long)r);
}
else if (l.GetType() == typeof(decimal) && r.GetType() == typeof(decimal))
{
return((decimal)l == (decimal)r);
}
else if (l.GetType() == typeof(long) && r.GetType() == typeof(decimal))
{
return((decimal)(long)l == (decimal)r);
}
else if (l.GetType() == typeof(decimal) && r.GetType() == typeof(long))
{
return((decimal)l == (decimal)(long)r);
}
else if (l.GetType() == typeof(PartialTime) && r.GetType() == typeof(PartialTime))
{
return((PartialTime)l == (PartialTime)r);
}
else if (l.GetType() == typeof(PartialDateTime) && r.GetType() == typeof(PartialDateTime))
{
return((PartialDateTime)l == (PartialDateTime)r);
}
else
{
return(false);
}
}
else if (l == null && r == null)
{
// Compare complex types (extensions on primitives are not compared, but handled (=ignored) above
var childrenL = left.Children();
var childrenR = right.Children();
return(childrenL.IsEqualTo(childrenR, compareNames: true)); // NOTE: Assumes null will never be returned when any() children exist
}
else
{
// Else, we're comparing a complex (without a value) to a primitive which (probably) should return false
return(false);
}
}
#pragma warning restore 612, 618
public static byte[] ToXmlBytes(this ITypedElement source, FhirXmlSerializationSettings settings = null)
=> SerializationUtil.WriteXmlToBytes(writer => source.WriteTo(writer, settings));
public static string ToXml(this ITypedElement source, FhirXmlSerializationSettings settings = null) => SerializationUtil.WriteXmlToString(writer => source.WriteTo(writer, settings), settings?.Pretty ?? false, settings?.AppendNewLine ?? false);
public static XDocument ToXDocument(this ITypedElement source, FhirXmlSerializationSettings settings = null) => new FhirXmlBuilder(settings).Build(source);
/// <summary>
/// Considers the type of the element provided as parameter
/// </summary>
/// <param name="element">The element which uses this type</param>
private void ConsiderTypeOfElement(ITypedElement element)
{
ModelElement modelElement = element as ModelElement;
if (modelElement != null)
{
if (Model != null)
{
if ((element.Type == Model) && (element != Model))
{
Usages.Add(new Usage(Model, modelElement, Usage.ModeEnum.Type));
}
}
else
{
if (Filter.AcceptableChoice(element.Type))
{
Usages.Add(new Usage(element.Type, modelElement, Usage.ModeEnum.Type));
}
}
}
}
/// <summary>
/// Provides the mode for the typed element provided
/// </summary>
/// <param name="element"></param>
/// <returns></returns>
public Usage.ModeEnum GetModeForTypedElement(ITypedElement element)
{
Usage.ModeEnum retVal = Usage.ModeEnum.Read;
ReferenceVisitor visitor = new ReferenceVisitor(element);
visitor.ConsiderInterpreterTreeNode(Statement);
foreach (Usage usage in visitor.Usages)
{
if (usage.Mode != null && usage.Mode != Usage.ModeEnum.Read)
{
retVal = (Usage.ModeEnum) usage.Mode;
break;
}
}
return retVal;
}
protected void InsertElement(ITypedElement element, TextualExplanation text)
{
text.Write(element.Name);
text.Write(" => ");
Structure structure = element.Type as Structure;
if (structure != null)
{
text.WriteLine(StripUseless(structure.FullName, WritingContext()) + "{");
text.Indent(4, () =>
{
bool first = true;
foreach (StructureElement subElement in structure.Elements)
{
if (!first)
{
text.WriteLine(",");
}
InsertElement(subElement, text);
first = false;
}
});
text.WriteLine();
text.Write("}");
}
else
{
IValue value = null;
if (string.IsNullOrEmpty(element.Default))
{
// No default value for element, get the one of the type
if (element.Type != null && element.Type.DefaultValue != null)
{
value = element.Type.DefaultValue;
}
}
else
{
if (element.Type != null)
{
value = element.Type.getValue(element.Default);
}
}
if (value != null)
{
text.Write(StripUseless(value.FullName, WritingContext()));
}
}
}
public PrimitiveValueReader(ITypedElement data)
{
_current = data;
_inspector = BaseFhirParser.Inspector;
}
public static MaskingNode ForSummary(ITypedElement node) =>
new MaskingNode(node, new MaskingNodeSettings
{
IncludeInSummary = true,
PreserveBundle = MaskingNodeSettings.PreserveBundleMode.Root
});
/// <summary>
/// Provides the changes performed by this statement
/// </summary>
/// <param name="context">The context on which the changes should be computed</param>
/// <param name="changes">The list to fill with the changes</param>
/// <param name="explanation">The explanatino to fill, if any</param>
/// <param name="apply">Indicates that the changes should be applied immediately</param>
/// <param name="runner"></param>
public override void GetChanges(InterpretationContext context, ChangeList changes, ExplanationPart explanation,
bool apply, Runner runner)
{
if (Call != null)
{
// Explain what happens in this statement
explanation = ExplanationPart.CreateSubExplanation(explanation, this);
InterpretationContext ctxt = GetContext(context, explanation);
Procedure procedure = Call.GetProcedure(ctxt, explanation);
if (procedure != null)
{
ctxt.HasSideEffects = true;
// If the procedure has been defined in a structure,
// ensure that it is applied to an instance of that structure
Structure structure = procedure.Enclosing as Structure;
if (structure != null)
{
ITypedElement current = ctxt.Instance as ITypedElement;
while (current != null)
{
if (current.Type != structure)
{
current = current.Enclosing as ITypedElement;
}
else
{
ctxt.Instance = current;
ExplanationPart.CreateSubExplanation(explanation, "Instance", current);
current = null;
}
}
}
ExplanationPart part = ExplanationPart.CreateSubExplanation(explanation, procedure);
if (ctxt.Instance is IVariable)
{
ExplanationPart.SetNamable(part, ctxt.Instance);
ExplanationPart instanceExplanation = ExplanationPart.CreateSubExplanation(part, "instance = ");
ExplanationPart.SetNamable(instanceExplanation, ctxt.Instance);
}
int token = ctxt.LocalScope.PushContext();
foreach (
KeyValuePair <Actual, IValue> pair in Call.AssignParameterValues(context, procedure, true, part))
{
ctxt.LocalScope.SetVariable(pair.Key, pair.Value);
}
foreach (Rule rule in procedure.Rules)
{
ApplyRule(rule, changes, ctxt, part, runner);
}
ctxt.LocalScope.PopContext(token);
}
else
{
AddError("Cannot determine the called procedure for " + ToString(), RuleChecksEnum.ExecutionFailed);
}
}
else
{
AddError("Expression " + ToString() + " is not a valid procedure call", RuleChecksEnum.ExecutionFailed);
}
}
/// <summary>
/// Considers the type of the element provided as parameter
/// </summary>
/// <param name="element">The element which uses this type</param>
private void ConsiderTypeOfElement(ITypedElement element)
{
ModelElement modelElement = element as ModelElement;
if (modelElement != null)
{
Type current = element.Type;
while (current != null)
{
if (Model != null)
{
if ((current == Model) && (element != Model))
{
Usages.Add(new Usage(Model, modelElement, Usage.ModeEnum.Type));
}
}
else
{
if (Filter.AcceptableChoice(current))
{
Usages.Add(new Usage(element.Type, modelElement, Usage.ModeEnum.Type));
}
}
current = EnclosingFinder<Type>.find(current);
}
}
}
public FhirEvaluationContext(ITypedElement context) : base(context)
{
}
/// <summary>
/// Provides the statement which modifies the element
/// </summary>
/// <param name="variable"></param>
/// <returns>null if no statement modifies the element</returns>
public override VariableUpdateStatement Modifies(ITypedElement variable)
{
VariableUpdateStatement retVal = null;
if (variable == Target)
{
retVal = this;
}
return retVal;
}
internal ResourceElement(ITypedElement instance, object resourceInstance)
: this(instance)
{
EnsureArg.IsNotNull(resourceInstance, nameof(resourceInstance));
ResourceInstance = resourceInstance;
}
/// <summary>
/// Indicates whether this rule reads the content of this variable
/// </summary>
/// <param name="variable"></param>
/// <returns></returns>
public bool Reads(ITypedElement variable)
{
foreach (PreCondition precondition in PreConditions)
{
if (precondition.Reads(variable))
{
return true;
}
}
foreach (Action action in Actions)
{
if (action.Reads(variable))
{
return true;
}
}
return false;
}
internal BubbledChangeEventArgs(IModelElement element, ITypedElement feature = null)
{
Element = element;
Feature = feature;
}
/// <summary>
/// Indicates whether this action reads the variable
/// </summary>
/// <param name="variable"></param>
/// <returns></returns>
public bool Reads(ITypedElement variable)
{
if (Statement != null)
{
return Statement.Reads(variable);
}
return false;
}
public static T ParsePrimitive <T>(this ITypedElement instance) where T : Primitive, new()
=> new T()
{
ObjectValue = instance.Value
};
public static Base ToPoco(this ITypedElement element, PocoBuilderSettings settings = null) => new PocoBuilder(settings).BuildFrom(element);
public static T ToPoco <T>(this ITypedElement element, PocoBuilderSettings settings = null) where T : Base => (T)element.ToPoco(settings);
public static IDisposable Catch(this ITypedElement source, ExceptionNotificationHandler handler) =>
source is IExceptionSource s?s.Catch(handler) : throw new NotImplementedException("Element does not implement IExceptionSource.");
public IList <Bug.Common.Dto.Indexing.IndexUri> Set(Bug.Common.Enums.FhirVersion fhirVersion, ITypedElement typedElement, Bug.Common.Enums.ResourceType resourceType, int searchParameterId, string searchParameterName)
{
switch (fhirVersion)
{
case Common.Enums.FhirVersion.Stu3:
var Stu3Tool = IFhirIndexUriSetterSupportFactory.GetStu3();
return(Stu3Tool.Set(typedElement, resourceType, searchParameterId, searchParameterName));
case Common.Enums.FhirVersion.R4:
var R4Tool = IFhirIndexUriSetterSupportFactory.GetR4();
return(R4Tool.Set(typedElement, resourceType, searchParameterId, searchParameterName));
default:
throw new FhirVersionFatalException(fhirVersion);
}
}
public static IEnumerable <object> Annotations(this ITypedElement nav, Type type) => nav is IAnnotated ann?ann.Annotations(type) : Enumerable.Empty <object>();
private TypedElementToSourceNodeAdapter(TypedElementToSourceNodeAdapter parent, ITypedElement child)
{
Current = child;
ExceptionHandler = parent.ExceptionHandler;
}
private (bool included, bool mandatory) included(ITypedElement node)
{
var scope = getScope(node);
// Trivially, we will include the root
if (!scope.Location.Contains("."))
{
return(true, false);
}
bool atRootBundle() => atBundle() && scope.ParentResource == null;
bool atBundle() => scope.NearestResourceType == "Bundle";
switch (_settings.PreserveBundle)
{
case MaskingNodeSettings.PreserveBundleMode.All when atBundle():
case MaskingNodeSettings.PreserveBundleMode.Root when atRootBundle():
return(true, false);
// fall through...
}
var included = _settings.IncludeAll || _includeAll;
bool mandatory = false; // included because it's required & includeMandatory is on
var ed = scope.Definition;
if (ed != null)
{
mandatory = _settings.IncludeMandatory && ed.IsRequired;
included |= mandatory;
included |= _settings.IncludeInSummary && ed.InSummary;
}
var loc = scope.LocalLocation;
var nearest = scope.NearestResourceType;
included |= _settings.IncludeElements?.Any(matches) ?? false;
if (_settings.ExcludeElements?.Any(matches) == true)
{
return(false, false);
}
bool matches(string filter)
{
var f = nearest + "." + filter;
return(loc == f || loc.StartsWith(f + ".") || loc.StartsWith(f + "[")); // include matches + children
}
if (_settings.ExcludeMarkdown && scope.InstanceType == "markdown")
{
return(false, false);
}
if (_settings.ExcludeNarrative & scope.InstanceType == "Narrative")
{
return(false, false);
}
return(included, mandatory);
}
static ITypedElement resolver(ITypedElement f, EvaluationContext ctx)
{
return(ctx is FhirEvaluationContext fctx?f.Resolve(fctx.ElementResolver) : f.Resolve());
}
/// <summary>
/// Refactors an element which has a type
/// </summary>
/// <param name="element">The element that has been modified</param>
/// <param name="user">The user which references this type</param>
private static void RefactorTypedElement(ModelElement element, ITypedElement user)
{
if (user != null)
{
try
{
ModelElement enclosing = EnclosingFinder<NameSpace>.find(user, true);
Function function = user as Function;
if (function != null)
{
bool refactor = false;
Type current = function.ReturnType;
while (current != null && !refactor)
{
refactor = current == element;
current = EnclosingFinder<Type>.find(current);
}
if (refactor)
{
function.TypeName = function.ReturnType.ReferenceName(enclosing);
}
}
else
{
bool refactor = false;
Type current = user.Type;
while (current != null && !refactor)
{
refactor = current == element;
current = EnclosingFinder<Type>.find(current);
}
if (refactor)
{
user.TypeName = user.Type.ReferenceName(enclosing);
}
}
}
catch (Exception e)
{
((ModelElement)user).AddError("Cannot refactor this element, reason = " + e.Message);
}
}
}
public void DeleteSearchParameter(ITypedElement searchParam)
{
_inner.DeleteSearchParameter(searchParam);
}
public bool Read(ITypedElement variable)
{
bool retVal = false;
foreach (PreCondition preCondition in PreConditions)
{
if (preCondition.Reads(variable))
{
retVal = true;
break;
}
}
if (!retVal && Expression != null)
{
foreach (IVariable var in Expression.GetVariables())
{
if (var == variable)
{
retVal = true;
break;
}
}
}
return retVal;
}
public static bool Contains(this IEnumerable <ITypedElement> focus, ITypedElement value)
{
return(focus.Contains(value, new EqualityOperators.ValueProviderEqualityComparer()));
}
/// <summary>
/// Provides the statement which modifies the variable
/// </summary>
/// <param name="variable"></param>
/// <returns>null if no statement modifies the element</returns>
public override VariableUpdateStatement Modifies(ITypedElement variable)
{
VariableUpdateStatement retVal = AppliedStatement.Modifies(variable);
return retVal;
}
private static CompiledExpression getExecutableConstraint(Validator v, OperationOutcome outcome, ITypedElement instance,
ElementDefinition.ConstraintComponent constraintElement)
{
var compiledExpression = constraintElement.Annotation <CompiledConstraintAnnotation>()?.Expression;
if (compiledExpression == null)
{
var fpExpressionText = constraintElement.GetFhirPathConstraint();
if (fpExpressionText != null)
{
try
{
compiledExpression = v.FpCompiler.Compile(fpExpressionText);
constraintElement.AddAnnotation(new CompiledConstraintAnnotation {
Expression = compiledExpression
});
}
catch (Exception e)
{
v.Trace(outcome, $"Compilation of FhirPath for constraint '{constraintElement.Key}' failed: {e.Message}",
Issue.PROFILE_ELEMENTDEF_INVALID_FHIRPATH_EXPRESSION, instance);
}
}
else
{
v.Trace(outcome, $"Encountered an invariant ({constraintElement.Key}) that has no FhirPath expression, skipping validation of this constraint",
Issue.UNSUPPORTED_CONSTRAINT_WITHOUT_FHIRPATH, instance);
}
}
return(compiledExpression);
}
/// <summary>
/// Provides the statement which modifies the variable
/// </summary>
/// <param name="variable"></param>
/// <returns>null if no statement modifies the element</returns>
public override VariableUpdateStatement Modifies(ITypedElement variable)
{
VariableUpdateStatement retVal = null;
return retVal;
}
public EvaluationContext GetEvaluationContext(ITypedElement element)
{
return(new FhirEvaluationContext(element));
}
/// <summary>
/// Indicates whether this statement reads the variable
/// </summary>
/// <param name="variable"></param>
/// <returns></returns>
public virtual bool Reads(ITypedElement variable)
{
List<ITypedElement> variablesRead = new List<ITypedElement>();
ReadElements(variablesRead);
return variablesRead.Contains(variable);
}
/// <summary>
/// Provides the statement which modifies the element
/// </summary>
/// <param name="element"></param>
/// <returns>null if no statement modifies the element</returns>
public override VariableUpdateStatement Modifies(ITypedElement element)
{
return(null);
}
/// <summary>
/// Provides the statement which modifies the variable
/// </summary>
/// <param name="variable"></param>
/// <returns>null if no statement modifies the element</returns>
public VariableUpdateStatement Modifies(ITypedElement variable)
{
VariableUpdateStatement retVal = null;
foreach (Action action in Actions)
{
retVal = action.Modifies(variable);
if (retVal != null)
{
return retVal;
}
}
return retVal;
}
private IEnumerable <SearchIndexEntry> ProcessNonCompositeSearchParameter(SearchParameterInfo searchParameter, ITypedElement resource, EvaluationContext context)
{
EnsureArg.IsNotNull(searchParameter, nameof(searchParameter));
Debug.Assert(searchParameter.Type != SearchParamType.Composite, "The search parameter must be non-composite.");
SearchParameterInfo searchParameterInfo = searchParameter;
foreach (ISearchValue searchValue in ExtractSearchValues(
searchParameter.Url.ToString(),
searchParameter.Type,
searchParameter.TargetResourceTypes,
resource,
searchParameter.Expression,
context))
{
yield return(new SearchIndexEntry(searchParameterInfo, searchValue));
}
}
/// <summary>
/// Indicates whether this preCondition reads the variable
/// </summary>
/// <param name="variable"></param>
/// <returns></returns>
public bool Reads(ITypedElement variable)
{
bool retVal = false;
if (Expression != null)
{
foreach (ITypedElement el in Expression.GetVariables())
{
if (el == variable)
{
retVal = true;
break;
}
}
if (!retVal)
{
Call call = Expression as Call;
if (call != null)
{
retVal = call.Reads(variable);
}
}
}
return retVal;
}
private IReadOnlyList <ISearchValue> ExtractSearchValues(
string searchParameterDefinitionUrl,
SearchParamType?searchParameterType,
IReadOnlyList <string> allowedReferenceResourceTypes,
ITypedElement element,
string fhirPathExpression,
EvaluationContext context)
{
Debug.Assert(searchParameterType != SearchParamType.Composite, "The search parameter must be non-composite.");
var results = new List <ISearchValue>();
// For simple value type, we can parse the expression directly.
IEnumerable <ITypedElement> extractedValues = Enumerable.Empty <ITypedElement>();
try
{
extractedValues = element.Select(fhirPathExpression, context);
}
catch (Exception ex)
{
_logger.LogWarning(
ex,
"Failed to extract the values using '{FhirPathExpression}' against '{ElementType}'.",
fhirPathExpression,
element.GetType());
}
Debug.Assert(extractedValues != null, "The extracted values should not be null.");
// If there is target set, then filter the extracted values to only those types.
if (searchParameterType == SearchParamType.Reference &&
allowedReferenceResourceTypes?.Count > 0)
{
List <string> targetResourceTypes = _targetTypesLookup.GetOrAdd(searchParameterDefinitionUrl, _ =>
{
return(allowedReferenceResourceTypes.Select(t => t.ToString()).ToList());
});
// TODO: The expression for reference search parameters in STU3 has issues.
// The reference search parameter could be pointing to an element that can be multiple types. For example,
// the Appointment.participant.actor can be type of Patient, Practitioner, Related Person, Location, and so on.
// Some search parameter could refer to this property but restrict to certain types. For example,
// Appointment's location search parameter is returned only when Appointment.participant.actor is Location element.
// The STU3 expressions don't have this restriction so everything is being returned. This is addressed in R4 release (see
// http://community.fhir.org/t/expression-seems-incorrect-for-reference-search-parameter-thats-only-applicable-to-certain-types/916/2).
// Therefore, for now, we will need to compare the reference value itself (which can be internal or external references), and restrict
// the values ourselves.
extractedValues = extractedValues.Where(ev =>
{
if (ev.InstanceType.Equals("ResourceReference", StringComparison.OrdinalIgnoreCase))
{
var rr = ev.Scalar("reference") as string;
return(rr != null && targetResourceTypes.Any(trt => rr.Contains(trt, StringComparison.Ordinal)));
}
return(true);
});
}
foreach (var extractedValue in extractedValues)
{
if (!_fhirElementTypeConverterManager.TryGetConverter(extractedValue.InstanceType, GetSearchValueTypeForSearchParamType(searchParameterType), out IFhirNodeToSearchValueTypeConverter converter))
{
_logger.LogWarning(
"The FHIR element '{ElementType}' is not supported.",
extractedValue.InstanceType);
continue;
}
IEnumerable <ISearchValue> searchValues = converter.ConvertTo(extractedValue);
if (searchValues != null)
{
if (searchParameterType == SearchParamType.Reference && allowedReferenceResourceTypes?.Count == 1)
{
// For references, if the type is not specified in the reference string, we can set the type on the search value because
// in this case it can only be of one type.
string singleAllowedResourceType = allowedReferenceResourceTypes[0];
foreach (ISearchValue searchValue in searchValues)
{
if (searchValue is ReferenceSearchValue rsr && string.IsNullOrEmpty(rsr.ResourceType))
{
results.Add(new ReferenceSearchValue(rsr.Kind, rsr.BaseUri, singleAllowedResourceType, rsr.ResourceId));
}
else
{
results.Add(searchValue);
}
}
}
/// <summary>
/// Provides the statement which modifies the variable
/// </summary>
/// <param name="variable"></param>
/// <returns>null if no statement modifies the element</returns>
public VariableUpdateStatement Modifies(ITypedElement variable)
{
if (Statement != null)
{
return Statement.Modifies(variable);
}
return null;
}
private IEnumerable <SearchIndexEntry> ProcessCompositeSearchParameter(SearchParameterInfo searchParameter, ITypedElement resource, EvaluationContext context)
{
Debug.Assert(searchParameter?.Type == SearchParamType.Composite, "The search parameter must be composite.");
SearchParameterInfo compositeSearchParameterInfo = searchParameter;
IEnumerable <ITypedElement> rootObjects = resource.Select(searchParameter.Expression, context);
foreach (var rootObject in rootObjects)
{
int numberOfComponents = searchParameter.Component.Count;
bool skip = false;
var componentValues = new IReadOnlyList <ISearchValue> [numberOfComponents];
// For each object extracted from the expression, we will need to evaluate each component.
for (int i = 0; i < numberOfComponents; i++)
{
SearchParameterComponentInfo component = searchParameter.Component[i];
// First find the type of the component.
SearchParameterInfo componentSearchParameterDefinition = searchParameter.Component[i].ResolvedSearchParameter;
IReadOnlyList <ISearchValue> extractedComponentValues = ExtractSearchValues(
componentSearchParameterDefinition.Url.ToString(),
componentSearchParameterDefinition.Type,
componentSearchParameterDefinition.TargetResourceTypes,
rootObject,
component.Expression,
context);
// Filter out any search value that's not valid as a composite component.
extractedComponentValues = extractedComponentValues
.Where(sv => sv.IsValidAsCompositeComponent)
.ToArray();
if (!extractedComponentValues.Any())
{
// One of the components didn't have any value and therefore it will not be indexed.
skip = true;
break;
}
componentValues[i] = extractedComponentValues;
}
if (skip)
{
continue;
}
yield return(new SearchIndexEntry(compositeSearchParameterInfo, new CompositeSearchValue(componentValues)));
}
}
/// <summary>
/// Provides the statement which modifies the element
/// </summary>
/// <param name="element"></param>
/// <returns>null if no statement modifies the element</returns>
public override VariableUpdateStatement Modifies(ITypedElement element)
{
return null;
}
public static IEnumerable <ITypedElement> DescendantsAndSelf(this ITypedElement element) =>
(new[] { element }).Concat(element.Descendants());
/// <summary>
/// Indicates whether this statement reads the variable
/// </summary>
/// <param name="variable"></param>
/// <returns></returns>
public virtual bool Reads(ITypedElement variable)
{
bool retVal = false;
List<ITypedElement> variablesRead = new List<ITypedElement>();
ReadElements(variablesRead);
retVal = variablesRead.Contains(variable);
return retVal;
}
/// <summary>
/// Refactors an element which has a type
/// </summary>
/// <param name="element">The element that has been modified</param>
/// <param name="user">The user which references this type</param>
private static void RefactorTypedElement(ModelElement element, ITypedElement user)
{
if (user != null)
{
ModelElement enclosing = EnclosingFinder<NameSpace>.find(user, true);
try
{
Function userFunction = user as Function;
if ((user.Type == element))
{
string newName = element.ReferenceName(enclosing);
user.TypeName = newName;
}
else if (userFunction != null && userFunction.ReturnType == element)
{
userFunction.ReturnType = element as Type;
}
else if (element is NameSpace)
{
string newName;
Function function = user as Function;
if (function != null)
{
newName = function.ReturnType.ReferenceName(user as ModelElement);
user.TypeName = newName;
}
else
{
newName = user.Type.ReferenceName(user as ModelElement);
user.TypeName = newName;
}
}
}
catch (Exception e)
{
((ModelElement) user).AddError("Cannot refactor this element, reason = " + e.Message);
}
}
}
