public void TestAssemblyInspection()
{
var inspector = new ModelInspector();
// Inspect the HL7.Fhir.Model assembly
inspector.Import(typeof(Resource).Assembly);
// Check for presence of some basic ingredients
Assert.IsNotNull(inspector.FindClassMappingForResource("patient"));
Assert.IsNotNull(inspector.FindClassMappingForFhirDataType("HumanName"));
Assert.IsNotNull(inspector.FindClassMappingForFhirDataType("code"));
Assert.IsNotNull(inspector.FindClassMappingForFhirDataType("boolean"));
// Verify presence of nested enumerations
Assert.IsNotNull(inspector.FindEnumMappingByType(typeof(Address.AddressUse)));
// Should have skipped abstract classes
Assert.IsNull(inspector.FindClassMappingForResource("ComplexElement"));
Assert.IsNull(inspector.FindClassMappingForResource("Element"));
Assert.IsNull(inspector.FindClassMappingForResource("Resource"));
// The open generic Code<> should not be there
var codeOfT = inspector.FindClassMappingByType(typeof(Code <>));
Assert.IsNull(codeOfT);
}
public void TestAssemblyInspection()
{
var inspector = new ModelInspector();
// Inspect the HL7.Fhir.Model assembly
inspector.Import(typeof(Resource).GetTypeInfo().Assembly);
// Check for presence of some basic ingredients
Assert.IsNotNull(inspector.FindClassMappingForResource("patient"));
Assert.IsNotNull(inspector.FindClassMappingForFhirDataType("HumanName"));
Assert.IsNotNull(inspector.FindClassMappingForFhirDataType("code"));
Assert.IsNotNull(inspector.FindClassMappingForFhirDataType("boolean"));
// Should also have found the abstract classes
Assert.IsNotNull(inspector.FindClassMappingForFhirDataType("Element"));
Assert.IsNotNull(inspector.FindClassMappingForResource("Resource"));
// The open generic Code<> should not be there
var codeOfT = inspector.FindClassMappingByType(typeof(Code <>));
Assert.IsNull(codeOfT);
}
public object Deserialize(object existing = null, bool nested = false)
{
if (_reader.CurrentToken == TokenType.Object)
{
// If there's no a priori knowledge of the type of Resource we will encounter,
// we'll have to determine from the data itself.
var resourceType = _reader.GetResourceTypeName(nested);
var mappedType = _inspector.FindClassMappingForResource(resourceType);
if (mappedType == null)
{
// Special courtesy case
if (resourceType == "feed" || resourceType == "Bundle")
{
throw Error.Format("Encountered a feed instead of a resource", _reader);
}
else
{
throw Error.Format("Encountered unknown resource type {0}", _reader, resourceType);
}
}
if (existing == null)
{
var fac = new DefaultModelFactory();
existing = fac.Create(mappedType.NativeType);
}
else
{
if (mappedType.NativeType != existing.GetType())
{
throw Error.Argument("existing", "Existing instance is of type {0}, but data indicates resource is a {1}", existing.GetType().Name, resourceType);
}
}
// Delegate the actual work to the ComplexTypeReader, since
// the serialization of Resources and ComplexTypes are virtually the same
var cplxReader = new ComplexTypeReader(_reader);
return(cplxReader.Deserialize(mappedType, existing));
}
else
{
throw Error.Format("Trying to read a resource, but reader is not at the start of an object", _reader);
}
}
public Resource Deserialize(Resource existing = null)
{
// If there's no a priori knowledge of the type of Resource we will encounter,
// we'll have to determine from the data itself.
var resourceTypeName = _reader.GetResourceTypeName();
var mapping = _inspector.FindClassMappingForResource(resourceTypeName);
if (mapping == null)
{
throw Error.Format("Asked to deserialize unknown resource '" + resourceTypeName + "'", _reader);
}
// Delegate the actual work to the ComplexTypeReader, since
// the serialization of Resources and ComplexTypes are virtually the same
var cplxReader = new ComplexTypeReader(_reader, Settings);
return((Resource)cplxReader.Deserialize(mapping, existing));
}
#pragma warning restore 612,618
public Resource Deserialize(Resource existing = null)
{
if (_reader.InstanceType is null)
{
ComplexTypeReader.RaiseFormatError(
"Underlying data source was not able to provide the actual instance type of the resource.", _reader.Location);
}
var mapping = _inspector.FindClassMappingForResource(_reader.InstanceType);
if (mapping == null)
{
ComplexTypeReader.RaiseFormatError($"Asked to deserialize unknown resource '{_reader.InstanceType}'", _reader.Location);
}
// Delegate the actual work to the ComplexTypeReader, since
// the serialization of Resources and ComplexTypes are virtually the same
var cplxReader = new ComplexTypeReader(_reader, Settings);
return((Resource)cplxReader.Deserialize(mapping, existing));
}
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);
}