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.WebConfigToRoleCA;
21  import org.codelibs.fess.es.config.cbean.cq.WebConfigToRoleCQ;
22  import org.codelibs.fess.es.config.cbean.cq.bs.BsWebConfigToRoleCQ;
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 BsWebConfigToRoleCA extends EsAbstractConditionAggregation {
39  
40      // ===================================================================================
41      //                                                                     Aggregation Set
42      //                                                                           =========
43  
44      public void filter(String name, EsAbstractConditionQuery.OperatorCall<BsWebConfigToRoleCQ> queryLambda,
45              ConditionOptionCall<FilterAggregationBuilder> opLambda, OperatorCall<BsWebConfigToRoleCA> aggsLambda) {
46          WebConfigToRoleCQ cq = new WebConfigToRoleCQ();
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              WebConfigToRoleCA ca = new WebConfigToRoleCA();
56              aggsLambda.callback(ca);
57              ca.getAggregationBuilderList().forEach(builder::subAggregation);
58          }
59      }
60  
61      public void global(String name, ConditionOptionCall<GlobalAggregationBuilder> opLambda, OperatorCall<BsWebConfigToRoleCA> aggsLambda) {
62          GlobalAggregationBuilder builder = regGlobalA(name);
63          if (opLambda != null) {
64              opLambda.callback(builder);
65          }
66          if (aggsLambda != null) {
67              WebConfigToRoleCA ca = new WebConfigToRoleCA();
68              aggsLambda.callback(ca);
69              ca.getAggregationBuilderList().forEach(builder::subAggregation);
70          }
71      }
72  
73      public void sampler(String name, ConditionOptionCall<SamplerAggregationBuilder> opLambda, OperatorCall<BsWebConfigToRoleCA> aggsLambda) {
74          SamplerAggregationBuilder builder = regSamplerA(name);
75          if (opLambda != null) {
76              opLambda.callback(builder);
77          }
78          if (aggsLambda != null) {
79              WebConfigToRoleCA ca = new WebConfigToRoleCA();
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 setRoleTypeId_Terms() {
100         setRoleTypeId_Terms(null);
101     }
102 
103     public void setRoleTypeId_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
104         setRoleTypeId_Terms("roleTypeId", opLambda, null);
105     }
106 
107     public void setRoleTypeId_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsWebConfigToRoleCA> aggsLambda) {
108         setRoleTypeId_Terms("roleTypeId", opLambda, aggsLambda);
109     }
110 
111     public void setRoleTypeId_Terms(String name, ConditionOptionCall<TermsAggregationBuilder> opLambda,
112             OperatorCall<BsWebConfigToRoleCA> aggsLambda) {
113         TermsAggregationBuilder builder = regTermsA(name, "roleTypeId");
114         if (opLambda != null) {
115             opLambda.callback(builder);
116         }
117         if (aggsLambda != null) {
118             WebConfigToRoleCA ca = new WebConfigToRoleCA();
119             aggsLambda.callback(ca);
120             ca.getAggregationBuilderList().forEach(builder::subAggregation);
121         }
122     }
123 
124     public void setRoleTypeId_SignificantTerms() {
125         setRoleTypeId_SignificantTerms(null);
126     }
127 
128     public void setRoleTypeId_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda) {
129         setRoleTypeId_SignificantTerms("roleTypeId", opLambda, null);
130     }
131 
132     public void setRoleTypeId_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
133             OperatorCall<BsWebConfigToRoleCA> aggsLambda) {
134         setRoleTypeId_SignificantTerms("roleTypeId", opLambda, aggsLambda);
135     }
136 
137     public void setRoleTypeId_SignificantTerms(String name, ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
138             OperatorCall<BsWebConfigToRoleCA> aggsLambda) {
139         SignificantTermsAggregationBuilder builder = regSignificantTermsA(name, "roleTypeId");
140         if (opLambda != null) {
141             opLambda.callback(builder);
142         }
143         if (aggsLambda != null) {
144             WebConfigToRoleCA ca = new WebConfigToRoleCA();
145             aggsLambda.callback(ca);
146             ca.getAggregationBuilderList().forEach(builder::subAggregation);
147         }
148     }
149 
150     public void setRoleTypeId_IpRange() {
151         setRoleTypeId_IpRange(null);
152     }
153 
154     public void setRoleTypeId_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda) {
155         setRoleTypeId_IpRange("roleTypeId", opLambda, null);
156     }
157 
158     public void setRoleTypeId_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda, OperatorCall<BsWebConfigToRoleCA> aggsLambda) {
159         setRoleTypeId_IpRange("roleTypeId", opLambda, aggsLambda);
160     }
161 
162     public void setRoleTypeId_IpRange(String name, ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
163             OperatorCall<BsWebConfigToRoleCA> aggsLambda) {
164         IpRangeAggregationBuilder builder = regIpRangeA(name, "roleTypeId");
165         if (opLambda != null) {
166             opLambda.callback(builder);
167         }
168         if (aggsLambda != null) {
169             WebConfigToRoleCA ca = new WebConfigToRoleCA();
170             aggsLambda.callback(ca);
171             ca.getAggregationBuilderList().forEach(builder::subAggregation);
172         }
173     }
174 
175     public void setRoleTypeId_Count() {
176         setRoleTypeId_Count(null);
177     }
178 
179     public void setRoleTypeId_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
180         setRoleTypeId_Count("roleTypeId", opLambda);
181     }
182 
183     public void setRoleTypeId_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
184         ValueCountAggregationBuilder builder = regCountA(name, "roleTypeId");
185         if (opLambda != null) {
186             opLambda.callback(builder);
187         }
188     }
189 
190     public void setRoleTypeId_Cardinality() {
191         setRoleTypeId_Cardinality(null);
192     }
193 
194     public void setRoleTypeId_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
195         setRoleTypeId_Cardinality("roleTypeId", opLambda);
196     }
197 
198     public void setRoleTypeId_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
199         CardinalityAggregationBuilder builder = regCardinalityA(name, "roleTypeId");
200         if (opLambda != null) {
201             opLambda.callback(builder);
202         }
203     }
204 
205     public void setRoleTypeId_Missing() {
206         setRoleTypeId_Missing(null);
207     }
208 
209     public void setRoleTypeId_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
210         setRoleTypeId_Missing("roleTypeId", opLambda, null);
211     }
212 
213     public void setRoleTypeId_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsWebConfigToRoleCA> aggsLambda) {
214         setRoleTypeId_Missing("roleTypeId", opLambda, aggsLambda);
215     }
216 
217     public void setRoleTypeId_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
218             OperatorCall<BsWebConfigToRoleCA> aggsLambda) {
219         MissingAggregationBuilder builder = regMissingA(name, "roleTypeId");
220         if (opLambda != null) {
221             opLambda.callback(builder);
222         }
223         if (aggsLambda != null) {
224             WebConfigToRoleCA ca = new WebConfigToRoleCA();
225             aggsLambda.callback(ca);
226             ca.getAggregationBuilderList().forEach(builder::subAggregation);
227         }
228     }
229 
230     public void setWebConfigId_Terms() {
231         setWebConfigId_Terms(null);
232     }
233 
234     public void setWebConfigId_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
235         setWebConfigId_Terms("webConfigId", opLambda, null);
236     }
237 
238     public void setWebConfigId_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsWebConfigToRoleCA> aggsLambda) {
239         setWebConfigId_Terms("webConfigId", opLambda, aggsLambda);
240     }
241 
242     public void setWebConfigId_Terms(String name, ConditionOptionCall<TermsAggregationBuilder> opLambda,
243             OperatorCall<BsWebConfigToRoleCA> aggsLambda) {
244         TermsAggregationBuilder builder = regTermsA(name, "webConfigId");
245         if (opLambda != null) {
246             opLambda.callback(builder);
247         }
248         if (aggsLambda != null) {
249             WebConfigToRoleCA ca = new WebConfigToRoleCA();
250             aggsLambda.callback(ca);
251             ca.getAggregationBuilderList().forEach(builder::subAggregation);
252         }
253     }
254 
255     public void setWebConfigId_SignificantTerms() {
256         setWebConfigId_SignificantTerms(null);
257     }
258 
259     public void setWebConfigId_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda) {
260         setWebConfigId_SignificantTerms("webConfigId", opLambda, null);
261     }
262 
263     public void setWebConfigId_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
264             OperatorCall<BsWebConfigToRoleCA> aggsLambda) {
265         setWebConfigId_SignificantTerms("webConfigId", opLambda, aggsLambda);
266     }
267 
268     public void setWebConfigId_SignificantTerms(String name, ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
269             OperatorCall<BsWebConfigToRoleCA> aggsLambda) {
270         SignificantTermsAggregationBuilder builder = regSignificantTermsA(name, "webConfigId");
271         if (opLambda != null) {
272             opLambda.callback(builder);
273         }
274         if (aggsLambda != null) {
275             WebConfigToRoleCA ca = new WebConfigToRoleCA();
276             aggsLambda.callback(ca);
277             ca.getAggregationBuilderList().forEach(builder::subAggregation);
278         }
279     }
280 
281     public void setWebConfigId_IpRange() {
282         setWebConfigId_IpRange(null);
283     }
284 
285     public void setWebConfigId_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda) {
286         setWebConfigId_IpRange("webConfigId", opLambda, null);
287     }
288 
289     public void setWebConfigId_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda, OperatorCall<BsWebConfigToRoleCA> aggsLambda) {
290         setWebConfigId_IpRange("webConfigId", opLambda, aggsLambda);
291     }
292 
293     public void setWebConfigId_IpRange(String name, ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
294             OperatorCall<BsWebConfigToRoleCA> aggsLambda) {
295         IpRangeAggregationBuilder builder = regIpRangeA(name, "webConfigId");
296         if (opLambda != null) {
297             opLambda.callback(builder);
298         }
299         if (aggsLambda != null) {
300             WebConfigToRoleCA ca = new WebConfigToRoleCA();
301             aggsLambda.callback(ca);
302             ca.getAggregationBuilderList().forEach(builder::subAggregation);
303         }
304     }
305 
306     public void setWebConfigId_Count() {
307         setWebConfigId_Count(null);
308     }
309 
310     public void setWebConfigId_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
311         setWebConfigId_Count("webConfigId", opLambda);
312     }
313 
314     public void setWebConfigId_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
315         ValueCountAggregationBuilder builder = regCountA(name, "webConfigId");
316         if (opLambda != null) {
317             opLambda.callback(builder);
318         }
319     }
320 
321     public void setWebConfigId_Cardinality() {
322         setWebConfigId_Cardinality(null);
323     }
324 
325     public void setWebConfigId_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
326         setWebConfigId_Cardinality("webConfigId", opLambda);
327     }
328 
329     public void setWebConfigId_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
330         CardinalityAggregationBuilder builder = regCardinalityA(name, "webConfigId");
331         if (opLambda != null) {
332             opLambda.callback(builder);
333         }
334     }
335 
336     public void setWebConfigId_Missing() {
337         setWebConfigId_Missing(null);
338     }
339 
340     public void setWebConfigId_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
341         setWebConfigId_Missing("webConfigId", opLambda, null);
342     }
343 
344     public void setWebConfigId_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsWebConfigToRoleCA> aggsLambda) {
345         setWebConfigId_Missing("webConfigId", opLambda, aggsLambda);
346     }
347 
348     public void setWebConfigId_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
349             OperatorCall<BsWebConfigToRoleCA> aggsLambda) {
350         MissingAggregationBuilder builder = regMissingA(name, "webConfigId");
351         if (opLambda != null) {
352             opLambda.callback(builder);
353         }
354         if (aggsLambda != null) {
355             WebConfigToRoleCA ca = new WebConfigToRoleCA();
356             aggsLambda.callback(ca);
357             ca.getAggregationBuilderList().forEach(builder::subAggregation);
358         }
359     }
360 
361 }