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

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

Introduction

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

Prototype

public boolean getBooleanValue() throws IOException, JsonParseException 

Source Link

Document

Convenience accessor that can be called when the current token is JsonToken#VALUE_TRUE or JsonToken#VALUE_FALSE .

Usage

From source file:com.github.fabioticconi.roguelite.systems.BootstrapSystem.java

public void loadBody(final String filename, final EntityEdit edit) throws IOException {
    final YAMLFactory factory = new YAMLFactory();
    final JsonParser parser = factory.createParser(new File(filename));

    int str = 0, agi = 0, con = 0, skin = 0, sight = 0;
    boolean herbivore = false, carnivore = false;

    parser.nextToken(); // START_OBJECT

    while (parser.nextToken() != null) {
        final String name = parser.getCurrentName();

        if (name == null)
            break;

        parser.nextToken(); // get in value

        System.out.println(name);

        if (name.equals("strength")) {
            str = parser.getIntValue();//from w  w  w.  j av  a  2  s .  c  om
            edit.create(Strength.class).value = Util.ensureRange(str, -2, 2);
        } else if (name.equals("agility")) {
            agi = parser.getIntValue();
            edit.create(Agility.class).value = Util.ensureRange(agi, -2, 2);
        } else if (name.equals("constitution")) {
            con = parser.getIntValue();
            edit.create(Constitution.class).value = Util.ensureRange(con, -2, 2);
        } else if (name.equals("skin")) {
            skin = parser.getIntValue();
            edit.create(Skin.class).value = Util.ensureRange(skin, -2, 2);
        } else if (name.equals("sight")) {
            sight = parser.getIntValue();
            edit.create(Sight.class).value = Util.ensureRange(sight, 1, 18);
        } else if (name.equals("herbivore")) {
            herbivore = parser.getBooleanValue();

            if (herbivore)
                edit.create(Herbivore.class);
        } else if (name.equals("carnivore")) {
            carnivore = parser.getBooleanValue();

            if (carnivore)
                edit.create(Carnivore.class);
        }
    }

    // TODO check if neither herbivore nor carnivore? player is currently as such, for testing

    // Secondary Attributes
    final int size = Math.round((con - agi) / 2f);
    edit.create(Size.class).value = size;
    edit.create(Stamina.class).value = 5 + str + con;
    edit.create(Speed.class).value = (con - str - agi + 6) / 12f;

    // Tertiary Attributes
    edit.create(Hunger.class).value = (size / 2f) + 2f;
}

From source file:com.cedarsoft.serialization.serializers.jackson.VersionRangeSerializer.java

@Nonnull
@Override// w ww.  ja  v a 2s .  c  om
public VersionRange deserialize(@Nonnull JsonParser deserializeFrom, @Nonnull Version formatVersion)
        throws VersionException, IOException, JsonProcessingException {
    //min
    JacksonParserWrapper parserWrapper = new JacksonParserWrapper(deserializeFrom);
    parserWrapper.nextToken();
    parserWrapper.verifyCurrentToken(JsonToken.FIELD_NAME);
    String currentName3 = parserWrapper.getCurrentName();

    if (!PROPERTY_MIN.equals(currentName3)) {
        throw new JsonParseException(
                "Invalid field. Expected <" + PROPERTY_MIN + "> but was <" + currentName3 + ">",
                parserWrapper.getCurrentLocation());
    }
    parserWrapper.nextToken();
    Version min = Version.parse(deserializeFrom.getText());
    //max
    parserWrapper.nextToken();
    parserWrapper.verifyCurrentToken(JsonToken.FIELD_NAME);
    String currentName2 = parserWrapper.getCurrentName();

    if (!PROPERTY_MAX.equals(currentName2)) {
        throw new JsonParseException(
                "Invalid field. Expected <" + PROPERTY_MAX + "> but was <" + currentName2 + ">",
                parserWrapper.getCurrentLocation());
    }
    parserWrapper.nextToken();
    Version max = Version.parse(deserializeFrom.getText());
    //includeLower
    parserWrapper.nextToken();
    parserWrapper.verifyCurrentToken(JsonToken.FIELD_NAME);
    String currentName1 = parserWrapper.getCurrentName();

    if (!PROPERTY_INCLUDELOWER.equals(currentName1)) {
        throw new JsonParseException(
                "Invalid field. Expected <" + PROPERTY_INCLUDELOWER + "> but was <" + currentName1 + ">",
                parserWrapper.getCurrentLocation());
    }
    parserWrapper.nextToken();
    boolean includeLower = deserializeFrom.getBooleanValue();
    //includeUpper
    parserWrapper.nextToken();
    parserWrapper.verifyCurrentToken(JsonToken.FIELD_NAME);
    String currentName = parserWrapper.getCurrentName();

    if (!PROPERTY_INCLUDEUPPER.equals(currentName)) {
        throw new JsonParseException(
                "Invalid field. Expected <" + PROPERTY_INCLUDEUPPER + "> but was <" + currentName + ">",
                parserWrapper.getCurrentLocation());
    }
    parserWrapper.nextToken();
    boolean includeUpper = deserializeFrom.getBooleanValue();
    //Finally closing element
    parserWrapper.nextToken(JsonToken.END_OBJECT);
    //Constructing the deserialized object
    return new VersionRange(min, max, includeLower, includeUpper);
}

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

/**
 * Parse the specified input stream and return a user.
 *
 * @param inputStream input stream//from  w w w. ja v a2s .c o  m
 * @return the specified input stream parsed into a user
 */
@Override
public User parseUser(final InputStream inputStream) {
    checkNotNull(inputStream);
    JsonParser parser = null;
    try {
        parser = jsonFactory.createParser(inputStream);
        parser.nextToken();

        String id = null;
        String profileId = null;
        boolean genotyped = false;
        List<Profile> profiles = new ArrayList<Profile>();

        while (parser.nextToken() != JsonToken.END_OBJECT) {
            String field = parser.getCurrentName();
            parser.nextToken();
            if ("id".equals(field)) {
                id = parser.getText();
            } else if ("profiles".equals(field)) {
                while (parser.nextToken() != JsonToken.END_ARRAY) {
                    while (parser.nextToken() != JsonToken.END_OBJECT) {
                        String profileField = parser.getCurrentName();
                        parser.nextToken();
                        if ("id".equals(profileField)) {
                            profileId = parser.getText();
                        } else if ("genotyped".equals(profileField)) {
                            genotyped = parser.getBooleanValue();
                        }
                    }
                    profiles.add(new Profile(profileId, genotyped));
                }
            }
        }
        return new User(id, profiles);
    } catch (IOException e) {
        logger.warn("could not parse user", e);
    } finally {
        try {
            inputStream.close();
        } catch (Exception e) {
            // ignored
        }
        try {
            parser.close();
        } catch (Exception e) {
            // ignored
        }
    }
    return null;
}

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);/* www.ja  va2s  . c  o  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:pl.selvin.android.syncframework.content.BaseContentProvider.java

protected boolean Sync(String service, String scope, String params) {
    final Date start = new Date();
    boolean hasError = false;
    if (params == null)
        params = "";
    final SQLiteDatabase db = mDB.getWritableDatabase();
    final ArrayList<TableInfo> notifyTableInfo = new ArrayList<TableInfo>();

    final String download = String.format(contentHelper.DOWNLOAD_SERVICE_URI, service, scope, params);
    final String upload = String.format(contentHelper.UPLOAD_SERVICE_URI, service, scope, params);
    final String scopeServerBlob = String.format("%s.%s.%s", service, scope, _.serverBlob);
    String serverBlob = null;/*from w  ww  .  java2 s. com*/
    Cursor cur = db.query(BlobsTable.NAME, new String[] { BlobsTable.C_VALUE }, BlobsTable.C_NAME + "=?",
            new String[] { scopeServerBlob }, null, null, null);
    final String originalBlob;
    if (cur.moveToFirst()) {
        originalBlob = serverBlob = cur.getString(0);
    } else {
        originalBlob = null;
    }
    cur.close();
    db.beginTransaction();
    try {
        boolean nochanges = false;
        if (serverBlob != null) {
            nochanges = !contentHelper.hasDirtTable(db, scope);
        }
        boolean resolve = false;
        final Metadata meta = new Metadata();
        final HashMap<String, Object> vals = new HashMap<String, Object>();
        final ContentValues cv = new ContentValues(2);
        JsonFactory jsonFactory = new JsonFactory();
        JsonToken current = null;
        String name = null;
        boolean moreChanges = false;
        boolean forceMoreChanges = false;
        do {
            final int requestMethod;
            final String serviceRequestUrl;
            final ContentProducer contentProducer;

            if (serverBlob != null) {
                requestMethod = HTTP_POST;
                if (nochanges) {
                    serviceRequestUrl = download;
                } else {
                    serviceRequestUrl = upload;
                    forceMoreChanges = true;
                }
                contentProducer = new SyncContentProducer(jsonFactory, db, scope, serverBlob, !nochanges,
                        notifyTableInfo, contentHelper);
                nochanges = true;
            } else {
                requestMethod = HTTP_GET;
                serviceRequestUrl = download;
                contentProducer = null;

            }
            if (moreChanges) {
                db.beginTransaction();
            }

            Result result = executeRequest(requestMethod, serviceRequestUrl, contentProducer);
            if (result.getStatus() == HttpStatus.SC_OK) {
                final JsonParser jp = jsonFactory.createParser(result.getInputStream());

                jp.nextToken(); // skip ("START_OBJECT(d) expected");
                jp.nextToken(); // skip ("FIELD_NAME(d) expected");
                if (jp.nextToken() != JsonToken.START_OBJECT)
                    throw new Exception("START_OBJECT(d - object) expected");
                while (jp.nextToken() != JsonToken.END_OBJECT) {
                    name = jp.getCurrentName();
                    if (_.__sync.equals(name)) {
                        current = jp.nextToken();
                        while (jp.nextToken() != JsonToken.END_OBJECT) {
                            name = jp.getCurrentName();
                            current = jp.nextToken();
                            if (_.serverBlob.equals(name)) {
                                serverBlob = jp.getText();
                            } else if (_.moreChangesAvailable.equals(name)) {
                                moreChanges = jp.getBooleanValue() || forceMoreChanges;
                                forceMoreChanges = false;
                            } else if (_.resolveConflicts.equals(name)) {
                                resolve = jp.getBooleanValue();
                            }
                        }
                    } else if (_.results.equals(name)) {
                        if (jp.nextToken() != JsonToken.START_ARRAY)
                            throw new Exception("START_ARRAY(results) expected");
                        while (jp.nextToken() != JsonToken.END_ARRAY) {
                            meta.isDeleted = false;
                            meta.tempId = null;
                            vals.clear();
                            while (jp.nextToken() != JsonToken.END_OBJECT) {
                                name = jp.getCurrentName();
                                current = jp.nextToken();
                                if (current == JsonToken.VALUE_STRING) {
                                    vals.put(name, jp.getText());
                                } else if (current == JsonToken.VALUE_NUMBER_INT) {
                                    vals.put(name, jp.getLongValue());
                                } else if (current == JsonToken.VALUE_NUMBER_FLOAT) {
                                    vals.put(name, jp.getDoubleValue());
                                } else if (current == JsonToken.VALUE_FALSE) {
                                    vals.put(name, 0L);
                                } else if (current == JsonToken.VALUE_TRUE) {
                                    vals.put(name, 1L);
                                } else if (current == JsonToken.VALUE_NULL) {
                                    vals.put(name, null);
                                } else {
                                    if (current == JsonToken.START_OBJECT) {
                                        if (_.__metadata.equals(name)) {
                                            while (jp.nextToken() != JsonToken.END_OBJECT) {
                                                name = jp.getCurrentName();
                                                jp.nextToken();
                                                if (_.uri.equals(name)) {
                                                    meta.uri = jp.getText();
                                                } else if (_.type.equals(name)) {
                                                    meta.type = jp.getText();
                                                } else if (_.isDeleted.equals(name)) {
                                                    meta.isDeleted = jp.getBooleanValue();
                                                } else if (_.tempId.equals(name)) {
                                                    meta.tempId = jp.getText();
                                                }
                                            }
                                        } else if (_.__syncConflict.equals(name)) {
                                            while (jp.nextToken() != JsonToken.END_OBJECT) {
                                                name = jp.getCurrentName();
                                                jp.nextToken();
                                                if (_.isResolved.equals(name)) {
                                                } else if (_.conflictResolution.equals(name)) {
                                                } else if (_.conflictingChange.equals(name)) {
                                                    while (jp.nextToken() != JsonToken.END_OBJECT) {
                                                        name = jp.getCurrentName();
                                                        current = jp.nextToken();
                                                        if (current == JsonToken.START_OBJECT) {
                                                            if (_.__metadata.equals(name)) {
                                                                while (jp.nextToken() != JsonToken.END_OBJECT) {

                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            // resolve conf

                                        } else if (_.__syncError.equals(name)) {
                                            while (jp.nextToken() != JsonToken.END_OBJECT) {
                                                name = jp.getCurrentName();
                                                jp.nextToken();
                                            }
                                        }
                                    }
                                }
                            }
                            TableInfo tab = contentHelper.getTableFromType(meta.type);
                            if (meta.isDeleted) {
                                tab.DeleteWithUri(meta.uri, db);
                            } else {
                                tab.SyncJSON(vals, meta, db);
                            }
                            if (!notifyTableInfo.contains(tab))
                                notifyTableInfo.add(tab);
                        }
                    }
                }
                jp.close();
                if (!hasError) {
                    cv.clear();
                    cv.put(BlobsTable.C_NAME, scopeServerBlob);
                    cv.put(BlobsTable.C_VALUE, serverBlob);
                    cv.put(BlobsTable.C_DATE, Calendar.getInstance().getTimeInMillis());
                    cv.put(BlobsTable.C_STATE, 0);
                    db.replace(BlobsTable.NAME, null, cv);
                    db.setTransactionSuccessful();
                    db.endTransaction();
                    if (DEBUG) {
                        Log.d(TAG, "CP-Sync: commit changes");
                    }
                    final ContentResolver cr = getContext().getContentResolver();
                    for (TableInfo t : notifyTableInfo) {
                        final Uri nu = contentHelper.getDirUri(t.name, false);
                        cr.notifyChange(nu, null, false);
                        // false - do not force sync cause we are in sync
                        if (DEBUG) {
                            Log.d(TAG, "CP-Sync: notifyChange table: " + t.name + ", uri: " + nu);
                        }

                        for (String n : t.notifyUris) {
                            cr.notifyChange(Uri.parse(n), null, false);
                            if (DEBUG) {
                                Log.d(TAG, "+uri: " + n);
                            }
                        }
                    }
                    notifyTableInfo.clear();
                }
            } else {
                if (DEBUG) {
                    Log.e(TAG, "Server error in fetching remote contacts: " + result.getStatus());
                }
                hasError = true;
                break;
            }
        } while (moreChanges);
    } catch (final ConnectTimeoutException e) {
        hasError = true;
        if (DEBUG) {
            Log.e(TAG, "ConnectTimeoutException", e);
        }
    } catch (final IOException e) {
        hasError = true;
        if (DEBUG) {
            Log.e(TAG, Log.getStackTraceString(e));
        }
    } catch (final ParseException e) {
        hasError = true;
        if (DEBUG) {
            Log.e(TAG, "ParseException", e);
        }
    } catch (final Exception e) {
        hasError = true;
        if (DEBUG) {
            Log.e(TAG, "ParseException", e);
        }
    }
    if (hasError) {
        db.endTransaction();
        ContentValues cv = new ContentValues();
        cv.put(BlobsTable.C_NAME, scopeServerBlob);
        cv.put(BlobsTable.C_VALUE, originalBlob);
        cv.put(BlobsTable.C_DATE, Calendar.getInstance().getTimeInMillis());
        cv.put(BlobsTable.C_STATE, -1);
        db.replace(BlobsTable.NAME, null, cv);
    }
    /*-if (!hasError) {
    final ContentValues cv = new ContentValues(2);
     cv.put(BlobsTable.C_NAME, scopeServerBlob);
     cv.put(BlobsTable.C_VALUE, serverBlob);
     db.replace(BlobsTable.NAME, null, cv);
     db.setTransactionSuccessful();
    }
    db.endTransaction();
    if (!hasError) {
     for (String t : notifyTableInfo) {
    getContext().getContentResolver().notifyChange(getDirUri(t),
          null);
     }
    }*/
    if (DEBUG) {
        Helpers.LogInfo(start);
    }
    return !hasError;
}

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 {/*from  w w w .j  a  v  a 2 s.c  o  m*/
            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.concentricsky.android.khanacademy.data.remote.LibraryUpdaterTask.java

private ContentValues parseObject(JsonParser parser, SQLiteDatabase tempDb, String parentId, int seq)
        throws JsonParseException, IOException {
    // TODO : Grab id of root topic here, and store it in shared prefs, in case it ever
    //        changes. Currently we assume "root" and a change would be catastrophic.
    ContentValues result = new ContentValues();
    ChildArrayResults childResults = null;
    boolean badKind = false;

    result.put("parentTopic_id", parentId);
    result.put("seq", seq);

    while (parser.nextValue() != JsonToken.END_OBJECT) {

        // Allows us to burn through the rest of the object once we discover it's an exercise or something else we don't care about.
        if (badKind)
            continue;

        String fieldName = parser.getCurrentName();

        // Keys present will determine object type.
        if (stringFields.contains(fieldName)) {
            // Use getValueAsString over getText; getText returns "null" while getValueAsString returns null.
            String value = parser.getValueAsString();
            result.put(fieldName, value);

            if ("id".equals(fieldName)) {
                if (childResults != null) {
                    addParentIdToChildren(tempDb, childResults, value);
                }/*from  w  ww  .  java 2s  .  com*/
            }
        } else if (intFields.contains(fieldName)) {
            result.put(fieldName, parser.getIntValue());
        } else if (booleanFields.contains(fieldName)) {
            result.put(fieldName, parser.getBooleanValue());
        } else if ("children".equals(fieldName)) {
            childResults = parseChildArray(parser, tempDb,
                    result.containsKey("id") ? result.getAsString("id") : null);
            result.put("video_count", childResults.videoCount);
            result.put("child_kind", childResults.childKind);
            result.put("thumb_id", childResults.thumbId);
        } else if ("download_urls".equals(fieldName)) {
            parseDownloadUrls(parser, result);
        } else if (null == fieldName) {
            // Noop. Just in case.
        } else {
            JsonToken next = parser.getCurrentToken();
            if (next == JsonToken.START_OBJECT || next == JsonToken.START_ARRAY) {
                // Skip this object or array, leaving us pointing at the matching end_object / end_array token.
                parser.skipChildren();
            }
        }
    }

    // Ignore types we don't need.
    if (badKind) {
        return null;
    }

    // Having parsed this whole object, we can insert it.
    if (result.containsKey("kind")) {
        String kind = result.getAsString("kind");
        if ("Topic".equals(kind)) {
            if (result.containsKey("id")) {
                result.put("_id", result.getAsString("id"));
                result.remove("id");
            }
            if (result.containsKey("child_kind")) {
                String child_kind = result.getAsString("child_kind");
                if ("Topic".equals(child_kind) || "Video".equals(child_kind)) {
                    insertTopic(tempDb, result);
                }
            }
        } else if ("Video".equals(kind)) {
            if (result.containsKey("id")) {
                result.put("video_id", result.getAsString("id"));
                result.remove("id");
            }
            insertTopicVideo(tempDb, result);
            insertVideo(tempDb, result);
        }
    }

    return result;
}

From source file:com.adobe.communities.ugc.migration.importer.MessagesImportServlet.java

private void importMessages(final SlingHttpServletRequest request, final JsonParser jsonParser,
        final Map<String, Object> messageModifiers) throws ServletException {

    if (!jsonParser.getCurrentToken().equals(JsonToken.START_ARRAY)) {
        throw new ServletException("unexpected starting token " + jsonParser.getCurrentToken().asString());
    }/*from   www. j ava 2s . c  om*/

    try {
        jsonParser.nextToken(); //presumably, we will advance to a "start object" token
        while (!jsonParser.getCurrentToken().equals(JsonToken.END_ARRAY)) {
            final Map<String, Map<String, Boolean>> recipientModifiers = new HashMap<String, Map<String, Boolean>>();
            final Map<String, Object> props = new HashMap<String, Object>();
            final Map<String, Object> messageModifier = new HashMap<String, Object>();
            List<FileDataSource> attachments = new ArrayList<FileDataSource>();
            String sender = "";
            jsonParser.nextToken(); //field name
            while (!jsonParser.getCurrentToken().equals(JsonToken.END_OBJECT)) {
                final String fieldName = jsonParser.getCurrentName();
                jsonParser.nextToken(); //value
                if (fieldName.equals("senderId")) {
                    sender = URLDecoder.decode(jsonParser.getValueAsString(), "UTF-8");
                } else if (fieldName.equals("added")) {
                    final Calendar calendar = new GregorianCalendar();
                    calendar.setTimeInMillis(jsonParser.getLongValue());
                    messageModifier.put("added", calendar);
                } else if (fieldName.equals("recipients")) {
                    // build the string for the "to" property and also create the modifiers we'll need later
                    final StringBuilder recipientString = new StringBuilder();
                    //iterate over each key (each being a recipient id)
                    if (jsonParser.getCurrentToken().equals(JsonToken.START_OBJECT)) {
                        jsonParser.nextToken(); // should get first recipientId
                        while (!jsonParser.getCurrentToken().equals(JsonToken.END_OBJECT)) {
                            final String recipientId = jsonParser.getCurrentName();
                            jsonParser.nextToken(); //start object
                            jsonParser.nextToken(); //first label
                            final Map<String, Boolean> interactionModifiers = new HashMap<String, Boolean>();
                            while (!jsonParser.getCurrentToken().equals(JsonToken.END_OBJECT)) {
                                final String label = jsonParser.getCurrentName();
                                jsonParser.nextToken();
                                final Boolean labelValue = jsonParser.getBooleanValue();
                                interactionModifiers.put(label, labelValue);
                                jsonParser.nextToken(); //next label or end object
                            }
                            try {
                                final String userPath = userPropertiesService.getAuthorizablePath(recipientId);
                                recipientModifiers.put(userPath, interactionModifiers);
                                recipientString.append(recipientId);
                            } catch (final RepositoryException e) {
                                // log the fact that a recipient specified in the json file doesn't exist in this
                                // environment
                                throw new ServletException(
                                        "A recipient specified in the migration file couldn't "
                                                + "be found in this environment",
                                        e);
                            }
                            jsonParser.nextToken(); // next recipientId or end object
                            if (jsonParser.getCurrentToken().equals(JsonToken.FIELD_NAME)) {
                                recipientString.append(';');
                            }
                        }
                        props.put("to", recipientString);
                        messageModifier.put("recipientDetails", recipientModifiers);
                    }
                } else if (fieldName.equals(ContentTypeDefinitions.LABEL_ATTACHMENTS)) {
                    UGCImportHelper.getAttachments(jsonParser, attachments);
                } else {
                    props.put(fieldName, URLDecoder.decode(jsonParser.getValueAsString(), "UTF-8"));
                }
                jsonParser.nextToken(); //either next field name or end object
            }
            final Random range = new Random();
            final String key = String.valueOf(range.nextInt(Integer.MAX_VALUE))
                    + String.valueOf(range.nextInt(Integer.MAX_VALUE));
            // we're going to temporarily overwrite the subject (to do a search) and need to track its initial value
            if (props.containsKey("subject")) {
                messageModifier.put("subject", props.get("subject"));
            } else {
                messageModifier.put("subject", "");
            }
            props.put("subject", key); //use subject as the search key
            messageModifiers.put(key, messageModifier);
            try {
                short result = messagingService.create(request.getResourceResolver(), request.getResource(),
                        sender, props, attachments,
                        clientUtilsFactory.getClientUtilities(xss, request, socialUtils));

                if (result != 200) {
                    throw new ServletException("Message sending failed. Return code was " + result);
                }
            } catch (final OperationException e) {
                throw new ServletException("Unable to create a message through the operation service", e);
            }
            jsonParser.nextToken(); //either END_ARRAY or START_OBJECT
        }

    } catch (final IOException e) {
        throw new ServletException("Encountered exception while parsing json content", e);
    }
}

From source file:com.netflix.hollow.jsonadapter.discover.HollowJsonAdapterSchemaDiscoverer.java

private void discoverSchemaField(JsonParser parser, JsonToken token, String fieldName,
        HollowDiscoveredSchema schema) throws IOException {

    if (token != JsonToken.FIELD_NAME) {
        switch (token) {
        case START_ARRAY:
            String listName = schemaNamer.subCollectionName(schema.schemaName, "ArrayOf", fieldName);
            String elementName = schemaNamer.subObjectName(schema.schemaName, "", fieldName);
            if (isDebug)
                System.out.println(String.format(
                        "\t ARR[START] token=%s schemaName=%s fieldName=%s listName=%s elementName=%s", token,
                        schema.schemaName, fieldName, listName, elementName));

            discoveredSchema(listName, DiscoveredSchemaType.LIST, elementName);
            schema.addField(fieldName, FieldType.REFERENCE, listName);

            HollowDiscoveredSchema elementSchema = discoveredSchema(elementName, DiscoveredSchemaType.OBJECT,
                    null);/*from  w ww . j a va 2s  . com*/
            discoverSubArraySchemas(parser, elementSchema);
            if (isDebug)
                System.out.println(String.format(
                        "\t ARR[END] token=%s schemaName=%s fieldName=%s listName=%s elementName=%s elementSchema=%s",
                        token, schema.schemaName, fieldName, listName, elementName, elementSchema));

            break;
        case START_OBJECT:
            String subObjectName = schemaNamer.subObjectName(schema.schemaName, "", fieldName);
            //if (isDebug) System.out.println("\t\t [MAP CHECK] subObjectName=" + subObjectName + "\t" + mapTypes.contains(subObjectName) + "\t" + mapTypes);
            if (mapTypes.contains(subObjectName)) {
                String subMapName = schemaNamer.subCollectionName(schema.schemaName, "MapOf", fieldName);
                if (isDebug)
                    System.out.println(String.format(
                            "\t MAP[START] token=%s schemaName=%s fieldName=%s subMapName=%s subObjectName=%s",
                            token, schema.schemaName, fieldName, subMapName, subObjectName));

                discoveredSchema(subMapName, DiscoveredSchemaType.MAP, subObjectName);
                schema.addField(fieldName, FieldType.REFERENCE, subMapName);

                HollowDiscoveredSchema valueSchema = discoveredSchema(subObjectName,
                        DiscoveredSchemaType.OBJECT, null);
                discoverSubMapSchemas(parser, valueSchema);
                if (isDebug)
                    System.out.println(String.format(
                            "\t MAP[END] token=%s schemaName=%s fieldName=%s subMapName=%s subObjectName=%s valueSchema=%s",
                            token, schema.schemaName, fieldName, subMapName, subObjectName, valueSchema));
            } else {
                if (isDebug)
                    System.out.println(
                            String.format("\t OBJ[START] token=%s schemaName=%s fieldName=%s subObjectName=%s",
                                    token, schema.schemaName, fieldName, subObjectName));
                HollowDiscoveredSchema subObjectSchema = discoveredSchema(subObjectName,
                        DiscoveredSchemaType.OBJECT, null);
                if (fieldName != null)
                    schema.addField(fieldName, FieldType.REFERENCE, subObjectName);

                discoverSchemas(parser, subObjectSchema);
                if (isDebug)
                    System.out.println(String.format(
                            "\t OBJ[END] token=%s schemaName=%s fieldName=%s subObjectName=%s subObjectSchema=%s",
                            token, schema.schemaName, fieldName, subObjectName, subObjectSchema));
            }

            break;
        case VALUE_NUMBER_INT:
            if (isDebug)
                System.out.println(String.format("\t FIELD token=%s schemaName=%s fieldName=%s value=%s", token,
                        schema.schemaName, fieldName, parser.getLongValue()));
            schema.addField(fieldName, FieldType.LONG);
            break;
        case VALUE_NUMBER_FLOAT:
            if (isDebug)
                System.out.println(String.format("\t FIELD token=%s schemaName=%s fieldName=%s value=%s", token,
                        schema.schemaName, fieldName, parser.getDoubleValue()));
            schema.addField(fieldName, FieldType.DOUBLE);
            break;
        case VALUE_NULL:
            if (isDebug)
                System.out.println(String.format("\t FIELD token=%s schemaName=%s fieldName=%s", token,
                        schema.schemaName, fieldName));
            break;
        case VALUE_STRING:
            if (isDebug)
                System.out.println(String.format("\t FIELD token=%s schemaName=%s fieldName=%s value=%s", token,
                        schema.schemaName, fieldName, parser.getValueAsString()));
            schema.addField(fieldName, FieldType.STRING);
            break;
        case VALUE_FALSE:
        case VALUE_TRUE:
            if (isDebug)
                System.out.println(String.format("\t FIELD token=%s schemaName=%s fieldName=%s value=%s", token,
                        schema.schemaName, fieldName, parser.getBooleanValue()));
            schema.addField(fieldName, FieldType.BOOLEAN);
            break;
        default:
        }
    }
}

From source file:org.hippoecm.frontend.service.restproxy.custom.json.deserializers.AnnotationJsonDeserializer.java

protected Object deserializeAnnotationAttribute(Class<? extends Annotation> annotationClass,
        Method annotationAttribute, JsonParser jsonParser) throws JsonParseException, IOException {

    jsonParser.nextToken();//w w w  .jav a 2s  .c o  m
    if (annotationAttribute.getReturnType() == byte.class
            || annotationAttribute.getReturnType() == Byte.class) {
        return jsonParser.getNumberValue().byteValue();
    } else if (annotationAttribute.getReturnType() == short.class
            || annotationAttribute.getReturnType() == Short.class) {
        return jsonParser.getNumberValue().shortValue();
    } else if (annotationAttribute.getReturnType() == int.class
            || annotationAttribute.getReturnType() == Integer.class) {
        return jsonParser.getNumberValue().intValue();
    } else if (annotationAttribute.getReturnType() == long.class
            || annotationAttribute.getReturnType() == Long.class) {
        return jsonParser.getNumberValue().longValue();
    } else if (annotationAttribute.getReturnType() == float.class
            || annotationAttribute.getReturnType() == Float.class) {
        return jsonParser.getNumberValue().floatValue();
    } else if (annotationAttribute.getReturnType() == double.class
            || annotationAttribute.getReturnType() == Double.class) {
        return jsonParser.getNumberValue().doubleValue();
    } else if (annotationAttribute.getReturnType() == double.class
            || annotationAttribute.getReturnType() == Double.class) {
        return jsonParser.getNumberValue().doubleValue();
    } else if (annotationAttribute.getReturnType() == boolean.class
            || annotationAttribute.getReturnType() == Boolean.class) {
        return jsonParser.getBooleanValue();
    } else if (annotationAttribute.getReturnType() == char.class
            || annotationAttribute.getReturnType() == Character.class) {
        return jsonParser.getText().charAt(0);
    } else if (annotationAttribute.getReturnType() == String.class) {
        return jsonParser.getText();
    } else if (annotationAttribute.getReturnType() == byte[].class) {
        return deserializeBytePrimitiveArrayAnnotationAttribute(jsonParser);
    } else if (annotationAttribute.getReturnType() == Byte[].class) {
        return deserializeByteArrayAnnotationAttribute(jsonParser);
    } else if (annotationAttribute.getReturnType() == short[].class) {
        return deserializeShortPrimitiveArrayAnnotationAttribute(jsonParser);
    } else if (annotationAttribute.getReturnType() == Short[].class) {
        return deserializeShortArrayAnnotationAttribute(jsonParser);
    } else if (annotationAttribute.getReturnType() == int[].class) {
        return deserializeIntegerPrimitiveArrayAnnotationAttribute(jsonParser);
    } else if (annotationAttribute.getReturnType() == Short[].class) {
        return deserializeIntegerArrayAnnotationAttribute(jsonParser);
    } else if (annotationAttribute.getReturnType() == long[].class) {
        return deserializeLongPrimitiveArrayAnnotationAttribute(jsonParser);
    } else if (annotationAttribute.getReturnType() == Long[].class) {
        return deserializeLongArrayAnnotationAttribute(jsonParser);
    } else if (annotationAttribute.getReturnType() == float[].class) {
        return deserializeFloatPrimitiveArrayAnnotationAttribute(jsonParser);
    } else if (annotationAttribute.getReturnType() == Float[].class) {
        return deserializeFloatArrayAnnotationAttribute(jsonParser);
    } else if (annotationAttribute.getReturnType() == double[].class) {
        return deserializeDoublePrimitiveArrayAnnotationAttribute(jsonParser);
    } else if (annotationAttribute.getReturnType() == Double[].class) {
        return deserializeDoubleArrayAnnotationAttribute(jsonParser);
    } else if (annotationAttribute.getReturnType() == boolean[].class) {
        return deserializeBooleanPrimitiveArrayAnnotationAttribute(jsonParser);
    } else if (annotationAttribute.getReturnType() == Boolean[].class) {
        return deserializeBooleanArrayAnnotationAttribute(jsonParser);
    } else if (annotationAttribute.getReturnType() == char[].class) {
        return deserializeCharacterPrimitiveArrayAnnotationAttribute(jsonParser);
    } else if (annotationAttribute.getReturnType() == Character[].class) {
        return deserializeCharacterArrayAnnotationAttribute(jsonParser);
    } else if (annotationAttribute.getReturnType() == String[].class) {
        return deserializeStringArrayAnnotationAttribute(jsonParser);
    } else {
        throw new IllegalArgumentException(
                "Unrecognized attribute value type " + annotationAttribute.getReturnType().getName()
                        + " for annotation " + annotationClass.getName());

    }
}