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

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

Introduction

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

Prototype

public abstract ObjectCodec getCodec();

Source Link

Document

Accessor for ObjectCodec associated with this parser, if any.

Usage

From source file:org.numenta.nupic.algorithms.CLAClassifierDeserializer.java

@Override
public CLAClassifier deserialize(JsonParser jp, DeserializationContext ctxt)
        throws IOException, JsonProcessingException {

    ObjectCodec oc = jp.getCodec();
    JsonNode node = oc.readTree(jp);//w  ww .  ja va  2s  .com

    CLAClassifier retVal = new CLAClassifier();
    retVal.alpha = node.get("alpha").asDouble();
    retVal.actValueAlpha = node.get("actValueAlpha").asDouble();
    retVal.learnIteration = node.get("learnIteration").asInt();
    retVal.recordNumMinusLearnIteration = node.get("recordNumMinusLearnIteration").asInt();
    retVal.maxBucketIdx = node.get("maxBucketIdx").asInt();

    String[] steps = node.get("steps").asText().split(",");
    TIntList t = new TIntArrayList();
    for (String step : steps) {
        t.add(Integer.parseInt(step));
    }
    retVal.steps = t;

    String[] tupleStrs = node.get("patternNZHistory").asText().split(";");
    Deque<Tuple> patterns = new Deque<Tuple>(tupleStrs.length);
    for (String tupleStr : tupleStrs) {
        String[] tupleParts = tupleStr.split("-");
        int iteration = Integer.parseInt(tupleParts[0]);
        String pattern = tupleParts[1].substring(1, tupleParts[1].indexOf("]")).trim();
        String[] indexes = pattern.split(",");
        int[] indices = new int[indexes.length];
        for (int i = 0; i < indices.length; i++) {
            indices[i] = Integer.parseInt(indexes[i].trim());
        }
        Tuple tup = new Tuple(iteration, indices);
        patterns.append(tup);
    }
    retVal.patternNZHistory = patterns;

    Map<Tuple, BitHistory> bitHistoryMap = new HashMap<Tuple, BitHistory>();
    String[] bithists = node.get("activeBitHistory").asText().split(";");
    for (String bh : bithists) {
        String[] parts = bh.split("-");

        String[] left = parts[0].split(",");
        Tuple iteration = new Tuple(Integer.parseInt(left[0].trim()), Integer.parseInt(left[1].trim()));

        BitHistory bitHistory = new BitHistory();
        String[] right = parts[1].split("=");
        bitHistory.id = right[0].trim();

        TDoubleList dubs = new TDoubleArrayList();
        String[] stats = right[1].substring(1, right[1].indexOf("}")).trim().split(",");
        for (int i = 0; i < stats.length; i++) {
            dubs.add(Double.parseDouble(stats[i].trim()));
        }
        bitHistory.stats = dubs;

        bitHistory.lastTotalUpdate = Integer.parseInt(right[2].trim());

        bitHistoryMap.put(iteration, bitHistory);
    }
    retVal.activeBitHistory = bitHistoryMap;

    ArrayNode jn = (ArrayNode) node.get("actualValues");
    List<Object> l = new ArrayList<Object>();
    for (int i = 0; i < jn.size(); i++) {
        JsonNode n = jn.get(i);
        try {
            double d = Double.parseDouble(n.asText().trim());
            l.add(d);
        } catch (Exception e) {
            l.add(n.asText().trim());
        }
    }
    retVal.actualValues = l;

    //Go back and set the classifier on the BitHistory objects
    for (Tuple tuple : bitHistoryMap.keySet()) {
        bitHistoryMap.get(tuple).classifier = retVal;
    }

    return retVal;
}

From source file:org.mycontroller.standalone.api.jaxrs.mixins.GatewayMixin.java

@Override
public Gateway deserialize(JsonParser jp, DeserializationContext ctxt)
        throws IOException, JsonProcessingException {
    ObjectCodec objectCodec = jp.getCodec();
    JsonNode node = objectCodec.readTree(jp);

    if (node.get("id") == null && node.get("type") == null) {
        return null;
    }/*ww w  .j a va  2  s.co m*/

    GATEWAY_TYPE gatewayType = GATEWAY_TYPE.fromString(node.get("type").asText());

    Gateway gateway = null;
    switch (gatewayType) {
    case SERIAL:
        GatewaySerial gatewaySerial = new GatewaySerial();
        gatewaySerial.setDriver(SERIAL_PORT_DRIVER.fromString(node.get("driver").asText()));
        gatewaySerial.setPortName(node.get("portName").asText());
        gatewaySerial.setBaudRate(node.get("baudRate").asInt());
        gatewaySerial.setRetryFrequency(node.get("retryFrequency").asLong());
        gateway = gatewaySerial;
        break;
    case ETHERNET:
        GatewayEthernet gatewayEthernet = new GatewayEthernet();
        gatewayEthernet.setHost(node.get("host").asText());
        gatewayEthernet.setPort(node.get("port").asInt());
        gatewayEthernet.setAliveFrequency(node.get("aliveFrequency").asLong());
        gateway = gatewayEthernet;
        break;
    case MQTT:
        GatewayMQTT gatewayMQTT = new GatewayMQTT();
        gatewayMQTT.setBrokerHost(node.get("brokerHost").asText());
        gatewayMQTT.setClientId(node.get("clientId").asText());
        gatewayMQTT.setTopicsPublish(node.get("topicsPublish").asText());
        gatewayMQTT.setTopicsSubscribe(node.get("topicsSubscribe").asText());
        gatewayMQTT.setUsername(node.get("username").asText());
        gatewayMQTT.setPassword(node.get("password").asText());
        gateway = gatewayMQTT;
        break;
    case PHANT_IO:
        GatewayPhantIO gatewayPhantIO = new GatewayPhantIO();
        gatewayPhantIO.setUrl(node.get("url").asText());
        gatewayPhantIO.setTrustHostType(TRUST_HOST_TYPE.fromString(node.get("trustHostType").asText()));
        gatewayPhantIO.setPublicKey(node.get("publicKey").asText());
        if (node.get("privateKey") != null) {
            gatewayPhantIO.setPrivateKey(node.get("privateKey").asText());
        }
        gatewayPhantIO.setPollFrequency(node.get("pollFrequency").asInt());
        gatewayPhantIO.setRecordsLimit(node.get("recordsLimit").asLong());
        gatewayPhantIO.setLastUpdate(System.currentTimeMillis() - (McUtils.SECOND * 10));
        gateway = gatewayPhantIO;
    default:
        break;
    }
    //Update RuleDefinition details
    if (node.get("id") != null) {
        gateway.setId(node.get("id").asInt());
    }
    gateway.setEnabled(node.get("enabled").asBoolean());
    gateway.setName(node.get("name").asText());
    gateway.setType(gatewayType);
    gateway.setNetworkType(NETWORK_TYPE.fromString(node.get("networkType").asText()));
    return gateway;
}

From source file:com.cloudmine.api.persistance.CMJacksonModule.java

public CMJacksonModule() {
    super("CustomModule", new Version(1, 0, 0, null));
    addSerializer(new JsonSerializer<Date>() {

        @Override//from w w w. ja v a2 s .c o m
        public void serialize(Date value, JsonGenerator jgen, SerializerProvider provider)
                throws IOException, JsonProcessingException {
            jgen.writeStartObject();
            jgen.writeRaw(JsonUtilities.convertDateToUnwrappedJsonClass(value));
            jgen.writeEndObject();
        }

        @Override
        public Class<Date> handledType() {
            return Date.class;
        }
    });

    addDeserializer(Date.class, new JsonDeserializer<Date>() {
        @Override
        public Date deserialize(JsonParser jp, DeserializationContext ctxt)
                throws IOException, JsonProcessingException {
            ObjectMapper mapper = (ObjectMapper) jp.getCodec();
            ObjectNode root = (ObjectNode) mapper.readTree(jp);
            JsonNode classNode = root.get(JsonUtilities.CLASS_KEY);
            boolean isDate = classNode != null && JsonUtilities.DATE_CLASS.equals(classNode.asText());
            if (isDate) {
                JsonNode timeNode = root.get(JsonUtilities.TIME_KEY);
                if (timeNode != null) {
                    Long seconds = timeNode.asLong();
                    Date date = new Date(seconds * 1000);
                    return date;
                }
            }
            return null;
        }
    });
    addSerializer(new JsonSerializer<SimpleCMObject>() {

        @Override
        public void serialize(SimpleCMObject value, JsonGenerator jgen, SerializerProvider provider)
                throws IOException {
            jgen.writeStartObject();
            String json = null;
            try {
                json = value.asUnkeyedObject();
            } catch (ConversionException e) {
                LOG.error("Error while serializing, sending empty json", e);
                json = JsonUtilities.EMPTY_JSON;
            }
            jgen.writeRaw(JsonUtilities.unwrap(json));
            jgen.writeEndObject();
        }

        @Override
        public Class<SimpleCMObject> handledType() {
            return SimpleCMObject.class;
        }
    });

    addSerializer(jsonSerializerForType(CMFile.class));
    addSerializer(jsonSerializerForType(CMSessionToken.class));
    addSerializer(jsonSerializerForType(CMType.class));
    addSerializer(jsonSerializerForType(TransportableString.class));
    addSerializer(jsonSerializerForType(ResponseBase.class));

}

From source file:org.createnet.raptor.models.objects.deserializer.ServiceObjectDeserializer.java

@Override
public ServiceObject deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {

    ServiceObject serviceObject = new ServiceObject();

    JsonNode tree = jp.getCodec().readTree(jp);

    if (tree.has("id")) {
        serviceObject.id = getText("id", tree);
    }/*from ww  w.j a  v  a2  s  .  c o  m*/

    if (tree.has("userId")) {
        serviceObject.userId = getText("userId", tree);
    }

    if (tree.has("name")) {
        serviceObject.name = getText("name", tree);
    }

    if (tree.has("description")) {
        serviceObject.description = getText("description", tree);
    }

    if (tree.has("parentId")) {
        serviceObject.parentId = getText("parentId", tree);
    }

    if (tree.has("path")) {
        serviceObject.path = getText("path", tree);
    }

    if (tree.has("streams")) {

        if (tree.get("streams").isObject()) {

            Iterator<String> fieldNames = tree.get("streams").fieldNames();
            while (fieldNames.hasNext()) {

                String name = fieldNames.next();
                JsonNode jsonStream = tree.get("streams").get(name);

                Stream stream = new Stream(name, jsonStream, serviceObject);
                serviceObject.streams.put(stream.name, stream);
            }
        }

        if (tree.get("streams").isArray()) {
            for (JsonNode jsonStream : tree.get("streams")) {
                Stream stream = new Stream(jsonStream);
                serviceObject.streams.put(stream.name, stream);
            }
        }

    }

    if (tree.has("actions")) {

        if (tree.get("actions").isArray()) {
            for (JsonNode json : tree.get("actions")) {
                Action actuation = new Action(json, serviceObject);
                serviceObject.actions.put(actuation.name, actuation);
            }
        }

        if (tree.get("actions").isObject()) {
            Iterator<String> fieldNames = tree.get("actions").fieldNames();
            while (fieldNames.hasNext()) {

                String name = fieldNames.next();
                JsonNode json = tree.get("actions").get(name);

                Action actuation = new Action(name, json, serviceObject);
                serviceObject.actions.put(actuation.name, actuation);
            }
        }

    }

    return serviceObject;
}

From source file:org.wikidata.wdtk.datamodel.json.jackson.AliasesDeserializer.java

@Override
public Map<String, List<JacksonMonolingualTextValue>> deserialize(JsonParser jp, DeserializationContext ctxt)
        throws IOException, JsonProcessingException {

    Map<String, List<JacksonMonolingualTextValue>> contents = new HashMap<>();

    try {//from   w ww .  j ava2 s  .c  om
        JsonNode node = jp.getCodec().readTree(jp);
        if (!node.isArray()) {
            Iterator<Entry<String, JsonNode>> nodeIterator = node.fields();
            while (nodeIterator.hasNext()) {
                List<JacksonMonolingualTextValue> mltvList = new ArrayList<>();
                Entry<String, JsonNode> currentNode = nodeIterator.next();
                // get the list of MLTVs
                Iterator<JsonNode> mltvListIterator = currentNode.getValue().iterator();
                while (mltvListIterator.hasNext()) {
                    JsonNode mltvEntry = mltvListIterator.next();
                    String language = mltvEntry.get("language").asText();
                    String value = mltvEntry.get("value").asText();
                    mltvList.add(new JacksonMonolingualTextValue(language, value));
                }

                contents.put(currentNode.getKey(), mltvList);
            }
        }

    } catch (JsonProcessingException e) {
        e.printStackTrace();
    } catch (Exception e) {
        e.printStackTrace();
    }

    return contents;

}

From source file:org.mycontroller.standalone.api.jaxrs.mixins.OperationMixin.java

@Override
public Operation deserialize(JsonParser jp, DeserializationContext ctxt)
        throws IOException, JsonProcessingException {
    ObjectCodec objectCodec = jp.getCodec();
    JsonNode node = objectCodec.readTree(jp);

    OPERATION_TYPE operationType = OPERATION_TYPE.fromString(node.get("type").asText());

    Operation operation = null;//from   w w w.j a v a  2 s .c o  m
    switch (operationType) {
    case EXECUTE_SCRIPT:
        OperationExecuteScript operationExecuteScript = new OperationExecuteScript();
        operationExecuteScript.setScriptFile(node.get("scriptFile").asText());
        if (node.get("scriptBindings") != null) {
            operationExecuteScript.setScriptBindings(RestUtils.getObjectMapper()
                    .convertValue(node.get("scriptBindings"), new TypeReference<HashMap<String, Object>>() {
                    }));
        }
        operation = operationExecuteScript;
        break;
    case SEND_EMAIL:
        OperationSendEmail operationSendEmail = new OperationSendEmail();
        operationSendEmail.setEmailSubject(node.get("emailSubject").asText());
        operationSendEmail.setToEmailAddresses(node.get("toEmailAddresses").asText());
        operationSendEmail.setTemplate(node.get("template").asText());
        operation = operationSendEmail;
        break;
    case SEND_PAYLOAD:
        OperationSendPayload operationSendPayload = new OperationSendPayload();
        operationSendPayload.setResourceType(RESOURCE_TYPE.fromString(node.get("resourceType").asText()));
        operationSendPayload.setResourceId(node.get("resourceId").asInt());
        operationSendPayload.setPayload(node.get("payload").asText());
        if (node.get("delayTime") != null) {
            operationSendPayload.setDelayTime(node.get("delayTime").asLong());
        } else {
            operationSendPayload.setDelayTime(0L);
        }
        operation = operationSendPayload;
        break;
    case REQUEST_PAYLOAD:
        OperationRequestPayload operationRequestPayload = new OperationRequestPayload();
        operationRequestPayload.setResourceType(RESOURCE_TYPE.fromString(node.get("resourceType").asText()));
        operationRequestPayload.setResourceId(node.get("resourceId").asInt());
        operation = operationRequestPayload;
        break;
    case SEND_PUSHBULLET_NOTE:
        OperationSendPushbulletNote operationSendPushbulletNote = new OperationSendPushbulletNote();
        operationSendPushbulletNote.setTitle(node.get("title").asText());
        if (node.get("idens") != null) {
            operationSendPushbulletNote.setIdens(node.get("idens").asText());
        }
        if (node.get("body") != null) {
            operationSendPushbulletNote.setBody(node.get("body").asText());
        }
        operation = operationSendPushbulletNote;
        break;
    case SEND_SMS:
        OperationSendSMS operationSendSMS = new OperationSendSMS();
        operationSendSMS.setToPhoneNumbers(node.get("toPhoneNumbers").asText());
        operationSendSMS.setCustomMessage(node.get("customMessage").asText());
        operation = operationSendSMS;
        break;
    default:
        break;
    }
    //Update RuleDefinition details
    if (node.get("id") != null) {
        operation.setId(node.get("id").asInt());
    }
    operation.setEnabled(node.get("enabled").asBoolean());
    operation.setName(node.get("name").asText());
    operation.setType(operationType);
    //operation.setUser(User.builder().id(node.get("user").get("id").intValue()).build());
    return operation;
}

From source file:org.jfrog.build.extractor.clientConfiguration.client.ArtifactoryDependenciesClient.java

/**
 * Reads HTTP response and converts it to object of the type specified.
 *
 * @param response     response to read// w  w w. j a  v a  2s .c o m
 * @param valueType    response object type
 * @param errorMessage error message to throw in case of error
 * @param <T>          response object type
 * @return response object converted from HTTP Json reponse to the type specified.
 * @throws java.io.IOException if reading or converting response fails.
 */
private <T> T readResponse(HttpResponse response, TypeReference<T> valueType, String errorMessage,
        boolean ignorMissingFields) throws IOException {

    if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
        HttpEntity entity = response.getEntity();
        if (entity == null) {
            return null;
        }

        InputStream content = null;

        try {
            content = entity.getContent();
            JsonParser parser = httpClient.createJsonParser(content);
            if (ignorMissingFields) {
                ((ObjectMapper) parser.getCodec()).configure(FAIL_ON_UNKNOWN_PROPERTIES, false);
            }
            // http://wiki.fasterxml.com/JacksonDataBinding
            return parser.readValueAs(valueType);
        } finally {
            if (content != null) {
                IOUtils.closeQuietly(content);
            }
        }
    } else {
        HttpEntity httpEntity = response.getEntity();
        if (httpEntity != null) {
            IOUtils.closeQuietly(httpEntity.getContent());
        }
        throw new IOException(errorMessage + ": " + response.getStatusLine());
    }
}

From source file:pl.edu.pwr.iiar.zak.thermalKit.deserializers.ThermometerUnitDeserializer.java

/**
 * Override main method which deserializes the JSON description of the heater to Java
 * object.// w w w  .  j ava 2  s .  c  o  m
 *
 * @param jp                     JSON parser
 * @param deserializationContext Deserialization context
 * @return HeaterUnit obejct
 * @throws IOException
 * @throws JsonProcessingException
 */
@Override
public ThermometerUnit deserialize(JsonParser jp, DeserializationContext deserializationContext)
        throws IOException, JsonProcessingException {
    JsonNode node = jp.getCodec().readTree(jp);
    ThermometerUnit heaterUnit = new ThermometerUnit();

    try {
        heaterUnit.setType(node.get("type").asText());
    } catch (JGeneriloException e) {
        e.printStackTrace();
    }
    heaterUnit.setCLBSize((Integer) (node.get("CLBsize")).numberValue());
    heaterUnit.setInstancesNum((Integer) (node.get("instancesNum")).numberValue());
    heaterUnit.setInstances(deserializeThermalInstances((ArrayNode) node.get("instances")));
    heaterUnit.setInternalNets(
            deserializeNets((ArrayNode) node.get("nets"), createInstancesHashMap(heaterUnit.getInstances())));

    return heaterUnit;
}

From source file:com.msopentech.odatajclient.engine.data.impl.JSONPropertyDeserializer.java

@Override
protected JSONProperty doDeserialize(final JsonParser parser, final DeserializationContext ctxt)
        throws IOException, JsonProcessingException {

    final ObjectNode tree = (ObjectNode) parser.getCodec().readTree(parser);

    final JSONProperty property = new JSONProperty();

    if (tree.hasNonNull(ODataConstants.JSON_METADATA)) {
        property.setMetadata(URI.create(tree.get(ODataConstants.JSON_METADATA).textValue()));
        tree.remove(ODataConstants.JSON_METADATA);
    }//from  w w w  .  ja  va  2s.  c o  m

    try {
        final DocumentBuilder builder = XMLUtils.DOC_BUILDER_FACTORY.newDocumentBuilder();
        final Document document = builder.newDocument();

        Element content = document.createElement(ODataConstants.ELEM_PROPERTY);

        if (property.getMetadata() != null) {
            final String metadataURI = property.getMetadata().toASCIIString();
            final int dashIdx = metadataURI.lastIndexOf('#');
            if (dashIdx != -1) {
                content.setAttribute(ODataConstants.ATTR_M_TYPE, metadataURI.substring(dashIdx + 1));
            }
        }

        JsonNode subtree = null;
        if (tree.has(ODataConstants.JSON_VALUE)) {
            if (tree.has(ODataConstants.JSON_TYPE)
                    && StringUtils.isBlank(content.getAttribute(ODataConstants.ATTR_M_TYPE))) {

                content.setAttribute(ODataConstants.ATTR_M_TYPE, tree.get(ODataConstants.JSON_TYPE).asText());
            }

            final JsonNode value = tree.get(ODataConstants.JSON_VALUE);
            if (value.isValueNode()) {
                content.appendChild(document.createTextNode(value.asText()));
            } else if (EdmSimpleType.isGeospatial(content.getAttribute(ODataConstants.ATTR_M_TYPE))) {
                subtree = tree.objectNode();
                ((ObjectNode) subtree).put(ODataConstants.JSON_VALUE, tree.get(ODataConstants.JSON_VALUE));
                if (StringUtils.isNotBlank(content.getAttribute(ODataConstants.ATTR_M_TYPE))) {
                    ((ObjectNode) subtree).put(ODataConstants.JSON_VALUE + "@" + ODataConstants.JSON_TYPE,
                            content.getAttribute(ODataConstants.ATTR_M_TYPE));
                }
            } else {
                subtree = tree.get(ODataConstants.JSON_VALUE);
            }
        } else {
            subtree = tree;
        }

        if (subtree != null) {
            JSONDOMTreeUtils.buildSubtree(client, content, subtree);
        }

        final List<Node> children = XMLUtils.getChildNodes(content, Node.ELEMENT_NODE);
        if (children.size() == 1) {
            final Element value = (Element) children.iterator().next();
            if (ODataConstants.JSON_VALUE.equals(XMLUtils.getSimpleName(value))) {
                if (StringUtils.isNotBlank(content.getAttribute(ODataConstants.ATTR_M_TYPE))) {
                    value.setAttribute(ODataConstants.ATTR_M_TYPE,
                            content.getAttribute(ODataConstants.ATTR_M_TYPE));
                }
                content = value;
            }
        }

        property.setContent(content);
    } catch (ParserConfigurationException e) {
        throw new JsonParseException("Cannot build property", parser.getCurrentLocation(), e);
    }

    return property;
}

From source file:org.apache.unomi.persistence.spi.PropertyTypedObjectDeserializer.java

@Override
public Object deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
    if (jp.getCurrentTokenId() != JsonTokenId.ID_START_OBJECT) {
        return super.deserialize(jp, ctxt);
    }/* w  ww  .  j  a  v  a2 s. co  m*/
    ObjectCodec codec = jp.getCodec();
    TreeNode treeNode = codec.readTree(jp);
    Class<? extends Object> objectClass = null;
    if (treeNode instanceof ObjectNode) {
        ObjectNode root = (ObjectNode) treeNode;
        Iterator<Map.Entry<String, JsonNode>> elementsIterator = root.fields();
        while (elementsIterator.hasNext()) {
            Map.Entry<String, JsonNode> element = elementsIterator.next();
            String name = element.getKey();
            if (fieldValuesToMatch.containsKey(name)) {
                Set<String> valuesToMatch = fieldValuesToMatch.get(name);
                for (String valueToMatch : valuesToMatch) {
                    if (element.getValue().asText().matches(valueToMatch)) {
                        objectClass = registry.get(name + "=" + valueToMatch);
                        break;
                    }
                }
                if (objectClass != null) {
                    break;
                }
            }
        }
        if (objectClass == null) {
            objectClass = HashMap.class;
        }
    } else {

    }
    if (objectClass == null) {
        return super.deserialize(codec.treeAsTokens(treeNode), ctxt);
    }
    return codec.treeToValue(treeNode, objectClass);
}