Java 类com.fasterxml.jackson.core.JsonParser 实例源码

@Override public AnInterface deserialize(JsonParser jp, DeserializationContext ctxt)
    throws IOException {
  if (jp.getCurrentToken() != JsonToken.START_OBJECT) {
    throw new AssertionError("Expected start object.");
  }

  String name = null;

  while (jp.nextToken() != JsonToken.END_OBJECT) {
    switch (jp.getCurrentName()) {
      case "name":
        name = jp.getValueAsString();
        break;
    }
  }

  return new AnImplementation(name);
}

private void parseInputArrayOfStrings(final JsonParser parser,
                                      final List<String> inputs,
                                      final DriverCache cache,
                                      final Set<ValueGroup> groups) {
    EhSupport.propagate(() -> {
        parser.nextToken();
        while (parser.nextToken() != JsonToken.END_ARRAY) {
            String value = parser.getText();
            if (value.startsWith(GroupDriver.VG_PREFIX) && !cache.contains(value)) {
                final String groupName = value.split(":")[1];
                final Optional<ValueGroup> group =
                        groups.stream().filter(valueGroup -> valueGroup.getName().equals(groupName)).findFirst();
                if (group.isPresent()) {
                    value = GroupDriver.VG_PREFIX + group.get().getId();
                } else {
                    inputs.add(value);
                }
            }
            inputs.add(value);
        }
    });
}

public void _testTokenAccess(JsonFactory jf, boolean useStream) throws Exception
{
    final String DOC = "[ ]";
    JsonParser jp = useStream ?
            jf.createParser(ObjectReadContext.empty(), new ByteArrayInputStream(DOC.getBytes("UTF-8")))
            : jf.createParser(ObjectReadContext.empty(), DOC);
    assertNull(jp.currentToken());
    jp.clearCurrentToken();
    assertNull(jp.currentToken());
    assertNull(jp.getEmbeddedObject());
    assertToken(JsonToken.START_ARRAY, jp.nextToken());
    assertToken(JsonToken.START_ARRAY, jp.currentToken());
    jp.clearCurrentToken();
    assertNull(jp.currentToken());
    // Also: no codec defined by default
    try {
        jp.readValueAsTree();
        fail("Should get exception without codec");
    } catch (UnsupportedOperationException e) {
        verifyException(e, "Operation not supported");
    }
    jp.close();
}

public static RegisterMessage deserialize(JsonParser jp) throws IOException {
    jp.nextToken();
    long request = jp.getLongValue();

    boolean discloseCaller = false;
    jp.nextToken();
    Map<String, Object> options = ParserUtil.readObject(jp);
    if (options != null) {
        discloseCaller = (boolean) options.getOrDefault("disclose_caller", false);
    }

    jp.nextToken();
    String procedure = jp.getValueAsString();

    return new RegisterMessage(request, procedure, discloseCaller);
}

@Test
public void shouldThrowIfAnExtraordinaryExceptionHappensWhenParsingAsGenericMap() throws Exception {
    JsonNode value = mock(ObjectNode.class);
    when(value.getNodeType()).thenReturn(JsonNodeType.OBJECT);

    JsonNodeClaim claim = (JsonNodeClaim) claimFromNode(value);
    JsonNodeClaim spiedClaim = spy(claim);
    ObjectMapper mockedMapper = mock(ObjectMapper.class);
    when(spiedClaim.getObjectMapper()).thenReturn(mockedMapper);
    JsonParser mockedParser = mock(JsonParser.class);
    when(mockedMapper.treeAsTokens(value)).thenReturn(mockedParser);
    when(mockedParser.readValueAs(ArgumentMatchers.any(TypeReference.class))).thenThrow(IOException.class);

    exception.expect(JWTDecodeException.class);
    spiedClaim.asMap();
}

@Test
public void testSkipChildren() throws IOException {
    JsonParser[] jsonParserArray = new JsonParser[3];
    IOContext ioContext = new IOContext(new BufferRecycler(), jsonParserArray, true);
    byte[] byteArray = new byte[8];
    InputStream byteArrayInputStream = new ByteArrayInputStream(byteArray, 0, (byte) 58);
    UTF8StreamJsonParser uTF8StreamJsonParser = new UTF8StreamJsonParser(ObjectReadContext.empty(),
            ioContext,
            0, byteArrayInputStream, ByteQuadsCanonicalizer.createRoot(),
            byteArray, -1, (byte) 9, true);
    JsonParserDelegate jsonParserDelegate = new JsonParserDelegate(jsonParserArray[0]);
    JsonParserSequence jsonParserSequence = JsonParserSequence.createFlattened(true, uTF8StreamJsonParser, jsonParserDelegate);
    JsonParserSequence jsonParserSequenceTwo = (JsonParserSequence) jsonParserSequence.skipChildren();

    assertEquals(2, jsonParserSequenceTwo.containedParsersCount());
}

@Override
public Value jsonToColumnValue(JsonParser parser, ValueMetadata metadata) throws IOException {
    JsonToken token;
    Value value;

    // Go to the next token
    token = parser.nextToken();

    if (token != JsonToken.VALUE_STRING && token != JsonToken.VALUE_NULL) {
        throw new IOException("Unable to parse field " + metadata.getName() + " expected string or null at line " + parser.getCurrentLocation().getLineNr());
    }

    // Can be a integer or null
    if (token == JsonToken.VALUE_STRING) {
        value = new Value(parser.getValueAsString(), metadata);
    } else {
        // null
        if (metadata.isNotNull()) {
            throw new IOException("Unable to parse field " + metadata.getName() + " expected string but found null at line " + parser.getCurrentLocation().getLineNr());
        }

        value = new Value(metadata);
    }

    return value;
}

private void configureFeature(Object feature, boolean enabled) {
    if (feature instanceof JsonParser.Feature) {
        this.objectMapper.configure((JsonParser.Feature) feature, enabled);
    }
    else if (feature instanceof JsonGenerator.Feature) {
        this.objectMapper.configure((JsonGenerator.Feature) feature, enabled);
    }
    else if (feature instanceof SerializationFeature) {
        this.objectMapper.configure((SerializationFeature) feature, enabled);
    }
    else if (feature instanceof DeserializationFeature) {
        this.objectMapper.configure((DeserializationFeature) feature, enabled);
    }
    else if (feature instanceof MapperFeature) {
        this.objectMapper.configure((MapperFeature) feature, enabled);
    }
    else {
        throw new FatalBeanException("Unknown feature class: " + feature.getClass().getName());
    }
}

/**
 * Parse a text-format message from {@code input} and merge the contents into {@code builder}.
 * Extensions will be recognized if they are registered in {@code extensionRegistry}.
 * @throws IOException
 */
public void merge(JsonParser parser,
                         ExtensionRegistry extensionRegistry,
                         Message.Builder builder) throws IOException {

    JsonToken token = parser.nextToken();
    if (token.equals(JsonToken.START_OBJECT)) {
        token = parser.nextToken();
    }
    while (token != null && !token.equals(JsonToken.END_OBJECT)) {
        mergeField(parser, extensionRegistry, builder);
        token = parser.nextToken();
    }

    // Test to make sure the tokenizer has reached the end of the stream.
    if (parser.nextToken() != null) {
        throw new RuntimeException("Expecting the end of the stream, but there seems to be more data!  Check the input for a valid JSON format.");
    }
}

@Override
public NonPrivateFieldsAndAccessorsFieldDetectionPolicyModel parse(JsonParser jsonParser) throws IOException {
    NonPrivateFieldsAndAccessorsFieldDetectionPolicyModel instance = new NonPrivateFieldsAndAccessorsFieldDetectionPolicyModel();
    if (jsonParser.getCurrentToken() == null) {
        jsonParser.nextToken();
    }
    if (jsonParser.getCurrentToken() != JsonToken.START_OBJECT) {
        jsonParser.skipChildren();
        return null;
    }
    while (jsonParser.nextToken() != JsonToken.END_OBJECT) {
        String fieldName = jsonParser.getCurrentName();
        jsonParser.nextToken();
        parseField(instance, fieldName, jsonParser);
        jsonParser.skipChildren();
    }
    return instance;
}

@Override
public ParentModel parse(JsonParser jsonParser) throws IOException {
    ParentModel instance = new ParentModel();
    if (jsonParser.getCurrentToken() == null) {
        jsonParser.nextToken();
    }
    if (jsonParser.getCurrentToken() != JsonToken.START_OBJECT) {
        jsonParser.skipChildren();
        return null;
    }
    while (jsonParser.nextToken() != JsonToken.END_OBJECT) {
        String fieldName = jsonParser.getCurrentName();
        jsonParser.nextToken();
        parseField(instance, fieldName, jsonParser);
        jsonParser.skipChildren();
    }
    return instance;
}

public static Object getValueFromFieldType(JsonParser parser, MinorType fieldType) throws IOException {
  switch (fieldType) {
    case BIGINT:
      return parser.getLongValue();
    case VARCHAR:
      return parser.getValueAsString();
    case FLOAT4:
      return parser.getFloatValue();
    case BIT:
      return parser.getBooleanValue();
    case LATE:
    case NULL:
      return null;
    default:
      throw new RuntimeException("Unexpected Field type to return value: " + fieldType.toString());
  }
}

@Override
public LocalDateTime deserialize(JsonParser parser, DeserializationContext context) throws IOException
{
    if (parser.hasTokenId(JsonTokenId.ID_STRING)) {
        String string = parser.getText().trim();
        if (string.length() == 0) {
            return null;
        }

        try {
            return LocalDateTime.parse(string, DateTimeFormatter.ISO_LOCAL_DATE_TIME);
        } catch (DateTimeException e) {
            throw new IOException(e);
        }
    }
    if (parser.hasTokenId(JsonTokenId.ID_EMBEDDED_OBJECT)) {
        return (LocalDateTime) parser.getEmbeddedObject();
    }
    throw context.wrongTokenException(parser, JsonToken.VALUE_STRING, "Expected string.");
}

@Override
public PrivateFieldModel parse(JsonParser jsonParser) throws IOException {
    PrivateFieldModel instance = new PrivateFieldModel();
    if (jsonParser.getCurrentToken() == null) {
        jsonParser.nextToken();
    }
    if (jsonParser.getCurrentToken() != JsonToken.START_OBJECT) {
        jsonParser.skipChildren();
        return null;
    }
    while (jsonParser.nextToken() != JsonToken.END_OBJECT) {
        String fieldName = jsonParser.getCurrentName();
        jsonParser.nextToken();
        parseField(instance, fieldName, jsonParser);
        jsonParser.skipChildren();
    }
    return instance;
}

public static UnsubscribedMessage deserialize(JsonParser jp) throws IOException {
    jp.nextToken();
    long request = jp.getLongValue();

    Long subscriptionId = null;
    String reason = null;

    JsonToken token = jp.nextToken();
    if (token == JsonToken.START_OBJECT) {
        Map<String, Object> details = ParserUtil.readObject(jp);
        reason = (String) details.get("reason");

        Object subscriptionObj = details.get("subscription");
        if (subscriptionObj != null) {
            subscriptionId = ((Number) subscriptionObj).longValue();
        }
    }

    return new UnsubscribedMessage(request, subscriptionId, reason);
}

@Override
public Date deserialize(JsonParser gen, DeserializationContext ctxt) throws IOException, JsonProcessingException {
    String date = gen.getText();

    if (StringUtils.isEmpty(date)) {
        return null;
    }

    if (StringUtils.isNumeric(date)) {
        return new Date(Long.valueOf(date));
    }
    try {
        DateTime dt = fmt.parseDateTime(date);
        return dt.toDate();
    } catch (Exception e) {
        throw new IOException(e);
    }
}

private Collection<Object> deserializeWithRetry(JsonParser p, DeserializationContext ctxt, JavaType contentType) throws IOException {
    final CollectionType collectionType = ctxt.getTypeFactory().constructCollectionType(Collection.class, contentType);

    try {
        return p.getCodec().readValue(p, collectionType);

    } catch (JsonMappingException e) {
        // attempt to read the value as string
        final String escapedString = p.getValueAsString();

        // stop here if value could not be read
        if (isNull(escapedString)) {
            throw ctxt.instantiationException(Collection.class, "Read null value when attempting to deserialize " + collectionType.toString());
        }

        // un-escape double quotes
        String unescapedString = escapedString.replaceAll("\"", "\"");

        // and attempt to parse again
        return new ObjectMapper().readValue(unescapedString, collectionType);
    }
}

@Override
public PostContingencyResult deserialize(JsonParser parser, DeserializationContext deserializationContext) throws IOException {
    Contingency contingency = null;
    LimitViolationsResult limitViolationsResult = null;

    while (parser.nextToken() != JsonToken.END_OBJECT) {
        switch (parser.getCurrentName()) {
            case "contingency":
                parser.nextToken();
                contingency = parser.readValueAs(Contingency.class);
                break;

            case "limitViolationsResult":
                parser.nextToken();
                limitViolationsResult = parser.readValueAs(LimitViolationsResult.class);
                break;

            default:
                throw new AssertionError("Unexpected field: " + parser.getCurrentName());
        }
    }

    return new PostContingencyResult(contingency, limitViolationsResult);
}

@Override
public SolrQuery deserialize(JsonParser parser, DeserializationContext context)
        throws IOException, JsonProcessingException {
    JsonNode node = parser.getCodec().readTree(parser);
    String serialization = node.get(SERIALIZATION).textValue();
    return SerializationUtils.deserialize(Base64.decodeBase64(serialization.getBytes()));
}

/**
 *  Deserialize date.
 *
 * @param jsonparser
 * @param context
 * @return
 * @throws IOException
 * @throws JsonProcessingException
 */
@Override
public Date deserialize(JsonParser jsonparser, DeserializationContext context)
        throws IOException, JsonProcessingException {

    String date = jsonparser.getText();
    try {
        return formatter.parse(date);
    } catch (Exception e) {
    }

    return null;
}

public boolean stopDAG() {

    ObjectMapper mapper = new ObjectMapper();
       mapper.configure(JsonParser.Feature.ALLOW_COMMENTS, true);
       deployer.stopDag();
       // TODO remove the entry from the RD
       return true;
}

@Override
public Date parse(JsonParser jsonParser) throws IOException {
    String dateString = jsonParser.getValueAsString(null);
    if (dateString != null) {
        try {
            return mDateFormat.get().parse(dateString);
        } catch (ParseException e) {
            return null;
        }
    } else {
        return null;
    }
}

public BigDecimal unmarshall(JsonUnmarshallerContext unmarshallerContext) throws Exception {
    JsonParser parser = unmarshallerContext.getJsonParser();
    Unmarshaller<BigInteger, JsonUnmarshallerContext> bigIntegerUnmarshaller = unmarshallerContext.getUnmarshaller(BigInteger.class);

    JsonToken current = parser.getCurrentToken();
    if (current != JsonToken.START_ARRAY) {
        throw new SdkClientException("Invalid BigDecimal Format.");
    }
    parser.nextToken();
    int exponent = parser.getIntValue();
    parser.nextToken();
    BigInteger mantissa = bigIntegerUnmarshaller.unmarshall(unmarshallerContext);
    return new BigDecimal(mantissa, exponent);
}

@Override
public TimeSeries deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) {
    List<TimeSeries> timeSeriesList = TimeSeries.parseJson(jsonParser, true);
    if (timeSeriesList.size() != 1) {
        throw new TimeSeriesException("Time series JSON deserialization error");
    }
    return timeSeriesList.get(0);
}

@BeforeClass
public static void setUp() {
  // Initialize object mapper for testing.
  mapper = new ObjectMapper();
  // With this configuration we save a lot of quotes and escaping when creating JSON strings.
  mapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
  mapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
  // Initialize validator for testing including custom mappings.
  validator = Validation.byDefaultProvider()
          .configure()
          .addMapping(AbstractRequestTest.class.getClassLoader().getResourceAsStream(VALIDATION_MAPPINGS))
          .buildValidatorFactory()
          .getValidator();
}

@Override
public Choice.Builder deserialize(JsonParser jsonParser,
                                  DeserializationContext deserializationContext) throws IOException {
    final JsonNode node = jsonParser.getCodec().readTree(jsonParser);
    return Choice.builder()
                 .nextStateName(node.get(PropertyNames.NEXT).asText())
                 .condition(conditionDeserializer.deserializeCondition(node));
}

@Override
public final Dienstbundel deserialize(final JsonParser jp, final DeserializationContext ctxt) throws IOException {
    final ObjectCodec oc = jp.getCodec();
    final JsonNode node = oc.readTree(jp);

    final Leveringsautorisatie leveringsautorisatie =
            entityManager.getReference(Leveringsautorisatie.class, JsonUtils.getAsInteger(node, DienstbundelModule.LEVERINGSAUTORISATIE));

    final Dienstbundel dienstbundel = new Dienstbundel(leveringsautorisatie);
    dienstbundel.setLeveringsautorisatie(leveringsautorisatie);
    dienstbundel.setId(JsonUtils.getAsInteger(node, DienstbundelModule.ID));
    dienstbundel.setNaam(JsonUtils.getAsString(node, DienstbundelModule.NAAM));
    dienstbundel.setDatumIngang(JsonUtils.getAsInteger(node, DienstbundelModule.DATUM_INGANG));
    dienstbundel.setDatumEinde(JsonUtils.getAsInteger(node, DienstbundelModule.DATUM_EINDE));
    dienstbundel.setNaderePopulatiebeperking(JsonUtils.getAsString(node, DienstbundelModule.NADERE_POPULATIE_BEPERKING));
    dienstbundel.setIndicatieNaderePopulatiebeperkingVolledigGeconverteerd(
        JsonUtils.getAsBoolean(
            node,
            DienstbundelModule.INDICATIE_NADERE_POPULATIE_BEPERKING_GECONVERTEERD,
            DienstbundelModule.WAARDE_NEE,
            Boolean.FALSE,
            null));
    dienstbundel.setToelichting(JsonUtils.getAsString(node, DienstbundelModule.TOELICHTING));
    dienstbundel.setIndicatieGeblokkeerd(
        JsonUtils.getAsBoolean(node, DienstbundelModule.INDICATIE_GEBLOKKEERD, DienstbundelModule.WAARDE_JA, Boolean.TRUE, null));

    return dienstbundel;
}

@Override
public AddressOverview deserialize(JsonParser parser, DeserializationContext context)   
        throws IOException, JsonProcessingException {
    List<Object> propertyList = context.readValue(parser, context.getTypeFactory()
            .constructCollectionType(ArrayList.class, Object.class));
    return toAddressOverview(propertyList);
}

@Override
public PrivateKey deserialize(JsonParser jsonParser, DeserializationContext context) throws IOException {
    jsonParser.setCodec(OBJECT_MAPPER);
    JsonNode node = jsonParser.getCodec().readTree(jsonParser);

    try {
        return createPrivateKey(Base64.getDecoder().decode(node.asText()));
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

@Override
public final Leveringsautorisatie deserialize(final JsonParser jp, final DeserializationContext ctxt) throws IOException {
    final ObjectCodec oc = jp.getCodec();
    final JsonNode node = oc.readTree(jp);

    final Stelsel stelsel = EnumUtils.getAsEnum(Stelsel.class, JsonUtils.getAsInteger(node, LeveringsautorisatieModule.STELSEL));
    final Boolean indicatieModelautorisatie =
            JsonUtils.getAsBoolean(
                node,
                LeveringsautorisatieModule.INDICATIE_MODEL_AUTORISATIE,
                LeveringsautorisatieModule.WAARDE_JA,
                Boolean.TRUE,
                Boolean.FALSE);
    final Leveringsautorisatie leveringsautorisatie = new Leveringsautorisatie(stelsel, indicatieModelautorisatie);
    leveringsautorisatie.setId(JsonUtils.getAsInteger(node, LeveringsautorisatieModule.ID));
    leveringsautorisatie.setNaam(JsonUtils.getAsString(node, LeveringsautorisatieModule.NAAM));
    leveringsautorisatie.setProtocolleringsniveau(
        EnumUtils.getAsEnum(Protocolleringsniveau.class, JsonUtils.getAsInteger(node, LeveringsautorisatieModule.PROTOCOLLERINGSNIVEAU)));
    leveringsautorisatie.setIndicatieAliasSoortAdministratieveHandelingLeveren(
        JsonUtils.getAsBoolean(
            node,
            LeveringsautorisatieModule.INDICATIE_ALIAS_LEVEREN,
            LeveringsautorisatieModule.WAARDE_JA,
            Boolean.TRUE,
            Boolean.FALSE));
    leveringsautorisatie.setDatumIngang(JsonUtils.getAsInteger(node, LeveringsautorisatieModule.DATUM_INGANG));
    leveringsautorisatie.setDatumEinde(JsonUtils.getAsInteger(node, LeveringsautorisatieModule.DATUM_EINDE));
    leveringsautorisatie.setPopulatiebeperking(JsonUtils.getAsString(node, LeveringsautorisatieModule.POPULATIE_BEPERKING));
    leveringsautorisatie.setToelichting(JsonUtils.getAsString(node, LeveringsautorisatieModule.TOELICHTING));
    leveringsautorisatie.setIndicatieGeblokkeerd(
        JsonUtils.getAsBoolean(node, LeveringsautorisatieModule.INDICATIE_GEBLOKKEERD, LeveringsautorisatieModule.WAARDE_JA, Boolean.TRUE, null));

    return leveringsautorisatie;
}

@SuppressWarnings("unchecked")
@Override
   public AbstractEntity deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException,
           JsonProcessingException {
       Long entityId = jp.getLongValue();
       Class<? extends AbstractEntity> valueClass = (Class<? extends AbstractEntity>) handledType();
       return (AbstractEntity) AppLoader.getInstance(Dao.class).load(valueClass, entityId);
   }

public AsyncMissingValuesInObjectTest(Collection<JsonParser.Feature> features) {
    this.factory = new JsonFactory();
    this.features = new HashSet<JsonParser.Feature>(features);

    for (JsonParser.Feature feature : features) {
        factory.enable(feature);
    }
}

@Override
public TriggerDefinition deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
    JsonNode root = p.getCodec().readTree(p);
    JsonNode triggerKey = root.get("triggerKey");
    JsonNode description = root.get("description");
    JsonNode jobKey = root.get("jobKey");
    JsonNode triggerData = root.get("triggerData");
    JsonNode misfireInstruction = root.get("misfireInstruction");
    JsonNode cron = root.get("cronExpression");

    if (triggerKey == null || jobKey == null) {
        throw new IOException("JSON is missing a triggerKey and jobKey");
    }

    if (cron == null) {
        return TriggerDefinitionBuilder.immediate()
                                       .identifiedAs(mapper.convertValue(triggerKey, NameAndGroup.class))
                                       .forJob(mapper.convertValue(jobKey, NameAndGroup.class))
                                       .withDescription(description != null ? description.textValue() : null)
                                       .withData(triggerData != null ? mapper.convertValue(triggerData, Map.class) : emptyMap())
                                       .withMisfireInstruction(misfireInstruction != null ? mapper.convertValue(misfireInstruction, Immediate.MisfireInstruction.class) : null)
                                       .build();
    } else {
        return TriggerDefinitionBuilder.cron()
                                .identifiedAs(mapper.convertValue(triggerKey, NameAndGroup.class))
                                .forJob(mapper.convertValue(jobKey, NameAndGroup.class))
                                .withCronExpression(cron.textValue())
                                .withDescription(description != null ? description.textValue() : null)
                                .withData(triggerData != null ? mapper.convertValue(triggerData, Map.class) : emptyMap())
                                .withMisfireInstruction(misfireInstruction != null ? mapper.convertValue(misfireInstruction, Cron.MisfireInstruction.class) : null)
                                .build();
    }
}

@Override
public VrijBericht deserialize(final JsonParser jp, final DeserializationContext ctxt) throws IOException {
    final ObjectCodec oc = jp.getCodec();
    final JsonNode node = oc.readTree(jp);

    final Integer id = JsonUtils.getAsInteger(node, "id");
    VrijBericht vrijBericht;
    if (id != null) {
        // Bij een bestaand vrij bericht alleen indicatieGelezen aanpassen.
        vrijBericht = entityManager.find(VrijBericht.class, id);
        final String ongelezen = JsonUtils.getAsString(node, "ongelezen");
        boolean gelezen;
        switch (ongelezen) {
            case "Nee":
                gelezen = true;
                break;
            case "Ja":
            default:
                gelezen = false;
        }
        vrijBericht.setIndicatieGelezen(gelezen);
    } else {
        final Short soortvrijberId = JsonUtils.getAsShort(node, "soortvrijber");
        final String data = JsonUtils.getAsString(node, "data");
        final SoortVrijBericht soortVrijBericht = entityManager.getReference(SoortVrijBericht.class, soortvrijberId);
        vrijBericht =
                new VrijBericht(SoortBerichtVrijBericht.STUUR_VRIJ_BERICHT, soortVrijBericht,
                        Timestamp.from(DatumUtil.nuAlsZonedDateTimeInNederland().toInstant()), data, null);
        final ArrayNode partijen = (ArrayNode) node.get("partijen");
        for (JsonNode partijNode : partijen) {
            final Short partijId = Short.valueOf(partijNode.asText());
            final VrijBerichtPartij vrijBerichtPartij = new VrijBerichtPartij(vrijBericht, partijRepository.findOne(partijId));
            vrijBericht.getVrijBerichtPartijen().add(vrijBerichtPartij);
        }
    }
    return vrijBericht;
}

@Override
public LocalDate deserialize(JsonParser parser, DeserializationContext context) throws IOException {
    switch(parser.getCurrentToken()) {
        case START_ARRAY:
            if(parser.nextToken() == JsonToken.END_ARRAY) {
                return null;
            }
            int year = parser.getIntValue();

            parser.nextToken();
            int month = parser.getIntValue();

            parser.nextToken();
            int day = parser.getIntValue();

            if(parser.nextToken() != JsonToken.END_ARRAY) {
                throw context.wrongTokenException(parser, JsonToken.END_ARRAY, "Expected array to end.");
            }
            return LocalDate.of(year, month, day);

        case VALUE_STRING:
            String string = parser.getText().trim();
            if(string.length() == 0) {
                return null;
            }
            return LocalDate.parse(string, ISO_DATE_OPTIONAL_TIME);
        default:
            throw context.wrongTokenException(parser, JsonToken.START_ARRAY, "Expected array or string.");
    }
}

@Override
public void deserialize(InputStream stream, BlockingQueue<T> outputQueue)
        throws WaySegmentDeserializationException {
    try {
        JsonParser jp = jsonFactory.createParser(stream);       
        JsonToken token = jp.nextToken();
        long count = 0;

        ISegmentAdapter<IBaseSegmentDTO, T> adapter = null;
        while(!jp.isClosed()){
            token = jp.nextToken();
            // extract type of segments. its encoded as the name of the array field holding the segments
            if (jp.getCurrentToken() == JsonToken.FIELD_NAME) {             
                String segmentType = jp.getCurrentName();
                adapter = this.getAndRegisterDeserializers(segmentType);
            }
            else if(token != null && token != JsonToken.END_ARRAY && token != JsonToken.END_OBJECT) {
                enqueue(outputQueue, processSegment(jp, adapter));
                count++;
            }
        }

        log.info("parsed and enqueued: " + count + " segments");
       } catch (Exception e) {
           throw new WaySegmentDeserializationException(e.getMessage(),e);
       }        
}

private void write(BitWriter writer, JsonToken token, JsonParser parser) throws IOException {
  // TODO JASON - finish other cases
  if (token == JsonToken.VALUE_NUMBER_INT) {
    writer.writeBit(parser.getIntValue() == 1 ? 1 : 0);
  } else if (token == JsonToken.VALUE_TRUE || token == JsonToken.VALUE_FALSE){
    writer.writeBit(parser.getBooleanValue() ? 1 : 0);
  } else if (token == JsonToken.VALUE_STRING) {
    writer.writeBit(ElasticsearchJsonReader.parseElasticBoolean(parser.getValueAsString()) ? 1 : 0);
  } else {
    throw UserException.dataReadError()
        .message("While reading from elasticsearch, unexpected data type in a boolean column: " + token).build(logger);
  }

}

private void _testAsDouble(int mode) throws Exception
{
    final String input = "[ 1, -3, 4.98, true, false, null, \"-17.25\", \"foo\" ]";
    JsonParser p = createParser(mode, input);

    assertToken(JsonToken.START_ARRAY, p.nextToken());
    assertEquals(0.0, p.getValueAsDouble());
    assertEquals(9.0, p.getValueAsDouble(9.0));

    assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken());
    assertEquals(1., p.getValueAsDouble());
    assertEquals(1., p.getValueAsDouble(-99.0));
    assertToken(JsonToken.VALUE_NUMBER_INT, p.nextToken());
    assertEquals(-3., p.getValueAsDouble());
    assertToken(JsonToken.VALUE_NUMBER_FLOAT, p.nextToken());
    assertEquals(4.98, p.getValueAsDouble());
    assertEquals(4.98, p.getValueAsDouble(12.5));
    assertToken(JsonToken.VALUE_TRUE, p.nextToken());
    assertEquals(1.0, p.getValueAsDouble());
    assertToken(JsonToken.VALUE_FALSE, p.nextToken());
    assertEquals(0.0, p.getValueAsDouble());
    assertToken(JsonToken.VALUE_NULL, p.nextToken());
    assertEquals(0.0, p.getValueAsDouble());
    assertEquals(0.0, p.getValueAsDouble(27.8));
    assertToken(JsonToken.VALUE_STRING, p.nextToken());
    assertEquals(-17.25, p.getValueAsDouble());
    assertEquals(-17.25, p.getValueAsDouble(1.9));
    assertToken(JsonToken.VALUE_STRING, p.nextToken());
    assertEquals(0.0, p.getValueAsDouble());
    assertEquals(1.25, p.getValueAsDouble(1.25));

    assertToken(JsonToken.END_ARRAY, p.nextToken());
    assertEquals(0.0, p.getValueAsDouble());
    assertEquals(7.5, p.getValueAsDouble(7.5));

    p.close();
}

@Override
protected Item deserializeObject(JsonParser jsonParser, DeserializationContext context, ObjectCodec codec, JsonNode tree) throws IOException {
    System.out.println("deserializeObject");
    String description = tree.get("description").asText();
    String location = tree.get("location").asText();
    return new Item(1l,description, location, null);
}

@Test
public void shouldReturnUnknownTypeIfValueIsNull() throws IOException {
    final JsonParser parserMock = mock(JsonParser.class);
    final DeserializationContext contextMock = mock(DeserializationContext.class);

    when(parserMock.getValueAsString()).thenReturn(null);

    final SystemEventType result = systemEventTypeDeserializer.deserialize(parserMock, contextMock);

    assertThat(result).isEqualTo(SystemEventType.UNKNOWN);
}