ReferenceConverter.cs

Go to the documentation of this file.

using System;
using System.Collections.Concurrent;
using System.Linq;
using System.Reflection;
 
using AnalyzeRe.APITypes;
using AnalyzeRe.Utilities;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
 
namespace AnalyzeRe.JsonConverters
{
    public class ReferenceConverter : JsonConverter
    {
        #region Configuration Options
        public enum ReferenceSerializationMethod
        {
            UseReferencesOnly,
            ExpandIfResolved,
            ExpandReferenceValues,
        }
 
        public ReferenceSerializationMethod SerializationMethod { get; set; }
        #endregion Configuration Options
 
        #region Constructor
        public ReferenceConverter(
            ReferenceSerializationMethod serializationMethod = ReferenceSerializationMethod.UseReferencesOnly)
        {
            SerializationMethod = serializationMethod;
        }
        #endregion Constructor
 
        #region Constants
        private const string RefIdPropertyName = nameof(IReference.ref_id);
        private const string HrefPropertyName = nameof(IReference.href);
        private const string ReferenceTypePropertyName = nameof(IReference.reference_type);
        #endregion Constants
 
        private static readonly ConcurrentDictionary<Type, bool> CanConvertCache =
            new ConcurrentDictionary<Type, bool>();
 
        #region Public Methods
        public override bool CanConvert(Type objectType)
        {
            return CanConvertCache.GetOrAdd(objectType, type =>
                type.IsSubclassOf(typeof(Reference)) ||
                type.IsSubclassOfRawGeneric(typeof(IReference<>)));
        }
 
        private static bool TryGetStringProperty(JObject jObject, string propertyName, out string value)
        {
            if (!jObject.TryGetValue(propertyName, out JToken token))
            {
                value = null;
                return false;
            }
            value  = token.Type == JTokenType.Null ? null :
                token.Type == JTokenType.String ? token.Value<string>() :
                throw new JsonReaderException($"Expected the {propertyName} value " +
                    $"to be a JSON \"string\" but a {token.Type.ToString()} was returned ({token})");
            return true;
        }
 
        public override object ReadJson(
            JsonReader reader,
            Type objectType,
            object existingValue,
            JsonSerializer serializer)
        {
            if (reader.TokenType == JsonToken.Null)
                return null;
            // Load JObject from stream
            JObject jObject = JObject.Load(reader);
 
            using (JsonReader jObjectReader =
                   JsonCreationConverter.CopyReaderForObject(reader, jObject))
            {
                // By default, set the reference type based on the object we're populating
                Type referenceInnerType = objectType.IsGenericType ?
                    objectType.GetGenericArguments()[0] : typeof(IAPIResource);
 
                // Start out assuming this reference is potentially inlined if this json has any attributes
                bool isReferenceInlined = jObject.Any<JToken>();
                // Attempt to extract each of the "pure-reference" fields we might encounter
                // If *any* of these fields are present, then we know this reference is not inlined.
                isReferenceInlined &= !TryGetStringProperty(jObject, ReferenceTypePropertyName, out string strReferenceType);
                isReferenceInlined &= !TryGetStringProperty(jObject, RefIdPropertyName, out string strRefId);
                isReferenceInlined &= !TryGetStringProperty(jObject, HrefPropertyName, out string strHref);
 
                // If possible, try to pick a more specific reference type to instantiate.
                // This will only have a value if the reference is resolved, inlined,
                // and contains a derived instance of a polymorphic type
                Type runtimeType = null;
                if (isReferenceInlined)
                {
                    if (TryGetStringProperty(jObject, APIType_Polymorphic.TypePropertyName, out string strType) &&
                        !String.IsNullOrEmpty(strType))
                        TypeResolver.ResolveTypeByName(strType, out runtimeType, typeof(IAPIResource));
                }
                else
                {
                    // See if the reference json indicated its reference type
                    if (!String.IsNullOrEmpty(strReferenceType))
                        TypeResolver.ResolveTypeByName(strReferenceType, out runtimeType, typeof(IAPIResource));
                    // Otherwise, if an href was provided, determine the type based on it
                    else if (!String.IsNullOrEmpty(strHref))
                        runtimeType = TypeResolver.ResolveBaseTypeByURL(strHref);
                }
                
                // If any of the above approaches reveal a more specific runtime type,
                // attempt to use it when instantiating our Reference object.
                if (runtimeType != null)
                {
                    // Make sure that if the resolved inner reference type is generic, we resolve
                    // its generic arguments to some covariantly-valid type.
                    if (runtimeType.IsGenericType)
                        runtimeType = TypeResolver.GetGenericCovariantBase(runtimeType);
                    // Ensure this new type is assignable to the required type before replacing it
                    if (referenceInnerType.IsAssignableFrom(runtimeType))
                        referenceInnerType = runtimeType;
                }
 
                // Produce the type of the reference object we must construct.
                Type referenceType = typeof(Reference<>).MakeGenericTypeFast(referenceInnerType);
 
                // Ensure that the resolved reference type is compatible with the target property type.
                if (!objectType.IsAssignableFrom(referenceType))
                    throw new InvalidOperationException("The provided reference type: '" +
                        referenceType.NiceTypeName() + "' did not match the expected type: '" +
                        objectType.NiceTypeName() + "'");
 
                object newReference;
                // Easy case, the server just sent us a reference object
                if (!isReferenceInlined)
                {
                    ConstructorInfo referenceConstructor = referenceType.GetConstructor(
                        new[] { typeof(string), typeof(string) });
                    if (referenceConstructor == null)
                        throw new Exception("Missing Reference Constructor " +
                            referenceType.NiceTypeName() + "(string, string)");
                    // Construct the new reference using the deserialized data.
                    newReference = referenceConstructor.Invoke(
                        new object[] { strRefId, strHref });
                }
                // Hard case, the server sent us an 'inlined'/'resolved' object, which we
                // will have to wrap in a Reference object to fit our object model.
                else
                {
                    // Create the generic constructor that will be used to
                    // construct our new reference object.
                    ConstructorInfo newReferenceConstructor =
                        referenceType.GetConstructor(new[] { referenceInnerType });
                    if (newReferenceConstructor == null)
                        throw new Exception("Could not find a constructor for '" +
                            referenceType.NiceTypeName() + "' taking a parameter of type '" +
                            referenceInnerType.NiceTypeName() + "'");
 
                    // Create the inner object that will be passed to the reference constructor
                    object referenceValue = serializer.Deserialize(jObjectReader, referenceInnerType);
 
                    // Construct the new reference object, passing the contained
                    // value to the constructor
                    newReference = newReferenceConstructor.Invoke(new[] { referenceValue });
                }
                return newReference;
            }
        }
 
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            if (value == null)
            {
                writer.WriteNull();
                return;
            }
 
            bool resolveReference = false;
            if (!(value is IReference<IAPIResource> reference))
                throw new InvalidOperationException($"Unhandled case for ReferenceSerializer. " +
                    $"Unexpected non-Reference value: {value}");
 
            // If the object is null, or we've been told explicitly to use references only,
            // do not resolve references.
            // If we are told to resolve references, or we were told to expand references
            // if they are resolved, and this one is resolved, or this one is resolved and it has
            // no ref_id (meaning it cannot be represented as a reference) resolveReference = true
            if (SerializationMethod == ReferenceSerializationMethod.ExpandReferenceValues ||
                    (reference.resolved && (reference.ref_id == null ||
                    SerializationMethod == ReferenceSerializationMethod.ExpandIfResolved)))
                resolveReference = true;
 
            // If resolve reference is set to true, serialize the entire reference value,
            // otherwise, serialize the reference using the base serializer
            if (resolveReference)
                serializer.Serialize(writer, reference.GetValue());
            else
            {
                // We want to serialize using the current serializer settings,
                // but use the default serializing behaviour (to avoid infinite recursion).
                JsonSerializerSettings recurseSettings = serializer.GetJsonSerializerSettings();
                recurseSettings.Converters.Remove(
                    serializer.Converters.OfType<ReferenceConverter>().Cast<JsonConverter>().Single());
                JsonSerializer.Create(recurseSettings).Serialize(writer, reference);
            }
        }
        #endregion Public Methods
    }
}