ExtendedBounds extendedBounds = null; try (JsonXContentParser parser = new JsonXContentParser(NamedXContentRegistry.EMPTY, LoggingDeprecationHandler.INSTANCE, new JsonFactory().createParser(value))) { extendedBounds = ExtendedBounds.PARSER.parse(parser, null); } catch (IOException ex) { List<Integer> indexList = new LinkedList<>();
/** * Parse the clear scroll response body into a new {@link ClearScrollResponse} object */ public static ClearScrollResponse fromXContent(XContentParser parser) throws IOException { return PARSER.apply(parser, null); }
protected static <T extends BroadcastResponse> void declareBroadcastFields(ConstructingObjectParser<T, Void> PARSER) { ConstructingObjectParser<BroadcastResponse, Void> shardsParser = new ConstructingObjectParser<>("_shards", true, arg -> new BroadcastResponse((int) arg[0], (int) arg[1], (int) arg[2], (List<DefaultShardOperationFailedException>) arg[3])); shardsParser.declareInt(constructorArg(), TOTAL_FIELD); shardsParser.declareInt(constructorArg(), SUCCESSFUL_FIELD); shardsParser.declareInt(constructorArg(), FAILED_FIELD); shardsParser.declareObjectArray(optionalConstructorArg(), (p, c) -> DefaultShardOperationFailedException.fromXContent(p), FAILURES_FIELD); PARSER.declareObject(constructorArg(), shardsParser, _SHARDS_FIELD); }
protected static <T extends AcknowledgedResponse> void declareAcknowledgedField(ConstructingObjectParser<T, Void> objectParser) { objectParser.declareField(constructorArg(), (parser, context) -> parser.booleanValue(), ACKNOWLEDGED, ObjectParser.ValueType.BOOLEAN); }
private static final ConstructingObjectParser<Boolean, Void> ACKNOWLEDGED_FLAG_PARSER = new ConstructingObjectParser<>( "acknowledged_flag", true, args -> (Boolean) args[0]); ACKNOWLEDGED_FLAG_PARSER.declareField(constructorArg(), (parser, context) -> parser.booleanValue(), ACKNOWLEDGED, ObjectParser.ValueType.BOOLEAN); return ACKNOWLEDGED_FLAG_PARSER.apply(parser, null);
private static final String REASON = "reason"; private static final ConstructingObjectParser<DefaultShardOperationFailedException, Void> PARSER = new ConstructingObjectParser<>( "failures", true, arg -> new DefaultShardOperationFailedException((String) arg[0], (int) arg[1] ,(Throwable) arg[2])); PARSER.declareString(constructorArg(), new ParseField(INDEX)); PARSER.declareInt(constructorArg(), new ParseField(SHARD_ID)); PARSER.declareObject(constructorArg(), (p, c) -> ElasticsearchException.fromXContent(p), new ParseField(REASON));
public static final ConstructingObjectParser<TaskResult, Void> PARSER = new ConstructingObjectParser<>( "stored_task_result", a -> { int i = 0; }); static { PARSER.declareBoolean(constructorArg(), new ParseField("completed")); PARSER.declareObject(constructorArg(), TaskInfo.PARSER, new ParseField("task")); ObjectParserHelper<TaskResult, Void> parserHelper = new ObjectParserHelper<>(); parserHelper.declareRawObject(PARSER, optionalConstructorArg(), new ParseField("error")); parserHelper.declareRawObject(PARSER, optionalConstructorArg(), new ParseField("response"));
protected static <T> ConstructingObjectParser<T, Void> setupParser(String name, TriFunction< List<TaskInfo>, List<TaskOperationFailure>, List<ElasticsearchException>, T> ctor) { ConstructingObjectParser<T, Void> parser = new ConstructingObjectParser<>(name, true, constructingObjects -> { int i = 0; @SuppressWarnings("unchecked") List<TaskInfo> tasks = (List<TaskInfo>) constructingObjects[i++]; @SuppressWarnings("unchecked") List<TaskOperationFailure> tasksFailures = (List<TaskOperationFailure>) constructingObjects[i++]; @SuppressWarnings("unchecked") List<ElasticsearchException> nodeFailures = (List<ElasticsearchException>) constructingObjects[i]; return ctor.apply(tasks,tasksFailures, nodeFailures); }); parser.declareObjectArray(optionalConstructorArg(), TaskInfo.PARSER, new ParseField(TASKS)); parser.declareObjectArray(optionalConstructorArg(), (p, c) -> TaskOperationFailure.fromXContent(p), new ParseField(TASK_FAILURES)); parser.declareObjectArray(optionalConstructorArg(), (p, c) -> ElasticsearchException.fromXContent(p), new ParseField(NODE_FAILURES)); return parser; }
protected static <T> ConstructingObjectParser<T, Void> generateParser(String name, Function<Boolean, T> ctor, String parseField) { ConstructingObjectParser<T, Void> p = new ConstructingObjectParser<>(name, true, args -> ctor.apply((boolean) args[0])); p.declareBoolean(constructorArg(), new ParseField(parseField)); return p; }
public static <T extends NodesResponse> void declareCommonNodesResponseParsing(ConstructingObjectParser<T, Void> parser) { parser.declareObject(ConstructingObjectParser.constructorArg(), NodesResponseHeader::fromXContent, new ParseField("_nodes")); parser.declareString(ConstructingObjectParser.constructorArg(), new ParseField("cluster_name")); } }
public static <T extends NodesResponse> void declareCommonNodesResponseParsing(ConstructingObjectParser<T, Void> parser) { parser.declareNamedObjects(ConstructingObjectParser.constructorArg(), (p, c, n) -> Node.PARSER.apply(p, n), new ParseField("nodes")); NodesResponse.declareCommonNodesResponseParsing(parser); } }
constructorArgInfos.add(new ConstructorArgInfo(parseField, required)); objectParser.declareNamedObjects((target, v) -> target.constructorArg(position, parseField, v), namedObjectParser, wrapOrderedModeCallBack(orderedModeCallback), parseField); } else { numberOfFields += 1; objectParser.declareNamedObjects(queueingConsumer(consumer, parseField), namedObjectParser, wrapOrderedModeCallBack(orderedModeCallback), parseField);
@Override public <T> void declareField(BiConsumer<Value, T> consumer, ContextParser<Context, T> parser, ParseField parseField, ValueType type) { if (consumer == null) { throw new IllegalArgumentException("[consumer] is required"); } if (parser == null) { throw new IllegalArgumentException("[parser] is required"); } if (parseField == null) { throw new IllegalArgumentException("[parseField] is required"); } if (type == null) { throw new IllegalArgumentException("[type] is required"); } if (consumer == REQUIRED_CONSTRUCTOR_ARG_MARKER || consumer == OPTIONAL_CONSTRUCTOR_ARG_MARKER) { /* * Constructor arguments are detected by these "marker" consumers. It keeps the API looking clean even if it is a bit sleezy. We * then build a new consumer directly against the object parser that triggers the "constructor arg just arrived behavior" of the * parser. Conveniently, we can close over the position of the constructor in the argument list so we don't need to do any fancy * or expensive lookups whenever the constructor args come in. */ int position = constructorArgInfos.size(); boolean required = consumer == REQUIRED_CONSTRUCTOR_ARG_MARKER; constructorArgInfos.add(new ConstructorArgInfo(parseField, required)); objectParser.declareField((target, v) -> target.constructorArg(position, parseField, v), parser, parseField, type); } else { numberOfFields += 1; objectParser.declareField(queueingConsumer(consumer, parseField), parser, parseField, type); } }
new ConstructingObjectParser<>("shard_failure", true, SnapshotShardFailure::constructSnapshotShardFailure); SNAPSHOT_SHARD_FAILURE_PARSER.declareStringOrNull(ConstructingObjectParser.optionalConstructorArg(), new ParseField("reason")); SNAPSHOT_SHARD_FAILURE_PARSER.declareInt(ConstructingObjectParser.constructorArg(), new ParseField("shard_id")); SNAPSHOT_SHARD_FAILURE_PARSER.declareString(ConstructingObjectParser.optionalConstructorArg(), new ParseField("status"));
private static void declareMap(BiConsumer<HasPrivilegesResponse, Map<String, Object>> arg, String name) { PARSER.declareField(arg, XContentParser::map, new ParseField(name), ObjectParser.ValueType.OBJECT); }
protected static <T extends ShardsAcknowledgedResponse> void declareAcknowledgedAndShardsAcknowledgedFields( ConstructingObjectParser<T, Void> objectParser) { declareAcknowledgedField(objectParser); objectParser.declareField(constructorArg(), (parser, context) -> parser.booleanValue(), SHARDS_ACKNOWLEDGED, ObjectParser.ValueType.BOOLEAN); }
protected static <T> ConstructingObjectParser<T, Void> setupParser(String name, TriFunction< List<TaskInfo>, List<TaskOperationFailure>, List<ElasticsearchException>, T> ctor) { ConstructingObjectParser<T, Void> parser = new ConstructingObjectParser<>(name, true, constructingObjects -> { int i = 0; @SuppressWarnings("unchecked") List<TaskInfo> tasks = (List<TaskInfo>) constructingObjects[i++]; @SuppressWarnings("unchecked") List<TaskOperationFailure> tasksFailures = (List<TaskOperationFailure>) constructingObjects[i++]; @SuppressWarnings("unchecked") List<ElasticsearchException> nodeFailures = (List<ElasticsearchException>) constructingObjects[i]; return ctor.apply(tasks,tasksFailures, nodeFailures); }); parser.declareObjectArray(optionalConstructorArg(), TaskInfo.PARSER, new ParseField(TASKS)); parser.declareObjectArray(optionalConstructorArg(), (p, c) -> TaskOperationFailure.fromXContent(p), new ParseField(TASK_FAILURES)); parser.declareObjectArray(optionalConstructorArg(), (p, c) -> ElasticsearchException.fromXContent(p), new ParseField(NODE_FAILURES)); return parser; }
private static ConstructingObjectParser<ShardsAcknowledgedResponse, Void> buildParser() { ConstructingObjectParser<ShardsAcknowledgedResponse, Void> p = new ConstructingObjectParser<>("freeze", true, args -> new ShardsAcknowledgedResponse((boolean) args[0], (boolean) args[1])); p.declareBoolean(constructorArg(), new ParseField(AcknowledgedResponse.PARSE_FIELD_NAME)); p.declareBoolean(constructorArg(), new ParseField(SHARDS_PARSE_FIELD_NAME)); return p; }
constructorArgInfos.add(new ConstructorArgInfo(parseField, required)); objectParser.declareNamedObjects((target, v) -> target.constructorArg(position, parseField, v), namedObjectParser, wrapOrderedModeCallBack(orderedModeCallback), parseField); } else { numberOfFields += 1; objectParser.declareNamedObjects(queueingConsumer(consumer, parseField), namedObjectParser, wrapOrderedModeCallBack(orderedModeCallback), parseField);
@Override public <T> void declareField(BiConsumer<Value, T> consumer, ContextParser<Context, T> parser, ParseField parseField, ValueType type) { if (consumer == null) { throw new IllegalArgumentException("[consumer] is required"); } if (parser == null) { throw new IllegalArgumentException("[parser] is required"); } if (parseField == null) { throw new IllegalArgumentException("[parseField] is required"); } if (type == null) { throw new IllegalArgumentException("[type] is required"); } if (consumer == REQUIRED_CONSTRUCTOR_ARG_MARKER || consumer == OPTIONAL_CONSTRUCTOR_ARG_MARKER) { /* * Constructor arguments are detected by this "marker" consumer. It keeps the API looking clean even if it is a bit sleezy. We * then build a new consumer directly against the object parser that triggers the "constructor arg just arrived behavior" of the * parser. Conveniently, we can close over the position of the constructor in the argument list so we don't need to do any fancy * or expensive lookups whenever the constructor args come in. */ int position = constructorArgInfos.size(); boolean required = consumer == REQUIRED_CONSTRUCTOR_ARG_MARKER; constructorArgInfos.add(new ConstructorArgInfo(parseField, required)); objectParser.declareField((target, v) -> target.constructorArg(position, parseField, v), parser, parseField, type); } else { numberOfFields += 1; objectParser.declareField(queueingConsumer(consumer, parseField), parser, parseField, type); } }