#2910 Make Base implement IScopedNode - phase 1

src/Hl7.Fhir.Base/ElementModel/PocoElementNode.cs

@@ -14,7 +14,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 using P = Hl7.Fhir.ElementModel.Types;
 
 namespace Hl7.Fhir.ElementModel
@@ -32,7 +31,7 @@ internal PocoElementNode(ModelInspector inspector, Base root, string rootName =
         {
             Current = root;
             _inspector = inspector;
-            _myClassMapping = _inspector.FindOrImportClassMapping(root.GetType());
+            _myClassMapping = _inspector.FindOrImportClassMapping(root.GetType())!;
 
             InstanceType = ((IStructureDefinitionSummary)_myClassMapping).TypeName;
             Definition = ElementDefinitionSummary.ForRoot(_myClassMapping, rootName ?? root.TypeName);
@@ -54,7 +53,7 @@ private PocoElementNode(ModelInspector inspector, Base instance, PocoElementNode
             InstanceType = ((IStructureDefinitionSummary)_myClassMapping).TypeName;
             Definition = definition ?? throw Error.ArgumentNull(nameof(definition));
 
-            ExceptionHandler = parent.ExceptionHandler;
+        //    ExceptionHandler = parent.ExceptionHandler;
             Location = location;
             ShortPath = shortPath;
         }
@@ -70,7 +69,7 @@ private Type determineInstanceType(PropertyMapping definition)
             {
                 "url" => typeof(FhirUri),
                 "id" => typeof(FhirString),
-                "div" => typeof(XHtml),
+                //"div" => typeof(XHtml),
                 _ => throw new NotSupportedException(
                     $"Encountered unexpected primitive type {Name} in backward compat behaviour for PocoElementNode.InstanceType.")
             };
@@ -205,39 +204,20 @@ internal object ToITypedElementValue()
         {
             try
             {
-                switch (Current)
+                return Current switch
                 {
-                    case Hl7.Fhir.Model.Instant ins when ins.Value.HasValue:
-                        return P.DateTime.FromDateTimeOffset(ins.Value.Value);
-                    case Hl7.Fhir.Model.Time time when time.Value is { }:
-                        return P.Time.Parse(time.Value);
-                    case Hl7.Fhir.Model.Date dt when dt.Value is { }:
-                        return P.Date.Parse(dt.Value);
-                    case FhirDateTime fdt when fdt.Value is { }:
-                        return P.DateTime.Parse(fdt.Value);
-                    case Hl7.Fhir.Model.Integer fint:
-                        if (!fint.Value.HasValue)
-                            return null;
-                        return (int)fint.Value;
-                    case Hl7.Fhir.Model.Integer64 fint64:
-                        if (!fint64.Value.HasValue)
-                            return null;
-                        return (long)fint64.Value;
-                    case Hl7.Fhir.Model.PositiveInt pint:
-                        if (!pint.Value.HasValue)
-                            return null;
-                        return (int)pint.Value;
-                    case Hl7.Fhir.Model.UnsignedInt unsint:
-                        if (!unsint.Value.HasValue)
-                            return null;
-                        return (int)unsint.Value;
-                    case Hl7.Fhir.Model.Base64Binary b64:
-                        return b64.Value != null ? PrimitiveTypeConverter.ConvertTo<string>(b64.Value) : null;
-                    case PrimitiveType prim:
-                        return prim.ObjectValue;
-                    default:
-                        return null;
-                }
+                    Instant { Value: { } ins } => P.DateTime.FromDateTimeOffset(ins),
+                    Time { Value: { } time } => P.Time.Parse(time),
+                    Date { Value: { } dt } => P.Date.Parse(dt),
+                    FhirDateTime { Value: { } fdt } => P.DateTime.Parse(fdt),
+                    Integer fint => fint.Value,
+                    Integer64 fint64 => fint64.Value,
+                    PositiveInt pint => pint.Value,
+                    UnsignedInt unsint => unsint.Value,
+                    Base64Binary { Value: { } b64 } => PrimitiveTypeConverter.ConvertTo<string>(b64),
+                    PrimitiveType prim => prim.ObjectValue,
+                    _ => null
+                };
             }
             catch (FormatException)
             {
@@ -247,25 +227,24 @@ internal object ToITypedElementValue()
         }
 
 
-        public string InstanceType { get; private set; }
+        public string InstanceType { get; }
 
-        public string Location { get; private set; }
+        public string Location { get; }
 
         public string ResourceType => Current is Resource ? InstanceType : null;
 
         public IEnumerable<object> Annotations(Type type)
         {
             if (type == typeof(PocoElementNode) || type == typeof(ITypedElement) || type == typeof(IShortPathGenerator))
-                return new[] { this };
+                return [this];
             else if (type == typeof(IFhirValueProvider))
-                return new[] { this };
+                return [this];
             else if (type == typeof(IResourceTypeSupplier))
-                return new[] { this };
+                return [this];
             else if (FhirValue is IAnnotated ia)
                 return ia.Annotations(type);
-
             else
-                return Enumerable.Empty<object>();
+                return [];
         }
     }
 }

src/Hl7.Fhir.Base/ElementModel/TypedElementExtensions.cs

@@ -120,4 +120,4 @@ public static bool Matches<T>(this T value, T pattern) where T : IBaseElementNav
         }
     }
 }
-#nullable restore
+#nullable restore

src/Hl7.Fhir.Base/FhirPath/CompiledExpression.cs

@@ -1,6 +1,7 @@
 #nullable enable
 
 using Hl7.Fhir.ElementModel;
+using Hl7.Fhir.Model;
 using Hl7.FhirPath.Functions;
 using System.Collections.Generic;
 using System.Linq;

src/Hl7.Fhir.Base/FhirPath/Expressions/Closure.cs

@@ -8,6 +8,7 @@
 
 
 using Hl7.Fhir.ElementModel;
+using Hl7.Fhir.Model;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Dynamic;

src/Hl7.Fhir.Base/FhirPath/FhirPathCompiler.cs

@@ -7,6 +7,7 @@
  */
 
 using Hl7.Fhir.ElementModel;
+using Hl7.Fhir.Model;
 using Hl7.FhirPath.Expressions;
 using Hl7.FhirPath.Parser;
 using Hl7.FhirPath.Sprache;

src/Hl7.Fhir.Base/Model/Base.TypedElement.cs

@@ -0,0 +1,177 @@
+#if true
+
+#nullable enable
+
+using Hl7.Fhir.ElementModel;
+using Hl7.Fhir.Introspection;
+using Hl7.Fhir.Serialization;
+using Hl7.Fhir.Specification;
+using Hl7.Fhir.Utility;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+using P=Hl7.Fhir.ElementModel.Types;
+
+namespace Hl7.Fhir.Model;
+
+
+/// <summary>
+/// An element within a tree of typed FHIR data with also a parent element.
+/// </summary>
+/// <remarks>
+/// This interface represents FHIR data as a tree of elements, including type information either present in
+/// the instance or derived from fully aware of the FHIR definitions and types
+/// </remarks>
+#pragma warning disable CS0618 // Type or member is obsolete
+public interface IScopedNode : ITypedElement, IShortPathGenerator
+#pragma warning restore CS0618 // Type or member is obsolete
+{
+    /// <summary>
+    /// The parent node of this node, or null if this is the root node.
+    /// </summary>
+    IScopedNode? Parent { get; } 
+
+    // /// <summary>
+    // /// An indication of the location of this node within the data represented by the <c>ITypedElement</c>.
+    // /// </summary>
+    // /// <remarks>The format of the location is the dotted name of the property, including indices to make
+    // /// sure repeated occurrences of an element can be distinguished. It needs to be sufficiently precise to aid
+    // /// the user in locating issues in the data.</remarks>
+    // string Location { get; }
+}
+
+internal record ScopeInformation(IScopedNode? Parent, string Name, int? Index);
+
+
+public abstract partial class Base : IScopedNode,
+    IFhirValueProvider, IResourceTypeSupplier
+{
+    [NonSerialized]
+    private ScopeInformation? _scopeInfo;
+
+    private ScopeInformation ScopeInfo
+    {
+        get => LazyInitializer.EnsureInitialized(ref _scopeInfo, () => BuildRoot())!;
+        set => _scopeInfo = value;
+    } 
+
+    internal ScopeInformation BuildRoot(string? rootName = null) => new(null, rootName ?? TypeName, null);
+
+    internal Base WithScopeInfo(ScopeInformation info)
+    {
+        this.ScopeInfo = info;
+        return this;
+    }
+
+    IEnumerable<ITypedElement> IBaseElementNavigator<ITypedElement>.Children(string? name) =>
+        this.GetElementPairs()
+            .Where(ep => (name == null || name == ep.Key))
+            .SelectMany<KeyValuePair<string, object>, Base>(ep => 
+                (ep.Key, ep.Value) switch
+                {
+                    (_, Base b) => (IEnumerable<Base>)[b.WithScopeInfo(new ScopeInformation(this, ep.Key, null))],
+                    (_, IEnumerable<Base> list) => list.Select((item, idx) => item.WithScopeInfo(new ScopeInformation(this, ep.Key, idx))),
+                    ("url", string s) when this is Extension => [new FhirUri(s).WithScopeInfo(new ScopeInformation(this, ep.Key, null))],
+                    ("id", string s) when this is Element => [new FhirString(s).WithScopeInfo(new ScopeInformation(this, ep.Key, null))],
+                    ("value", _) => [],
+                    _ => throw new InvalidOperationException("Unexpected system primitive in child list")
+                }
+            );
+
+    IScopedNode? IScopedNode.Parent => ScopeInfo.Parent;
+
+    string IBaseElementNavigator<ITypedElement>.Name => ScopeInfo.Name;
+
+    // TODO:
+    //   Als wij een BackboneElement zijn, dan is onze naam niet this.TypeName maar "BackboneElement" of
+    //   "Element", afhankelijk van waar hij in de .net inheritance hierarchie zit.
+    //   HEt moet "code" zijn als dit een "Code<T>" is. Dat zijn geloof ik de afwijkingen.
+    //   Wellioht is er ook nog iets met de directe properties "Extension.url" en "Element.id" die van een
+    //   system type zijn ipv een FHIR type.
+    string? IBaseElementNavigator<ITypedElement>.InstanceType => 
+        ((IStructureDefinitionSummary)
+            ModelInspector
+                .ForType(this.GetType())
+                .FindOrImportClassMapping(this.GetType())!
+        ).TypeName;
+
+    private object? _value;
+    private object? _lastCachedValue;
+
+
+    internal object? ToITypedElementValue()
+    {
+        try
+        {
+            return this switch
+            {
+                Instant { Value: { } ins } => P.DateTime.FromDateTimeOffset(ins),
+                Time { Value: { } time } => P.Time.Parse(time),
+                Date { Value: { } dt } => P.Date.Parse(dt),
+                FhirDateTime { Value: { } fdt } => P.DateTime.Parse(fdt),
+                Integer fint => fint.Value,
+                Integer64 fint64 => fint64.Value,
+                PositiveInt pint => pint.Value,
+                UnsignedInt unsint => unsint.Value,
+                Base64Binary { Value: { } b64 } => PrimitiveTypeConverter.ConvertTo<string>(b64),
+                PrimitiveType prim => prim.ObjectValue,
+                _ => null
+            };
+        }
+        catch (FormatException)
+        {
+            // If it fails, just return the unparsed contents
+            return (this as PrimitiveType)?.ObjectValue;
+        }
+    }
+
+    object? IBaseElementNavigator<ITypedElement>.Value
+    {
+        get
+        {
+            if (this is not PrimitiveType { ObjectValue: { } ov }) return null;
+            if (ov == _lastCachedValue) return _value;
+            _value = ToITypedElementValue();
+            _lastCachedValue = ov;
+
+            return _value;
+        }
+    }
+
+    string ITypedElement.Location =>
+        (ScopeInfo.Index, ScopeInfo.Parent) switch
+        {
+            // if we have an index, write it
+            ({} idx, {} parent) => $"{parent.Location}.{ScopeInfo.Name}[{idx}]",
+            // if we do not, write 0 as idx
+            (_, {} parent) => $"{parent.Location}.{ScopeInfo.Name}[0]",
+            // if we have neither, we are the root.
+            _ => $"{ScopeInfo.Name}"
+        };
+
+    IElementDefinitionSummary? ITypedElement.Definition => null;
+
+    string IShortPathGenerator.ShortPath => 
+        (ScopeInfo.Index, ScopeInfo.Parent) switch
+        {
+            // if we have an index, we have a parent.
+            ({ } idx, {} parent) => $"{parent.ShortPath}.{ScopeInfo.Name}[{idx}]",
+            // Note that we omit indices here.
+            (_, { } parent) => $"{parent.ShortPath}.{ScopeInfo.Name}",
+            // if we have neither, we are the root. Note that we omit indices here.
+            _ => ScopeInfo.Name
+        };
+
+    public Base FhirValue => this;
+
+    string? IResourceTypeSupplier.ResourceType =>
+        this is Resource
+#pragma warning disable CS0618 // Type or member is obsolete
+            ? ((IBaseElementNavigator<ITypedElement>)this).InstanceType
+#pragma warning restore CS0618 // Type or member is obsolete
+            : null;
+}
+
+#endif

src/Hl7.Fhir.Base/Model/Base.cs

@@ -27,7 +27,7 @@ POSSIBILITY OF SUCH DAMAGE.
 
 */
 
-using Hl7.Fhir.Introspection;
+using Hl7.Fhir.ElementModel;
 using Hl7.Fhir.Utility;
 using System;
 using System.Collections;
@@ -51,7 +51,17 @@ public abstract partial class Base : IDeepCopyable, IDeepComparable,
 
         private AnnotationList annotations => LazyInitializer.EnsureInitialized(ref _annotations, () => new());
 
-        public IEnumerable<object> Annotations(Type type) => annotations.OfType(type);
+        public IEnumerable<object> Annotations(Type type)
+        {
+            if (type == typeof(ITypedElement) || type == typeof(IShortPathGenerator))
+                    return new[] { this };
+            else if (type == typeof(IFhirValueProvider))
+                return new[] { this };
+            else if (type == typeof(IResourceTypeSupplier))
+                return new[] { this };
+            else
+                return annotations.OfType(type);
+        }
 
         public void AddAnnotation(object annotation) => annotations.AddAnnotation(annotation);
 

src/Hl7.Fhir.Base/Rest/HttpContentParsers.cs

@@ -234,7 +234,7 @@ public static async Task<Binary> ReadBinaryDataFromMessage(this HttpResponseMess
             return ContentType.GetResourceFormatFromContentType(contentType) switch
             {
                 ResourceFormat.Xml when bodyText is not null && SerializationUtil.ProbeIsXml(bodyText) =>
-                            ser.DeserializeFromXml(bodyText),
+                            ser.DeserializeFromXml(bodyText) as Resource,
                 ResourceFormat.Json when bodyText is not null && SerializationUtil.ProbeIsJson(bodyText) =>
                             ser.DeserializeFromJson(bodyText),
                 ResourceFormat.Xml or ResourceFormat.Json =>
@@ -275,7 +275,7 @@ public static async Task<Binary> ReadBinaryDataFromMessage(this HttpResponseMess
             return ContentType.GetResourceFormatFromContentType(contentType) switch
             {
                 ResourceFormat.Xml when bodyText is not null && SerializationUtil.ProbeIsFhirXml(bodyText) =>
-                            ser.DeserializeFromXml(bodyText),
+                            ser.DeserializeFromXml(bodyText) as Resource,
                 ResourceFormat.Json when bodyText is not null && SerializationUtil.ProbeIsFhirJson(bodyText) =>
                             ser.DeserializeFromJson(bodyText),
                 _ => default

src/Hl7.Fhir.Base/Serialization/BaseFhirXmlPocoSerializer.cs

@@ -8,6 +8,7 @@
 
 #nullable enable
 
+using Hl7.Fhir.ElementModel;
 using Hl7.Fhir.Introspection;
 using Hl7.Fhir.Model;
 using Hl7.Fhir.Specification;
@@ -48,12 +49,12 @@ public void Serialize(IReadOnlyDictionary<string, object> members, XmlWriter wri
         {
             writer.WriteStartDocument();
 
-            var simulateRoot = members is not Resource;
+            var simulateRoot = ((IScopedNode)members).Parent is not null || members is not Resource;
             if (simulateRoot)
             {
                 // Serialization in XML of non-resources is problematic, since there's no root.
                 // It's a common usecase though, so "invent" a root that's the name of the element's type.
-                var rootElementName = members is Base b ? b.TypeName : members.GetType().Name;
+                var rootElementName = members is Base b ? ((ITypedElement)b).Name : members.GetType().Name;
                 writer.WriteStartElement(rootElementName, XmlNs.FHIR);
             }