|
1
10 package org.mmbase.bridge.util;
11
12 import java.util.*;
13
14 import org.mmbase.bridge.*;
15 import org.mmbase.storage.search.*;
16
17
18 public class SearchUtil {
19
20 public static final String  SOURCE = "SOURCE";
21 public static final String DESTINATION = "DESTINATION";
22
23 private SearchUtil() {
24 }
26
27 public static Node findNode(Cloud cloud, String managerName, String fieldname, String value) {
28 return findNode(cloud, managerName, fieldname, value, null, null);
29 }
30
31 public static Node findNode(Cloud cloud, String managerName, String fieldname, String value, String sortName) {
32 return findNode(cloud, managerName, fieldname, value, sortName, null);
33 }
34
35 public static Node findOrderedNode(Cloud cloud, String managerName, String sortName) {
36 return findNode(cloud, managerName, null, null, sortName, null);
37 }
38
39 public static Node findOrderedNode(Cloud cloud, String managerName, String sortName, String sortDirection) {
40 return findNode(cloud, managerName, null, null, sortName, sortDirection);
41 }
42
43 public static Node findNode(Cloud cloud, String managerName, String fieldname, String value, String sortName, String sortDirection) {
44 NodeList list = findNodeList(cloud, managerName, fieldname, value, sortName, sortDirection);
45 if (list.size() > 0) {
46 return list.getNode(0);
47 }
48 return null;
49 }
50
51 public static NodeList findNodeList(Cloud cloud, String managerName) {
52 return findNodeList(cloud, managerName, null, null, null, null);
53 }
54
55 public static NodeList findNodeList(Cloud cloud, String managerName, String fieldname, Object value) {
56 return findNodeList(cloud, managerName, fieldname, value, null, null);
57 }
58
59 public static NodeList findNodeList(Cloud cloud, String managerName, String fieldname, Object value, String sortName) {
60 return findNodeList(cloud, managerName, fieldname, value, sortName, null);
61 }
62
63 public static NodeList findOrderedNodeList(Cloud cloud, String managerName, String sortName) {
64 return findNodeList(cloud, managerName, null, null, sortName, null);
65 }
66
67 public static NodeList findOrderedNodeList(Cloud cloud, String managerName, String sortName, String sortDirection) {
68 return findNodeList(cloud, managerName, null, null, sortName, sortDirection);
69 }
70
71 public static NodeList findNodeList(Cloud cloud, String managerName, String fieldname, Object value, String sortName, String sortDirection) {
72 NodeManager manager = cloud.getNodeManager(managerName);
73 NodeQuery query = manager.createQuery();
74 if (!isEmptyOrWhitespace(fieldname)) {
75 if (value instanceof String ) {
76 addEqualConstraint(query, manager, fieldname, (String ) value);
77 }
78 else if (value instanceof Integer ) {
79 addEqualConstraint(query, manager, fieldname, (Integer ) value);
80 }
81 else if (value instanceof Boolean ) {
82 addEqualConstraint(query, manager, fieldname, (Boolean ) value);
83 }
84 else {
85 addEqualConstraint(query, manager, fieldname, value);
86 }
87 }
88 if (!isEmptyOrWhitespace(sortName)) {
89 addSortOrder(query, manager, sortName, sortDirection);
90 }
91 return manager.getList(query);
92 }
93
94 public static Node findRelatedNode(Node parent, String managerName, String role) {
95 return findRelatedNode(parent, managerName, role, null, null, null, null);
96 }
97
98 public static Node findRelatedNode(Node parent, String managerName, String role, String fieldname, Object value) {
99 return findRelatedNode(parent, managerName, role, fieldname, value, null, null);
100 }
101
102 public static Node findRelatedNode(Node parent, String managerName, String role, String fieldname, Object value, String sortName) {
103 return findRelatedNode(parent, managerName, role, fieldname, value, sortName, null);
104 }
105
106 public static Node findRelatedOrderedNode(Node parent, String managerName, String role, String sortName) {
107 return findRelatedNode(parent, managerName, role, null, null, sortName, null);
108 }
109
110 public static Node findRelatedOrderedNode(Node parent, String managerName, String role, String sortName, String sortDirection) {
111 return findRelatedNode(parent, managerName, role, null, null, sortName, sortDirection);
112 }
113
114 public static Node findRelatedNode(Node parent, String managerName, String role, String fieldname, Object value, String sortName, String sortDirection) {
115 NodeList list = findRelatedNodeList(parent, managerName, role, fieldname, value, sortName, sortDirection);
116 if (list.size() > 0) {
117 return list.getNode(0);
118 }
119 return null;
120 }
121
122 public static NodeList findRelatedNodeList(Node parent, String managerName, String role) {
123 return findRelatedNodeList(parent, managerName, role, null, null, null, null);
124 }
125
126 public static NodeList findRelatedNodeList(Node parent, String managerName, String role, String fieldname, Object value) {
127 return findRelatedNodeList(parent, managerName, role, fieldname, value, null, null);
128 }
129
130 public static NodeList findRelatedNodeList(Node parent, String managerName, String role, String fieldname, Object value, String sortName) {
131 return findRelatedNodeList(parent, managerName, role, fieldname, value, sortName, null);
132 }
133
134 public static NodeList findRelatedOrderedNodeList(Node parent, String managerName, String role, String sortName) {
135 return findRelatedNodeList(parent, managerName, role, null, null, sortName, null);
136 }
137
138 public static NodeList findRelatedOrderedNodeList(Node parent, String managerName, String role, String sortName, String sortDirection) {
139 return findRelatedNodeList(parent, managerName, role, null, null, sortName, sortDirection);
140 }
141
142 public static NodeList findRelatedNodeList(Node parent, String managerName, String role, String fieldname, Object value, String sortName, String sortDirection) {
143 NodeQuery query = createRelatedNodeListQuery(parent, managerName, role, fieldname, value, sortName, sortDirection);
144 return query.getNodeManager().getList(query);
145 }
146
147 public static NodeList findRelatedNodeList(Node parent, String managerName, String role, String fieldname, Object value, String sortName, String sortDirection, String searchdir) {
148 NodeQuery query = createRelatedNodeListQuery(parent, managerName, role, fieldname, value, sortName, sortDirection, searchdir);
149 return query.getNodeManager().getList(query);
150 }
151
152 public static NodeQuery createRelatedNodeListQuery(Node parent, String managerName, String role, String fieldname, Object value, String sortName, String sortDirection) {
153 return createRelatedNodeListQuery(parent, managerName, role, fieldname, value, sortName, sortDirection, DESTINATION);
154 }
155
156 public static NodeQuery createRelatedNodeListQuery(Node parent, String managerName, String role, String fieldname, Object value, String sortName, String sortDirection, String searchdir) {
157 NodeQuery query = createRelatedNodeListQuery(parent, managerName, role, searchdir);
158
159 NodeManager manager = parent.getCloud().getNodeManager(managerName);
160 if (!isEmptyOrWhitespace(fieldname)) {
161 if (value instanceof String ) {
162 addEqualConstraint(query, manager, fieldname, (String ) value);
163 }
164 else if (value instanceof Integer ) {
165 addEqualConstraint(query, manager, fieldname, (Integer ) value);
166 }
167 else if (value instanceof Boolean ) {
168 addEqualConstraint(query, manager, fieldname, (Boolean ) value);
169 }
170 else {
171 addEqualConstraint(query, manager, fieldname, value);
172 }
173 }
174 if (!isEmptyOrWhitespace(sortName)) {
175 if (sortName.startsWith(role + ".")) {
176 String sortField = sortName.substring(role.length() + 1);
177 RelationManager relationManager = null;
178 if (SOURCE.equals(searchdir)) {
179 relationManager = parent.getCloud().getRelationManager(manager, parent.getNodeManager(), role);
180 }
181 else {
182 relationManager = parent.getCloud().getRelationManager(parent.getNodeManager(), manager, role);
183 }
184 addRelationSortOrder(query, relationManager, sortField, sortDirection);
185 }
186 else {
187 addSortOrder(query, manager, sortName, sortDirection);
188 }
189 }
190 return query;
191 }
192
193 public static NodeQuery createRelatedNodeListQuery(Node parent, String managerName, String role) {
194 return createRelatedNodeListQuery(parent, managerName, role, DESTINATION);
195 }
196
197 public static NodeQuery createRelatedNodeListQuery(Node parent, String managerName, String role, String searchdir) {
198 NodeManager manager = parent.getCloud().getNodeManager(managerName);
199
200 NodeQuery query = parent.getCloud().createNodeQuery();
201 Step step1 = query.addStep(parent.getNodeManager());
202 query.addNode(step1, parent);
203
204 RelationStep step2 = query.addRelationStep(manager, role, searchdir);
205 Step step3 = step2.getNext();
206 query.setNodeStep(step3); return query;
208 }
209
210 public static RelationList findRelations(Node parent, String managerName, String role, String sortName, String sortDirection) {
211 return findRelations(parent, managerName, role, sortName, sortDirection, DESTINATION);
212 }
213
214 public static RelationList findRelations(Node parent, String managerName, String role, String sortName, String sortDirection, String searchdir) {
215 NodeManager manager = parent.getCloud().getNodeManager(managerName);
216 NodeQuery query = parent.getCloud().createNodeQuery();
217 Step step1 = query.addStep(parent.getNodeManager());
218 query.addNode(step1, parent);
219 RelationStep step = query.addRelationStep(manager, role, searchdir);
220 query.setNodeStep(step);
221
222 if (!isEmptyOrWhitespace(sortName)) {
223 RelationManager relationManager = parent.getCloud().getRelationManager(parent.getNodeManager(), manager, role);
224 addRelationSortOrder(query, relationManager, sortName, sortDirection);
225 }
226
227 NodeManager nm = query.getNodeManager();
228 return (RelationList) nm.getList(query);
229 }
230
231 public static void addSortOrder(NodeQuery query, NodeManager manager, String sortName, String sortDirection) {
232 StepField sf = query.getStepField(manager.getField(sortName));
233 addSortOrder(query, sf, sortDirection);
234 }
235
236 public static void addRelationSortOrder(NodeQuery query, RelationManager role, String sortName, String sortDirection) {
237 Field field = role.getField(sortName);
238 StepField sf = query.createStepField(query.getStep(role.getForwardRole()), field);
239 addSortOrder(query, sf, sortDirection);
240 }
241
242 public static void addSortOrder(NodeQuery query, StepField sf, String sortDirection) {
243 int dir = SortOrder.ORDER_ASCENDING;
244 if ("DOWN".equalsIgnoreCase(sortDirection)) {
245 dir = SortOrder.ORDER_DESCENDING;
246 }
247 query.addSortOrder(sf, dir);
248 }
249
250 public static void addEqualConstraint(NodeQuery query, NodeManager manager, String fieldname, String value) {
251 FieldValueConstraint constraint = createEqualConstraint(query, manager, fieldname, value);
252 addConstraint(query, constraint);
253 }
254
255 public static void addEqualConstraint(Query query, NodeManager manager, String fieldname, String value) {
256 FieldValueConstraint constraint = createEqualConstraint(query, manager, fieldname, value);
257 addConstraint(query, constraint);
258 }
259
260 public static FieldValueConstraint createEqualConstraint(NodeQuery query, NodeManager manager, String fieldname, String value) {
261 Field keyField = manager.getField(fieldname);
262 FieldValueConstraint constraint = createEqualConstraint(query, keyField, value);
263 return constraint;
264 }
265
266 public static FieldValueConstraint createEqualConstraint(Query query, NodeManager manager, String fieldname, String value) {
267 Field keyField = manager.getField(fieldname);
268 FieldValueConstraint constraint = createEqualConstraint(query, keyField, value);
269 return constraint;
270 }
271
272 public static void addEqualConstraint(NodeQuery query, NodeManager manager, String fieldname, Integer value) {
273 FieldValueConstraint constraint = createEqualConstraint(query, manager, fieldname, value);
274 addConstraint(query, constraint);
275 }
276
277 public static void addEqualConstraint(Query query, NodeManager manager, String fieldname, Integer value) {
278 FieldValueConstraint constraint = createEqualConstraint(query, manager, fieldname, value);
279 addConstraint(query, constraint);
280 }
281
282 public static FieldValueConstraint createEqualConstraint(NodeQuery query, NodeManager manager, String fieldname, Integer value) {
283 Field keyField = manager.getField(fieldname);
284 return createEqualConstraint(query, keyField, value);
285 }
286
287 public static FieldValueConstraint createEqualConstraint(Query query, NodeManager manager, String fieldname, Integer value) {
288 Field keyField = manager.getField(fieldname);
289 return createEqualConstraint(query, keyField, value);
290 }
291
292 public static void addEqualConstraint(NodeQuery query, NodeManager manager, String fieldname, Boolean value) {
293 FieldValueConstraint constraint = createEqualConstraint(query, manager, fieldname, value);
294 addConstraint(query, constraint);
295 }
296
297 public static void addEqualConstraint(Query query, NodeManager manager, String fieldname, Boolean value) {
298 FieldValueConstraint constraint = createEqualConstraint(query, manager, fieldname, value);
299 addConstraint(query, constraint);
300 }
301
302 public static FieldValueConstraint createEqualConstraint(NodeQuery query, NodeManager manager, String fieldname, Boolean value) {
303 Field keyField = manager.getField(fieldname);
304 return createEqualConstraint(query, keyField, value);
305 }
306
307 public static FieldValueConstraint createEqualConstraint(Query query, NodeManager manager, String fieldname, Boolean value) {
308 Field keyField = manager.getField(fieldname);
309 return createEqualConstraint(query, keyField, value);
310 }
311
312 public static void addEqualConstraint(NodeQuery query, NodeManager manager, String fieldname, Object value) {
313 FieldValueConstraint constraint = createEqualConstraint(query, manager, fieldname, value);
314 addConstraint(query, constraint);
315 }
316
317 public static void addEqualConstraint(Query query, NodeManager manager, String fieldname, Object value) {
318 FieldValueConstraint constraint = createEqualConstraint(query, manager, fieldname, value);
319 addConstraint(query, constraint);
320 }
321
322 public static FieldValueConstraint createEqualConstraint(NodeQuery query, NodeManager manager, String fieldname, Object value) {
323 Field keyField = manager.getField(fieldname);
324 return createEqualConstraint(query, keyField, value);
325 }
326
327 public static FieldValueConstraint createEqualConstraint(Query query, NodeManager manager, String fieldname, Object value) {
328 Field keyField = manager.getField(fieldname);
329 return createEqualConstraint(query, keyField, value);
330 }
331
332 public static void addEqualConstraint(NodeQuery query, Field field, String value) {
333 FieldValueConstraint constraint = createEqualConstraint(query, field, value);
334 addConstraint(query, constraint);
335 }
336
337 public static void addEqualConstraint(Query query, Field field, String value) {
338 FieldValueConstraint constraint = createEqualConstraint(query, field, value);
339 addConstraint(query, constraint);
340 }
341
342 public static FieldValueConstraint createEqualConstraint(NodeQuery query, Field field, String value) {
343 FieldValueConstraint constraint = query.createConstraint(query.getStepField(field),
344 FieldCompareConstraint.EQUAL, value);
345 query.setCaseSensitive(constraint, false);
346 return constraint;
347 }
348
349 public static FieldValueConstraint createEqualConstraint(Query query, Field field, String value) {
350 StepField equalsField = findField(query, field);
351 FieldValueConstraint constraint = query.createConstraint(equalsField,
352 FieldCompareConstraint.EQUAL, value);
353 query.setCaseSensitive(constraint, false);
354 return constraint;
355 }
356
357 public static void addEqualConstraint(NodeQuery query, Field field, Integer value) {
358 FieldValueConstraint constraint = createEqualConstraint(query, field, value);
359 addConstraint(query, constraint);
360 }
361
362 public static void addEqualConstraint(Query query, Field field, Integer value) {
363 FieldValueConstraint constraint = createEqualConstraint(query, field, value);
364 addConstraint(query, constraint);
365 }
366
367 public static FieldValueConstraint createEqualConstraint(NodeQuery query, Field field, Integer value) {
368 FieldValueConstraint constraint = query.createConstraint(query.getStepField(field),
369 FieldCompareConstraint.EQUAL, value);
370 return constraint;
371 }
372
373 public static FieldValueConstraint createEqualConstraint(Query query, Field field, Integer value) {
374 StepField equalsField = findField(query, field);
375 FieldValueConstraint constraint = query.createConstraint(equalsField,
376 FieldCompareConstraint.EQUAL, value);
377 return constraint;
378 }
379
380 public static void addEqualConstraint(NodeQuery query, Field field, Boolean value) {
381 FieldValueConstraint constraint = createEqualConstraint(query, field, value);
382 addConstraint(query, constraint);
383 }
384
385 public static void addEqualConstraint(Query query, Field field, Boolean value) {
386 FieldValueConstraint constraint = createEqualConstraint(query, field, value);
387 addConstraint(query, constraint);
388 }
389
390 public static FieldValueConstraint createEqualConstraint(NodeQuery query, Field field, Boolean value) {
391 FieldValueConstraint constraint = query.createConstraint(query.getStepField(field),
392 FieldCompareConstraint.EQUAL, value);
393 return constraint;
394 }
395
396 public static FieldValueConstraint createEqualConstraint(Query query, Field field, Boolean value) {
397 StepField equalsField = findField(query, field);
398 FieldValueConstraint constraint = query.createConstraint(equalsField,
399 FieldCompareConstraint.EQUAL, value);
400 return constraint;
401 }
402
403 public static void addEqualConstraint(NodeQuery query, Field field, Object value) {
404 FieldValueConstraint constraint = createEqualConstraint(query, field, value);
405 addConstraint(query, constraint);
406 }
407
408 public static void addEqualConstraint(Query query, Field field, Object value) {
409 FieldValueConstraint constraint = createEqualConstraint(query, field, value);
410 addConstraint(query, constraint);
411 }
412
413 public static FieldValueConstraint createEqualConstraint(NodeQuery query, Field field, Object value) {
414 FieldValueConstraint constraint = query.createConstraint(query.getStepField(field),
415 FieldCompareConstraint.EQUAL, value);
416 return constraint;
417 }
418
419 public static FieldValueConstraint createEqualConstraint(Query query, Field field, Object value) {
420 StepField equalsField = findField(query, field);
421 FieldValueConstraint constraint = query.createConstraint(equalsField,
422 FieldCompareConstraint.EQUAL, value);
423 return constraint;
424 }
425
426 public static StepField findField(Query query, Field field) {
427 StepField equalsField = null;
428 Iterator fields = query.getFields().iterator();
429 while(fields.hasNext()) {
430 StepField stepField = (StepField) fields.next();
431 if (stepField.getStep().getTableName().equals(field.getNodeManager().getName())) {
432 if (stepField.getFieldName().equals(field.getName())) {
433 equalsField = stepField;
434 }
435 }
436 }
437 if (equalsField == null) {
438 Step equalsStep = query.getStep(field.getNodeManager().getName());
439 if (equalsStep == null) {
440 throw new IllegalArgumentException ("Step " + field.getNodeManager().getName() + " not found in query");
441
442 }
443 equalsField = query.createStepField(equalsStep, field);
444 }
445 if (equalsField == null) {
446 throw new IllegalArgumentException ("Field " + field.getName() + " not found in query");
447 }
448
449 return equalsField;
450 }
451
452 public static void addLikeConstraint(NodeQuery query, Field field, String value) {
453 FieldValueConstraint constraint = createLikeConstraint(query, field, value);
454 addConstraint(query, constraint);
455 }
456
457 public static FieldValueConstraint createLikeConstraint(NodeQuery query, Field field, String value) {
458 FieldValueConstraint constraint = query.createConstraint(query.getStepField(field),
459 FieldCompareConstraint.LIKE, "%" + value + "%");
460 query.setCaseSensitive(constraint, false);
461 return constraint;
462 }
463
464 public static void addDayConstraint(NodeQuery query, NodeManager nodeManager, String fieldName,
465 String daysToCompare) {
466
467 if (!isEmptyOrWhitespace(daysToCompare) && !daysToCompare.equals("0")
468 && daysToCompare.matches("\\-?\\d+")) {
469
470 Field field = nodeManager.getField(fieldName);
471
472 long now = (System.currentTimeMillis());
473
474 long msecondsToCompare = (1000 * 60 * 60 * 24 * Long.parseLong(daysToCompare));
475 long date = now + msecondsToCompare;
476
477 long compareField1 = (msecondsToCompare < 0) ? date : now;
478 long compareField2 = (msecondsToCompare < 0) ? now : date;
479
480 addDatetimeConstraint(query, field, compareField1, compareField2);
481 }
482 }
483
484 public static void addDatetimeConstraint(NodeQuery query, Field field, long from, long to) {
485 FieldValueBetweenConstraint constraint = createDatetimeConstraint(query, field, from, to);
486 addConstraint(query, constraint);
487 }
488
489 public static FieldValueBetweenConstraint createDatetimeConstraint(NodeQuery query, Field field, long from, long to) {
490 FieldValueBetweenConstraint constraint = null;
491 if (field.getType() == Field.TYPE_DATETIME) {
492 constraint = query.createConstraint(query.getStepField(field),
493 new Date(from), new Date(to));
494 }
495 else {
496 constraint = query.createConstraint(query.getStepField(field),
497 new Long (from), new Long (to));
498 }
499 return constraint;
500 }
501
502 public static void addLimitConstraint(NodeQuery query, int offset, int maxNumber) {
503 if (offset > 0) {
504 query.setOffset(offset);
505 }
506 if (maxNumber > 0) {
507 query.setMaxNumber(maxNumber);
508 }
509 }
510
511 public static void addTypeConstraints(NodeQuery query, List types) {
512 FieldValueInConstraint constraint = createTypeConstraints(query, types);
513 addConstraint(query, constraint);
514 }
515
516 public static FieldValueInConstraint createTypeConstraints(NodeQuery query, List types) {
517 Cloud cloud = query.getCloud();
518 SortedSet set = new TreeSet();
519 for (Iterator iter = types.iterator(); iter.hasNext();) {
520 String type = (String ) iter.next();
521 NodeManager manager = cloud.getNodeManager(type);
522 set.add(new Integer (manager.getNumber()));
523 }
524 Field field = query.getNodeManager().getField("otype");
525 return createInConstraint(query, field, set);
526 }
527
528 public static void addNodesConstraints(Query query, Field field, NodeList nodes) {
529 SortedSet set = createNodesConstraints(nodes);
530 addInConstraint(query, field, set);
531 }
532
533 public static SortedSet createNodesConstraints(NodeList nodes) {
534 SortedSet set = new TreeSet();
535 for (Iterator iter = nodes.iterator(); iter.hasNext();) {
536 Node node = (Node) iter.next();
537 set.add(new Integer (node.getNumber()));
538 }
539 return set;
540 }
541
542 public static void addInConstraint(Query query, Field field, SortedSet set) {
543 FieldValueInConstraint constraint = createInConstraint(query, field, set);
544 addConstraint(query, constraint);
545 }
546
547 public static FieldValueInConstraint createInConstraint(Query query, Field field, SortedSet set) {
548 query.getStep(field.getNodeManager().getName());
549 StepField stepfield = getStepField(query, field);
550 FieldValueInConstraint constraint = query.createConstraint(stepfield, set);
551 return constraint;
552 }
553
554 public static StepField getStepField(Query query, Field field) {
555 StepField stepfield = null;
556 Iterator fields = query.getFields().iterator();
557 while(fields.hasNext()) {
558 StepField tempStepField = (StepField) fields.next();
559 if (tempStepField.getFieldName().equals(field.getName())) {
560 if (tempStepField.getStep().getAlias().equals(field.getNodeManager().getName())) {
561 stepfield = tempStepField;
562 }
563 }
564 }
565 return stepfield;
566 }
567
568 public static void addConstraint(Query query, Constraint constraint) {
569 addConstraint(query, constraint, CompositeConstraint.LOGICAL_AND);
570 }
571
572 public static Constraint createANDConstraint(Query query, Constraint one, Constraint two) {
573 return createLogicalConstraint(query, one, two, CompositeConstraint.LOGICAL_OR);
574 }
575
576 public static void addORConstraint(Query query, Constraint constraint) {
577 addConstraint(query, constraint, CompositeConstraint.LOGICAL_OR);
578 }
579
580 public static Constraint addORConstraint(Query query, Constraint one, Constraint two) {
581 return createLogicalConstraint(query, one, two, CompositeConstraint.LOGICAL_OR);
582 }
583
584 public static void addConstraint(Query query, Constraint constraint, int operator) {
585 if (query.getConstraint() == null) {
586 query.setConstraint(constraint);
587 }
588 else {
589 CompositeConstraint newc = createLogicalConstraint(query, query.getConstraint(), constraint, operator);
590 query.setConstraint(newc);
591 }
592 }
593
594 public static CompositeConstraint createLogicalConstraint(Query query, Constraint one, Constraint two, int operator) {
595 CompositeConstraint newc = query.createConstraint(one,
596 operator, two);
597 return newc;
598 }
599
600
606 public static boolean isEmptyOrWhitespace(String str) {
607 return (str == null) || "".equals(str.trim());
608 }
609
610 }
611 |
Popular Tags |
Java API By Example, From Geeks To Geeks.