public object GetDefaultValue()

in lang/csharp/src/apache/main/Reflect/ReflectDefaultReader.cs [199:371]
139 lines of code
38 McCabe index (conditional complexity)

        public object GetDefaultValue(Schema s, JToken defaultValue)
        {
            if (defaultValue == null)
            {
                return null;
            }

            switch (s.Tag)
            {
                case Schema.Type.Boolean:
                    if (defaultValue.Type != JTokenType.Boolean)
                    {
                        throw new AvroException("Default boolean value " + defaultValue.ToString() + " is invalid, expected is json boolean.");
                    }

                    return (bool)defaultValue;

                case Schema.Type.Int:
                    if (defaultValue.Type != JTokenType.Integer)
                    {
                        throw new AvroException("Default int value " + defaultValue.ToString() + " is invalid, expected is json integer.");
                    }

                    return Convert.ToInt32((int)defaultValue);

                case Schema.Type.Long:
                    if (defaultValue.Type != JTokenType.Integer)
                    {
                        throw new AvroException("Default long value " + defaultValue.ToString() + " is invalid, expected is json integer.");
                    }

                    return Convert.ToInt64((long)defaultValue);

                case Schema.Type.Float:
                    if (defaultValue.Type != JTokenType.Float)
                    {
                        throw new AvroException("Default float value " + defaultValue.ToString() + " is invalid, expected is json number.");
                    }

                    return (float)defaultValue;

                case Schema.Type.Double:
                    if (defaultValue.Type == JTokenType.Integer)
                    {
                        return Convert.ToDouble((int)defaultValue);
                    }
                    else if (defaultValue.Type == JTokenType.Float)
                    {
                        return Convert.ToDouble((float)defaultValue);
                    }
                    else
                    {
                        throw new AvroException("Default double value " + defaultValue.ToString() + " is invalid, expected is json number.");
                    }

                case Schema.Type.Bytes:
                    if (defaultValue.Type != JTokenType.String)
                    {
                        throw new AvroException("Default bytes value " + defaultValue.ToString() + " is invalid, expected is json string.");
                    }

                    var en = System.Text.Encoding.GetEncoding("iso-8859-1");
                    return en.GetBytes((string)defaultValue);

                case Schema.Type.Fixed:
                    if (defaultValue.Type != JTokenType.String)
                    {
                        throw new AvroException("Default fixed value " + defaultValue.ToString() + " is invalid, expected is json string.");
                    }

                    en = System.Text.Encoding.GetEncoding("iso-8859-1");
                    int len = (s as FixedSchema).Size;
                    byte[] bb = en.GetBytes((string)defaultValue);
                    if (bb.Length != len)
                    {
                        throw new AvroException("Default fixed value " + defaultValue.ToString() + " is not of expected length " + len);
                    }

                    return typeof(byte[]);

                case Schema.Type.String:
                    if (defaultValue.Type != JTokenType.String)
                    {
                        throw new AvroException("Default string value " + defaultValue.ToString() + " is invalid, expected is json string.");
                    }

                    return (string)defaultValue;

                case Schema.Type.Enumeration:
                    if (defaultValue.Type != JTokenType.String)
                    {
                        throw new AvroException("Default enum value " + defaultValue.ToString() + " is invalid, expected is json string.");
                    }

                    return (s as EnumSchema).Ordinal((string)defaultValue);

                case Schema.Type.Null:
                    if (defaultValue.Type != JTokenType.Null)
                    {
                        throw new AvroException("Default null value " + defaultValue.ToString() + " is invalid, expected is json null.");
                    }

                    return null;

                case Schema.Type.Array:
                    if (defaultValue.Type != JTokenType.Array)
                    {
                        throw new AvroException("Default array value " + defaultValue.ToString() + " is invalid, expected is json array.");
                    }

                    JArray jarr = defaultValue as JArray;
                    var array = (IEnumerable)Activator.CreateInstance(GetTypeFromSchema(s, false));
                    var arrayHelper = _classCache.GetArrayHelper(s as ArraySchema, array);
                    foreach (JToken jitem in jarr)
                    {
                        arrayHelper.Add(GetDefaultValue((s as ArraySchema).ItemSchema, jitem));
                    }

                    return array;

                case Schema.Type.Record:
                case Schema.Type.Error:
                    if (defaultValue.Type != JTokenType.Object)
                    {
                        throw new AvroException($"Default record value {defaultValue.ToString()} is invalid, expected is json object.");
                    }

                    RecordSchema rcs = s as RecordSchema;
                    JObject jo = defaultValue as JObject;
                    var rec = RecordFactory(GetTypeFromSchema(rcs, false));
                    if (rec == null)
                    {
                        throw new Exception($"Couldn't create type matching schema name {rcs.Fullname}");
                    }

                    foreach (Field field in rcs)
                    {
                        JToken val = jo[field.Name];
                        if (val == null)
                            val = field.DefaultValue;
                        if (val == null)
                        {
                            throw new AvroException($"No default value for field {field.Name}");
                        }

                        _classCache.GetClass(rcs).SetValue(rec, field, GetDefaultValue(field.Schema, val));
                    }

                    return rec;

                case Schema.Type.Map:
                    if (defaultValue.Type != JTokenType.Object)
                    {
                        throw new AvroException($"Default map value {defaultValue.ToString()} is invalid, expected is json object.");
                    }

                    jo = defaultValue as JObject;
                    var map = (System.Collections.IDictionary)Activator.CreateInstance(GetTypeFromSchema(s, false));

                    foreach (KeyValuePair<string, JToken> jp in jo)
                    {
                        map.Add(jp.Key, GetDefaultValue((s as MapSchema).ValueSchema, jp.Value));
                    }

                    return map;

                case Schema.Type.Union:
                    return GetDefaultValue((s as UnionSchema).Schemas[0], defaultValue);

                default:
                    throw new AvroException($"Unsupported schema type {s.Tag}");
            }
        }