private static JsonNode defaultValueFromConnect()

in schema-converter/avro-schema-converter/src/main/java/org/apache/rocketmq/schema/avro/AvroData.java [697:773]
74 lines of code
21 McCabe index (conditional complexity)

    private static JsonNode defaultValueFromConnect(Schema schema, Object value) {
        try {
            // If this is a logical type, convert it from the convenient Java type to the underlying
            // serializeable format
            Object defaultVal = toAvroLogical(schema, value);

            switch (schema.getFieldType()) {
                case INT8:
                    return JsonNodeFactory.instance.numberNode(((Byte) defaultVal).intValue());
                case INT16:
                    return JsonNodeFactory.instance.numberNode(((Short) defaultVal).intValue());
                case INT32:
                    return JsonNodeFactory.instance.numberNode((Integer) defaultVal);
                case INT64:
                    return JsonNodeFactory.instance.numberNode((Long) defaultVal);
                case FLOAT32:
                    return JsonNodeFactory.instance.numberNode((Float) defaultVal);
                case FLOAT64:
                    return JsonNodeFactory.instance.numberNode((Double) defaultVal);
                case BOOLEAN:
                    return JsonNodeFactory.instance.booleanNode((Boolean) defaultVal);
                case STRING:
                    return JsonNodeFactory.instance.textNode((String) defaultVal);
                case BYTES:
                    if (defaultVal instanceof byte[]) {
                        return JsonNodeFactory.instance.textNode(new String((byte[]) defaultVal,
                                StandardCharsets.ISO_8859_1));
                    } else {
                        return JsonNodeFactory.instance.textNode(new String(((ByteBuffer) defaultVal).array(),
                                StandardCharsets.ISO_8859_1));
                    }
                case ARRAY: {
                    ArrayNode array = JsonNodeFactory.instance.arrayNode();
                    for (Object elem : (Collection<Object>) defaultVal) {
                        array.add(defaultValueFromConnect(schema.getValueSchema(), elem));
                    }
                    return array;
                }
                case MAP:
                    if (schema.getKeySchema().getFieldType() == FieldType.STRING && !schema.getKeySchema().isOptional()) {
                        ObjectNode node = JsonNodeFactory.instance.objectNode();
                        for (Map.Entry<String, Object> entry : ((Map<String, Object>) defaultVal).entrySet()) {
                            JsonNode entryDef = defaultValueFromConnect(schema.getValueSchema(), entry.getValue());
                            node.put(entry.getKey(), entryDef);
                        }
                        return node;
                    } else {
                        ArrayNode array = JsonNodeFactory.instance.arrayNode();
                        for (Map.Entry<Object, Object> entry : ((Map<Object, Object>) defaultVal).entrySet()) {
                            JsonNode keyDefault = defaultValueFromConnect(schema.getKeySchema(), entry.getKey());
                            JsonNode valDefault = defaultValueFromConnect(schema.getValueSchema(), entry.getValue());
                            ArrayNode jsonEntry = JsonNodeFactory.instance.arrayNode();
                            jsonEntry.add(keyDefault);
                            jsonEntry.add(valDefault);
                            array.add(jsonEntry);
                        }
                        return array;
                    }
                case STRUCT: {
                    ObjectNode node = JsonNodeFactory.instance.objectNode();
                    Struct struct = (Struct) defaultVal;
                    for (Field field : schema.getFields()) {
                        JsonNode fieldDef = defaultValueFromConnect(field.getSchema(), struct.get(field));
                        node.set(field.getName(), fieldDef);
                    }
                    return node;
                }
                default:
                    throw new ConnectException("Unknown schema type:" + schema.getFieldType());
            }
        } catch (ClassCastException e) {
            throw new ConnectException("Invalid type used for default value of "
                    + schema.getFieldType()
                    + " field: "
                    + schema.getDefaultValue().getClass());
        }
    }