Java JsonValue.isObject方法代码示例

import org.apache.jena.atlas.json.JsonValue; //导入方法依赖的package包/类
private static JsonObject getFieldAsObject(JsonObject arg, String field) {
    try {
        if ( ! arg.hasKey(field) ) {
            LOG.warn("Bad request: Missing Field: "+field+" Arg: "+JSON.toStringFlat(arg)) ;
            throw new DeltaBadRequestException("Missing field: "+field) ;
        }
        JsonValue jv = arg.get(field) ;
        if ( ! jv.isObject() ) {
            
        }
        return jv.getAsObject();
    } catch (JsonException ex) {
        LOG.warn("Bad request: Field: "+field+" Arg: "+JSON.toStringFlat(arg)) ;
        throw new DeltaBadRequestException("Bad field '"+field+"' : "+arg.get(field)) ;
    }
}
 

import org.apache.jena.atlas.json.JsonValue; //导入方法依赖的package包/类
/**
 * Execute any one-off parts of the template
 */
public void preamble(ConverterProcess config, BindingEnv env) {
    if (spec.hasKey(JSONConstants.SOURCES)) {
        JsonValue sspec = spec.get(JSONConstants.SOURCES);
        if (sspec != null) {
            if (sspec.isObject()) {
                processSourceSpec(sspec, config);
            } else if (sspec.isArray()) {
                for (Iterator<JsonValue> i = sspec.getAsArray().iterator(); i.hasNext();) {
                    processSourceSpec(i.next(), config);
                }
            }
        }
    }
}
 

import org.apache.jena.atlas.json.JsonValue; //导入方法依赖的package包/类
private void processSourceSpec(JsonValue spec, ConverterProcess config) {
    try {
        MapSource source = null;
        if (spec.isObject()) {
            source = MapSourceFactory.sourceFrom(spec.getAsObject(), config);
        }
        if (source == null) {
            throw new EpiException("Failed to instantiate mapping source: " + spec);
        } else {
            config.getDataContext().registerSource(source);
        }
    } catch (IOException e) {
        throw new EpiException(e);
    }
}
 

import org.apache.jena.atlas.json.JsonValue; //导入方法依赖的package包/类
protected Template getTemplateRef(JsonValue ref, DataContext dc) {
    if (ref.isString()) {
        return new TemplateRef(ref.getAsString().value(), dc);
    } else if (ref.isObject()) {
        return TemplateFactory.templateFrom(ref.getAsObject(), dc);
    } else {
        throw new EpiException("Template must be specified as a name or an embedded object: " + ref);
    }
}
 

import org.apache.jena.atlas.json.JsonValue; //导入方法依赖的package包/类
protected List<Template> getTemplates(JsonValue tspec, DataContext dc) {
    List<Template> templates = new ArrayList<>();
    if (tspec != null) {
        if (tspec.isObject()) {
            templates.add( TemplateFactory.templateFrom(tspec.getAsObject(), dc) );
        } else if (tspec.isArray()) {
            for (Iterator<JsonValue> i = tspec.getAsArray().iterator(); i.hasNext();) {
                templates.add( TemplateFactory.templateFrom(i.next(), dc) );
            }
        } else if (tspec.isString()) {
            templates.add( new TemplateRef(tspec.getAsString().value(), dc) );
        }
    }
    return templates;
}
 

import org.apache.jena.atlas.json.JsonValue; //导入方法依赖的package包/类
public static Template templateFrom(JsonValue json, DataContext dc) {
    if (json.isArray()) {
        JsonArray templates = json.getAsArray();
        Template firstTemplate = null;
        for (Iterator<JsonValue> i = templates.iterator(); i.hasNext();) {
            JsonValue j = i.next();
            if (j.isObject()) {
                Template t = templateFrom(j.getAsObject(), dc);
                if (firstTemplate == null) {
                    firstTemplate = t;
                }
                if (t.getName() != null) {
                    dc.registerTemplate(t);
                }
            }
        }
        return firstTemplate;
    } else if (json.isObject()) {
        JsonObject jo = json.getAsObject();
        if (ResourceMapTemplate.isSpec(jo)) {
            return new ResourceMapTemplate(jo, dc);
        } else if (ParameterizedTemplate.isSpec(jo)) {
            return new ParameterizedTemplate(jo, dc);
        } else if (HierarchyTemplate.isSpec(jo)) {
            return new HierarchyTemplate(jo, dc);
        } else if (CompositeTemplate.isSpec(jo)) {
            return new CompositeTemplate(jo, dc);
        } else {
            return null;
        }
    } else if (json.isString()) {
        return new TemplateRef( json.getAsString().value(), dc);
    } else {
        
        throw new EpiException("Templates must be specified as a JSON object or an array of objects");
    }
}
 

import org.apache.jena.atlas.json.JsonValue; //导入方法依赖的package包/类
protected void parseBindings(JsonValue jv) {
    if (jv.isObject()) {
        parameters.add( getBindingSet( jv.getAsObject() ) );
    } else if (jv.isArray()) {
        Iterator<JsonValue> i = jv.getAsArray().iterator();
        while (i.hasNext()) {
            parseBindings(i.next());
        }
    } else {
        throw new EpiException("Illegal value for bind, bindings must be objects or arrays of objects");
    }
}
 

import org.apache.jena.atlas.json.JsonValue; //导入方法依赖的package包/类
/**
 * Set the parameters to show in the configuration window, and create UI elements for the user to set them.
 *
 * @param jsonParamDescriptions Parameters as specified by the JedAI library
 */
public void setParameters(JsonArray jsonParamDescriptions, ListProperty<JPair<String, Object>> parametersProperty) {
    this.jsonParamDescriptions = jsonParamDescriptions;
    this.parametersProperty = parametersProperty;

    // Determine if there are, and we should use previously set values for the parameters
    ObservableList<JPair<String, Object>> prevParams = parametersProperty.get();

    boolean usePrevParams = false;
    if (prevParams != null && !prevParams.isEmpty() && prevParams.size() == jsonParamDescriptions.size()) {
        // We can use the previously set parameters for this
        usePrevParams = true;
    }

    // If the method is parameter-free, display it
    if (this.jsonParamDescriptions.isEmpty()) {
        configureParamsLabel.setText("This is a parameter-free method!");
    } else {
        // Generate the form to configure the method
        int gridRows = 0;
        for (JsonValue jsonParam : this.jsonParamDescriptions) {
            if (jsonParam.isObject()) {
                JsonObject jsonParamObj = jsonParam.getAsObject();

                // If we have previous values for the parameters, modify the JSON object's default value
                if (usePrevParams) {
                    // Save original default value to another parameter, in order to be able to display it
                    JsonValue originalDefault = jsonParamObj.get("defaultValue");
                    if (originalDefault != null) {
                        jsonParamObj.put("defaultValueOriginal", originalDefault);
                    }

                    // Put as the new defaultValue the previous one
                    jsonParamObj.put("defaultValue", prevParams.get(gridRows).getRight().toString());
                }

                // Create controls for setting this parameter
                addParameterControls(jsonParamObj, gridRows++);
            } else if (jsonParam.isArray()) {
                throw new UnsupportedOperationException("Cannot handle JSON array yet (?)");
            }
        }
    }
}
 

import org.apache.jena.atlas.json.JsonValue; //导入方法依赖的package包/类
private JsonObject rpc(String opName, JsonObject arg) {
    JsonValue r = rpcToValue(opName, arg);
    if ( ! r.isObject() )
        throw new DeltaException("Bad result to '"+opName+"': "+JSON.toStringFlat(r));
    return r.getAsObject();
}
 

import org.apache.jena.atlas.json.JsonValue; //导入方法依赖的package包/类
private JsonObject rpcOnce(String opName, JsonObject arg) {
    JsonValue r = rpcOnceToValue(opName, arg);
    if ( ! r.isObject() )
        throw new DeltaException("Bad result to '"+opName+"': "+JSON.toStringFlat(r));
    return r.getAsObject();
}