1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.codelibs.fess.opensearch.config.cbean.cq.bs;
17
18 import java.time.LocalDateTime;
19 import java.util.ArrayList;
20 import java.util.Collection;
21
22 import org.codelibs.fess.opensearch.config.allcommon.EsAbstractConditionQuery;
23 import org.codelibs.fess.opensearch.config.cbean.cq.RelatedContentCQ;
24 import org.dbflute.cbean.ckey.ConditionKey;
25 import org.opensearch.index.query.BoolQueryBuilder;
26 import org.opensearch.index.query.CommonTermsQueryBuilder;
27 import org.opensearch.index.query.ExistsQueryBuilder;
28 import org.opensearch.index.query.IdsQueryBuilder;
29 import org.opensearch.index.query.MatchPhrasePrefixQueryBuilder;
30 import org.opensearch.index.query.MatchPhraseQueryBuilder;
31 import org.opensearch.index.query.MatchQueryBuilder;
32 import org.opensearch.index.query.PrefixQueryBuilder;
33 import org.opensearch.index.query.RangeQueryBuilder;
34 import org.opensearch.index.query.RegexpQueryBuilder;
35 import org.opensearch.index.query.SpanTermQueryBuilder;
36 import org.opensearch.index.query.TermQueryBuilder;
37 import org.opensearch.index.query.TermsQueryBuilder;
38 import org.opensearch.index.query.WildcardQueryBuilder;
39 import org.opensearch.index.query.functionscore.FunctionScoreQueryBuilder;
40 import org.opensearch.index.query.functionscore.FunctionScoreQueryBuilder.FilterFunctionBuilder;
41
42
43
44
45 public abstract class BsRelatedContentCQ extends EsAbstractConditionQuery {
46
47 protected static final Class<?> suppressUnusedImportLocalDateTime = LocalDateTime.class;
48
49
50
51
52 @Override
53 public String asTableDbName() {
54 return "related_content";
55 }
56
57 @Override
58 public String xgetAliasName() {
59 return "related_content";
60 }
61
62
63
64
65 public void functionScore(OperatorCall<RelatedContentCQ> queryLambda,
66 ScoreFunctionCall<ScoreFunctionCreator<RelatedContentCQ>> functionsLambda,
67 final ConditionOptionCall<FunctionScoreQueryBuilder> opLambda) {
68 RelatedContentCQ cq = new RelatedContentCQ();
69 queryLambda.callback(cq);
70 final Collection<FilterFunctionBuilder> list = new ArrayList<>();
71 if (functionsLambda != null) {
72 functionsLambda.callback((cqLambda, scoreFunctionBuilder) -> {
73 RelatedContentCQ cf = new RelatedContentCQ();
74 cqLambda.callback(cf);
75 list.add(new FilterFunctionBuilder(cf.getQuery(), scoreFunctionBuilder));
76 });
77 }
78 final FunctionScoreQueryBuilder builder = regFunctionScoreQ(cq.getQuery(), list);
79 if (opLambda != null) {
80 opLambda.callback(builder);
81 }
82 }
83
84 public void filtered(FilteredCall<RelatedContentCQ, RelatedContentCQ> filteredLambda) {
85 filtered(filteredLambda, null);
86 }
87
88 public void filtered(FilteredCall<RelatedContentCQ, RelatedContentCQ> filteredLambda, ConditionOptionCall<BoolQueryBuilder> opLambda) {
89 bool((must, should, mustNot, filter) -> {
90 filteredLambda.callback(must, filter);
91 }, opLambda);
92 }
93
94 public void not(OperatorCall<RelatedContentCQ> notLambda) {
95 not(notLambda, null);
96 }
97
98 public void not(final OperatorCall<RelatedContentCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {
99 bool((must, should, mustNot, filter) -> notLambda.callback(mustNot), opLambda);
100 }
101
102 public void bool(BoolCall<RelatedContentCQ> boolLambda) {
103 bool(boolLambda, null);
104 }
105
106 public void bool(BoolCall<RelatedContentCQ> boolLambda, ConditionOptionCall<BoolQueryBuilder> opLambda) {
107 RelatedContentCQ mustQuery = new RelatedContentCQ();
108 RelatedContentCQ shouldQuery = new RelatedContentCQ();
109 RelatedContentCQ mustNotQuery = new RelatedContentCQ();
110 RelatedContentCQ filterQuery = new RelatedContentCQ();
111 boolLambda.callback(mustQuery, shouldQuery, mustNotQuery, filterQuery);
112 if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries() || filterQuery.hasQueries()) {
113 BoolQueryBuilder builder = regBoolCQ(mustQuery.getQueryBuilderList(), shouldQuery.getQueryBuilderList(),
114 mustNotQuery.getQueryBuilderList(), filterQuery.getQueryBuilderList());
115 if (opLambda != null) {
116 opLambda.callback(builder);
117 }
118 }
119 }
120
121
122
123
124 public void setId_Equal(String id) {
125 setId_Term(id, null);
126 }
127
128 public void setId_Equal(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
129 setId_Term(id, opLambda);
130 }
131
132 public void setId_Term(String id) {
133 setId_Term(id, null);
134 }
135
136 public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
137 TermQueryBuilder builder = regTermQ("_id", id);
138 if (opLambda != null) {
139 opLambda.callback(builder);
140 }
141 }
142
143 public void setId_NotEqual(String id) {
144 setId_NotTerm(id, null);
145 }
146
147 public void setId_NotTerm(String id) {
148 setId_NotTerm(id, null);
149 }
150
151 public void setId_NotEqual(String id, ConditionOptionCall<BoolQueryBuilder> opLambda) {
152 setId_NotTerm(id, opLambda);
153 }
154
155 public void setId_NotTerm(String id, ConditionOptionCall<BoolQueryBuilder> opLambda) {
156 not(not -> not.setId_Term(id), opLambda);
157 }
158
159 public void setId_Terms(Collection<String> idList) {
160 setId_Terms(idList, null);
161 }
162
163 public void setId_Terms(Collection<String> idList, ConditionOptionCall<IdsQueryBuilder> opLambda) {
164 IdsQueryBuilder builder = regIdsQ(idList);
165 if (opLambda != null) {
166 opLambda.callback(builder);
167 }
168 }
169
170 public void setId_InScope(Collection<String> idList) {
171 setId_Terms(idList, null);
172 }
173
174 public void setId_InScope(Collection<String> idList, ConditionOptionCall<IdsQueryBuilder> opLambda) {
175 setId_Terms(idList, opLambda);
176 }
177
178 @Deprecated
179 public BsRelatedContentCQ addOrderBy_Id_Asc() {
180 regOBA("_id");
181 return this;
182 }
183
184 @Deprecated
185 public BsRelatedContentCQ addOrderBy_Id_Desc() {
186 regOBD("_id");
187 return this;
188 }
189
190 public void setContent_Equal(String content) {
191 setContent_Term(content, null);
192 }
193
194 public void setContent_Equal(String content, ConditionOptionCall<TermQueryBuilder> opLambda) {
195 setContent_Term(content, opLambda);
196 }
197
198 public void setContent_Term(String content) {
199 setContent_Term(content, null);
200 }
201
202 public void setContent_Term(String content, ConditionOptionCall<TermQueryBuilder> opLambda) {
203 TermQueryBuilder builder = regTermQ("content", content);
204 if (opLambda != null) {
205 opLambda.callback(builder);
206 }
207 }
208
209 public void setContent_NotEqual(String content) {
210 setContent_NotTerm(content, null);
211 }
212
213 public void setContent_NotTerm(String content) {
214 setContent_NotTerm(content, null);
215 }
216
217 public void setContent_NotEqual(String content, ConditionOptionCall<BoolQueryBuilder> opLambda) {
218 setContent_NotTerm(content, opLambda);
219 }
220
221 public void setContent_NotTerm(String content, ConditionOptionCall<BoolQueryBuilder> opLambda) {
222 not(not -> not.setContent_Term(content), opLambda);
223 }
224
225 public void setContent_Terms(Collection<String> contentList) {
226 setContent_Terms(contentList, null);
227 }
228
229 public void setContent_Terms(Collection<String> contentList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
230 TermsQueryBuilder builder = regTermsQ("content", contentList);
231 if (opLambda != null) {
232 opLambda.callback(builder);
233 }
234 }
235
236 public void setContent_InScope(Collection<String> contentList) {
237 setContent_Terms(contentList, null);
238 }
239
240 public void setContent_InScope(Collection<String> contentList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
241 setContent_Terms(contentList, opLambda);
242 }
243
244 public void setContent_Match(String content) {
245 setContent_Match(content, null);
246 }
247
248 public void setContent_Match(String content, ConditionOptionCall<MatchQueryBuilder> opLambda) {
249 MatchQueryBuilder builder = regMatchQ("content", content);
250 if (opLambda != null) {
251 opLambda.callback(builder);
252 }
253 }
254
255 public void setContent_MatchPhrase(String content) {
256 setContent_MatchPhrase(content, null);
257 }
258
259 public void setContent_MatchPhrase(String content, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
260 MatchPhraseQueryBuilder builder = regMatchPhraseQ("content", content);
261 if (opLambda != null) {
262 opLambda.callback(builder);
263 }
264 }
265
266 public void setContent_MatchPhrasePrefix(String content) {
267 setContent_MatchPhrasePrefix(content, null);
268 }
269
270 public void setContent_MatchPhrasePrefix(String content, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
271 MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("content", content);
272 if (opLambda != null) {
273 opLambda.callback(builder);
274 }
275 }
276
277 public void setContent_Fuzzy(String content) {
278 setContent_Fuzzy(content, null);
279 }
280
281 public void setContent_Fuzzy(String content, ConditionOptionCall<MatchQueryBuilder> opLambda) {
282 MatchQueryBuilder builder = regFuzzyQ("content", content);
283 if (opLambda != null) {
284 opLambda.callback(builder);
285 }
286 }
287
288 public void setContent_Prefix(String content) {
289 setContent_Prefix(content, null);
290 }
291
292 public void setContent_Prefix(String content, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
293 PrefixQueryBuilder builder = regPrefixQ("content", content);
294 if (opLambda != null) {
295 opLambda.callback(builder);
296 }
297 }
298
299 public void setContent_Wildcard(String content) {
300 setContent_Wildcard(content, null);
301 }
302
303 public void setContent_Wildcard(String content, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
304 WildcardQueryBuilder builder = regWildcardQ("content", content);
305 if (opLambda != null) {
306 opLambda.callback(builder);
307 }
308 }
309
310 public void setContent_Regexp(String content) {
311 setContent_Regexp(content, null);
312 }
313
314 public void setContent_Regexp(String content, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
315 RegexpQueryBuilder builder = regRegexpQ("content", content);
316 if (opLambda != null) {
317 opLambda.callback(builder);
318 }
319 }
320
321 public void setContent_SpanTerm(String content) {
322 setContent_SpanTerm("content", null);
323 }
324
325 public void setContent_SpanTerm(String content, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
326 SpanTermQueryBuilder builder = regSpanTermQ("content", content);
327 if (opLambda != null) {
328 opLambda.callback(builder);
329 }
330 }
331
332 public void setContent_GreaterThan(String content) {
333 setContent_GreaterThan(content, null);
334 }
335
336 public void setContent_GreaterThan(String content, ConditionOptionCall<RangeQueryBuilder> opLambda) {
337 final Object _value = content;
338 RangeQueryBuilder builder = regRangeQ("content", ConditionKey.CK_GREATER_THAN, _value);
339 if (opLambda != null) {
340 opLambda.callback(builder);
341 }
342 }
343
344 public void setContent_LessThan(String content) {
345 setContent_LessThan(content, null);
346 }
347
348 public void setContent_LessThan(String content, ConditionOptionCall<RangeQueryBuilder> opLambda) {
349 final Object _value = content;
350 RangeQueryBuilder builder = regRangeQ("content", ConditionKey.CK_LESS_THAN, _value);
351 if (opLambda != null) {
352 opLambda.callback(builder);
353 }
354 }
355
356 public void setContent_GreaterEqual(String content) {
357 setContent_GreaterEqual(content, null);
358 }
359
360 public void setContent_GreaterEqual(String content, ConditionOptionCall<RangeQueryBuilder> opLambda) {
361 final Object _value = content;
362 RangeQueryBuilder builder = regRangeQ("content", ConditionKey.CK_GREATER_EQUAL, _value);
363 if (opLambda != null) {
364 opLambda.callback(builder);
365 }
366 }
367
368 public void setContent_LessEqual(String content) {
369 setContent_LessEqual(content, null);
370 }
371
372 public void setContent_LessEqual(String content, ConditionOptionCall<RangeQueryBuilder> opLambda) {
373 final Object _value = content;
374 RangeQueryBuilder builder = regRangeQ("content", ConditionKey.CK_LESS_EQUAL, _value);
375 if (opLambda != null) {
376 opLambda.callback(builder);
377 }
378 }
379
380 public void setContent_Exists() {
381 setContent_Exists(null);
382 }
383
384 public void setContent_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
385 ExistsQueryBuilder builder = regExistsQ("content");
386 if (opLambda != null) {
387 opLambda.callback(builder);
388 }
389 }
390
391 @Deprecated
392 public void setContent_CommonTerms(String content) {
393 setContent_CommonTerms(content, null);
394 }
395
396 @Deprecated
397 public void setContent_CommonTerms(String content, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
398 CommonTermsQueryBuilder builder = regCommonTermsQ("content", content);
399 if (opLambda != null) {
400 opLambda.callback(builder);
401 }
402 }
403
404 public BsRelatedContentCQ addOrderBy_Content_Asc() {
405 regOBA("content");
406 return this;
407 }
408
409 public BsRelatedContentCQ addOrderBy_Content_Desc() {
410 regOBD("content");
411 return this;
412 }
413
414 public void setCreatedBy_Equal(String createdBy) {
415 setCreatedBy_Term(createdBy, null);
416 }
417
418 public void setCreatedBy_Equal(String createdBy, ConditionOptionCall<TermQueryBuilder> opLambda) {
419 setCreatedBy_Term(createdBy, opLambda);
420 }
421
422 public void setCreatedBy_Term(String createdBy) {
423 setCreatedBy_Term(createdBy, null);
424 }
425
426 public void setCreatedBy_Term(String createdBy, ConditionOptionCall<TermQueryBuilder> opLambda) {
427 TermQueryBuilder builder = regTermQ("createdBy", createdBy);
428 if (opLambda != null) {
429 opLambda.callback(builder);
430 }
431 }
432
433 public void setCreatedBy_NotEqual(String createdBy) {
434 setCreatedBy_NotTerm(createdBy, null);
435 }
436
437 public void setCreatedBy_NotTerm(String createdBy) {
438 setCreatedBy_NotTerm(createdBy, null);
439 }
440
441 public void setCreatedBy_NotEqual(String createdBy, ConditionOptionCall<BoolQueryBuilder> opLambda) {
442 setCreatedBy_NotTerm(createdBy, opLambda);
443 }
444
445 public void setCreatedBy_NotTerm(String createdBy, ConditionOptionCall<BoolQueryBuilder> opLambda) {
446 not(not -> not.setCreatedBy_Term(createdBy), opLambda);
447 }
448
449 public void setCreatedBy_Terms(Collection<String> createdByList) {
450 setCreatedBy_Terms(createdByList, null);
451 }
452
453 public void setCreatedBy_Terms(Collection<String> createdByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
454 TermsQueryBuilder builder = regTermsQ("createdBy", createdByList);
455 if (opLambda != null) {
456 opLambda.callback(builder);
457 }
458 }
459
460 public void setCreatedBy_InScope(Collection<String> createdByList) {
461 setCreatedBy_Terms(createdByList, null);
462 }
463
464 public void setCreatedBy_InScope(Collection<String> createdByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
465 setCreatedBy_Terms(createdByList, opLambda);
466 }
467
468 public void setCreatedBy_Match(String createdBy) {
469 setCreatedBy_Match(createdBy, null);
470 }
471
472 public void setCreatedBy_Match(String createdBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
473 MatchQueryBuilder builder = regMatchQ("createdBy", createdBy);
474 if (opLambda != null) {
475 opLambda.callback(builder);
476 }
477 }
478
479 public void setCreatedBy_MatchPhrase(String createdBy) {
480 setCreatedBy_MatchPhrase(createdBy, null);
481 }
482
483 public void setCreatedBy_MatchPhrase(String createdBy, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
484 MatchPhraseQueryBuilder builder = regMatchPhraseQ("createdBy", createdBy);
485 if (opLambda != null) {
486 opLambda.callback(builder);
487 }
488 }
489
490 public void setCreatedBy_MatchPhrasePrefix(String createdBy) {
491 setCreatedBy_MatchPhrasePrefix(createdBy, null);
492 }
493
494 public void setCreatedBy_MatchPhrasePrefix(String createdBy, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
495 MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("createdBy", createdBy);
496 if (opLambda != null) {
497 opLambda.callback(builder);
498 }
499 }
500
501 public void setCreatedBy_Fuzzy(String createdBy) {
502 setCreatedBy_Fuzzy(createdBy, null);
503 }
504
505 public void setCreatedBy_Fuzzy(String createdBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
506 MatchQueryBuilder builder = regFuzzyQ("createdBy", createdBy);
507 if (opLambda != null) {
508 opLambda.callback(builder);
509 }
510 }
511
512 public void setCreatedBy_Prefix(String createdBy) {
513 setCreatedBy_Prefix(createdBy, null);
514 }
515
516 public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
517 PrefixQueryBuilder builder = regPrefixQ("createdBy", createdBy);
518 if (opLambda != null) {
519 opLambda.callback(builder);
520 }
521 }
522
523 public void setCreatedBy_Wildcard(String createdBy) {
524 setCreatedBy_Wildcard(createdBy, null);
525 }
526
527 public void setCreatedBy_Wildcard(String createdBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
528 WildcardQueryBuilder builder = regWildcardQ("createdBy", createdBy);
529 if (opLambda != null) {
530 opLambda.callback(builder);
531 }
532 }
533
534 public void setCreatedBy_Regexp(String createdBy) {
535 setCreatedBy_Regexp(createdBy, null);
536 }
537
538 public void setCreatedBy_Regexp(String createdBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
539 RegexpQueryBuilder builder = regRegexpQ("createdBy", createdBy);
540 if (opLambda != null) {
541 opLambda.callback(builder);
542 }
543 }
544
545 public void setCreatedBy_SpanTerm(String createdBy) {
546 setCreatedBy_SpanTerm("createdBy", null);
547 }
548
549 public void setCreatedBy_SpanTerm(String createdBy, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
550 SpanTermQueryBuilder builder = regSpanTermQ("createdBy", createdBy);
551 if (opLambda != null) {
552 opLambda.callback(builder);
553 }
554 }
555
556 public void setCreatedBy_GreaterThan(String createdBy) {
557 setCreatedBy_GreaterThan(createdBy, null);
558 }
559
560 public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
561 final Object _value = createdBy;
562 RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, _value);
563 if (opLambda != null) {
564 opLambda.callback(builder);
565 }
566 }
567
568 public void setCreatedBy_LessThan(String createdBy) {
569 setCreatedBy_LessThan(createdBy, null);
570 }
571
572 public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
573 final Object _value = createdBy;
574 RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_THAN, _value);
575 if (opLambda != null) {
576 opLambda.callback(builder);
577 }
578 }
579
580 public void setCreatedBy_GreaterEqual(String createdBy) {
581 setCreatedBy_GreaterEqual(createdBy, null);
582 }
583
584 public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
585 final Object _value = createdBy;
586 RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, _value);
587 if (opLambda != null) {
588 opLambda.callback(builder);
589 }
590 }
591
592 public void setCreatedBy_LessEqual(String createdBy) {
593 setCreatedBy_LessEqual(createdBy, null);
594 }
595
596 public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
597 final Object _value = createdBy;
598 RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, _value);
599 if (opLambda != null) {
600 opLambda.callback(builder);
601 }
602 }
603
604 public void setCreatedBy_Exists() {
605 setCreatedBy_Exists(null);
606 }
607
608 public void setCreatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
609 ExistsQueryBuilder builder = regExistsQ("createdBy");
610 if (opLambda != null) {
611 opLambda.callback(builder);
612 }
613 }
614
615 @Deprecated
616 public void setCreatedBy_CommonTerms(String createdBy) {
617 setCreatedBy_CommonTerms(createdBy, null);
618 }
619
620 @Deprecated
621 public void setCreatedBy_CommonTerms(String createdBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
622 CommonTermsQueryBuilder builder = regCommonTermsQ("createdBy", createdBy);
623 if (opLambda != null) {
624 opLambda.callback(builder);
625 }
626 }
627
628 public BsRelatedContentCQ addOrderBy_CreatedBy_Asc() {
629 regOBA("createdBy");
630 return this;
631 }
632
633 public BsRelatedContentCQ addOrderBy_CreatedBy_Desc() {
634 regOBD("createdBy");
635 return this;
636 }
637
638 public void setCreatedTime_Equal(Long createdTime) {
639 setCreatedTime_Term(createdTime, null);
640 }
641
642 public void setCreatedTime_Equal(Long createdTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
643 setCreatedTime_Term(createdTime, opLambda);
644 }
645
646 public void setCreatedTime_Term(Long createdTime) {
647 setCreatedTime_Term(createdTime, null);
648 }
649
650 public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
651 TermQueryBuilder builder = regTermQ("createdTime", createdTime);
652 if (opLambda != null) {
653 opLambda.callback(builder);
654 }
655 }
656
657 public void setCreatedTime_NotEqual(Long createdTime) {
658 setCreatedTime_NotTerm(createdTime, null);
659 }
660
661 public void setCreatedTime_NotTerm(Long createdTime) {
662 setCreatedTime_NotTerm(createdTime, null);
663 }
664
665 public void setCreatedTime_NotEqual(Long createdTime, ConditionOptionCall<BoolQueryBuilder> opLambda) {
666 setCreatedTime_NotTerm(createdTime, opLambda);
667 }
668
669 public void setCreatedTime_NotTerm(Long createdTime, ConditionOptionCall<BoolQueryBuilder> opLambda) {
670 not(not -> not.setCreatedTime_Term(createdTime), opLambda);
671 }
672
673 public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
674 setCreatedTime_Terms(createdTimeList, null);
675 }
676
677 public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
678 TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList);
679 if (opLambda != null) {
680 opLambda.callback(builder);
681 }
682 }
683
684 public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
685 setCreatedTime_Terms(createdTimeList, null);
686 }
687
688 public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
689 setCreatedTime_Terms(createdTimeList, opLambda);
690 }
691
692 public void setCreatedTime_Match(Long createdTime) {
693 setCreatedTime_Match(createdTime, null);
694 }
695
696 public void setCreatedTime_Match(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
697 MatchQueryBuilder builder = regMatchQ("createdTime", createdTime);
698 if (opLambda != null) {
699 opLambda.callback(builder);
700 }
701 }
702
703 public void setCreatedTime_MatchPhrase(Long createdTime) {
704 setCreatedTime_MatchPhrase(createdTime, null);
705 }
706
707 public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
708 MatchPhraseQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime);
709 if (opLambda != null) {
710 opLambda.callback(builder);
711 }
712 }
713
714 public void setCreatedTime_MatchPhrasePrefix(Long createdTime) {
715 setCreatedTime_MatchPhrasePrefix(createdTime, null);
716 }
717
718 public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
719 MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime);
720 if (opLambda != null) {
721 opLambda.callback(builder);
722 }
723 }
724
725 public void setCreatedTime_Fuzzy(Long createdTime) {
726 setCreatedTime_Fuzzy(createdTime, null);
727 }
728
729 public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
730 MatchQueryBuilder builder = regFuzzyQ("createdTime", createdTime);
731 if (opLambda != null) {
732 opLambda.callback(builder);
733 }
734 }
735
736 public void setCreatedTime_GreaterThan(Long createdTime) {
737 setCreatedTime_GreaterThan(createdTime, null);
738 }
739
740 public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
741 final Object _value = createdTime;
742 RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, _value);
743 if (opLambda != null) {
744 opLambda.callback(builder);
745 }
746 }
747
748 public void setCreatedTime_LessThan(Long createdTime) {
749 setCreatedTime_LessThan(createdTime, null);
750 }
751
752 public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
753 final Object _value = createdTime;
754 RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, _value);
755 if (opLambda != null) {
756 opLambda.callback(builder);
757 }
758 }
759
760 public void setCreatedTime_GreaterEqual(Long createdTime) {
761 setCreatedTime_GreaterEqual(createdTime, null);
762 }
763
764 public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
765 final Object _value = createdTime;
766 RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, _value);
767 if (opLambda != null) {
768 opLambda.callback(builder);
769 }
770 }
771
772 public void setCreatedTime_LessEqual(Long createdTime) {
773 setCreatedTime_LessEqual(createdTime, null);
774 }
775
776 public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
777 final Object _value = createdTime;
778 RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, _value);
779 if (opLambda != null) {
780 opLambda.callback(builder);
781 }
782 }
783
784 public void setCreatedTime_Exists() {
785 setCreatedTime_Exists(null);
786 }
787
788 public void setCreatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
789 ExistsQueryBuilder builder = regExistsQ("createdTime");
790 if (opLambda != null) {
791 opLambda.callback(builder);
792 }
793 }
794
795 @Deprecated
796 public void setCreatedTime_CommonTerms(Long createdTime) {
797 setCreatedTime_CommonTerms(createdTime, null);
798 }
799
800 @Deprecated
801 public void setCreatedTime_CommonTerms(Long createdTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
802 CommonTermsQueryBuilder builder = regCommonTermsQ("createdTime", createdTime);
803 if (opLambda != null) {
804 opLambda.callback(builder);
805 }
806 }
807
808 public BsRelatedContentCQ addOrderBy_CreatedTime_Asc() {
809 regOBA("createdTime");
810 return this;
811 }
812
813 public BsRelatedContentCQ addOrderBy_CreatedTime_Desc() {
814 regOBD("createdTime");
815 return this;
816 }
817
818 public void setSortOrder_Equal(Integer sortOrder) {
819 setSortOrder_Term(sortOrder, null);
820 }
821
822 public void setSortOrder_Equal(Integer sortOrder, ConditionOptionCall<TermQueryBuilder> opLambda) {
823 setSortOrder_Term(sortOrder, opLambda);
824 }
825
826 public void setSortOrder_Term(Integer sortOrder) {
827 setSortOrder_Term(sortOrder, null);
828 }
829
830 public void setSortOrder_Term(Integer sortOrder, ConditionOptionCall<TermQueryBuilder> opLambda) {
831 TermQueryBuilder builder = regTermQ("sortOrder", sortOrder);
832 if (opLambda != null) {
833 opLambda.callback(builder);
834 }
835 }
836
837 public void setSortOrder_NotEqual(Integer sortOrder) {
838 setSortOrder_NotTerm(sortOrder, null);
839 }
840
841 public void setSortOrder_NotTerm(Integer sortOrder) {
842 setSortOrder_NotTerm(sortOrder, null);
843 }
844
845 public void setSortOrder_NotEqual(Integer sortOrder, ConditionOptionCall<BoolQueryBuilder> opLambda) {
846 setSortOrder_NotTerm(sortOrder, opLambda);
847 }
848
849 public void setSortOrder_NotTerm(Integer sortOrder, ConditionOptionCall<BoolQueryBuilder> opLambda) {
850 not(not -> not.setSortOrder_Term(sortOrder), opLambda);
851 }
852
853 public void setSortOrder_Terms(Collection<Integer> sortOrderList) {
854 setSortOrder_Terms(sortOrderList, null);
855 }
856
857 public void setSortOrder_Terms(Collection<Integer> sortOrderList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
858 TermsQueryBuilder builder = regTermsQ("sortOrder", sortOrderList);
859 if (opLambda != null) {
860 opLambda.callback(builder);
861 }
862 }
863
864 public void setSortOrder_InScope(Collection<Integer> sortOrderList) {
865 setSortOrder_Terms(sortOrderList, null);
866 }
867
868 public void setSortOrder_InScope(Collection<Integer> sortOrderList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
869 setSortOrder_Terms(sortOrderList, opLambda);
870 }
871
872 public void setSortOrder_Match(Integer sortOrder) {
873 setSortOrder_Match(sortOrder, null);
874 }
875
876 public void setSortOrder_Match(Integer sortOrder, ConditionOptionCall<MatchQueryBuilder> opLambda) {
877 MatchQueryBuilder builder = regMatchQ("sortOrder", sortOrder);
878 if (opLambda != null) {
879 opLambda.callback(builder);
880 }
881 }
882
883 public void setSortOrder_MatchPhrase(Integer sortOrder) {
884 setSortOrder_MatchPhrase(sortOrder, null);
885 }
886
887 public void setSortOrder_MatchPhrase(Integer sortOrder, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
888 MatchPhraseQueryBuilder builder = regMatchPhraseQ("sortOrder", sortOrder);
889 if (opLambda != null) {
890 opLambda.callback(builder);
891 }
892 }
893
894 public void setSortOrder_MatchPhrasePrefix(Integer sortOrder) {
895 setSortOrder_MatchPhrasePrefix(sortOrder, null);
896 }
897
898 public void setSortOrder_MatchPhrasePrefix(Integer sortOrder, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
899 MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("sortOrder", sortOrder);
900 if (opLambda != null) {
901 opLambda.callback(builder);
902 }
903 }
904
905 public void setSortOrder_Fuzzy(Integer sortOrder) {
906 setSortOrder_Fuzzy(sortOrder, null);
907 }
908
909 public void setSortOrder_Fuzzy(Integer sortOrder, ConditionOptionCall<MatchQueryBuilder> opLambda) {
910 MatchQueryBuilder builder = regFuzzyQ("sortOrder", sortOrder);
911 if (opLambda != null) {
912 opLambda.callback(builder);
913 }
914 }
915
916 public void setSortOrder_GreaterThan(Integer sortOrder) {
917 setSortOrder_GreaterThan(sortOrder, null);
918 }
919
920 public void setSortOrder_GreaterThan(Integer sortOrder, ConditionOptionCall<RangeQueryBuilder> opLambda) {
921 final Object _value = sortOrder;
922 RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_THAN, _value);
923 if (opLambda != null) {
924 opLambda.callback(builder);
925 }
926 }
927
928 public void setSortOrder_LessThan(Integer sortOrder) {
929 setSortOrder_LessThan(sortOrder, null);
930 }
931
932 public void setSortOrder_LessThan(Integer sortOrder, ConditionOptionCall<RangeQueryBuilder> opLambda) {
933 final Object _value = sortOrder;
934 RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_THAN, _value);
935 if (opLambda != null) {
936 opLambda.callback(builder);
937 }
938 }
939
940 public void setSortOrder_GreaterEqual(Integer sortOrder) {
941 setSortOrder_GreaterEqual(sortOrder, null);
942 }
943
944 public void setSortOrder_GreaterEqual(Integer sortOrder, ConditionOptionCall<RangeQueryBuilder> opLambda) {
945 final Object _value = sortOrder;
946 RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_GREATER_EQUAL, _value);
947 if (opLambda != null) {
948 opLambda.callback(builder);
949 }
950 }
951
952 public void setSortOrder_LessEqual(Integer sortOrder) {
953 setSortOrder_LessEqual(sortOrder, null);
954 }
955
956 public void setSortOrder_LessEqual(Integer sortOrder, ConditionOptionCall<RangeQueryBuilder> opLambda) {
957 final Object _value = sortOrder;
958 RangeQueryBuilder builder = regRangeQ("sortOrder", ConditionKey.CK_LESS_EQUAL, _value);
959 if (opLambda != null) {
960 opLambda.callback(builder);
961 }
962 }
963
964 public void setSortOrder_Exists() {
965 setSortOrder_Exists(null);
966 }
967
968 public void setSortOrder_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
969 ExistsQueryBuilder builder = regExistsQ("sortOrder");
970 if (opLambda != null) {
971 opLambda.callback(builder);
972 }
973 }
974
975 @Deprecated
976 public void setSortOrder_CommonTerms(Integer sortOrder) {
977 setSortOrder_CommonTerms(sortOrder, null);
978 }
979
980 @Deprecated
981 public void setSortOrder_CommonTerms(Integer sortOrder, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
982 CommonTermsQueryBuilder builder = regCommonTermsQ("sortOrder", sortOrder);
983 if (opLambda != null) {
984 opLambda.callback(builder);
985 }
986 }
987
988 public BsRelatedContentCQ addOrderBy_SortOrder_Asc() {
989 regOBA("sortOrder");
990 return this;
991 }
992
993 public BsRelatedContentCQ addOrderBy_SortOrder_Desc() {
994 regOBD("sortOrder");
995 return this;
996 }
997
998 public void setTerm_Equal(String term) {
999 setTerm_Term(term, null);
1000 }
1001
1002 public void setTerm_Equal(String term, ConditionOptionCall<TermQueryBuilder> opLambda) {
1003 setTerm_Term(term, opLambda);
1004 }
1005
1006 public void setTerm_Term(String term) {
1007 setTerm_Term(term, null);
1008 }
1009
1010 public void setTerm_Term(String term, ConditionOptionCall<TermQueryBuilder> opLambda) {
1011 TermQueryBuilder builder = regTermQ("term", term);
1012 if (opLambda != null) {
1013 opLambda.callback(builder);
1014 }
1015 }
1016
1017 public void setTerm_NotEqual(String term) {
1018 setTerm_NotTerm(term, null);
1019 }
1020
1021 public void setTerm_NotTerm(String term) {
1022 setTerm_NotTerm(term, null);
1023 }
1024
1025 public void setTerm_NotEqual(String term, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1026 setTerm_NotTerm(term, opLambda);
1027 }
1028
1029 public void setTerm_NotTerm(String term, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1030 not(not -> not.setTerm_Term(term), opLambda);
1031 }
1032
1033 public void setTerm_Terms(Collection<String> termList) {
1034 setTerm_Terms(termList, null);
1035 }
1036
1037 public void setTerm_Terms(Collection<String> termList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1038 TermsQueryBuilder builder = regTermsQ("term", termList);
1039 if (opLambda != null) {
1040 opLambda.callback(builder);
1041 }
1042 }
1043
1044 public void setTerm_InScope(Collection<String> termList) {
1045 setTerm_Terms(termList, null);
1046 }
1047
1048 public void setTerm_InScope(Collection<String> termList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1049 setTerm_Terms(termList, opLambda);
1050 }
1051
1052 public void setTerm_Match(String term) {
1053 setTerm_Match(term, null);
1054 }
1055
1056 public void setTerm_Match(String term, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1057 MatchQueryBuilder builder = regMatchQ("term", term);
1058 if (opLambda != null) {
1059 opLambda.callback(builder);
1060 }
1061 }
1062
1063 public void setTerm_MatchPhrase(String term) {
1064 setTerm_MatchPhrase(term, null);
1065 }
1066
1067 public void setTerm_MatchPhrase(String term, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1068 MatchPhraseQueryBuilder builder = regMatchPhraseQ("term", term);
1069 if (opLambda != null) {
1070 opLambda.callback(builder);
1071 }
1072 }
1073
1074 public void setTerm_MatchPhrasePrefix(String term) {
1075 setTerm_MatchPhrasePrefix(term, null);
1076 }
1077
1078 public void setTerm_MatchPhrasePrefix(String term, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1079 MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("term", term);
1080 if (opLambda != null) {
1081 opLambda.callback(builder);
1082 }
1083 }
1084
1085 public void setTerm_Fuzzy(String term) {
1086 setTerm_Fuzzy(term, null);
1087 }
1088
1089 public void setTerm_Fuzzy(String term, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1090 MatchQueryBuilder builder = regFuzzyQ("term", term);
1091 if (opLambda != null) {
1092 opLambda.callback(builder);
1093 }
1094 }
1095
1096 public void setTerm_Prefix(String term) {
1097 setTerm_Prefix(term, null);
1098 }
1099
1100 public void setTerm_Prefix(String term, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
1101 PrefixQueryBuilder builder = regPrefixQ("term", term);
1102 if (opLambda != null) {
1103 opLambda.callback(builder);
1104 }
1105 }
1106
1107 public void setTerm_Wildcard(String term) {
1108 setTerm_Wildcard(term, null);
1109 }
1110
1111 public void setTerm_Wildcard(String term, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
1112 WildcardQueryBuilder builder = regWildcardQ("term", term);
1113 if (opLambda != null) {
1114 opLambda.callback(builder);
1115 }
1116 }
1117
1118 public void setTerm_Regexp(String term) {
1119 setTerm_Regexp(term, null);
1120 }
1121
1122 public void setTerm_Regexp(String term, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
1123 RegexpQueryBuilder builder = regRegexpQ("term", term);
1124 if (opLambda != null) {
1125 opLambda.callback(builder);
1126 }
1127 }
1128
1129 public void setTerm_SpanTerm(String term) {
1130 setTerm_SpanTerm("term", null);
1131 }
1132
1133 public void setTerm_SpanTerm(String term, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
1134 SpanTermQueryBuilder builder = regSpanTermQ("term", term);
1135 if (opLambda != null) {
1136 opLambda.callback(builder);
1137 }
1138 }
1139
1140 public void setTerm_GreaterThan(String term) {
1141 setTerm_GreaterThan(term, null);
1142 }
1143
1144 public void setTerm_GreaterThan(String term, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1145 final Object _value = term;
1146 RangeQueryBuilder builder = regRangeQ("term", ConditionKey.CK_GREATER_THAN, _value);
1147 if (opLambda != null) {
1148 opLambda.callback(builder);
1149 }
1150 }
1151
1152 public void setTerm_LessThan(String term) {
1153 setTerm_LessThan(term, null);
1154 }
1155
1156 public void setTerm_LessThan(String term, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1157 final Object _value = term;
1158 RangeQueryBuilder builder = regRangeQ("term", ConditionKey.CK_LESS_THAN, _value);
1159 if (opLambda != null) {
1160 opLambda.callback(builder);
1161 }
1162 }
1163
1164 public void setTerm_GreaterEqual(String term) {
1165 setTerm_GreaterEqual(term, null);
1166 }
1167
1168 public void setTerm_GreaterEqual(String term, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1169 final Object _value = term;
1170 RangeQueryBuilder builder = regRangeQ("term", ConditionKey.CK_GREATER_EQUAL, _value);
1171 if (opLambda != null) {
1172 opLambda.callback(builder);
1173 }
1174 }
1175
1176 public void setTerm_LessEqual(String term) {
1177 setTerm_LessEqual(term, null);
1178 }
1179
1180 public void setTerm_LessEqual(String term, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1181 final Object _value = term;
1182 RangeQueryBuilder builder = regRangeQ("term", ConditionKey.CK_LESS_EQUAL, _value);
1183 if (opLambda != null) {
1184 opLambda.callback(builder);
1185 }
1186 }
1187
1188 public void setTerm_Exists() {
1189 setTerm_Exists(null);
1190 }
1191
1192 public void setTerm_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
1193 ExistsQueryBuilder builder = regExistsQ("term");
1194 if (opLambda != null) {
1195 opLambda.callback(builder);
1196 }
1197 }
1198
1199 @Deprecated
1200 public void setTerm_CommonTerms(String term) {
1201 setTerm_CommonTerms(term, null);
1202 }
1203
1204 @Deprecated
1205 public void setTerm_CommonTerms(String term, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
1206 CommonTermsQueryBuilder builder = regCommonTermsQ("term", term);
1207 if (opLambda != null) {
1208 opLambda.callback(builder);
1209 }
1210 }
1211
1212 public BsRelatedContentCQ addOrderBy_Term_Asc() {
1213 regOBA("term");
1214 return this;
1215 }
1216
1217 public BsRelatedContentCQ addOrderBy_Term_Desc() {
1218 regOBD("term");
1219 return this;
1220 }
1221
1222 public void setUpdatedBy_Equal(String updatedBy) {
1223 setUpdatedBy_Term(updatedBy, null);
1224 }
1225
1226 public void setUpdatedBy_Equal(String updatedBy, ConditionOptionCall<TermQueryBuilder> opLambda) {
1227 setUpdatedBy_Term(updatedBy, opLambda);
1228 }
1229
1230 public void setUpdatedBy_Term(String updatedBy) {
1231 setUpdatedBy_Term(updatedBy, null);
1232 }
1233
1234 public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall<TermQueryBuilder> opLambda) {
1235 TermQueryBuilder builder = regTermQ("updatedBy", updatedBy);
1236 if (opLambda != null) {
1237 opLambda.callback(builder);
1238 }
1239 }
1240
1241 public void setUpdatedBy_NotEqual(String updatedBy) {
1242 setUpdatedBy_NotTerm(updatedBy, null);
1243 }
1244
1245 public void setUpdatedBy_NotTerm(String updatedBy) {
1246 setUpdatedBy_NotTerm(updatedBy, null);
1247 }
1248
1249 public void setUpdatedBy_NotEqual(String updatedBy, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1250 setUpdatedBy_NotTerm(updatedBy, opLambda);
1251 }
1252
1253 public void setUpdatedBy_NotTerm(String updatedBy, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1254 not(not -> not.setUpdatedBy_Term(updatedBy), opLambda);
1255 }
1256
1257 public void setUpdatedBy_Terms(Collection<String> updatedByList) {
1258 setUpdatedBy_Terms(updatedByList, null);
1259 }
1260
1261 public void setUpdatedBy_Terms(Collection<String> updatedByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1262 TermsQueryBuilder builder = regTermsQ("updatedBy", updatedByList);
1263 if (opLambda != null) {
1264 opLambda.callback(builder);
1265 }
1266 }
1267
1268 public void setUpdatedBy_InScope(Collection<String> updatedByList) {
1269 setUpdatedBy_Terms(updatedByList, null);
1270 }
1271
1272 public void setUpdatedBy_InScope(Collection<String> updatedByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1273 setUpdatedBy_Terms(updatedByList, opLambda);
1274 }
1275
1276 public void setUpdatedBy_Match(String updatedBy) {
1277 setUpdatedBy_Match(updatedBy, null);
1278 }
1279
1280 public void setUpdatedBy_Match(String updatedBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1281 MatchQueryBuilder builder = regMatchQ("updatedBy", updatedBy);
1282 if (opLambda != null) {
1283 opLambda.callback(builder);
1284 }
1285 }
1286
1287 public void setUpdatedBy_MatchPhrase(String updatedBy) {
1288 setUpdatedBy_MatchPhrase(updatedBy, null);
1289 }
1290
1291 public void setUpdatedBy_MatchPhrase(String updatedBy, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1292 MatchPhraseQueryBuilder builder = regMatchPhraseQ("updatedBy", updatedBy);
1293 if (opLambda != null) {
1294 opLambda.callback(builder);
1295 }
1296 }
1297
1298 public void setUpdatedBy_MatchPhrasePrefix(String updatedBy) {
1299 setUpdatedBy_MatchPhrasePrefix(updatedBy, null);
1300 }
1301
1302 public void setUpdatedBy_MatchPhrasePrefix(String updatedBy, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1303 MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("updatedBy", updatedBy);
1304 if (opLambda != null) {
1305 opLambda.callback(builder);
1306 }
1307 }
1308
1309 public void setUpdatedBy_Fuzzy(String updatedBy) {
1310 setUpdatedBy_Fuzzy(updatedBy, null);
1311 }
1312
1313 public void setUpdatedBy_Fuzzy(String updatedBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1314 MatchQueryBuilder builder = regFuzzyQ("updatedBy", updatedBy);
1315 if (opLambda != null) {
1316 opLambda.callback(builder);
1317 }
1318 }
1319
1320 public void setUpdatedBy_Prefix(String updatedBy) {
1321 setUpdatedBy_Prefix(updatedBy, null);
1322 }
1323
1324 public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
1325 PrefixQueryBuilder builder = regPrefixQ("updatedBy", updatedBy);
1326 if (opLambda != null) {
1327 opLambda.callback(builder);
1328 }
1329 }
1330
1331 public void setUpdatedBy_Wildcard(String updatedBy) {
1332 setUpdatedBy_Wildcard(updatedBy, null);
1333 }
1334
1335 public void setUpdatedBy_Wildcard(String updatedBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
1336 WildcardQueryBuilder builder = regWildcardQ("updatedBy", updatedBy);
1337 if (opLambda != null) {
1338 opLambda.callback(builder);
1339 }
1340 }
1341
1342 public void setUpdatedBy_Regexp(String updatedBy) {
1343 setUpdatedBy_Regexp(updatedBy, null);
1344 }
1345
1346 public void setUpdatedBy_Regexp(String updatedBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
1347 RegexpQueryBuilder builder = regRegexpQ("updatedBy", updatedBy);
1348 if (opLambda != null) {
1349 opLambda.callback(builder);
1350 }
1351 }
1352
1353 public void setUpdatedBy_SpanTerm(String updatedBy) {
1354 setUpdatedBy_SpanTerm("updatedBy", null);
1355 }
1356
1357 public void setUpdatedBy_SpanTerm(String updatedBy, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
1358 SpanTermQueryBuilder builder = regSpanTermQ("updatedBy", updatedBy);
1359 if (opLambda != null) {
1360 opLambda.callback(builder);
1361 }
1362 }
1363
1364 public void setUpdatedBy_GreaterThan(String updatedBy) {
1365 setUpdatedBy_GreaterThan(updatedBy, null);
1366 }
1367
1368 public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1369 final Object _value = updatedBy;
1370 RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, _value);
1371 if (opLambda != null) {
1372 opLambda.callback(builder);
1373 }
1374 }
1375
1376 public void setUpdatedBy_LessThan(String updatedBy) {
1377 setUpdatedBy_LessThan(updatedBy, null);
1378 }
1379
1380 public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1381 final Object _value = updatedBy;
1382 RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, _value);
1383 if (opLambda != null) {
1384 opLambda.callback(builder);
1385 }
1386 }
1387
1388 public void setUpdatedBy_GreaterEqual(String updatedBy) {
1389 setUpdatedBy_GreaterEqual(updatedBy, null);
1390 }
1391
1392 public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1393 final Object _value = updatedBy;
1394 RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, _value);
1395 if (opLambda != null) {
1396 opLambda.callback(builder);
1397 }
1398 }
1399
1400 public void setUpdatedBy_LessEqual(String updatedBy) {
1401 setUpdatedBy_LessEqual(updatedBy, null);
1402 }
1403
1404 public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1405 final Object _value = updatedBy;
1406 RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, _value);
1407 if (opLambda != null) {
1408 opLambda.callback(builder);
1409 }
1410 }
1411
1412 public void setUpdatedBy_Exists() {
1413 setUpdatedBy_Exists(null);
1414 }
1415
1416 public void setUpdatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
1417 ExistsQueryBuilder builder = regExistsQ("updatedBy");
1418 if (opLambda != null) {
1419 opLambda.callback(builder);
1420 }
1421 }
1422
1423 @Deprecated
1424 public void setUpdatedBy_CommonTerms(String updatedBy) {
1425 setUpdatedBy_CommonTerms(updatedBy, null);
1426 }
1427
1428 @Deprecated
1429 public void setUpdatedBy_CommonTerms(String updatedBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
1430 CommonTermsQueryBuilder builder = regCommonTermsQ("updatedBy", updatedBy);
1431 if (opLambda != null) {
1432 opLambda.callback(builder);
1433 }
1434 }
1435
1436 public BsRelatedContentCQ addOrderBy_UpdatedBy_Asc() {
1437 regOBA("updatedBy");
1438 return this;
1439 }
1440
1441 public BsRelatedContentCQ addOrderBy_UpdatedBy_Desc() {
1442 regOBD("updatedBy");
1443 return this;
1444 }
1445
1446 public void setUpdatedTime_Equal(Long updatedTime) {
1447 setUpdatedTime_Term(updatedTime, null);
1448 }
1449
1450 public void setUpdatedTime_Equal(Long updatedTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
1451 setUpdatedTime_Term(updatedTime, opLambda);
1452 }
1453
1454 public void setUpdatedTime_Term(Long updatedTime) {
1455 setUpdatedTime_Term(updatedTime, null);
1456 }
1457
1458 public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
1459 TermQueryBuilder builder = regTermQ("updatedTime", updatedTime);
1460 if (opLambda != null) {
1461 opLambda.callback(builder);
1462 }
1463 }
1464
1465 public void setUpdatedTime_NotEqual(Long updatedTime) {
1466 setUpdatedTime_NotTerm(updatedTime, null);
1467 }
1468
1469 public void setUpdatedTime_NotTerm(Long updatedTime) {
1470 setUpdatedTime_NotTerm(updatedTime, null);
1471 }
1472
1473 public void setUpdatedTime_NotEqual(Long updatedTime, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1474 setUpdatedTime_NotTerm(updatedTime, opLambda);
1475 }
1476
1477 public void setUpdatedTime_NotTerm(Long updatedTime, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1478 not(not -> not.setUpdatedTime_Term(updatedTime), opLambda);
1479 }
1480
1481 public void setUpdatedTime_Terms(Collection<Long> updatedTimeList) {
1482 setUpdatedTime_Terms(updatedTimeList, null);
1483 }
1484
1485 public void setUpdatedTime_Terms(Collection<Long> updatedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1486 TermsQueryBuilder builder = regTermsQ("updatedTime", updatedTimeList);
1487 if (opLambda != null) {
1488 opLambda.callback(builder);
1489 }
1490 }
1491
1492 public void setUpdatedTime_InScope(Collection<Long> updatedTimeList) {
1493 setUpdatedTime_Terms(updatedTimeList, null);
1494 }
1495
1496 public void setUpdatedTime_InScope(Collection<Long> updatedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1497 setUpdatedTime_Terms(updatedTimeList, opLambda);
1498 }
1499
1500 public void setUpdatedTime_Match(Long updatedTime) {
1501 setUpdatedTime_Match(updatedTime, null);
1502 }
1503
1504 public void setUpdatedTime_Match(Long updatedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1505 MatchQueryBuilder builder = regMatchQ("updatedTime", updatedTime);
1506 if (opLambda != null) {
1507 opLambda.callback(builder);
1508 }
1509 }
1510
1511 public void setUpdatedTime_MatchPhrase(Long updatedTime) {
1512 setUpdatedTime_MatchPhrase(updatedTime, null);
1513 }
1514
1515 public void setUpdatedTime_MatchPhrase(Long updatedTime, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1516 MatchPhraseQueryBuilder builder = regMatchPhraseQ("updatedTime", updatedTime);
1517 if (opLambda != null) {
1518 opLambda.callback(builder);
1519 }
1520 }
1521
1522 public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime) {
1523 setUpdatedTime_MatchPhrasePrefix(updatedTime, null);
1524 }
1525
1526 public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1527 MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("updatedTime", updatedTime);
1528 if (opLambda != null) {
1529 opLambda.callback(builder);
1530 }
1531 }
1532
1533 public void setUpdatedTime_Fuzzy(Long updatedTime) {
1534 setUpdatedTime_Fuzzy(updatedTime, null);
1535 }
1536
1537 public void setUpdatedTime_Fuzzy(Long updatedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1538 MatchQueryBuilder builder = regFuzzyQ("updatedTime", updatedTime);
1539 if (opLambda != null) {
1540 opLambda.callback(builder);
1541 }
1542 }
1543
1544 public void setUpdatedTime_GreaterThan(Long updatedTime) {
1545 setUpdatedTime_GreaterThan(updatedTime, null);
1546 }
1547
1548 public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1549 final Object _value = updatedTime;
1550 RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, _value);
1551 if (opLambda != null) {
1552 opLambda.callback(builder);
1553 }
1554 }
1555
1556 public void setUpdatedTime_LessThan(Long updatedTime) {
1557 setUpdatedTime_LessThan(updatedTime, null);
1558 }
1559
1560 public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1561 final Object _value = updatedTime;
1562 RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, _value);
1563 if (opLambda != null) {
1564 opLambda.callback(builder);
1565 }
1566 }
1567
1568 public void setUpdatedTime_GreaterEqual(Long updatedTime) {
1569 setUpdatedTime_GreaterEqual(updatedTime, null);
1570 }
1571
1572 public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1573 final Object _value = updatedTime;
1574 RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, _value);
1575 if (opLambda != null) {
1576 opLambda.callback(builder);
1577 }
1578 }
1579
1580 public void setUpdatedTime_LessEqual(Long updatedTime) {
1581 setUpdatedTime_LessEqual(updatedTime, null);
1582 }
1583
1584 public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1585 final Object _value = updatedTime;
1586 RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, _value);
1587 if (opLambda != null) {
1588 opLambda.callback(builder);
1589 }
1590 }
1591
1592 public void setUpdatedTime_Exists() {
1593 setUpdatedTime_Exists(null);
1594 }
1595
1596 public void setUpdatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
1597 ExistsQueryBuilder builder = regExistsQ("updatedTime");
1598 if (opLambda != null) {
1599 opLambda.callback(builder);
1600 }
1601 }
1602
1603 @Deprecated
1604 public void setUpdatedTime_CommonTerms(Long updatedTime) {
1605 setUpdatedTime_CommonTerms(updatedTime, null);
1606 }
1607
1608 @Deprecated
1609 public void setUpdatedTime_CommonTerms(Long updatedTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
1610 CommonTermsQueryBuilder builder = regCommonTermsQ("updatedTime", updatedTime);
1611 if (opLambda != null) {
1612 opLambda.callback(builder);
1613 }
1614 }
1615
1616 public BsRelatedContentCQ addOrderBy_UpdatedTime_Asc() {
1617 regOBA("updatedTime");
1618 return this;
1619 }
1620
1621 public BsRelatedContentCQ addOrderBy_UpdatedTime_Desc() {
1622 regOBD("updatedTime");
1623 return this;
1624 }
1625
1626 public void setVirtualHost_Equal(String virtualHost) {
1627 setVirtualHost_Term(virtualHost, null);
1628 }
1629
1630 public void setVirtualHost_Equal(String virtualHost, ConditionOptionCall<TermQueryBuilder> opLambda) {
1631 setVirtualHost_Term(virtualHost, opLambda);
1632 }
1633
1634 public void setVirtualHost_Term(String virtualHost) {
1635 setVirtualHost_Term(virtualHost, null);
1636 }
1637
1638 public void setVirtualHost_Term(String virtualHost, ConditionOptionCall<TermQueryBuilder> opLambda) {
1639 TermQueryBuilder builder = regTermQ("virtualHost", virtualHost);
1640 if (opLambda != null) {
1641 opLambda.callback(builder);
1642 }
1643 }
1644
1645 public void setVirtualHost_NotEqual(String virtualHost) {
1646 setVirtualHost_NotTerm(virtualHost, null);
1647 }
1648
1649 public void setVirtualHost_NotTerm(String virtualHost) {
1650 setVirtualHost_NotTerm(virtualHost, null);
1651 }
1652
1653 public void setVirtualHost_NotEqual(String virtualHost, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1654 setVirtualHost_NotTerm(virtualHost, opLambda);
1655 }
1656
1657 public void setVirtualHost_NotTerm(String virtualHost, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1658 not(not -> not.setVirtualHost_Term(virtualHost), opLambda);
1659 }
1660
1661 public void setVirtualHost_Terms(Collection<String> virtualHostList) {
1662 setVirtualHost_Terms(virtualHostList, null);
1663 }
1664
1665 public void setVirtualHost_Terms(Collection<String> virtualHostList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1666 TermsQueryBuilder builder = regTermsQ("virtualHost", virtualHostList);
1667 if (opLambda != null) {
1668 opLambda.callback(builder);
1669 }
1670 }
1671
1672 public void setVirtualHost_InScope(Collection<String> virtualHostList) {
1673 setVirtualHost_Terms(virtualHostList, null);
1674 }
1675
1676 public void setVirtualHost_InScope(Collection<String> virtualHostList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1677 setVirtualHost_Terms(virtualHostList, opLambda);
1678 }
1679
1680 public void setVirtualHost_Match(String virtualHost) {
1681 setVirtualHost_Match(virtualHost, null);
1682 }
1683
1684 public void setVirtualHost_Match(String virtualHost, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1685 MatchQueryBuilder builder = regMatchQ("virtualHost", virtualHost);
1686 if (opLambda != null) {
1687 opLambda.callback(builder);
1688 }
1689 }
1690
1691 public void setVirtualHost_MatchPhrase(String virtualHost) {
1692 setVirtualHost_MatchPhrase(virtualHost, null);
1693 }
1694
1695 public void setVirtualHost_MatchPhrase(String virtualHost, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1696 MatchPhraseQueryBuilder builder = regMatchPhraseQ("virtualHost", virtualHost);
1697 if (opLambda != null) {
1698 opLambda.callback(builder);
1699 }
1700 }
1701
1702 public void setVirtualHost_MatchPhrasePrefix(String virtualHost) {
1703 setVirtualHost_MatchPhrasePrefix(virtualHost, null);
1704 }
1705
1706 public void setVirtualHost_MatchPhrasePrefix(String virtualHost, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1707 MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("virtualHost", virtualHost);
1708 if (opLambda != null) {
1709 opLambda.callback(builder);
1710 }
1711 }
1712
1713 public void setVirtualHost_Fuzzy(String virtualHost) {
1714 setVirtualHost_Fuzzy(virtualHost, null);
1715 }
1716
1717 public void setVirtualHost_Fuzzy(String virtualHost, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1718 MatchQueryBuilder builder = regFuzzyQ("virtualHost", virtualHost);
1719 if (opLambda != null) {
1720 opLambda.callback(builder);
1721 }
1722 }
1723
1724 public void setVirtualHost_Prefix(String virtualHost) {
1725 setVirtualHost_Prefix(virtualHost, null);
1726 }
1727
1728 public void setVirtualHost_Prefix(String virtualHost, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
1729 PrefixQueryBuilder builder = regPrefixQ("virtualHost", virtualHost);
1730 if (opLambda != null) {
1731 opLambda.callback(builder);
1732 }
1733 }
1734
1735 public void setVirtualHost_Wildcard(String virtualHost) {
1736 setVirtualHost_Wildcard(virtualHost, null);
1737 }
1738
1739 public void setVirtualHost_Wildcard(String virtualHost, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
1740 WildcardQueryBuilder builder = regWildcardQ("virtualHost", virtualHost);
1741 if (opLambda != null) {
1742 opLambda.callback(builder);
1743 }
1744 }
1745
1746 public void setVirtualHost_Regexp(String virtualHost) {
1747 setVirtualHost_Regexp(virtualHost, null);
1748 }
1749
1750 public void setVirtualHost_Regexp(String virtualHost, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
1751 RegexpQueryBuilder builder = regRegexpQ("virtualHost", virtualHost);
1752 if (opLambda != null) {
1753 opLambda.callback(builder);
1754 }
1755 }
1756
1757 public void setVirtualHost_SpanTerm(String virtualHost) {
1758 setVirtualHost_SpanTerm("virtualHost", null);
1759 }
1760
1761 public void setVirtualHost_SpanTerm(String virtualHost, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
1762 SpanTermQueryBuilder builder = regSpanTermQ("virtualHost", virtualHost);
1763 if (opLambda != null) {
1764 opLambda.callback(builder);
1765 }
1766 }
1767
1768 public void setVirtualHost_GreaterThan(String virtualHost) {
1769 setVirtualHost_GreaterThan(virtualHost, null);
1770 }
1771
1772 public void setVirtualHost_GreaterThan(String virtualHost, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1773 final Object _value = virtualHost;
1774 RangeQueryBuilder builder = regRangeQ("virtualHost", ConditionKey.CK_GREATER_THAN, _value);
1775 if (opLambda != null) {
1776 opLambda.callback(builder);
1777 }
1778 }
1779
1780 public void setVirtualHost_LessThan(String virtualHost) {
1781 setVirtualHost_LessThan(virtualHost, null);
1782 }
1783
1784 public void setVirtualHost_LessThan(String virtualHost, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1785 final Object _value = virtualHost;
1786 RangeQueryBuilder builder = regRangeQ("virtualHost", ConditionKey.CK_LESS_THAN, _value);
1787 if (opLambda != null) {
1788 opLambda.callback(builder);
1789 }
1790 }
1791
1792 public void setVirtualHost_GreaterEqual(String virtualHost) {
1793 setVirtualHost_GreaterEqual(virtualHost, null);
1794 }
1795
1796 public void setVirtualHost_GreaterEqual(String virtualHost, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1797 final Object _value = virtualHost;
1798 RangeQueryBuilder builder = regRangeQ("virtualHost", ConditionKey.CK_GREATER_EQUAL, _value);
1799 if (opLambda != null) {
1800 opLambda.callback(builder);
1801 }
1802 }
1803
1804 public void setVirtualHost_LessEqual(String virtualHost) {
1805 setVirtualHost_LessEqual(virtualHost, null);
1806 }
1807
1808 public void setVirtualHost_LessEqual(String virtualHost, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1809 final Object _value = virtualHost;
1810 RangeQueryBuilder builder = regRangeQ("virtualHost", ConditionKey.CK_LESS_EQUAL, _value);
1811 if (opLambda != null) {
1812 opLambda.callback(builder);
1813 }
1814 }
1815
1816 public void setVirtualHost_Exists() {
1817 setVirtualHost_Exists(null);
1818 }
1819
1820 public void setVirtualHost_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
1821 ExistsQueryBuilder builder = regExistsQ("virtualHost");
1822 if (opLambda != null) {
1823 opLambda.callback(builder);
1824 }
1825 }
1826
1827 @Deprecated
1828 public void setVirtualHost_CommonTerms(String virtualHost) {
1829 setVirtualHost_CommonTerms(virtualHost, null);
1830 }
1831
1832 @Deprecated
1833 public void setVirtualHost_CommonTerms(String virtualHost, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
1834 CommonTermsQueryBuilder builder = regCommonTermsQ("virtualHost", virtualHost);
1835 if (opLambda != null) {
1836 opLambda.callback(builder);
1837 }
1838 }
1839
1840 public BsRelatedContentCQ addOrderBy_VirtualHost_Asc() {
1841 regOBA("virtualHost");
1842 return this;
1843 }
1844
1845 public BsRelatedContentCQ addOrderBy_VirtualHost_Desc() {
1846 regOBD("virtualHost");
1847 return this;
1848 }
1849
1850 }