Example usage for com.fasterxml.jackson.core JsonParser getIntValue

List of usage examples for com.fasterxml.jackson.core JsonParser getIntValue

  1. HOME
  2. Java
  3. com.fasterxml
  4. com.fasterxml.jackson.core.*
  5. JsonParser
  6. getIntValue

Introduction

In this page you can find the example usage for com.fasterxml.jackson.core JsonParser getIntValue.

Prototype

public abstract int getIntValue() throws IOException, JsonParseException;

Source Link

Document

Numeric accessor that can be called when the current token is of type JsonToken#VALUE_NUMBER_INT and it can be expressed as a value of Java int primitive type.

Usage

From source file:com.google.openrtb.json.OpenRtbJsonReader.java

protected void readAudioField(JsonParser par, Audio.Builder audio, String fieldName) throws IOException {
    // Video & Audio common

    switch (fieldName) {
    case "mimes":
        for (startArray(par); endArray(par); par.nextToken()) {
            audio.addMimes(par.getText());
        }//from  w ww .j av a  2 s.  c om
        break;
    case "minduration":
        audio.setMinduration(par.getIntValue());
        break;
    case "maxduration":
        audio.setMaxduration(par.getIntValue());
        break;
    case "protocols":
        for (startArray(par); endArray(par); par.nextToken()) {
            Protocol value = Protocol.valueOf(par.getIntValue());
            if (checkEnum(value)) {
                audio.addProtocols(value);
            }
        }
        break;
    case "startdelay":
        audio.setStartdelay(par.getIntValue());
        break;
    case "sequence":
        audio.setSequence(par.getIntValue());
        break;
    case "battr":
        for (startArray(par); endArray(par); par.nextToken()) {
            CreativeAttribute value = CreativeAttribute.valueOf(par.getIntValue());
            if (checkEnum(value)) {
                audio.addBattr(value);
            }
        }
        break;
    case "maxextended":
        audio.setMaxextended(par.getIntValue());
        break;
    case "minbitrate":
        audio.setMinbitrate(par.getIntValue());
        break;
    case "maxbitrate":
        audio.setMaxbitrate(par.getIntValue());
        break;
    case "delivery":
        for (startArray(par); endArray(par); par.nextToken()) {
            ContentDeliveryMethod value = ContentDeliveryMethod.valueOf(par.getIntValue());
            if (checkEnum(value)) {
                audio.addDelivery(value);
            }
        }
        break;
    case "companionad":
        if (peekStructStart(par) == JsonToken.START_ARRAY) {
            // OpenRTB 2.2+
            for (startArray(par); endArray(par); par.nextToken()) {
                audio.addCompanionad(readBanner(par));
            }
        }
        break;
    case "api":
        for (startArray(par); endArray(par); par.nextToken()) {
            APIFramework value = APIFramework.valueOf(par.getIntValue());
            if (checkEnum(value)) {
                audio.addApi(value);
            }
        }
        break;
    case "companiontype":
        for (startArray(par); endArray(par); par.nextToken()) {
            CompanionType value = CompanionType.valueOf(par.getIntValue());
            if (checkEnum(value)) {
                audio.addCompaniontype(value);
            }
        }
        break;

    // Audio only

    case "maxseq":
        audio.setMaxseq(par.getIntValue());
        break;
    case "feed": {
        FeedType feed = FeedType.valueOf(par.getIntValue());
        if (checkEnum(feed)) {
            audio.setFeed(feed);
        }
    }
        break;
    case "stitched":
        audio.setStitched(par.getValueAsBoolean());
        break;
    case "nvol": {
        VolumeNormalizationMode value = VolumeNormalizationMode.valueOf(par.getIntValue());
        if (checkEnum(value)) {
            audio.setNvol(value);
        }
    }
        break;

    default:
        readOther(audio, par, fieldName);
    }
}

From source file:com.netflix.hollow.jsonadapter.HollowJsonAdapter.java

private void addObjectField(JsonParser parser, JsonToken token, ObjectMappedFieldPath mappedFieldPath)
        throws IOException {
    if (mappedFieldPath == null) {
        skipObjectField(parser, token);/*from  w w w.  j av a  2s.  co  m*/
    } 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, 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 = stateEngine.add(schema.getReferencedType(fieldPosition), referencedRec);
                writeRec.setReference(fieldName, referencedOrdinal);
                break;
            default:
            }
        case VALUE_NULL:
            break;
        default:
        }
    }
}

From source file:org.debezium.core.doc.JacksonReader.java

private Document parseDocument(JsonParser parser, boolean nested) throws IOException {
    // Iterate over the fields in the top-level document ...
    BasicDocument doc = new BasicDocument();
    JsonToken token = null;//  w  w w .j av a  2s  .c o  m
    if (!nested) {
        // We expect the START_OBJECT token ...
        token = parser.nextToken();
        if (!nested && token != JsonToken.START_OBJECT) {
            throw new IOException("Expected data to start with an Object, but was " + token);
        }
    }
    String fieldName = null;
    token = parser.nextToken();
    while (token != JsonToken.END_OBJECT) {
        switch (token) {
        case FIELD_NAME:
            fieldName = parser.getCurrentName();
            break;
        case START_OBJECT:
            doc.setDocument(fieldName, parseDocument(parser, true));
            break;
        case START_ARRAY:
            doc.setArray(fieldName, parseArray(parser));
            break;
        case VALUE_STRING:
            doc.setString(fieldName, parser.getValueAsString());
            break;
        case VALUE_TRUE:
            doc.setBoolean(fieldName, true);
            break;
        case VALUE_FALSE:
            doc.setBoolean(fieldName, false);
            break;
        case VALUE_NULL:
            doc.setNull(fieldName);
            break;
        case VALUE_NUMBER_FLOAT:
        case VALUE_NUMBER_INT:
            switch (parser.getNumberType()) {
            case FLOAT:
                doc.setNumber(fieldName, parser.getFloatValue());
                break;
            case DOUBLE:
                doc.setNumber(fieldName, parser.getDoubleValue());
                break;
            case BIG_DECIMAL:
                doc.setNumber(fieldName, parser.getDecimalValue());
                break;
            case INT:
                doc.setNumber(fieldName, parser.getIntValue());
                break;
            case LONG:
                doc.setNumber(fieldName, parser.getLongValue());
                break;
            case BIG_INTEGER:
                doc.setNumber(fieldName, parser.getBigIntegerValue());
                break;
            }
            break;
        case VALUE_EMBEDDED_OBJECT:
            // disregard this, since it's an extension ...
            break;
        case NOT_AVAILABLE:
            throw new JsonParseException("Non-blocking parsers are not supported", parser.getCurrentLocation());
        case END_ARRAY:
            throw new JsonParseException("Not expecting an END_ARRAY token", parser.getCurrentLocation());
        case END_OBJECT:
            throw new JsonParseException("Not expecting an END_OBJECT token", parser.getCurrentLocation());
        }
        token = parser.nextToken();
    }
    return doc;
}

From source file:name.gumartinm.weather.information.parser.JPOSCurrentParser.java

private void getCurrentWeatherDataObjects(final Current currentWeatherData, final JsonParser jParser,
        final String fieldname) throws JsonParseException, IOException {
    if ("coord".equals(fieldname)) {
        while (jParser.nextToken() != JsonToken.END_OBJECT) {
            final String namefield = jParser.getCurrentName();
            jParser.nextToken(); // move to value
            if ("lon".equals(namefield)) {
                currentWeatherData.getCoord().setLon(jParser.getDoubleValue());
            }//from   ww  w  . j a v a 2 s .c o  m
            if ("lat".equals(namefield)) {
                currentWeatherData.getCoord().setLat(jParser.getDoubleValue());
            }
        }
    }
    if ("sys".equals(fieldname)) {
        while (jParser.nextToken() != JsonToken.END_OBJECT) {
            final String namefield = jParser.getCurrentName();
            jParser.nextToken(); // move to value
            if ("message".equals(namefield)) {
                currentWeatherData.getSys().setMessage(jParser.getDoubleValue());
            }
            if ("country".equals(namefield)) {
                currentWeatherData.getSys().setCountry(jParser.getValueAsString());
            }
            if ("sunrise".equals(namefield)) {
                currentWeatherData.getSys().setSunrise(jParser.getValueAsLong());
            }
            if ("sunset".equals(namefield)) {
                currentWeatherData.getSys().setSunset(jParser.getValueAsLong());
            }
        }
    }
    if ("weather".equals(fieldname)) {
        final Weather weather = new Weather();
        currentWeatherData.getWeather().add(weather);
        while (jParser.nextToken() != JsonToken.END_OBJECT) {
            final String namefield = jParser.getCurrentName();
            jParser.nextToken(); // move to value
            if ("id".equals(namefield)) {
                weather.setId(jParser.getIntValue());
            }
            if ("main".equals(namefield)) {
                weather.setMain(jParser.getText());
            }
            if ("description".equals(namefield)) {
                weather.setDescription(jParser.getText());
            }
            if ("icon".equals(namefield)) {
                weather.setIcon(jParser.getText());
            }

        }
    }
    if ("base".equals(fieldname)) {
        currentWeatherData.setBase(jParser.getText());
    }
    if ("main".equals(fieldname)) {
        while (jParser.nextToken() != JsonToken.END_OBJECT) {
            final String namefield = jParser.getCurrentName();
            jParser.nextToken(); // move to value
            if ("temp".equals(namefield)) {
                currentWeatherData.getMain().setTemp(jParser.getDoubleValue());
            }
            if ("temp_min".equals(namefield)) {
                currentWeatherData.getMain().setTemp_min(jParser.getDoubleValue());
            }
            if ("temp_max".equals(namefield)) {
                currentWeatherData.getMain().setTemp_max(jParser.getDoubleValue());
            }
            if ("pressure".equals(namefield)) {
                currentWeatherData.getMain().setPressure(jParser.getDoubleValue());
            }
            if ("sea_level".equals(namefield)) {
                currentWeatherData.getMain().setSea_level(jParser.getDoubleValue());
            }
            if ("grnd_level".equals(namefield)) {
                currentWeatherData.getMain().setGrnd_level(jParser.getDoubleValue());
            }
            if ("humidity".equals(namefield)) {
                currentWeatherData.getMain().setHumidity(jParser.getDoubleValue());
            }
        }
    }
    if ("wind".equals(fieldname)) {
        while (jParser.nextToken() != JsonToken.END_OBJECT) {
            final String namefield = jParser.getCurrentName();
            jParser.nextToken(); // move to value
            if ("speed".equals(namefield)) {
                currentWeatherData.getWind().setSpeed(jParser.getDoubleValue());
            }
            if ("deg".equals(namefield)) {
                currentWeatherData.getWind().setDeg(jParser.getDoubleValue());
            }
        }
    }
    if ("clouds".equals(fieldname)) {
        while (jParser.nextToken() != JsonToken.END_OBJECT) {
            final String namefield = jParser.getCurrentName();
            jParser.nextToken(); // move to value
            if ("all".equals(namefield)) {
                currentWeatherData.getClouds().setAll(jParser.getDoubleValue());
            }
        }
    }
    if ("dt".equals(fieldname)) {
        currentWeatherData.setDt(jParser.getLongValue());
    }
    if ("rain".equals(fieldname)) {
        while (jParser.nextToken() != JsonToken.END_OBJECT) {
            final String namefield = jParser.getCurrentName();
            jParser.nextToken(); // move to value
            if ("3h".equals(namefield)) {
                currentWeatherData.getRain().set3h(jParser.getDoubleValue());
            }
        }
    }
    if ("snow".equals(fieldname)) {
        while (jParser.nextToken() != JsonToken.END_OBJECT) {
            final String namefield = jParser.getCurrentName();
            jParser.nextToken(); // move to value
            if ("3h".equals(namefield)) {
                currentWeatherData.getSnow().set3h(jParser.getDoubleValue());
            }
        }
    }
    if ("id".equals(fieldname)) {
        currentWeatherData.setId(jParser.getLongValue());
    }
    if ("name".equals(fieldname)) {
        currentWeatherData.setName(jParser.getText());
    }
    if ("cod".equals(fieldname)) {
        currentWeatherData.setCod(jParser.getIntValue());
    }
}

From source file:io.debezium.document.JacksonReader.java

private Document parseDocument(JsonParser parser, boolean nested) throws IOException {
    // Iterate over the fields in the top-level document ...
    BasicDocument doc = new BasicDocument();
    JsonToken token = null;// w w w  . j  a va  2s . c  om
    if (!nested) {
        // We expect the START_OBJECT token ...
        token = parser.nextToken();
        if (!nested && token != JsonToken.START_OBJECT) {
            throw new IOException("Expected data to start with an Object, but was " + token);
        }
    }
    String fieldName = null;
    token = parser.nextToken();
    while (token != JsonToken.END_OBJECT) {
        switch (token) {
        case FIELD_NAME:
            fieldName = parser.getCurrentName();
            break;
        case START_OBJECT:
            doc.setDocument(fieldName, parseDocument(parser, true));
            break;
        case START_ARRAY:
            doc.setArray(fieldName, parseArray(parser, true));
            break;
        case VALUE_STRING:
            doc.setString(fieldName, parser.getValueAsString());
            break;
        case VALUE_TRUE:
            doc.setBoolean(fieldName, true);
            break;
        case VALUE_FALSE:
            doc.setBoolean(fieldName, false);
            break;
        case VALUE_NULL:
            doc.setNull(fieldName);
            break;
        case VALUE_NUMBER_FLOAT:
        case VALUE_NUMBER_INT:
            switch (parser.getNumberType()) {
            case FLOAT:
                doc.setNumber(fieldName, parser.getFloatValue());
                break;
            case DOUBLE:
                doc.setNumber(fieldName, parser.getDoubleValue());
                break;
            case BIG_DECIMAL:
                doc.setNumber(fieldName, parser.getDecimalValue());
                break;
            case INT:
                doc.setNumber(fieldName, parser.getIntValue());
                break;
            case LONG:
                doc.setNumber(fieldName, parser.getLongValue());
                break;
            case BIG_INTEGER:
                doc.setNumber(fieldName, parser.getBigIntegerValue());
                break;
            }
            break;
        case VALUE_EMBEDDED_OBJECT:
            // disregard this, since it's an extension ...
            break;
        case NOT_AVAILABLE:
            throw new JsonParseException("Non-blocking parsers are not supported", parser.getCurrentLocation());
        case END_ARRAY:
            throw new JsonParseException("Not expecting an END_ARRAY token", parser.getCurrentLocation());
        case END_OBJECT:
            throw new JsonParseException("Not expecting an END_OBJECT token", parser.getCurrentLocation());
        }
        token = parser.nextToken();
    }
    return doc;
}

From source file:com.netflix.hollow.jsonadapter.HollowJsonAdapterPrimaryKeyFinder.java

private void addObjectField(JsonParser parser, JsonToken token, HollowObjectSchema schema, String fieldName,
        StringBuilder currentFieldPath) throws IOException {
    if (token != JsonToken.FIELD_NAME) {
        int fieldPosition = schema.getPosition(fieldName);

        if (fieldPosition == -1) {
            skipObjectField(parser, token);
        } else {// w  w w.j  av a2s  .c om
            int parentFieldPathLength = currentFieldPath.length();
            if (parentFieldPathLength > 0)
                currentFieldPath.append(".");
            currentFieldPath.append(fieldName);
            Integer keyFieldPosition = keyFieldPathPositions.get(currentFieldPath.toString());

            switch (token) {
            case START_ARRAY:
                skipSubArray(parser);
                break;
            case START_OBJECT:
                String referencedType = schema.getReferencedType(fieldName);
                HollowSchema referencedSchema = hollowSchemas.get(referencedType);

                if (referencedSchema.getSchemaType() == SchemaType.OBJECT)
                    addObject(parser, (HollowObjectSchema) referencedSchema, currentFieldPath);
                else
                    skipObject(parser);

                break;
            case VALUE_FALSE:
            case VALUE_TRUE:
            case VALUE_NUMBER_INT:
            case VALUE_NUMBER_FLOAT:
            case VALUE_STRING:
                switch (schema.getFieldType(fieldPosition)) {
                case BOOLEAN:
                    if (keyFieldPosition != null)
                        keyElementArray[keyFieldPosition.intValue()] = Boolean
                                .valueOf(parser.getBooleanValue());
                    break;
                case INT:
                    if (keyFieldPosition != null)
                        keyElementArray[keyFieldPosition.intValue()] = Integer.valueOf(parser.getIntValue());
                    break;
                case LONG:
                    if (keyFieldPosition != null)
                        keyElementArray[keyFieldPosition.intValue()] = Long.valueOf(parser.getLongValue());
                    break;
                case DOUBLE:
                    if (keyFieldPosition != null)
                        keyElementArray[keyFieldPosition.intValue()] = Double.valueOf(parser.getDoubleValue());
                    break;
                case FLOAT:
                    if (keyFieldPosition != null)
                        keyElementArray[keyFieldPosition.intValue()] = Float.valueOf(parser.getFloatValue());
                    break;
                case STRING:
                    if (keyFieldPosition != null)
                        keyElementArray[keyFieldPosition.intValue()] = parser.getValueAsString();
                    break;
                case REFERENCE:
                    if (keyFieldPosition != null)
                        throw new IllegalStateException("Key elements must not be REFERENCE");
                    HollowObjectSchema subSchema = (HollowObjectSchema) hollowSchemas
                            .get(schema.getReferencedType(fieldPosition));
                    currentFieldPath.append(".").append(subSchema.getFieldName(0));
                    keyFieldPosition = keyFieldPathPositions.get(currentFieldPath.toString());
                    if (keyFieldPosition != null) {
                        switch (subSchema.getFieldType(0)) {
                        case BOOLEAN:
                            if (keyFieldPosition != null)
                                keyElementArray[keyFieldPosition.intValue()] = Boolean
                                        .valueOf(parser.getBooleanValue());
                            break;
                        case INT:
                            if (keyFieldPosition != null)
                                keyElementArray[keyFieldPosition.intValue()] = Integer
                                        .valueOf(parser.getIntValue());
                            break;
                        case LONG:
                            if (keyFieldPosition != null)
                                keyElementArray[keyFieldPosition.intValue()] = Long
                                        .valueOf(parser.getLongValue());
                            break;
                        case DOUBLE:
                            if (keyFieldPosition != null)
                                keyElementArray[keyFieldPosition.intValue()] = Double
                                        .valueOf(parser.getDoubleValue());
                            break;
                        case FLOAT:
                            if (keyFieldPosition != null)
                                keyElementArray[keyFieldPosition.intValue()] = Float
                                        .valueOf(parser.getFloatValue());
                            break;
                        case STRING:
                            if (keyFieldPosition != null)
                                keyElementArray[keyFieldPosition.intValue()] = parser.getValueAsString();
                            break;
                        case REFERENCE:
                            throw new IllegalStateException("Key elements must not be REFERENCE");
                        default:
                        }
                    }

                default:
                }
            case VALUE_NULL:
                break;
            default:
            }

            currentFieldPath.setLength(parentFieldPathLength);
        }
    }
}

From source file:com.google.openrtb.json.OpenRtbJsonReader.java

protected void readBidResponseField(JsonParser par, BidResponse.Builder resp, String fieldName)
        throws IOException {
    switch (fieldName) {
    case "id":
        resp.setId(par.getText());//from   w  w w  .  ja va2  s .  c  om
        break;
    case "seatbid":
        for (startArray(par); endArray(par); par.nextToken()) {
            resp.addSeatbid(readSeatBid(par));
        }
        break;
    case "bidid":
        resp.setBidid(par.getText());
        break;
    case "cur":
        resp.setCur(par.getText());
        break;
    case "customdata":
        resp.setCustomdata(par.getText());
        break;
    case "nbr": {
        NoBidReason value = NoBidReason.valueOf(par.getIntValue());
        if (checkEnum(value)) {
            resp.setNbr(value);
        }
    }
        break;
    default:
        readOther(resp, par, fieldName);
    }
}

From source file:com.google.openrtb.json.OpenRtbJsonReader.java

protected void readDeviceField(JsonParser par, Device.Builder device, String fieldName) throws IOException {
    switch (fieldName) {
    case "ua":
        device.setUa(par.getText());// w w w . j a v a2s . c  o  m
        break;
    case "geo":
        device.setGeo(readGeo(par));
        break;
    case "dnt":
        device.setDnt(par.getValueAsBoolean());
        break;
    case "lmt":
        device.setLmt(par.getValueAsBoolean());
        break;
    case "ip":
        device.setIp(par.getText());
        break;
    case "ipv6":
        device.setIpv6(par.getText());
        break;
    case "devicetype": {
        DeviceType value = DeviceType.valueOf(par.getIntValue());
        if (checkEnum(value)) {
            device.setDevicetype(value);
        }
    }
        break;
    case "make":
        device.setMake(par.getText());
        break;
    case "model":
        device.setModel(par.getText());
        break;
    case "os":
        device.setOs(par.getText());
        break;
    case "osv":
        device.setOsv(par.getText());
        break;
    case "hwv":
        device.setHwv(par.getText());
        break;
    case "w":
        device.setW(par.getIntValue());
        break;
    case "h":
        device.setH(par.getIntValue());
        break;
    case "ppi":
        device.setPpi(par.getIntValue());
        break;
    case "pxratio":
        device.setPxratio(par.getValueAsDouble());
        break;
    case "js":
        device.setJs(par.getValueAsBoolean());
        break;
    case "flashver":
        device.setFlashver(par.getText());
        break;
    case "language":
        device.setLanguage(par.getText());
        break;
    case "carrier":
        device.setCarrier(par.getText());
        break;
    case "connectiontype": {
        ConnectionType value = ConnectionType.valueOf(par.getIntValue());
        if (checkEnum(value)) {
            device.setConnectiontype(value);
        }
    }
        break;
    case "ifa":
        device.setIfa(par.getText());
        break;
    case "didsha1":
        device.setDidsha1(par.getText());
        break;
    case "didmd5":
        device.setDidmd5(par.getText());
        break;
    case "dpidsha1":
        device.setDpidsha1(par.getText());
        break;
    case "dpidmd5":
        device.setDpidmd5(par.getText());
        break;
    case "macsha1":
        device.setMacsha1(par.getText());
        break;
    case "macmd5":
        device.setMacmd5(par.getText());
        break;
    case "geofetch":
        device.setGeofetch(par.getValueAsBoolean());
        break;
    default:
        readOther(device, par, fieldName);
    }
}

From source file:com.github.heuermh.personalgenome.client.converter.JacksonPersonalGenomeConverter.java

@Override
public List<Relative> parseRelatives(final InputStream inputStream) {
    checkNotNull(inputStream);//from   w  w w  . ja v  a 2s.  c om
    JsonParser parser = null;
    try {
        parser = jsonFactory.createParser(inputStream);
        parser.nextToken();

        List<Relative> relatives = new ArrayList<Relative>();

        String profileId = null;
        String matchId = null;
        double similarity = 0.0d;
        int sharedSegments = 0;
        Relationship relationship = null;
        Relationship userRelationship = null;
        Set<Relationship> range = new HashSet<Relationship>();

        while (parser.nextToken() != JsonToken.END_OBJECT) {
            String field = parser.getCurrentName();
            parser.nextToken();

            if ("id".equals(field)) {
                profileId = parser.getText();
            } else if ("relatives".equals(field)) {
                while (parser.nextToken() != JsonToken.END_ARRAY) {
                    while (parser.nextToken() != JsonToken.END_OBJECT) {
                        String relativeField = parser.getCurrentName();
                        parser.nextToken();

                        if ("match_id".equals(relativeField)) {
                            matchId = parser.getText();
                        } else if ("similarity".equals(relativeField)) {
                            similarity = Double.parseDouble(parser.getText());
                        } else if ("shared_segments".equals(relativeField)) {
                            sharedSegments = parser.getIntValue();
                        } else if ("relationship".equals(relativeField)) {
                            relationship = Relationship.fromDescription(parser.getText());
                        } else if ("user_relationship_code".equals(relativeField)) {
                            String code = parser.getText();
                            userRelationship = code == "null" ? null
                                    : Relationship.fromCode(Integer.parseInt(code));
                        } else if ("predicted_relationship_code".equals(relativeField)) {
                            if (relationship == null) {
                                String code = parser.getText();
                                relationship = code == "null" ? null
                                        : Relationship.fromCode(Integer.parseInt(code));
                            }
                        } else if ("range".equals(relativeField)) {
                            while (parser.nextToken() != JsonToken.END_ARRAY) {
                                range.add(Relationship.fromDescription(parser.getText()));
                            }
                        }
                        // ignored nested fields
                        else if ("family_locations".equals(relativeField)) {
                            while (parser.nextToken() != JsonToken.END_ARRAY) {
                                // ignore
                            }
                        } else if ("family_surnames".equals(relativeField)) {
                            while (parser.nextToken() != JsonToken.END_ARRAY) {
                                // ignore
                            }
                        } else if ("profile_picture_urls".equals(relativeField)) {
                            while (parser.nextToken() != JsonToken.END_OBJECT) {
                                // ignore
                            }
                        }
                    }
                }
                relatives.add(new Relative(profileId, matchId, similarity, sharedSegments, relationship,
                        userRelationship, range));
                matchId = null;
                similarity = 0.0d;
                sharedSegments = 0;
                relationship = null;
                userRelationship = null;
                range.clear();
            }
        }
        return relatives;
    } catch (IOException e) {
        logger.warn("could not parse relatives", e);
    } finally {
        try {
            inputStream.close();
        } catch (Exception e) {
            // ignored
        }
        try {
            parser.close();
        } catch (Exception e) {
            // ignored
        }
    }
    return null;
}

From source file:com.google.openrtb.json.OpenRtbJsonReader.java

protected void readNativeField(JsonParser par, Native.Builder nativ, String fieldName) throws IOException {
    switch (fieldName) {
    case "request":
        if (par.getCurrentToken() == JsonToken.VALUE_STRING) {
            nativ.setRequestNative(factory().newNativeReader().readNativeRequest(
                    new CharArrayReader(par.getTextCharacters(), par.getTextOffset(), par.getTextLength())));
        } else { // Object
            nativ.setRequestNative(factory().newNativeReader().readNativeRequest(par));
        }//from w w  w  . j a  v  a  2  s  .co m
        break;
    case "ver":
        nativ.setVer(par.getText());
        break;
    case "api":
        for (startArray(par); endArray(par); par.nextToken()) {
            APIFramework value = APIFramework.valueOf(par.getIntValue());
            if (checkEnum(value)) {
                nativ.addApi(value);
            }
        }
        break;
    case "battr":
        for (startArray(par); endArray(par); par.nextToken()) {
            CreativeAttribute value = CreativeAttribute.valueOf(par.getIntValue());
            if (checkEnum(value)) {
                nativ.addBattr(value);
            }
        }
        break;
    default:
        readOther(nativ, par, fieldName);
    }
}