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