1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.codelibs.fess.es.config.cbean.ca.bs;
17
18 import org.codelibs.fess.es.config.allcommon.EsAbstractConditionAggregation;
19 import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
20 import org.codelibs.fess.es.config.cbean.ca.CrawlingInfoParamCA;
21 import org.codelibs.fess.es.config.cbean.cq.CrawlingInfoParamCQ;
22 import org.codelibs.fess.es.config.cbean.cq.bs.BsCrawlingInfoParamCQ;
23 import org.elasticsearch.search.aggregations.bucket.filter.FilterAggregationBuilder;
24 import org.elasticsearch.search.aggregations.bucket.global.GlobalAggregationBuilder;
25 import org.elasticsearch.search.aggregations.bucket.histogram.HistogramAggregationBuilder;
26 import org.elasticsearch.search.aggregations.bucket.missing.MissingAggregationBuilder;
27 import org.elasticsearch.search.aggregations.bucket.range.RangeAggregationBuilder;
28 import org.elasticsearch.search.aggregations.bucket.range.ip.IpRangeAggregationBuilder;
29 import org.elasticsearch.search.aggregations.bucket.sampler.SamplerAggregationBuilder;
30 import org.elasticsearch.search.aggregations.bucket.significant.SignificantTermsAggregationBuilder;
31 import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
32 import org.elasticsearch.search.aggregations.metrics.avg.AvgAggregationBuilder;
33 import org.elasticsearch.search.aggregations.metrics.cardinality.CardinalityAggregationBuilder;
34 import org.elasticsearch.search.aggregations.metrics.max.MaxAggregationBuilder;
35 import org.elasticsearch.search.aggregations.metrics.min.MinAggregationBuilder;
36 import org.elasticsearch.search.aggregations.metrics.percentiles.PercentileRanksAggregationBuilder;
37 import org.elasticsearch.search.aggregations.metrics.percentiles.PercentilesAggregationBuilder;
38 import org.elasticsearch.search.aggregations.metrics.scripted.ScriptedMetricAggregationBuilder;
39 import org.elasticsearch.search.aggregations.metrics.stats.StatsAggregationBuilder;
40 import org.elasticsearch.search.aggregations.metrics.stats.extended.ExtendedStatsAggregationBuilder;
41 import org.elasticsearch.search.aggregations.metrics.sum.SumAggregationBuilder;
42 import org.elasticsearch.search.aggregations.metrics.tophits.TopHitsAggregationBuilder;
43 import org.elasticsearch.search.aggregations.metrics.valuecount.ValueCountAggregationBuilder;
44
45
46
47
48 public abstract class BsCrawlingInfoParamCA extends EsAbstractConditionAggregation {
49
50
51
52
53
54 public void filter(String name, EsAbstractConditionQuery.OperatorCall<BsCrawlingInfoParamCQ> queryLambda,
55 ConditionOptionCall<FilterAggregationBuilder> opLambda, OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
56 CrawlingInfoParamCQ cq = new CrawlingInfoParamCQ();
57 if (queryLambda != null) {
58 queryLambda.callback(cq);
59 }
60 FilterAggregationBuilder builder = regFilterA(name, cq.getQuery());
61 if (opLambda != null) {
62 opLambda.callback(builder);
63 }
64 if (aggsLambda != null) {
65 CrawlingInfoParamCA ca = new CrawlingInfoParamCA();
66 aggsLambda.callback(ca);
67 ca.getAggregationBuilderList().forEach(builder::subAggregation);
68 }
69 }
70
71 public void global(String name, ConditionOptionCall<GlobalAggregationBuilder> opLambda, OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
72 GlobalAggregationBuilder builder = regGlobalA(name);
73 if (opLambda != null) {
74 opLambda.callback(builder);
75 }
76 if (aggsLambda != null) {
77 CrawlingInfoParamCA ca = new CrawlingInfoParamCA();
78 aggsLambda.callback(ca);
79 ca.getAggregationBuilderList().forEach(builder::subAggregation);
80 }
81 }
82
83 public void sampler(String name, ConditionOptionCall<SamplerAggregationBuilder> opLambda, OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
84 SamplerAggregationBuilder builder = regSamplerA(name);
85 if (opLambda != null) {
86 opLambda.callback(builder);
87 }
88 if (aggsLambda != null) {
89 CrawlingInfoParamCA ca = new CrawlingInfoParamCA();
90 aggsLambda.callback(ca);
91 ca.getAggregationBuilderList().forEach(builder::subAggregation);
92 }
93 }
94
95 public void scriptedMetric(String name, ConditionOptionCall<ScriptedMetricAggregationBuilder> opLambda) {
96 ScriptedMetricAggregationBuilder builder = regScriptedMetricA(name);
97 if (opLambda != null) {
98 opLambda.callback(builder);
99 }
100 }
101
102 public void topHits(String name, ConditionOptionCall<TopHitsAggregationBuilder> opLambda) {
103 TopHitsAggregationBuilder builder = regTopHitsA(name);
104 if (opLambda != null) {
105 opLambda.callback(builder);
106 }
107 }
108
109 public void setCrawlingInfoId_Terms() {
110 setCrawlingInfoId_Terms(null);
111 }
112
113 public void setCrawlingInfoId_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
114 setCrawlingInfoId_Terms("crawlingInfoId", opLambda, null);
115 }
116
117 public void setCrawlingInfoId_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda,
118 OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
119 setCrawlingInfoId_Terms("crawlingInfoId", opLambda, aggsLambda);
120 }
121
122 public void setCrawlingInfoId_Terms(String name, ConditionOptionCall<TermsAggregationBuilder> opLambda,
123 OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
124 TermsAggregationBuilder builder = regTermsA(name, "crawlingInfoId");
125 if (opLambda != null) {
126 opLambda.callback(builder);
127 }
128 if (aggsLambda != null) {
129 CrawlingInfoParamCA ca = new CrawlingInfoParamCA();
130 aggsLambda.callback(ca);
131 ca.getAggregationBuilderList().forEach(builder::subAggregation);
132 }
133 }
134
135 public void setCrawlingInfoId_SignificantTerms() {
136 setCrawlingInfoId_SignificantTerms(null);
137 }
138
139 public void setCrawlingInfoId_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda) {
140 setCrawlingInfoId_SignificantTerms("crawlingInfoId", opLambda, null);
141 }
142
143 public void setCrawlingInfoId_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
144 OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
145 setCrawlingInfoId_SignificantTerms("crawlingInfoId", opLambda, aggsLambda);
146 }
147
148 public void setCrawlingInfoId_SignificantTerms(String name, ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
149 OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
150 SignificantTermsAggregationBuilder builder = regSignificantTermsA(name, "crawlingInfoId");
151 if (opLambda != null) {
152 opLambda.callback(builder);
153 }
154 if (aggsLambda != null) {
155 CrawlingInfoParamCA ca = new CrawlingInfoParamCA();
156 aggsLambda.callback(ca);
157 ca.getAggregationBuilderList().forEach(builder::subAggregation);
158 }
159 }
160
161 public void setCrawlingInfoId_IpRange() {
162 setCrawlingInfoId_IpRange(null);
163 }
164
165 public void setCrawlingInfoId_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda) {
166 setCrawlingInfoId_IpRange("crawlingInfoId", opLambda, null);
167 }
168
169 public void setCrawlingInfoId_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
170 OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
171 setCrawlingInfoId_IpRange("crawlingInfoId", opLambda, aggsLambda);
172 }
173
174 public void setCrawlingInfoId_IpRange(String name, ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
175 OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
176 IpRangeAggregationBuilder builder = regIpRangeA(name, "crawlingInfoId");
177 if (opLambda != null) {
178 opLambda.callback(builder);
179 }
180 if (aggsLambda != null) {
181 CrawlingInfoParamCA ca = new CrawlingInfoParamCA();
182 aggsLambda.callback(ca);
183 ca.getAggregationBuilderList().forEach(builder::subAggregation);
184 }
185 }
186
187 public void setCrawlingInfoId_Count() {
188 setCrawlingInfoId_Count(null);
189 }
190
191 public void setCrawlingInfoId_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
192 setCrawlingInfoId_Count("crawlingInfoId", opLambda);
193 }
194
195 public void setCrawlingInfoId_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
196 ValueCountAggregationBuilder builder = regCountA(name, "crawlingInfoId");
197 if (opLambda != null) {
198 opLambda.callback(builder);
199 }
200 }
201
202 public void setCrawlingInfoId_Cardinality() {
203 setCrawlingInfoId_Cardinality(null);
204 }
205
206 public void setCrawlingInfoId_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
207 setCrawlingInfoId_Cardinality("crawlingInfoId", opLambda);
208 }
209
210 public void setCrawlingInfoId_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
211 CardinalityAggregationBuilder builder = regCardinalityA(name, "crawlingInfoId");
212 if (opLambda != null) {
213 opLambda.callback(builder);
214 }
215 }
216
217 public void setCrawlingInfoId_Missing() {
218 setCrawlingInfoId_Missing(null);
219 }
220
221 public void setCrawlingInfoId_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
222 setCrawlingInfoId_Missing("crawlingInfoId", opLambda, null);
223 }
224
225 public void setCrawlingInfoId_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda,
226 OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
227 setCrawlingInfoId_Missing("crawlingInfoId", opLambda, aggsLambda);
228 }
229
230 public void setCrawlingInfoId_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
231 OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
232 MissingAggregationBuilder builder = regMissingA(name, "crawlingInfoId");
233 if (opLambda != null) {
234 opLambda.callback(builder);
235 }
236 if (aggsLambda != null) {
237 CrawlingInfoParamCA ca = new CrawlingInfoParamCA();
238 aggsLambda.callback(ca);
239 ca.getAggregationBuilderList().forEach(builder::subAggregation);
240 }
241 }
242
243 public void setCreatedTime_Avg() {
244 setCreatedTime_Avg(null);
245 }
246
247 public void setCreatedTime_Avg(ConditionOptionCall<AvgAggregationBuilder> opLambda) {
248 setCreatedTime_Avg("createdTime", opLambda);
249 }
250
251 public void setCreatedTime_Avg(String name, ConditionOptionCall<AvgAggregationBuilder> opLambda) {
252 AvgAggregationBuilder builder = regAvgA(name, "createdTime");
253 if (opLambda != null) {
254 opLambda.callback(builder);
255 }
256 }
257
258 public void setCreatedTime_Max() {
259 setCreatedTime_Max(null);
260 }
261
262 public void setCreatedTime_Max(ConditionOptionCall<MaxAggregationBuilder> opLambda) {
263 setCreatedTime_Max("createdTime", opLambda);
264 }
265
266 public void setCreatedTime_Max(String name, ConditionOptionCall<MaxAggregationBuilder> opLambda) {
267 MaxAggregationBuilder builder = regMaxA(name, "createdTime");
268 if (opLambda != null) {
269 opLambda.callback(builder);
270 }
271 }
272
273 public void setCreatedTime_Min() {
274 setCreatedTime_Min(null);
275 }
276
277 public void setCreatedTime_Min(ConditionOptionCall<MinAggregationBuilder> opLambda) {
278 setCreatedTime_Min("createdTime", opLambda);
279 }
280
281 public void setCreatedTime_Min(String name, ConditionOptionCall<MinAggregationBuilder> opLambda) {
282 MinAggregationBuilder builder = regMinA(name, "createdTime");
283 if (opLambda != null) {
284 opLambda.callback(builder);
285 }
286 }
287
288 public void setCreatedTime_Sum() {
289 setCreatedTime_Sum(null);
290 }
291
292 public void setCreatedTime_Sum(ConditionOptionCall<SumAggregationBuilder> opLambda) {
293 setCreatedTime_Sum("createdTime", opLambda);
294 }
295
296 public void setCreatedTime_Sum(String name, ConditionOptionCall<SumAggregationBuilder> opLambda) {
297 SumAggregationBuilder builder = regSumA(name, "createdTime");
298 if (opLambda != null) {
299 opLambda.callback(builder);
300 }
301 }
302
303 public void setCreatedTime_ExtendedStats() {
304 setCreatedTime_ExtendedStats(null);
305 }
306
307 public void setCreatedTime_ExtendedStats(ConditionOptionCall<ExtendedStatsAggregationBuilder> opLambda) {
308 setCreatedTime_ExtendedStats("createdTime", opLambda);
309 }
310
311 public void setCreatedTime_ExtendedStats(String name, ConditionOptionCall<ExtendedStatsAggregationBuilder> opLambda) {
312 ExtendedStatsAggregationBuilder builder = regExtendedStatsA(name, "createdTime");
313 if (opLambda != null) {
314 opLambda.callback(builder);
315 }
316 }
317
318 public void setCreatedTime_Stats() {
319 setCreatedTime_Stats(null);
320 }
321
322 public void setCreatedTime_Stats(ConditionOptionCall<StatsAggregationBuilder> opLambda) {
323 setCreatedTime_Stats("createdTime", opLambda);
324 }
325
326 public void setCreatedTime_Stats(String name, ConditionOptionCall<StatsAggregationBuilder> opLambda) {
327 StatsAggregationBuilder builder = regStatsA(name, "createdTime");
328 if (opLambda != null) {
329 opLambda.callback(builder);
330 }
331 }
332
333 public void setCreatedTime_Percentiles() {
334 setCreatedTime_Percentiles(null);
335 }
336
337 public void setCreatedTime_Percentiles(ConditionOptionCall<PercentilesAggregationBuilder> opLambda) {
338 setCreatedTime_Percentiles("createdTime", opLambda);
339 }
340
341 public void setCreatedTime_Percentiles(String name, ConditionOptionCall<PercentilesAggregationBuilder> opLambda) {
342 PercentilesAggregationBuilder builder = regPercentilesA(name, "createdTime");
343 if (opLambda != null) {
344 opLambda.callback(builder);
345 }
346 }
347
348 public void setCreatedTime_PercentileRanks() {
349 setCreatedTime_PercentileRanks(null);
350 }
351
352 public void setCreatedTime_PercentileRanks(ConditionOptionCall<PercentileRanksAggregationBuilder> opLambda) {
353 setCreatedTime_PercentileRanks("createdTime", opLambda);
354 }
355
356 public void setCreatedTime_PercentileRanks(String name, ConditionOptionCall<PercentileRanksAggregationBuilder> opLambda) {
357 PercentileRanksAggregationBuilder builder = regPercentileRanksA(name, "createdTime");
358 if (opLambda != null) {
359 opLambda.callback(builder);
360 }
361 }
362
363 public void setCreatedTime_Histogram() {
364 setCreatedTime_Histogram(null);
365 }
366
367 public void setCreatedTime_Histogram(ConditionOptionCall<HistogramAggregationBuilder> opLambda) {
368 setCreatedTime_Histogram("createdTime", opLambda, null);
369 }
370
371 public void setCreatedTime_Histogram(ConditionOptionCall<HistogramAggregationBuilder> opLambda,
372 OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
373 setCreatedTime_Histogram("createdTime", opLambda, aggsLambda);
374 }
375
376 public void setCreatedTime_Histogram(String name, ConditionOptionCall<HistogramAggregationBuilder> opLambda,
377 OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
378 HistogramAggregationBuilder builder = regHistogramA(name, "createdTime");
379 if (opLambda != null) {
380 opLambda.callback(builder);
381 }
382 if (aggsLambda != null) {
383 CrawlingInfoParamCA ca = new CrawlingInfoParamCA();
384 aggsLambda.callback(ca);
385 ca.getAggregationBuilderList().forEach(builder::subAggregation);
386 }
387 }
388
389 public void setCreatedTime_Range() {
390 setCreatedTime_Range(null);
391 }
392
393 public void setCreatedTime_Range(ConditionOptionCall<RangeAggregationBuilder> opLambda) {
394 setCreatedTime_Range("createdTime", opLambda, null);
395 }
396
397 public void setCreatedTime_Range(ConditionOptionCall<RangeAggregationBuilder> opLambda, OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
398 setCreatedTime_Range("createdTime", opLambda, aggsLambda);
399 }
400
401 public void setCreatedTime_Range(String name, ConditionOptionCall<RangeAggregationBuilder> opLambda,
402 OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
403 RangeAggregationBuilder builder = regRangeA(name, "createdTime");
404 if (opLambda != null) {
405 opLambda.callback(builder);
406 }
407 if (aggsLambda != null) {
408 CrawlingInfoParamCA ca = new CrawlingInfoParamCA();
409 aggsLambda.callback(ca);
410 ca.getAggregationBuilderList().forEach(builder::subAggregation);
411 }
412 }
413
414 public void setCreatedTime_Count() {
415 setCreatedTime_Count(null);
416 }
417
418 public void setCreatedTime_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
419 setCreatedTime_Count("createdTime", opLambda);
420 }
421
422 public void setCreatedTime_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
423 ValueCountAggregationBuilder builder = regCountA(name, "createdTime");
424 if (opLambda != null) {
425 opLambda.callback(builder);
426 }
427 }
428
429 public void setCreatedTime_Cardinality() {
430 setCreatedTime_Cardinality(null);
431 }
432
433 public void setCreatedTime_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
434 setCreatedTime_Cardinality("createdTime", opLambda);
435 }
436
437 public void setCreatedTime_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
438 CardinalityAggregationBuilder builder = regCardinalityA(name, "createdTime");
439 if (opLambda != null) {
440 opLambda.callback(builder);
441 }
442 }
443
444 public void setCreatedTime_Missing() {
445 setCreatedTime_Missing(null);
446 }
447
448 public void setCreatedTime_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
449 setCreatedTime_Missing("createdTime", opLambda, null);
450 }
451
452 public void setCreatedTime_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda,
453 OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
454 setCreatedTime_Missing("createdTime", opLambda, aggsLambda);
455 }
456
457 public void setCreatedTime_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
458 OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
459 MissingAggregationBuilder builder = regMissingA(name, "createdTime");
460 if (opLambda != null) {
461 opLambda.callback(builder);
462 }
463 if (aggsLambda != null) {
464 CrawlingInfoParamCA ca = new CrawlingInfoParamCA();
465 aggsLambda.callback(ca);
466 ca.getAggregationBuilderList().forEach(builder::subAggregation);
467 }
468 }
469
470 public void setKey_Terms() {
471 setKey_Terms(null);
472 }
473
474 public void setKey_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
475 setKey_Terms("key", opLambda, null);
476 }
477
478 public void setKey_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
479 setKey_Terms("key", opLambda, aggsLambda);
480 }
481
482 public void setKey_Terms(String name, ConditionOptionCall<TermsAggregationBuilder> opLambda,
483 OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
484 TermsAggregationBuilder builder = regTermsA(name, "key");
485 if (opLambda != null) {
486 opLambda.callback(builder);
487 }
488 if (aggsLambda != null) {
489 CrawlingInfoParamCA ca = new CrawlingInfoParamCA();
490 aggsLambda.callback(ca);
491 ca.getAggregationBuilderList().forEach(builder::subAggregation);
492 }
493 }
494
495 public void setKey_SignificantTerms() {
496 setKey_SignificantTerms(null);
497 }
498
499 public void setKey_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda) {
500 setKey_SignificantTerms("key", opLambda, null);
501 }
502
503 public void setKey_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
504 OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
505 setKey_SignificantTerms("key", opLambda, aggsLambda);
506 }
507
508 public void setKey_SignificantTerms(String name, ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
509 OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
510 SignificantTermsAggregationBuilder builder = regSignificantTermsA(name, "key");
511 if (opLambda != null) {
512 opLambda.callback(builder);
513 }
514 if (aggsLambda != null) {
515 CrawlingInfoParamCA ca = new CrawlingInfoParamCA();
516 aggsLambda.callback(ca);
517 ca.getAggregationBuilderList().forEach(builder::subAggregation);
518 }
519 }
520
521 public void setKey_IpRange() {
522 setKey_IpRange(null);
523 }
524
525 public void setKey_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda) {
526 setKey_IpRange("key", opLambda, null);
527 }
528
529 public void setKey_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda, OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
530 setKey_IpRange("key", opLambda, aggsLambda);
531 }
532
533 public void setKey_IpRange(String name, ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
534 OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
535 IpRangeAggregationBuilder builder = regIpRangeA(name, "key");
536 if (opLambda != null) {
537 opLambda.callback(builder);
538 }
539 if (aggsLambda != null) {
540 CrawlingInfoParamCA ca = new CrawlingInfoParamCA();
541 aggsLambda.callback(ca);
542 ca.getAggregationBuilderList().forEach(builder::subAggregation);
543 }
544 }
545
546 public void setKey_Count() {
547 setKey_Count(null);
548 }
549
550 public void setKey_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
551 setKey_Count("key", opLambda);
552 }
553
554 public void setKey_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
555 ValueCountAggregationBuilder builder = regCountA(name, "key");
556 if (opLambda != null) {
557 opLambda.callback(builder);
558 }
559 }
560
561 public void setKey_Cardinality() {
562 setKey_Cardinality(null);
563 }
564
565 public void setKey_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
566 setKey_Cardinality("key", opLambda);
567 }
568
569 public void setKey_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
570 CardinalityAggregationBuilder builder = regCardinalityA(name, "key");
571 if (opLambda != null) {
572 opLambda.callback(builder);
573 }
574 }
575
576 public void setKey_Missing() {
577 setKey_Missing(null);
578 }
579
580 public void setKey_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
581 setKey_Missing("key", opLambda, null);
582 }
583
584 public void setKey_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
585 setKey_Missing("key", opLambda, aggsLambda);
586 }
587
588 public void setKey_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
589 OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
590 MissingAggregationBuilder builder = regMissingA(name, "key");
591 if (opLambda != null) {
592 opLambda.callback(builder);
593 }
594 if (aggsLambda != null) {
595 CrawlingInfoParamCA ca = new CrawlingInfoParamCA();
596 aggsLambda.callback(ca);
597 ca.getAggregationBuilderList().forEach(builder::subAggregation);
598 }
599 }
600
601 public void setValue_Terms() {
602 setValue_Terms(null);
603 }
604
605 public void setValue_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
606 setValue_Terms("value", opLambda, null);
607 }
608
609 public void setValue_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
610 setValue_Terms("value", opLambda, aggsLambda);
611 }
612
613 public void setValue_Terms(String name, ConditionOptionCall<TermsAggregationBuilder> opLambda,
614 OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
615 TermsAggregationBuilder builder = regTermsA(name, "value");
616 if (opLambda != null) {
617 opLambda.callback(builder);
618 }
619 if (aggsLambda != null) {
620 CrawlingInfoParamCA ca = new CrawlingInfoParamCA();
621 aggsLambda.callback(ca);
622 ca.getAggregationBuilderList().forEach(builder::subAggregation);
623 }
624 }
625
626 public void setValue_SignificantTerms() {
627 setValue_SignificantTerms(null);
628 }
629
630 public void setValue_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda) {
631 setValue_SignificantTerms("value", opLambda, null);
632 }
633
634 public void setValue_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
635 OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
636 setValue_SignificantTerms("value", opLambda, aggsLambda);
637 }
638
639 public void setValue_SignificantTerms(String name, ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
640 OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
641 SignificantTermsAggregationBuilder builder = regSignificantTermsA(name, "value");
642 if (opLambda != null) {
643 opLambda.callback(builder);
644 }
645 if (aggsLambda != null) {
646 CrawlingInfoParamCA ca = new CrawlingInfoParamCA();
647 aggsLambda.callback(ca);
648 ca.getAggregationBuilderList().forEach(builder::subAggregation);
649 }
650 }
651
652 public void setValue_IpRange() {
653 setValue_IpRange(null);
654 }
655
656 public void setValue_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda) {
657 setValue_IpRange("value", opLambda, null);
658 }
659
660 public void setValue_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda, OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
661 setValue_IpRange("value", opLambda, aggsLambda);
662 }
663
664 public void setValue_IpRange(String name, ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
665 OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
666 IpRangeAggregationBuilder builder = regIpRangeA(name, "value");
667 if (opLambda != null) {
668 opLambda.callback(builder);
669 }
670 if (aggsLambda != null) {
671 CrawlingInfoParamCA ca = new CrawlingInfoParamCA();
672 aggsLambda.callback(ca);
673 ca.getAggregationBuilderList().forEach(builder::subAggregation);
674 }
675 }
676
677 public void setValue_Count() {
678 setValue_Count(null);
679 }
680
681 public void setValue_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
682 setValue_Count("value", opLambda);
683 }
684
685 public void setValue_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
686 ValueCountAggregationBuilder builder = regCountA(name, "value");
687 if (opLambda != null) {
688 opLambda.callback(builder);
689 }
690 }
691
692 public void setValue_Cardinality() {
693 setValue_Cardinality(null);
694 }
695
696 public void setValue_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
697 setValue_Cardinality("value", opLambda);
698 }
699
700 public void setValue_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
701 CardinalityAggregationBuilder builder = regCardinalityA(name, "value");
702 if (opLambda != null) {
703 opLambda.callback(builder);
704 }
705 }
706
707 public void setValue_Missing() {
708 setValue_Missing(null);
709 }
710
711 public void setValue_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
712 setValue_Missing("value", opLambda, null);
713 }
714
715 public void setValue_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
716 setValue_Missing("value", opLambda, aggsLambda);
717 }
718
719 public void setValue_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
720 OperatorCall<BsCrawlingInfoParamCA> aggsLambda) {
721 MissingAggregationBuilder builder = regMissingA(name, "value");
722 if (opLambda != null) {
723 opLambda.callback(builder);
724 }
725 if (aggsLambda != null) {
726 CrawlingInfoParamCA ca = new CrawlingInfoParamCA();
727 aggsLambda.callback(ca);
728 ca.getAggregationBuilderList().forEach(builder::subAggregation);
729 }
730 }
731
732 }