Example usage for com.fasterxml.jackson.core JsonGenerator useDefaultPrettyPrinter

List of usage examples for com.fasterxml.jackson.core JsonGenerator useDefaultPrettyPrinter

Introduction

In this page you can find the example usage for com.fasterxml.jackson.core JsonGenerator useDefaultPrettyPrinter.

Prototype

public abstract JsonGenerator useDefaultPrettyPrinter();

Source Link

Document

Convenience method for enabling pretty-printing using the default pretty printer ( com.fasterxml.jackson.core.util.DefaultPrettyPrinter ).

Usage

From source file:com.websocket.server.commons.JsonPojoMapper.java

public static void toJson(Object pojo, FileWriter fw, boolean prettyPrint)
        throws JsonMappingException, JsonGenerationException, IOException {
    JsonGenerator jsonGen = jsonFactory.createJsonGenerator(fw);
    if (prettyPrint) {
        jsonGen.useDefaultPrettyPrinter();
    }/*from w ww . j ava2 s.  c o m*/
    mapper.writeValue(jsonGen, pojo);
}

From source file:com.websocket.server.commons.JsonPojoMapper.java

public static String toJson(Object pojo, boolean prettyPrint)
        throws JsonMappingException, JsonGenerationException, IOException {
    StringWriter sw = new StringWriter();
    JsonGenerator jsonGen = jsonFactory.createJsonGenerator(sw);
    if (prettyPrint) {
        jsonGen.useDefaultPrettyPrinter();
    }/*  w  w w .  j  a  va2  s  .com*/
    mapper.writeValue(jsonGen, pojo);
    return sw.toString();
}

From source file:eu.project.ttc.readers.TermSuiteJsonCasSerializer.java

public static void serialize(Writer writer, JCas jCas) throws IOException {

    JsonFactory jsonFactory = new JsonFactory();
    JsonGenerator jg = jsonFactory.createGenerator(writer);
    jg.useDefaultPrettyPrinter();
    jg.writeStartObject();/*from   www  . ja v  a 2  s. c  o m*/
    jg.writeFieldName(F_SDI);
    writeSDI(jg, jCas);
    jg.writeFieldName(F_WORD_ANNOTATIONS);
    writeWordAnnotations(jg, jCas);
    jg.writeFieldName(F_TERM_OCC_ANNOTATIONS);
    writeTermOccAnnotations(jg, jCas);
    jg.writeFieldName(F_FIXED_EXPRESSIONS);
    writeFixedExpressions(jg, jCas);
    writeCoveredText(jg, jCas);
    jg.writeEndObject();
    jg.flush();
    writer.close();
}

From source file:com.teamlazerbeez.crm.sf.rest.HttpApiClientTest.java

private static String reformatJson(String input) throws IOException {
    JsonFactory jsonFactory = new JsonFactory();

    JsonParser parser = jsonFactory.createJsonParser(input);
    StringWriter writer = new StringWriter();
    JsonGenerator generator = jsonFactory.createJsonGenerator(writer);
    generator.useDefaultPrettyPrinter();

    while (parser.nextToken() != null) {
        generator.copyCurrentEvent(parser);
    }/* w  ww . j  a va  2s.co m*/

    generator.close();

    return writer.toString();
}

From source file:com.palominolabs.crm.sf.rest.HttpApiClientTest.java

private static String reformatJson(@Nullable String input) throws IOException {
    checkNotNull(input);//from  w  w  w . ja  v a  2 s.co m

    JsonFactory jsonFactory = new JsonFactory();

    JsonParser parser = jsonFactory.createParser(input);
    StringWriter writer = new StringWriter();
    JsonGenerator generator = jsonFactory.createGenerator(writer);
    generator.useDefaultPrettyPrinter();

    while (parser.nextToken() != null) {
        generator.copyCurrentEvent(parser);
    }

    generator.close();

    return writer.toString();
}

From source file:com.squarespace.template.GeneralUtils.java

/**
 * Formats the {@code node} as a string using the pretty printer.
 *///from w  ww. ja  va2  s  .c  om
public static String jsonPretty(JsonNode node) throws IOException {
    StringBuilder buf = new StringBuilder();
    JsonGenerator gen = JSON_FACTORY.createGenerator(new StringBuilderWriter(buf));
    gen.useDefaultPrettyPrinter();
    gen.setCodec(JsonUtils.getMapper());
    gen.writeTree(node);
    return buf.toString();
}

From source file:eionet.meta.exports.json.VocabularyJSONOutputHelper.java

/**
 * Writes JSON to output stream.//from   w w  w . j a va  2 s.  c  o m
 * <p>
 * NOTE: For readability purposes, nested blocks are used in this method while generating json contents.
 * </p>
 *
 * @param out
 *            output stream
 * @param vocabulary
 *            vocabulary base uri
 * @param concepts
 *            list of vocabulary concepts
 * @param language
 *            language for the preferred label
 * @throws java.io.IOException
 *             if error in I/O
 */
public static void writeJSON(OutputStream out, VocabularyFolder vocabulary, List<VocabularyConcept> concepts,
        String language) throws IOException {
    OutputStreamWriter osw = new OutputStreamWriter(out, "UTF-8");

    JsonFactory f = new JsonFactory();
    JsonGenerator generator = f.createGenerator(out);
    generator.useDefaultPrettyPrinter();

    language = StringUtils.trimToNull(language);
    boolean checkLanguage = StringUtils.isNotBlank(language);

    List<String> relationalDataElemIdentifiers = new ArrayList<String>();
    relationalDataElemIdentifiers.add(BROADER);
    relationalDataElemIdentifiers.add(NARROWER);

    // start json object
    generator.writeStartObject();
    // add context
    generator.writeObjectFieldStart(JSON_LD_CONTEXT);
    {
        generator.writeStringField(JSON_LD_BASE, VocabularyFolder.getBaseUri(vocabulary));
        generator.writeStringField(VocabularyOutputHelper.LinkedDataNamespaces.SKOS,
                VocabularyOutputHelper.LinkedDataNamespaces.SKOS_NS);
        generator.writeStringField(JSON_LD_CONCEPTS, SKOS_CONCEPT);
        generator.writeStringField(PREF_LABEL, SKOS_PREF_LABEL);
        for (String dataElemShortIdentifier : relationalDataElemIdentifiers) {
            generator.writeStringField(dataElemShortIdentifier, DATA_ELEM_MAP.get(dataElemShortIdentifier));
        }
        generator.writeStringField(JSON_LD_LANGUAGE,
                StringUtils.isNotBlank(language) ? language : DEFAULT_LANGUAGE);
    }
    generator.writeEndObject();
    // start writing concepts...
    generator.writeArrayFieldStart(JSON_LD_CONCEPTS);
    // iterate on concepts
    for (VocabularyConcept concept : concepts) {
        generator.writeStartObject();
        {
            generator.writeStringField(JSON_LD_ID, concept.getIdentifier());
            generator.writeStringField(JSON_LD_TYPE, SKOS_CONCEPT);
            // start writing prefLabels
            generator.writeArrayFieldStart(PREF_LABEL);
            {
                String label;
                String labelLang;
                if (checkLanguage) {
                    List<DataElement> dataElementValuesByNameAndLang = VocabularyOutputHelper
                            .getDataElementValuesByNameAndLang(SKOS_PREF_LABEL, language,
                                    concept.getElementAttributes());
                    if (dataElementValuesByNameAndLang != null && dataElementValuesByNameAndLang.size() > 0) {
                        label = dataElementValuesByNameAndLang.get(0).getAttributeValue();
                        labelLang = language;
                    } else {
                        dataElementValuesByNameAndLang = VocabularyOutputHelper
                                .getDataElementValuesByNameAndLang(SKOS_PREF_LABEL, DEFAULT_LANGUAGE,
                                        concept.getElementAttributes());
                        if (dataElementValuesByNameAndLang != null
                                && dataElementValuesByNameAndLang.size() > 0) {
                            label = dataElementValuesByNameAndLang.get(0).getAttributeValue();
                        } else {
                            label = concept.getLabel();
                        }
                        labelLang = DEFAULT_LANGUAGE;
                    }
                    generator.writeStartObject();
                    {
                        generator.writeStringField(JSON_LD_VALUE, label);
                        generator.writeStringField(JSON_LD_LANGUAGE, labelLang);
                    }
                    generator.writeEndObject();
                } else {
                    generator.writeStartObject();
                    {
                        generator.writeStringField(JSON_LD_VALUE, concept.getLabel());
                        generator.writeStringField(JSON_LD_LANGUAGE, DEFAULT_LANGUAGE);
                    }
                    generator.writeEndObject();
                    List<DataElement> dataElementValuesByName = VocabularyOutputHelper
                            .getDataElementValuesByName(SKOS_PREF_LABEL, concept.getElementAttributes());
                    if (dataElementValuesByName != null && dataElementValuesByName.size() > 0) {
                        for (DataElement elem : dataElementValuesByName) {
                            generator.writeStartObject();
                            {
                                generator.writeStringField(JSON_LD_VALUE, elem.getAttributeValue());
                                generator.writeStringField(JSON_LD_LANGUAGE, elem.getAttributeLanguage());
                            }
                            generator.writeEndObject();
                        }
                    }
                }
            }
            // end writing prefLabels
            generator.writeEndArray();
            // write data elements
            for (String shortDataElemIdentifier : relationalDataElemIdentifiers) {
                // check if it has this element
                List<DataElement> dataElementValuesByName = VocabularyOutputHelper.getDataElementValuesByName(
                        DATA_ELEM_MAP.get(shortDataElemIdentifier), concept.getElementAttributes());
                if (dataElementValuesByName != null && dataElementValuesByName.size() > 0) {
                    // start writing element values
                    generator.writeArrayFieldStart(shortDataElemIdentifier);
                    for (DataElement elem : dataElementValuesByName) {
                        generator.writeStartObject();
                        {
                            generator.writeStringField(JSON_LD_ID, elem.getRelatedConceptIdentifier());
                        }
                        generator.writeEndObject();
                    }
                    // end writing element values
                    generator.writeEndArray();
                }
            }
        }
        // end writing concept
        generator.writeEndObject();
    } // end of iteration on concepts
    generator.writeEndArray();
    // end of vocabulary name
    generator.writeEndObject();

    // close writer and stream
    generator.close();
    osw.close();
}

From source file:eu.project.ttc.models.index.JsonTermIndexIO.java

public static void save(Writer writer, TermIndex termIndex, JsonOptions options) throws IOException {
    JsonFactory jsonFactory = new JsonFactory(); // or, for data binding, org.codehaus.jackson.mapper.MappingJsonFactory 
    //      jsonFactory.configure(f, state)
    JsonGenerator jg = jsonFactory.createGenerator(writer); // or Stream, Reader
    jg.useDefaultPrettyPrinter();

    jg.writeStartObject();/*from  w  w  w.  j  ava 2s .c o  m*/

    jg.writeFieldName(METADATA);
    jg.writeStartObject();
    jg.writeFieldName(NAME);
    jg.writeString(termIndex.getName());
    jg.writeFieldName(LANG);
    jg.writeString(termIndex.getLang().getCode());
    if (termIndex.getCorpusId() != null) {
        jg.writeFieldName(CORPUS_ID);
        jg.writeString(termIndex.getCorpusId());
    }

    jg.writeFieldName(OCCURRENCE_STORAGE);
    if (options.isMongoDBOccStore()) {
        jg.writeString(OCCURRENCE_STORAGE_MONGODB);
        jg.writeFieldName(OCCURRENCE_MONGODB_STORE_URI);
        jg.writeString(options.getMongoDBOccStore());
    } else if (options.isEmbeddedOccurrences())
        jg.writeString(OCCURRENCE_STORAGE_EMBEDDED);
    else
        throw new IllegalStateException("Unknown storage mode");

    jg.writeFieldName(NB_WORD_ANNOTATIONS);
    jg.writeNumber(termIndex.getWordAnnotationsNum());
    jg.writeFieldName(NB_SPOTTED_TERMS);
    jg.writeNumber(termIndex.getSpottedTermsNum());

    jg.writeEndObject();

    jg.writeFieldName(INPUT_SOURCES);
    int idCnt = 0;
    Map<String, Integer> inputSources = Maps.newTreeMap();
    for (Document d : termIndex.getDocuments())
        if (!inputSources.containsKey(d.getUrl()))
            inputSources.put(d.getUrl(), ++idCnt);
    jg.writeStartObject();
    for (String uri : inputSources.keySet()) {
        jg.writeFieldName(inputSources.get(uri).toString());
        jg.writeString(uri);
    }
    jg.writeEndObject();

    jg.writeFieldName(WORDS);
    jg.writeStartArray();
    for (Word w : termIndex.getWords()) {
        jg.writeStartObject();
        jg.writeFieldName(LEMMA);
        jg.writeString(w.getLemma());
        jg.writeFieldName(STEM);
        jg.writeString(w.getStem());
        if (w.isCompound()) {
            jg.writeFieldName(COMPOUND_TYPE);
            jg.writeString(w.getCompoundType().name());
            jg.writeFieldName(COMPONENTS);
            jg.writeStartArray();
            for (Component c : w.getComponents()) {
                jg.writeStartObject();
                jg.writeFieldName(LEMMA);
                jg.writeString(c.getLemma());
                jg.writeFieldName(BEGIN);
                jg.writeNumber(c.getBegin());
                jg.writeFieldName(END);
                jg.writeNumber(c.getEnd());
                jg.writeEndObject();
            }
            jg.writeEndArray();
        }

        jg.writeEndObject();
    }
    jg.writeEndArray();

    Set<TermVariation> termVariations = Sets.newHashSet();

    jg.writeFieldName(TERMS);
    jg.writeStartArray();
    for (Term t : termIndex.getTerms()) {
        termVariations.addAll(t.getVariations());

        jg.writeStartObject();
        jg.writeFieldName(ID);
        jg.writeNumber(t.getId());
        jg.writeFieldName(RANK);
        jg.writeNumber(t.getRank());
        jg.writeFieldName(GROUPING_KEY);
        jg.writeString(t.getGroupingKey());
        jg.writeFieldName(WORDS);
        jg.writeStartArray();
        for (TermWord tw : t.getWords()) {
            jg.writeStartObject();
            jg.writeFieldName(SYN);
            jg.writeString(tw.getSyntacticLabel());
            jg.writeFieldName(LEMMA);
            jg.writeString(tw.getWord().getLemma());
            jg.writeEndObject();
        }
        jg.writeEndArray();

        jg.writeFieldName(FREQUENCY);
        jg.writeNumber(t.getFrequency());
        jg.writeFieldName(FREQ_NORM);
        jg.writeNumber(t.getFrequencyNorm());
        jg.writeFieldName(GENERAL_FREQ_NORM);
        jg.writeNumber(t.getGeneralFrequencyNorm());
        jg.writeFieldName(SPECIFICITY);
        jg.writeNumber(t.getSpecificity());
        jg.writeFieldName(SPOTTING_RULE);
        jg.writeString(t.getSpottingRule());

        if (options.withOccurrences() && options.isEmbeddedOccurrences()) {
            jg.writeFieldName(OCCURRENCES);
            jg.writeStartArray();
            for (TermOccurrence termOcc : t.getOccurrences()) {
                jg.writeStartObject();
                jg.writeFieldName(BEGIN);
                jg.writeNumber(termOcc.getBegin());
                jg.writeFieldName(END);
                jg.writeNumber(termOcc.getEnd());
                jg.writeFieldName(TEXT);
                jg.writeString(termOcc.getCoveredText());
                jg.writeFieldName(FILE);
                jg.writeNumber(inputSources.get(termOcc.getSourceDocument().getUrl()));
                jg.writeEndObject();
            }
            jg.writeEndArray();
        }

        if (options.isWithContexts() && t.isContextVectorComputed()) {
            jg.writeFieldName(CONTEXT);
            jg.writeStartObject();

            jg.writeFieldName(TOTAL_COOCCURRENCES);
            jg.writeNumber(t.getContextVector().getTotalCoccurrences());
            jg.writeFieldName(CO_OCCURRENCES);
            jg.writeStartArray();
            if (t.isContextVectorComputed()) {
                for (ContextVector.Entry contextEntry : t.getContextVector().getEntries()) {
                    jg.writeStartObject();
                    jg.writeFieldName(CO_TERM);
                    jg.writeString(contextEntry.getCoTerm().getGroupingKey());
                    jg.writeFieldName(NB_COCCS);
                    jg.writeNumber(contextEntry.getNbCooccs());
                    jg.writeFieldName(ASSOC_RATE);
                    jg.writeNumber(contextEntry.getAssocRate());
                    jg.writeEndObject();
                }
            }
            jg.writeEndArray();
            jg.writeEndObject();
        }

        jg.writeEndObject();
    }
    jg.writeEndArray();

    /* Variants */
    jg.writeFieldName(TERM_VARIATIONS);
    jg.writeStartArray();
    for (TermVariation v : termVariations) {
        jg.writeStartObject();
        jg.writeFieldName(BASE);
        jg.writeString(v.getBase().getGroupingKey());
        jg.writeFieldName(VARIANT);
        jg.writeString(v.getVariant().getGroupingKey());
        jg.writeFieldName(VARIANT_TYPE);
        jg.writeString(v.getVariationType().getShortName());
        jg.writeFieldName(INFO);
        jg.writeString(v.getInfo().toString());
        jg.writeFieldName(VARIANT_SCORE);
        jg.writeNumber(v.getScore());
        jg.writeEndObject();
    }
    jg.writeEndArray();

    jg.writeEndObject();
    jg.close();
}

From source file:ch.qos.logback.contrib.jackson.JacksonJsonFormatter.java

@Override
public String toJsonString(Map m) throws IOException {
    StringWriter writer = new StringWriter(BUFFER_SIZE);
    JsonGenerator generator = this.objectMapper.getFactory().createJsonGenerator(writer);

    if (isPrettyPrint()) {
        generator.useDefaultPrettyPrinter();
    }//from  w  ww  .j a  va 2 s  . c  o m

    this.objectMapper.writeValue(generator, m);

    writer.flush();

    return writer.toString();
}

From source file:de.odysseus.staxon.json.stream.jackson.JacksonStreamFactory.java

protected JsonGenerator configure(JsonGenerator generator, boolean pretty) {
    generator.configure(JsonGenerator.Feature.AUTO_CLOSE_TARGET, false);
    if (pretty) {
        generator.useDefaultPrettyPrinter();
    }/*ww w.j  ava 2s  .  co m*/
    return generator;
}