public void testJsonFactoryLinkage() {
    // first, implicit factory, giving implicit linkage
    assertSame(MAPPER, MAPPER.getFactory().getCodec());

    // and then explicit factory, which should also be implicitly linked
    JsonFactory f = new JsonFactory();
    ObjectMapper m = new ObjectMapper(f);
    assertSame(f, m.getFactory());
    assertSame(m, f.getCodec());
  }
 /**
  * Method that can be used to serialize any Java value as a String. Functionally equivalent to
  * calling {@link #writeValue(Writer,Object)} with {@link java.io.StringWriter} and constructing
  * String, but more efficient.
  *
  * <p>Note: prior to version 2.1, throws clause included {@link IOException}; 2.1 removed it.
  */
 public String writeValueAsString(Object value) throws JsonProcessingException {
   // alas, we have to pull the recycler directly here...
   SegmentedStringWriter sw = new SegmentedStringWriter(_jsonFactory._getBufferRecycler());
   try {
     _configAndWriteValue(_jsonFactory.createJsonGenerator(sw), value);
   } catch (JsonProcessingException e) { // to support [JACKSON-758]
     throw e;
   } catch (IOException e) { // shouldn't really happen, but is declared as possibility so:
     throw JsonMappingException.fromUnexpectedIOE(e);
   }
   return sw.getAndClear();
 }
 /**
  * Method that can be used to serialize any Java value as a byte array. Functionally equivalent to
  * calling {@link #writeValue(Writer,Object)} with {@link java.io.ByteArrayOutputStream} and
  * getting bytes, but more efficient. Encoding used will be UTF-8.
  *
  * <p>Note: prior to version 2.1, throws clause included {@link IOException}; 2.1 removed it.
  */
 public byte[] writeValueAsBytes(Object value) throws JsonProcessingException {
   ByteArrayBuilder bb = new ByteArrayBuilder(_jsonFactory._getBufferRecycler());
   try {
     _configAndWriteValue(_jsonFactory.createJsonGenerator(bb, JsonEncoding.UTF8), value);
   } catch (JsonProcessingException e) { // to support [JACKSON-758]
     throw e;
   } catch (IOException e) { // shouldn't really happen, but is declared as possibility so:
     throw JsonMappingException.fromUnexpectedIOE(e);
   }
   byte[] result = bb.toByteArray();
   bb.release();
   return result;
 }
Example #4
0
  private void process(File input) throws IOException {
    JsonFactory jsonF = new JsonFactory();
    JsonParser jp = jsonF.createJsonParser(input);
    TwitterEntry entry = read(jp);

    // let's write to a file, using UTF-8 encoding (only sensible one)
    StringWriter strw = new StringWriter();
    JsonGenerator jg = jsonF.createJsonGenerator(strw);
    jg.useDefaultPrettyPrinter(); // enable indentation just to make debug/testing easier

    // Here we would modify it... for now, will just (re)indent it

    write(jg, entry);

    System.out.println("Result = [" + strw.toString() + "]");
  }
 /**
  * Method for reading sequence of Objects from parser stream.
  *
  * @since 1.8
  */
 public <T> MappingIterator<T> readValues(URL src) throws IOException, JsonProcessingException {
   JsonParser jp = _jsonFactory.createJsonParser(src);
   if (_schema != null) {
     jp.setSchema(_schema);
   }
   DeserializationContext ctxt = _createDeserializationContext(jp, _config);
   return new MappingIterator<T>(_valueType, jp, ctxt, _findRootDeserializer(_config, _valueType));
 }
 protected final double _testRawDeser(int reps, byte[] json, ObjectReader reader)
     throws IOException {
   long start = System.nanoTime();
   final JsonFactory f = reader.getFactory();
   while (--reps >= 0) {
     JsonParser p = f.createParser(new ByteArrayInputStream(json));
     JsonToken t;
     while ((t = p.nextToken()) != null) {
       if (t == JsonToken.VALUE_STRING) {
         p.getText();
       } else if (t.isNumeric()) {
         p.getNumberValue();
       }
       ;
     }
     p.close();
   }
   hash = f.hashCode();
   return _msecsFromNanos(System.nanoTime() - start);
 }
  public static void main(String[] args) throws Exception {
    if (args.length != 1) {
      System.err.println("Usage: java [input]");
      System.exit(1);
    }
    byte[] data = readAll(args[0]);

    JsonFactory f = new JsonFactory();
    boolean doIntern = true;

    f.configure(JsonFactory.Feature.CANONICALIZE_FIELD_NAMES, doIntern);
    f.configure(JsonFactory.Feature.INTERN_FIELD_NAMES, doIntern);

    ObjectMapper m = new ObjectMapper();
    Object input1 = m.readValue(data, Object.class);
    JsonNode input2 = m.readTree(data);

    new ManualReadPerfUntypedStream()
        .testFromBytes(
            //            .testFromString(
            m, "JSON-as-Object", input1, Object.class, m, "JSON-as-Object2", input2, Object.class
            //               ,m, "JSON-as-Node", input2, JsonNode.class
            );
  }
 protected JsonParser constructParser(byte[] data) throws IOException {
   return _factory.createParser(data, 0, data.length);
 }
 protected JsonGenerator constructGenerator(OutputStream baos) throws IOException {
   return _factory.createGenerator(baos, JsonEncoding.UTF8);
 }
 protected JsonParser constructParser(InputStream in) throws IOException {
   return _factory.createParser(in);
 }
 public boolean isEnabled(JsonParser.Feature f) {
   return _jsonFactory.isEnabled(f);
 }
 public JsonNode readTree(String content) throws IOException, JsonProcessingException {
   return _bindAndCloseAsTree(_jsonFactory.createJsonParser(content));
 }
 public JsonNode readTree(Reader r) throws IOException, JsonProcessingException {
   return _bindAndCloseAsTree(_jsonFactory.createJsonParser(r));
 }
 public JsonNode readTree(InputStream in) throws IOException, JsonProcessingException {
   return _bindAndCloseAsTree(_jsonFactory.createJsonParser(in));
 }
 @SuppressWarnings("unchecked")
 public <T> T readValue(URL src) throws IOException, JsonProcessingException {
   return (T) _bindAndClose(_jsonFactory.createJsonParser(src));
 }
 @SuppressWarnings("unchecked")
 public <T> T readValue(byte[] src, int offset, int length)
     throws IOException, JsonProcessingException {
   return (T) _bindAndClose(_jsonFactory.createJsonParser(src, offset, length));
 }
 /**
  * Method that can be used to serialize any Java value as JSON output, written to File provided.
  */
 public void writeValue(File resultFile, Object value)
     throws IOException, JsonGenerationException, JsonMappingException {
   _configAndWriteValue(_jsonFactory.createJsonGenerator(resultFile, JsonEncoding.UTF8), value);
 }
 /**
  * Method that can be used to serialize any Java value as JSON output, using output stream
  * provided (using encoding {@link JsonEncoding#UTF8}).
  *
  * <p>Note: method does not close the underlying stream explicitly here; however, {@link
  * JsonFactory} this mapper uses may choose to close the stream depending on its settings (by
  * default, it will try to close it when {@link JsonGenerator} we construct is closed).
  */
 public void writeValue(OutputStream out, Object value)
     throws IOException, JsonGenerationException, JsonMappingException {
   _configAndWriteValue(_jsonFactory.createJsonGenerator(out, JsonEncoding.UTF8), value);
 }
 /**
  * Method that can be used to serialize any Java value as JSON output, using Writer provided.
  *
  * <p>Note: method does not close the underlying stream explicitly here; however, {@link
  * JsonFactory} this mapper uses may choose to close the stream depending on its settings (by
  * default, it will try to close it when {@link JsonGenerator} we construct is closed).
  */
 public void writeValue(Writer w, Object value)
     throws IOException, JsonGenerationException, JsonMappingException {
   _configAndWriteValue(_jsonFactory.createJsonGenerator(w), value);
 }