View Javadoc
1   /*
2    * Copyright 2012-2021 CodeLibs Project and the Others.
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    *     http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
13   * either express or implied. See the License for the specific language
14   * governing permissions and limitations under the License.
15   */
16  package org.codelibs.fess.es.config.cbean.ca.bs;
17  
18  import org.codelibs.fesen.search.aggregations.bucket.filter.FilterAggregationBuilder;
19  import org.codelibs.fesen.search.aggregations.bucket.global.GlobalAggregationBuilder;
20  import org.codelibs.fesen.search.aggregations.bucket.missing.MissingAggregationBuilder;
21  import org.codelibs.fesen.search.aggregations.bucket.range.IpRangeAggregationBuilder;
22  import org.codelibs.fesen.search.aggregations.bucket.sampler.SamplerAggregationBuilder;
23  import org.codelibs.fesen.search.aggregations.bucket.terms.SignificantTermsAggregationBuilder;
24  import org.codelibs.fesen.search.aggregations.bucket.terms.TermsAggregationBuilder;
25  import org.codelibs.fesen.search.aggregations.metrics.CardinalityAggregationBuilder;
26  import org.codelibs.fesen.search.aggregations.metrics.ScriptedMetricAggregationBuilder;
27  import org.codelibs.fesen.search.aggregations.metrics.TopHitsAggregationBuilder;
28  import org.codelibs.fesen.search.aggregations.metrics.ValueCountAggregationBuilder;
29  import org.codelibs.fess.es.config.allcommon.EsAbstractConditionAggregation;
30  import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
31  import org.codelibs.fess.es.config.cbean.ca.ElevateWordToLabelCA;
32  import org.codelibs.fess.es.config.cbean.cq.ElevateWordToLabelCQ;
33  import org.codelibs.fess.es.config.cbean.cq.bs.BsElevateWordToLabelCQ;
34  
35  /**
36   * @author ESFlute (using FreeGen)
37   */
38  public abstract class BsElevateWordToLabelCA extends EsAbstractConditionAggregation {
39  
40      // ===================================================================================
41      //                                                                     Aggregation Set
42      //                                                                           =========
43  
44      public void filter(String name, EsAbstractConditionQuery.OperatorCall<BsElevateWordToLabelCQ> queryLambda,
45              ConditionOptionCall<FilterAggregationBuilder> opLambda, OperatorCall<BsElevateWordToLabelCA> aggsLambda) {
46          ElevateWordToLabelCQ cq = new ElevateWordToLabelCQ();
47          if (queryLambda != null) {
48              queryLambda.callback(cq);
49          }
50          FilterAggregationBuilder builder = regFilterA(name, cq.getQuery());
51          if (opLambda != null) {
52              opLambda.callback(builder);
53          }
54          if (aggsLambda != null) {
55              ElevateWordToLabelCA ca = new ElevateWordToLabelCA();
56              aggsLambda.callback(ca);
57              ca.getAggregationBuilderList().forEach(builder::subAggregation);
58          }
59      }
60  
61      public void global(String name, ConditionOptionCall<GlobalAggregationBuilder> opLambda,
62              OperatorCall<BsElevateWordToLabelCA> aggsLambda) {
63          GlobalAggregationBuilder builder = regGlobalA(name);
64          if (opLambda != null) {
65              opLambda.callback(builder);
66          }
67          if (aggsLambda != null) {
68              ElevateWordToLabelCA ca = new ElevateWordToLabelCA();
69              aggsLambda.callback(ca);
70              ca.getAggregationBuilderList().forEach(builder::subAggregation);
71          }
72      }
73  
74      public void sampler(String name, ConditionOptionCall<SamplerAggregationBuilder> opLambda,
75              OperatorCall<BsElevateWordToLabelCA> aggsLambda) {
76          SamplerAggregationBuilder builder = regSamplerA(name);
77          if (opLambda != null) {
78              opLambda.callback(builder);
79          }
80          if (aggsLambda != null) {
81              ElevateWordToLabelCA ca = new ElevateWordToLabelCA();
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 setElevateWordId_Terms() {
102         setElevateWordId_Terms(null);
103     }
104 
105     public void setElevateWordId_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
106         setElevateWordId_Terms("elevateWordId", opLambda, null);
107     }
108 
109     public void setElevateWordId_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda,
110             OperatorCall<BsElevateWordToLabelCA> aggsLambda) {
111         setElevateWordId_Terms("elevateWordId", opLambda, aggsLambda);
112     }
113 
114     public void setElevateWordId_Terms(String name, ConditionOptionCall<TermsAggregationBuilder> opLambda,
115             OperatorCall<BsElevateWordToLabelCA> aggsLambda) {
116         TermsAggregationBuilder builder = regTermsA(name, "elevateWordId");
117         if (opLambda != null) {
118             opLambda.callback(builder);
119         }
120         if (aggsLambda != null) {
121             ElevateWordToLabelCA ca = new ElevateWordToLabelCA();
122             aggsLambda.callback(ca);
123             ca.getAggregationBuilderList().forEach(builder::subAggregation);
124         }
125     }
126 
127     public void setElevateWordId_SignificantTerms() {
128         setElevateWordId_SignificantTerms(null);
129     }
130 
131     public void setElevateWordId_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda) {
132         setElevateWordId_SignificantTerms("elevateWordId", opLambda, null);
133     }
134 
135     public void setElevateWordId_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
136             OperatorCall<BsElevateWordToLabelCA> aggsLambda) {
137         setElevateWordId_SignificantTerms("elevateWordId", opLambda, aggsLambda);
138     }
139 
140     public void setElevateWordId_SignificantTerms(String name, ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
141             OperatorCall<BsElevateWordToLabelCA> aggsLambda) {
142         SignificantTermsAggregationBuilder builder = regSignificantTermsA(name, "elevateWordId");
143         if (opLambda != null) {
144             opLambda.callback(builder);
145         }
146         if (aggsLambda != null) {
147             ElevateWordToLabelCA ca = new ElevateWordToLabelCA();
148             aggsLambda.callback(ca);
149             ca.getAggregationBuilderList().forEach(builder::subAggregation);
150         }
151     }
152 
153     public void setElevateWordId_IpRange() {
154         setElevateWordId_IpRange(null);
155     }
156 
157     public void setElevateWordId_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda) {
158         setElevateWordId_IpRange("elevateWordId", opLambda, null);
159     }
160 
161     public void setElevateWordId_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
162             OperatorCall<BsElevateWordToLabelCA> aggsLambda) {
163         setElevateWordId_IpRange("elevateWordId", opLambda, aggsLambda);
164     }
165 
166     public void setElevateWordId_IpRange(String name, ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
167             OperatorCall<BsElevateWordToLabelCA> aggsLambda) {
168         IpRangeAggregationBuilder builder = regIpRangeA(name, "elevateWordId");
169         if (opLambda != null) {
170             opLambda.callback(builder);
171         }
172         if (aggsLambda != null) {
173             ElevateWordToLabelCA ca = new ElevateWordToLabelCA();
174             aggsLambda.callback(ca);
175             ca.getAggregationBuilderList().forEach(builder::subAggregation);
176         }
177     }
178 
179     public void setElevateWordId_Count() {
180         setElevateWordId_Count(null);
181     }
182 
183     public void setElevateWordId_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
184         setElevateWordId_Count("elevateWordId", opLambda);
185     }
186 
187     public void setElevateWordId_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
188         ValueCountAggregationBuilder builder = regCountA(name, "elevateWordId");
189         if (opLambda != null) {
190             opLambda.callback(builder);
191         }
192     }
193 
194     public void setElevateWordId_Cardinality() {
195         setElevateWordId_Cardinality(null);
196     }
197 
198     public void setElevateWordId_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
199         setElevateWordId_Cardinality("elevateWordId", opLambda);
200     }
201 
202     public void setElevateWordId_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
203         CardinalityAggregationBuilder builder = regCardinalityA(name, "elevateWordId");
204         if (opLambda != null) {
205             opLambda.callback(builder);
206         }
207     }
208 
209     public void setElevateWordId_Missing() {
210         setElevateWordId_Missing(null);
211     }
212 
213     public void setElevateWordId_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
214         setElevateWordId_Missing("elevateWordId", opLambda, null);
215     }
216 
217     public void setElevateWordId_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda,
218             OperatorCall<BsElevateWordToLabelCA> aggsLambda) {
219         setElevateWordId_Missing("elevateWordId", opLambda, aggsLambda);
220     }
221 
222     public void setElevateWordId_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
223             OperatorCall<BsElevateWordToLabelCA> aggsLambda) {
224         MissingAggregationBuilder builder = regMissingA(name, "elevateWordId");
225         if (opLambda != null) {
226             opLambda.callback(builder);
227         }
228         if (aggsLambda != null) {
229             ElevateWordToLabelCA ca = new ElevateWordToLabelCA();
230             aggsLambda.callback(ca);
231             ca.getAggregationBuilderList().forEach(builder::subAggregation);
232         }
233     }
234 
235     public void setLabelTypeId_Terms() {
236         setLabelTypeId_Terms(null);
237     }
238 
239     public void setLabelTypeId_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
240         setLabelTypeId_Terms("labelTypeId", opLambda, null);
241     }
242 
243     public void setLabelTypeId_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda,
244             OperatorCall<BsElevateWordToLabelCA> aggsLambda) {
245         setLabelTypeId_Terms("labelTypeId", opLambda, aggsLambda);
246     }
247 
248     public void setLabelTypeId_Terms(String name, ConditionOptionCall<TermsAggregationBuilder> opLambda,
249             OperatorCall<BsElevateWordToLabelCA> aggsLambda) {
250         TermsAggregationBuilder builder = regTermsA(name, "labelTypeId");
251         if (opLambda != null) {
252             opLambda.callback(builder);
253         }
254         if (aggsLambda != null) {
255             ElevateWordToLabelCA ca = new ElevateWordToLabelCA();
256             aggsLambda.callback(ca);
257             ca.getAggregationBuilderList().forEach(builder::subAggregation);
258         }
259     }
260 
261     public void setLabelTypeId_SignificantTerms() {
262         setLabelTypeId_SignificantTerms(null);
263     }
264 
265     public void setLabelTypeId_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda) {
266         setLabelTypeId_SignificantTerms("labelTypeId", opLambda, null);
267     }
268 
269     public void setLabelTypeId_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
270             OperatorCall<BsElevateWordToLabelCA> aggsLambda) {
271         setLabelTypeId_SignificantTerms("labelTypeId", opLambda, aggsLambda);
272     }
273 
274     public void setLabelTypeId_SignificantTerms(String name, ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
275             OperatorCall<BsElevateWordToLabelCA> aggsLambda) {
276         SignificantTermsAggregationBuilder builder = regSignificantTermsA(name, "labelTypeId");
277         if (opLambda != null) {
278             opLambda.callback(builder);
279         }
280         if (aggsLambda != null) {
281             ElevateWordToLabelCA ca = new ElevateWordToLabelCA();
282             aggsLambda.callback(ca);
283             ca.getAggregationBuilderList().forEach(builder::subAggregation);
284         }
285     }
286 
287     public void setLabelTypeId_IpRange() {
288         setLabelTypeId_IpRange(null);
289     }
290 
291     public void setLabelTypeId_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda) {
292         setLabelTypeId_IpRange("labelTypeId", opLambda, null);
293     }
294 
295     public void setLabelTypeId_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
296             OperatorCall<BsElevateWordToLabelCA> aggsLambda) {
297         setLabelTypeId_IpRange("labelTypeId", opLambda, aggsLambda);
298     }
299 
300     public void setLabelTypeId_IpRange(String name, ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
301             OperatorCall<BsElevateWordToLabelCA> aggsLambda) {
302         IpRangeAggregationBuilder builder = regIpRangeA(name, "labelTypeId");
303         if (opLambda != null) {
304             opLambda.callback(builder);
305         }
306         if (aggsLambda != null) {
307             ElevateWordToLabelCA ca = new ElevateWordToLabelCA();
308             aggsLambda.callback(ca);
309             ca.getAggregationBuilderList().forEach(builder::subAggregation);
310         }
311     }
312 
313     public void setLabelTypeId_Count() {
314         setLabelTypeId_Count(null);
315     }
316 
317     public void setLabelTypeId_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
318         setLabelTypeId_Count("labelTypeId", opLambda);
319     }
320 
321     public void setLabelTypeId_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
322         ValueCountAggregationBuilder builder = regCountA(name, "labelTypeId");
323         if (opLambda != null) {
324             opLambda.callback(builder);
325         }
326     }
327 
328     public void setLabelTypeId_Cardinality() {
329         setLabelTypeId_Cardinality(null);
330     }
331 
332     public void setLabelTypeId_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
333         setLabelTypeId_Cardinality("labelTypeId", opLambda);
334     }
335 
336     public void setLabelTypeId_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
337         CardinalityAggregationBuilder builder = regCardinalityA(name, "labelTypeId");
338         if (opLambda != null) {
339             opLambda.callback(builder);
340         }
341     }
342 
343     public void setLabelTypeId_Missing() {
344         setLabelTypeId_Missing(null);
345     }
346 
347     public void setLabelTypeId_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
348         setLabelTypeId_Missing("labelTypeId", opLambda, null);
349     }
350 
351     public void setLabelTypeId_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda,
352             OperatorCall<BsElevateWordToLabelCA> aggsLambda) {
353         setLabelTypeId_Missing("labelTypeId", opLambda, aggsLambda);
354     }
355 
356     public void setLabelTypeId_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
357             OperatorCall<BsElevateWordToLabelCA> aggsLambda) {
358         MissingAggregationBuilder builder = regMissingA(name, "labelTypeId");
359         if (opLambda != null) {
360             opLambda.callback(builder);
361         }
362         if (aggsLambda != null) {
363             ElevateWordToLabelCA ca = new ElevateWordToLabelCA();
364             aggsLambda.callback(ca);
365             ca.getAggregationBuilderList().forEach(builder::subAggregation);
366         }
367     }
368 
369 }