private void addObjectField()

in hollow-jsonadapter/src/main/java/com/netflix/hollow/jsonadapter/HollowJsonAdapter.java [264:346]
79 lines of code
25 McCabe index (conditional complexity)

    private void addObjectField(JsonParser parser, FlatRecordWriter flatRecordWriter, JsonToken token, ObjectMappedFieldPath mappedFieldPath) throws IOException {
        if(mappedFieldPath == null) {
            skipObjectField(parser, token);
        } else {

            HollowObjectWriteRecord writeRec = mappedFieldPath.getWriteRecord();
            HollowObjectSchema schema = writeRec.getSchema();
            String fieldName = mappedFieldPath.getFieldName();
            int fieldPosition = mappedFieldPath.getFieldPosition();

            FieldProcessor processor = mappedFieldPath.getFieldProcessor();
            if(processor != null && token != JsonToken.VALUE_NULL) {
                processor.processField(parser, stateEngine, writeRec);
                return;
            }

            switch(token) {
                case START_ARRAY:
                case START_OBJECT:
                    int refOrdinal = parseSubType(parser, flatRecordWriter, token, schema.getReferencedType(fieldPosition));
                    writeRec.setReference(fieldName, refOrdinal);
                    break;
                case VALUE_FALSE:
                case VALUE_TRUE:
                case VALUE_NUMBER_INT:
                case VALUE_NUMBER_FLOAT:
                case VALUE_STRING:
                    switch(schema.getFieldType(fieldPosition)) {
                        case BOOLEAN:
                            writeRec.setBoolean(fieldName, parser.getBooleanValue());
                            break;
                        case INT:
                            writeRec.setInt(fieldName, parser.getIntValue());
                            break;
                        case LONG:
                            writeRec.setLong(fieldName, parser.getLongValue());
                            break;
                        case DOUBLE:
                            writeRec.setDouble(fieldName, parser.getDoubleValue());
                            break;
                        case FLOAT:
                            writeRec.setFloat(fieldName, parser.getFloatValue());
                            break;
                        case STRING:
                            writeRec.setString(fieldName, parser.getValueAsString());
                            break;
                        case REFERENCE:
                            HollowObjectWriteRecord referencedRec = (HollowObjectWriteRecord) getWriteRecord(schema.getReferencedType(fieldPosition));
                            referencedRec.reset();
                            String refFieldName = referencedRec.getSchema().getFieldName(0);
                            switch(referencedRec.getSchema().getFieldType(0)) {
                                case BOOLEAN:
                                    referencedRec.setBoolean(refFieldName, parser.getBooleanValue());
                                    break;
                                case INT:
                                    referencedRec.setInt(refFieldName, parser.getIntValue());
                                    break;
                                case LONG:
                                    referencedRec.setLong(refFieldName, parser.getLongValue());
                                    break;
                                case DOUBLE:
                                    referencedRec.setDouble(refFieldName, parser.getDoubleValue());
                                    break;
                                case FLOAT:
                                    referencedRec.setFloat(refFieldName, parser.getFloatValue());
                                    break;
                                case STRING:
                                    referencedRec.setString(refFieldName, parser.getValueAsString());
                                    break;
                                default:
                            }

                            int referencedOrdinal = addRecord(schema.getReferencedType(fieldPosition), referencedRec, flatRecordWriter);
                            writeRec.setReference(fieldName, referencedOrdinal);
                            break;
                        default:
                    }
                case VALUE_NULL:
                    break;
                default:
            }
        }
    }