View Javadoc
1   /*
2    * Copyright 2012-2017 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.fess.es.config.allcommon.EsAbstractConditionAggregation;
19  import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
20  import org.codelibs.fess.es.config.cbean.ca.LabelToRoleCA;
21  import org.codelibs.fess.es.config.cbean.cq.LabelToRoleCQ;
22  import org.codelibs.fess.es.config.cbean.cq.bs.BsLabelToRoleCQ;
23  import org.elasticsearch.search.aggregations.bucket.filter.FilterAggregationBuilder;
24  import org.elasticsearch.search.aggregations.bucket.global.GlobalAggregationBuilder;
25  import org.elasticsearch.search.aggregations.bucket.missing.MissingAggregationBuilder;
26  import org.elasticsearch.search.aggregations.bucket.range.ip.IpRangeAggregationBuilder;
27  import org.elasticsearch.search.aggregations.bucket.sampler.SamplerAggregationBuilder;
28  import org.elasticsearch.search.aggregations.bucket.significant.SignificantTermsAggregationBuilder;
29  import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
30  import org.elasticsearch.search.aggregations.metrics.cardinality.CardinalityAggregationBuilder;
31  import org.elasticsearch.search.aggregations.metrics.scripted.ScriptedMetricAggregationBuilder;
32  import org.elasticsearch.search.aggregations.metrics.tophits.TopHitsAggregationBuilder;
33  import org.elasticsearch.search.aggregations.metrics.valuecount.ValueCountAggregationBuilder;
34  
35  /**
36   * @author ESFlute (using FreeGen)
37   */
38  public abstract class BsLabelToRoleCA extends EsAbstractConditionAggregation {
39  
40      // ===================================================================================
41      //                                                                     Aggregation Set
42      //                                                                           =========
43  
44      public void filter(String name, EsAbstractConditionQuery.OperatorCall<BsLabelToRoleCQ> queryLambda,
45              ConditionOptionCall<FilterAggregationBuilder> opLambda, OperatorCall<BsLabelToRoleCA> aggsLambda) {
46          LabelToRoleCQ cq = new LabelToRoleCQ();
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              LabelToRoleCA ca = new LabelToRoleCA();
56              aggsLambda.callback(ca);
57              ca.getAggregationBuilderList().forEach(builder::subAggregation);
58          }
59      }
60  
61      public void global(String name, ConditionOptionCall<GlobalAggregationBuilder> opLambda, OperatorCall<BsLabelToRoleCA> aggsLambda) {
62          GlobalAggregationBuilder builder = regGlobalA(name);
63          if (opLambda != null) {
64              opLambda.callback(builder);
65          }
66          if (aggsLambda != null) {
67              LabelToRoleCA ca = new LabelToRoleCA();
68              aggsLambda.callback(ca);
69              ca.getAggregationBuilderList().forEach(builder::subAggregation);
70          }
71      }
72  
73      public void sampler(String name, ConditionOptionCall<SamplerAggregationBuilder> opLambda, OperatorCall<BsLabelToRoleCA> aggsLambda) {
74          SamplerAggregationBuilder builder = regSamplerA(name);
75          if (opLambda != null) {
76              opLambda.callback(builder);
77          }
78          if (aggsLambda != null) {
79              LabelToRoleCA ca = new LabelToRoleCA();
80              aggsLambda.callback(ca);
81              ca.getAggregationBuilderList().forEach(builder::subAggregation);
82          }
83      }
84  
85      public void scriptedMetric(String name, ConditionOptionCall<ScriptedMetricAggregationBuilder> opLambda) {
86          ScriptedMetricAggregationBuilder builder = regScriptedMetricA(name);
87          if (opLambda != null) {
88              opLambda.callback(builder);
89          }
90      }
91  
92      public void topHits(String name, ConditionOptionCall<TopHitsAggregationBuilder> opLambda) {
93          TopHitsAggregationBuilder builder = regTopHitsA(name);
94          if (opLambda != null) {
95              opLambda.callback(builder);
96          }
97      }
98  
99      public void setLabelTypeId_Terms() {
100         setLabelTypeId_Terms(null);
101     }
102 
103     public void setLabelTypeId_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
104         setLabelTypeId_Terms("labelTypeId", opLambda, null);
105     }
106 
107     public void setLabelTypeId_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsLabelToRoleCA> aggsLambda) {
108         setLabelTypeId_Terms("labelTypeId", opLambda, aggsLambda);
109     }
110 
111     public void setLabelTypeId_Terms(String name, ConditionOptionCall<TermsAggregationBuilder> opLambda,
112             OperatorCall<BsLabelToRoleCA> aggsLambda) {
113         TermsAggregationBuilder builder = regTermsA(name, "labelTypeId");
114         if (opLambda != null) {
115             opLambda.callback(builder);
116         }
117         if (aggsLambda != null) {
118             LabelToRoleCA ca = new LabelToRoleCA();
119             aggsLambda.callback(ca);
120             ca.getAggregationBuilderList().forEach(builder::subAggregation);
121         }
122     }
123 
124     public void setLabelTypeId_SignificantTerms() {
125         setLabelTypeId_SignificantTerms(null);
126     }
127 
128     public void setLabelTypeId_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda) {
129         setLabelTypeId_SignificantTerms("labelTypeId", opLambda, null);
130     }
131 
132     public void setLabelTypeId_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
133             OperatorCall<BsLabelToRoleCA> aggsLambda) {
134         setLabelTypeId_SignificantTerms("labelTypeId", opLambda, aggsLambda);
135     }
136 
137     public void setLabelTypeId_SignificantTerms(String name, ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
138             OperatorCall<BsLabelToRoleCA> aggsLambda) {
139         SignificantTermsAggregationBuilder builder = regSignificantTermsA(name, "labelTypeId");
140         if (opLambda != null) {
141             opLambda.callback(builder);
142         }
143         if (aggsLambda != null) {
144             LabelToRoleCA ca = new LabelToRoleCA();
145             aggsLambda.callback(ca);
146             ca.getAggregationBuilderList().forEach(builder::subAggregation);
147         }
148     }
149 
150     public void setLabelTypeId_IpRange() {
151         setLabelTypeId_IpRange(null);
152     }
153 
154     public void setLabelTypeId_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda) {
155         setLabelTypeId_IpRange("labelTypeId", opLambda, null);
156     }
157 
158     public void setLabelTypeId_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda, OperatorCall<BsLabelToRoleCA> aggsLambda) {
159         setLabelTypeId_IpRange("labelTypeId", opLambda, aggsLambda);
160     }
161 
162     public void setLabelTypeId_IpRange(String name, ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
163             OperatorCall<BsLabelToRoleCA> aggsLambda) {
164         IpRangeAggregationBuilder builder = regIpRangeA(name, "labelTypeId");
165         if (opLambda != null) {
166             opLambda.callback(builder);
167         }
168         if (aggsLambda != null) {
169             LabelToRoleCA ca = new LabelToRoleCA();
170             aggsLambda.callback(ca);
171             ca.getAggregationBuilderList().forEach(builder::subAggregation);
172         }
173     }
174 
175     public void setLabelTypeId_Count() {
176         setLabelTypeId_Count(null);
177     }
178 
179     public void setLabelTypeId_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
180         setLabelTypeId_Count("labelTypeId", opLambda);
181     }
182 
183     public void setLabelTypeId_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
184         ValueCountAggregationBuilder builder = regCountA(name, "labelTypeId");
185         if (opLambda != null) {
186             opLambda.callback(builder);
187         }
188     }
189 
190     public void setLabelTypeId_Cardinality() {
191         setLabelTypeId_Cardinality(null);
192     }
193 
194     public void setLabelTypeId_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
195         setLabelTypeId_Cardinality("labelTypeId", opLambda);
196     }
197 
198     public void setLabelTypeId_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
199         CardinalityAggregationBuilder builder = regCardinalityA(name, "labelTypeId");
200         if (opLambda != null) {
201             opLambda.callback(builder);
202         }
203     }
204 
205     public void setLabelTypeId_Missing() {
206         setLabelTypeId_Missing(null);
207     }
208 
209     public void setLabelTypeId_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
210         setLabelTypeId_Missing("labelTypeId", opLambda, null);
211     }
212 
213     public void setLabelTypeId_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsLabelToRoleCA> aggsLambda) {
214         setLabelTypeId_Missing("labelTypeId", opLambda, aggsLambda);
215     }
216 
217     public void setLabelTypeId_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
218             OperatorCall<BsLabelToRoleCA> aggsLambda) {
219         MissingAggregationBuilder builder = regMissingA(name, "labelTypeId");
220         if (opLambda != null) {
221             opLambda.callback(builder);
222         }
223         if (aggsLambda != null) {
224             LabelToRoleCA ca = new LabelToRoleCA();
225             aggsLambda.callback(ca);
226             ca.getAggregationBuilderList().forEach(builder::subAggregation);
227         }
228     }
229 
230     public void setRoleTypeId_Terms() {
231         setRoleTypeId_Terms(null);
232     }
233 
234     public void setRoleTypeId_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
235         setRoleTypeId_Terms("roleTypeId", opLambda, null);
236     }
237 
238     public void setRoleTypeId_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsLabelToRoleCA> aggsLambda) {
239         setRoleTypeId_Terms("roleTypeId", opLambda, aggsLambda);
240     }
241 
242     public void setRoleTypeId_Terms(String name, ConditionOptionCall<TermsAggregationBuilder> opLambda,
243             OperatorCall<BsLabelToRoleCA> aggsLambda) {
244         TermsAggregationBuilder builder = regTermsA(name, "roleTypeId");
245         if (opLambda != null) {
246             opLambda.callback(builder);
247         }
248         if (aggsLambda != null) {
249             LabelToRoleCA ca = new LabelToRoleCA();
250             aggsLambda.callback(ca);
251             ca.getAggregationBuilderList().forEach(builder::subAggregation);
252         }
253     }
254 
255     public void setRoleTypeId_SignificantTerms() {
256         setRoleTypeId_SignificantTerms(null);
257     }
258 
259     public void setRoleTypeId_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda) {
260         setRoleTypeId_SignificantTerms("roleTypeId", opLambda, null);
261     }
262 
263     public void setRoleTypeId_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
264             OperatorCall<BsLabelToRoleCA> aggsLambda) {
265         setRoleTypeId_SignificantTerms("roleTypeId", opLambda, aggsLambda);
266     }
267 
268     public void setRoleTypeId_SignificantTerms(String name, ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
269             OperatorCall<BsLabelToRoleCA> aggsLambda) {
270         SignificantTermsAggregationBuilder builder = regSignificantTermsA(name, "roleTypeId");
271         if (opLambda != null) {
272             opLambda.callback(builder);
273         }
274         if (aggsLambda != null) {
275             LabelToRoleCA ca = new LabelToRoleCA();
276             aggsLambda.callback(ca);
277             ca.getAggregationBuilderList().forEach(builder::subAggregation);
278         }
279     }
280 
281     public void setRoleTypeId_IpRange() {
282         setRoleTypeId_IpRange(null);
283     }
284 
285     public void setRoleTypeId_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda) {
286         setRoleTypeId_IpRange("roleTypeId", opLambda, null);
287     }
288 
289     public void setRoleTypeId_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda, OperatorCall<BsLabelToRoleCA> aggsLambda) {
290         setRoleTypeId_IpRange("roleTypeId", opLambda, aggsLambda);
291     }
292 
293     public void setRoleTypeId_IpRange(String name, ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
294             OperatorCall<BsLabelToRoleCA> aggsLambda) {
295         IpRangeAggregationBuilder builder = regIpRangeA(name, "roleTypeId");
296         if (opLambda != null) {
297             opLambda.callback(builder);
298         }
299         if (aggsLambda != null) {
300             LabelToRoleCA ca = new LabelToRoleCA();
301             aggsLambda.callback(ca);
302             ca.getAggregationBuilderList().forEach(builder::subAggregation);
303         }
304     }
305 
306     public void setRoleTypeId_Count() {
307         setRoleTypeId_Count(null);
308     }
309 
310     public void setRoleTypeId_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
311         setRoleTypeId_Count("roleTypeId", opLambda);
312     }
313 
314     public void setRoleTypeId_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
315         ValueCountAggregationBuilder builder = regCountA(name, "roleTypeId");
316         if (opLambda != null) {
317             opLambda.callback(builder);
318         }
319     }
320 
321     public void setRoleTypeId_Cardinality() {
322         setRoleTypeId_Cardinality(null);
323     }
324 
325     public void setRoleTypeId_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
326         setRoleTypeId_Cardinality("roleTypeId", opLambda);
327     }
328 
329     public void setRoleTypeId_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
330         CardinalityAggregationBuilder builder = regCardinalityA(name, "roleTypeId");
331         if (opLambda != null) {
332             opLambda.callback(builder);
333         }
334     }
335 
336     public void setRoleTypeId_Missing() {
337         setRoleTypeId_Missing(null);
338     }
339 
340     public void setRoleTypeId_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
341         setRoleTypeId_Missing("roleTypeId", opLambda, null);
342     }
343 
344     public void setRoleTypeId_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsLabelToRoleCA> aggsLambda) {
345         setRoleTypeId_Missing("roleTypeId", opLambda, aggsLambda);
346     }
347 
348     public void setRoleTypeId_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
349             OperatorCall<BsLabelToRoleCA> aggsLambda) {
350         MissingAggregationBuilder builder = regMissingA(name, "roleTypeId");
351         if (opLambda != null) {
352             opLambda.callback(builder);
353         }
354         if (aggsLambda != null) {
355             LabelToRoleCA ca = new LabelToRoleCA();
356             aggsLambda.callback(ca);
357             ca.getAggregationBuilderList().forEach(builder::subAggregation);
358         }
359     }
360 
361 }