private void write(PropertyMapping prop, object instance, ComplexTypeWriter.SerializationMode mode) { // If this is a primitive type, no classmappings and reflection is involved, // just serialize the primitive to the writer if (prop.IsPrimitive) { var writer = new PrimitiveValueWriter(_current); writer.Serialize(instance, prop.SerializationHint); return; } // A Choice property that contains a choice of any resource // (as used in Resource.contained) if (prop.Choice == ChoiceType.ResourceChoice) { var writer = new ResourceWriter(_current); writer.Serialize(instance, contained: true); return; } ClassMapping mapping = _inspector.ImportType(instance.GetType()); if (mode == ComplexTypeWriter.SerializationMode.AllMembers || mode == ComplexTypeWriter.SerializationMode.NonValueElements) { var cplxWriter = new ComplexTypeWriter(_current); cplxWriter.Serialize(mapping, instance, mode); } else { object value = mapping.PrimitiveValueProperty.GetValue(instance); write(mapping.PrimitiveValueProperty, value, ComplexTypeWriter.SerializationMode.AllMembers); } }
// If we have a normal complex property, for which the type has a primitive value member... private bool serializedIntoTwoProperties(PropertyMapping prop, object instance) { if (instance is IList) { instance = ((IList)instance)[0]; } if (!prop.IsPrimitive && prop.Choice != ChoiceType.ResourceChoice) { var mapping = _inspector.ImportType(instance.GetType()); return(mapping.HasPrimitiveValueMember); } else { return(false); } }
public void TypeDataTypeNameResolving() { var inspector = new ModelInspector(); inspector.ImportType(typeof(AnimalName)); inspector.ImportType(typeof(NewAnimalName)); var result = inspector.FindClassMappingForFhirDataType("animalname"); Assert.IsNotNull(result); Assert.AreEqual(result.NativeType, typeof(NewAnimalName)); // Validate a mapping for a type will return the newest registration result = inspector.FindClassMappingByType(typeof(AnimalName)); Assert.IsNotNull(result); Assert.AreEqual(typeof(NewAnimalName), result.NativeType); }
#pragma warning restore 612,618 public object Deserialize(PropertyMapping prop, string memberName, object existing = null) { if (prop == null) { throw Error.ArgumentNull(nameof(prop)); } // ArrayMode avoid the dispatcher making nested calls into the RepeatingElementReader again // when reading array elements. FHIR does not support nested arrays, and this avoids an endlessly // nesting series of dispatcher calls if (!_arrayMode && prop.IsCollection) { if (existing != null && !(existing is IList)) { throw Error.Argument(nameof(existing), "Can only read repeating elements into a type implementing IList"); } var reader = new RepeatingElementReader(_inspector, _current, Settings); return(reader.Deserialize(prop, memberName, (IList)existing)); } // If this is a primitive type, no classmappings and reflection is involved, // just parse the primitive from the input // NB: no choices for primitives! if (prop.IsPrimitive) { var reader = new PrimitiveValueReader(_current); return(reader.Deserialize(prop.ImplementingType)); } // A Choice property that contains a choice of any resource // (as used in Resource.contained) if (prop.Choice == ChoiceType.ResourceChoice) { var reader = new ComplexTypeReader(_inspector, _current, Settings); return(reader.Deserialize(null)); } if (_current.InstanceType is null) { ComplexTypeReader.RaiseFormatError( "Underlying data source was not able to provide the actual instance type of the resource.", _current.Location); } ClassMapping mapping = prop.Choice == ChoiceType.DatatypeChoice ? getMappingForType(memberName, _current.InstanceType) : _inspector.ImportType(prop.ImplementingType); // Handle other Choices having any datatype or a list of datatypes if (existing != null && !(existing is Resource) && !(existing is Element)) { throw Error.Argument(nameof(existing), "Can only read complex elements into types that are Element or Resource"); } var cplxReader = new ComplexTypeReader(_inspector, _current, Settings); return(cplxReader.Deserialize(mapping, (Base)existing)); }
public object Deserialize(PropertyMapping prop, string memberName, object existing = null) { if (prop == null) { throw Error.ArgumentNull("prop"); } // ArrayMode avoid the dispatcher making nested calls into the RepeatingElementReader again // when reading array elements. FHIR does not support nested arrays, and this avoids an endlessly // nesting series of dispatcher calls if (!_arrayMode && prop.IsCollection) { var reader = new RepeatingElementReader(_current); return(reader.Deserialize(prop, memberName, existing)); } // If this is a primitive type, no classmappings and reflection is involved, // just parse the primitive from the input // NB: no choices for primitives! if (prop.IsPrimitive) { var reader = new PrimitiveValueReader(_current); return(reader.Deserialize(prop.ElementType)); } // A Choice property that contains a choice of any resource // (as used in Resource.contained) if (prop.Choice == ChoiceType.ResourceChoice) { var reader = new ResourceReader(_current); return(reader.Deserialize(existing, nested: true)); } ClassMapping mapping; // Handle other Choices having any datatype or a list of datatypes if (prop.Choice == ChoiceType.DatatypeChoice) { // For Choice properties, determine the actual type of the element using // the suffix of the membername (i.e. deceasedBoolean, deceasedDate) // This function implements type substitution. mapping = determineElementPropertyType(prop, memberName); } // Else use the actual return type of the property else { mapping = _inspector.ImportType(prop.ElementType); } var cplxReader = new ComplexTypeReader(_current); return(cplxReader.Deserialize(mapping, existing)); }
public void TestResourceNameResolving() { var inspector = new ModelInspector(Specification.FhirRelease.STU3); inspector.ImportType(typeof(Way)); inspector.ImportType(typeof(Way2)); var way = inspector.FindClassMapping("Way"); Assert.IsNotNull(way); Assert.AreEqual(way.NativeType, typeof(Way)); var way2 = inspector.FindClassMapping("Way2"); Assert.IsNotNull(way2); Assert.AreEqual(way2.NativeType, typeof(Way2)); var noway = inspector.FindClassMapping("nonexistent"); Assert.IsNull(noway); }
public void TestResourceNameResolving() { var inspector = new ModelInspector(ModelInspector.R3_VERSION); inspector.ImportType(typeof(Way)); inspector.ImportType(typeof(Way2)); var way = inspector.FindClassMappingByName("wAy"); Assert.IsNotNull(way); Assert.AreEqual(way.NativeType, typeof(Way)); var way2 = inspector.FindClassMappingByName("Way2"); Assert.IsNotNull(way2); Assert.AreEqual(way2.NativeType, typeof(Way2)); var noway = inspector.FindClassMappingByName("nonexistent"); Assert.IsNull(noway); }
internal PocoElementNode(ModelInspector inspector, Base root, string rootName = null) { Current = root; _inspector = inspector; _myClassMapping = _inspector.ImportType(root.GetType()); InstanceType = ((IStructureDefinitionSummary)_myClassMapping).TypeName; Definition = ElementDefinitionSummary.ForRoot(_myClassMapping, rootName ?? root.TypeName); Location = InstanceType; ShortPath = InstanceType; }
public void TestResourceNameResolving() { var inspector = new ModelInspector(); inspector.ImportType(typeof(Road)); inspector.ImportType(typeof(Way)); inspector.ImportType(typeof(ProfiledWay)); inspector.ImportType(typeof(NewStreet)); //inspector.Process(); var road = inspector.FindClassMappingForResource("roAd"); Assert.IsNotNull(road); Assert.AreEqual(road.NativeType, typeof(Road)); var way = inspector.FindClassMappingForResource("Way"); Assert.IsNotNull(way); Assert.AreEqual(way.NativeType, typeof(Way)); var pway = inspector.FindClassMappingForResource("way", "http://nu.nl/profile#street"); Assert.IsNotNull(pway); Assert.AreEqual(pway.NativeType, typeof(ProfiledWay)); var pway2 = inspector.FindClassMappingForResource("way", "http://nux.nl/profile#street"); Assert.IsNotNull(pway2); Assert.AreEqual(pway2.NativeType, typeof(Way)); var street = inspector.FindClassMappingForResource("Street"); Assert.IsNotNull(street); Assert.AreEqual(street.NativeType, typeof(NewStreet)); var noway = inspector.FindClassMappingForResource("nonexistent"); Assert.IsNull(noway); }
internal void Serialize(Base instance, Rest.SummaryType summary, SerializationMode mode = SerializationMode.AllMembers, string root = null) { if (instance == null) { throw Error.ArgumentNull(nameof(instance)); } ClassMapping mapping = _inspector.ImportType(instance.GetType()); if (mapping == null) { throw Error.Format($"Asked to serialize unknown type '{instance.GetType()}'"); } var rootName = root ?? mapping.Name; _writer.WriteStartProperty(rootName); Serialize(mapping, instance, summary, mode); _writer.WriteEndProperty(); }
public void Serialize(Resource instance, Rest.SummaryType summary, bool contained = false) { if (instance == null) { throw Error.ArgumentNull(nameof(instance)); } var mapping = _inspector.ImportType(instance.GetType()); if (mapping == null) { throw Error.Format($"Asked to serialize unknown resource type '{instance.GetType()}'"); } _writer.WriteStartRootObject(mapping.Name, contained); var complexSerializer = new ComplexTypeWriter(_writer, Settings); Coding subsettedTag = null; bool createdMetaElement = false; if (summary != Rest.SummaryType.False && instance is Resource) { var resource = instance as Resource; if (resource.Meta == null) { resource.Meta = new Meta(); createdMetaElement = true; } if (!resource.Meta.Tag.Any(t => t.System == "http://hl7.org/fhir/v3/ObservationValue" && t.Code == "SUBSETTED")) { subsettedTag = new Coding("http://hl7.org/fhir/v3/ObservationValue", "SUBSETTED"); resource.Meta.Tag.Add(subsettedTag); } } complexSerializer.Serialize(mapping, instance, summary); Resource r = (instance as Resource); if (subsettedTag != null) { r.Meta.Tag.Remove(subsettedTag); } if (createdMetaElement) { r.Meta = null; // remove the meta element again. } _writer.WriteEndRootObject(contained); }
private PocoElementNode(ModelInspector inspector, Base instance, PocoElementNode parent, PropertyMapping definition, string location, string shortPath) { Current = instance; _inspector = inspector; var instanceType = determineInstanceType(instance.GetType(), definition); _myClassMapping = _inspector.ImportType(instanceType); InstanceType = ((IStructureDefinitionSummary)_myClassMapping).TypeName; Definition = definition ?? throw Error.ArgumentNull(nameof(definition)); ExceptionHandler = parent.ExceptionHandler; Location = location; ShortPath = shortPath; }
public void Serialize(object instance, bool summary, bool contained = false) { if (instance == null) { throw Error.ArgumentNull("instance"); } var mapping = _inspector.ImportType(instance.GetType()); _writer.WriteStartRootObject(mapping.Name, contained); var complexSerializer = new ComplexTypeWriter(_writer); complexSerializer.Serialize(mapping, instance, summary); _writer.WriteEndRootObject(contained); }
public void Serialize(object instance, Rest.SummaryType summary, bool contained = false, string root = null) { if (instance == null) { throw Error.ArgumentNull(nameof(instance)); } var mapping = _inspector.ImportType(instance.GetType()); var rootName = root ?? mapping.Name; _writer.WriteStartRootObject(rootName, contained); var complexSerializer = new ComplexTypeWriter(_writer); Coding subsettedTag = null; if (summary != Rest.SummaryType.False && instance is Resource) { Resource r = (instance as Resource); if (r != null) { // If we are subsetting the instance during serialization, ensure that there // is a meta element with that subsetting in it // (Helps make it easier to create conformant instances) if (r.Meta == null) { r.Meta = new Meta(); } if (r.Meta.Tag.Where(t => t.System == "http://hl7.org/fhir/v3/ObservationValue" && t.Code == "SUBSETTED").Count() == 0) { subsettedTag = new Coding("http://hl7.org/fhir/v3/ObservationValue", "SUBSETTED"); r.Meta.Tag.Add(subsettedTag); } } } complexSerializer.Serialize(mapping, instance, summary); if (subsettedTag != null) { Resource r = (instance as Resource); r.Meta.Tag.Remove(subsettedTag); } _writer.WriteEndRootObject(contained); }