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