1 package fr.ifremer.dali.dto.configuration.programStrategy;
2
3 import fr.ifremer.dali.dto.ErrorDTO;
4 import fr.ifremer.dali.dto.referential.DepartmentDTO;
5 import fr.ifremer.dali.dto.referential.LocationDTO;
6 import fr.ifremer.dali.dto.referential.PersonDTO;
7 import fr.ifremer.quadrige3.ui.core.dto.referential.BaseReferentialDTOBean;
8 import java.util.Collection;
9 import java.util.LinkedList;
10 import java.util.List;
11 import javax.annotation.Generated;
12
13 @Generated(value = "org.nuiton.eugene.java.SimpleJavaBeanTransformer", date = "Mon May 09 09:01:03 CEST 2022")
14 public abstract class AbstractProgramDTOBean extends BaseReferentialDTOBean implements ProgramDTO {
15
16 private static final long serialVersionUID = 7293639208041986101L;
17
18 protected String code;
19
20 protected String description;
21
22 protected String comment;
23
24 protected boolean strategiesLoaded;
25
26 protected boolean locationsLoaded;
27
28 protected boolean newCode;
29
30 protected boolean departmentHermetic;
31
32 protected Collection<StrategyDTO> strategies;
33
34 protected List<LocationDTO> locations;
35
36 protected Collection<ErrorDTO> errors;
37
38 protected Collection<PersonDTO> managerPersons;
39
40 protected Collection<PersonDTO> recorderPersons;
41
42 protected Collection<DepartmentDTO> recorderDepartments;
43
44 @Override
45 public String getCode() {
46 return code;
47 }
48
49 @Override
50 public void setCode(String code) {
51 String oldValue = getCode();
52 this.code = code;
53 firePropertyChange(PROPERTY_CODE, oldValue, code);
54 }
55
56 @Override
57 public String getDescription() {
58 return description;
59 }
60
61 @Override
62 public void setDescription(String description) {
63 String oldValue = getDescription();
64 this.description = description;
65 firePropertyChange(PROPERTY_DESCRIPTION, oldValue, description);
66 }
67
68 @Override
69 public String getComment() {
70 return comment;
71 }
72
73 @Override
74 public void setComment(String comment) {
75 String oldValue = getComment();
76 this.comment = comment;
77 firePropertyChange(PROPERTY_COMMENT, oldValue, comment);
78 }
79
80 @Override
81 public boolean isStrategiesLoaded() {
82 return strategiesLoaded;
83 }
84
85 @Override
86 public void setStrategiesLoaded(boolean strategiesLoaded) {
87 boolean oldValue = isStrategiesLoaded();
88 this.strategiesLoaded = strategiesLoaded;
89 firePropertyChange(PROPERTY_STRATEGIES_LOADED, oldValue, strategiesLoaded);
90 }
91
92 @Override
93 public boolean isLocationsLoaded() {
94 return locationsLoaded;
95 }
96
97 @Override
98 public void setLocationsLoaded(boolean locationsLoaded) {
99 boolean oldValue = isLocationsLoaded();
100 this.locationsLoaded = locationsLoaded;
101 firePropertyChange(PROPERTY_LOCATIONS_LOADED, oldValue, locationsLoaded);
102 }
103
104 @Override
105 public boolean isNewCode() {
106 return newCode;
107 }
108
109 @Override
110 public void setNewCode(boolean newCode) {
111 boolean oldValue = isNewCode();
112 this.newCode = newCode;
113 firePropertyChange(PROPERTY_NEW_CODE, oldValue, newCode);
114 }
115
116 @Override
117 public boolean isDepartmentHermetic() {
118 return departmentHermetic;
119 }
120
121 @Override
122 public void setDepartmentHermetic(boolean departmentHermetic) {
123 boolean oldValue = isDepartmentHermetic();
124 this.departmentHermetic = departmentHermetic;
125 firePropertyChange(PROPERTY_DEPARTMENT_HERMETIC, oldValue, departmentHermetic);
126 }
127
128 @Override
129 public StrategyDTO getStrategies(int index) {
130 StrategyDTO o = getChild(strategies, index);
131 return o;
132 }
133
134 @Override
135 public boolean isStrategiesEmpty() {
136 return strategies == null || strategies.isEmpty();
137 }
138
139 @Override
140 public int sizeStrategies() {
141 return strategies == null ? 0 : strategies.size();
142 }
143
144 @Override
145 public void addStrategies(StrategyDTO strategies) {
146 getStrategies().add(strategies);
147 firePropertyChange(PROPERTY_STRATEGIES, null, strategies);
148 }
149
150 @Override
151 public void addAllStrategies(Collection<StrategyDTO> strategies) {
152 getStrategies().addAll(strategies);
153 firePropertyChange(PROPERTY_STRATEGIES, null, strategies);
154 }
155
156 @Override
157 public boolean removeStrategies(StrategyDTO strategies) {
158 boolean removed = getStrategies().remove(strategies);
159 if (removed) {
160 firePropertyChange(PROPERTY_STRATEGIES, strategies, null);
161 }
162 return removed;
163 }
164
165 @Override
166 public boolean removeAllStrategies(Collection<StrategyDTO> strategies) {
167 boolean removed = getStrategies().removeAll(strategies);
168 if (removed) {
169 firePropertyChange(PROPERTY_STRATEGIES, strategies, null);
170 }
171 return removed;
172 }
173
174 @Override
175 public boolean containsStrategies(StrategyDTO strategies) {
176 boolean contains = getStrategies().contains(strategies);
177 return contains;
178 }
179
180 @Override
181 public boolean containsAllStrategies(Collection<StrategyDTO> strategies) {
182 boolean contains = getStrategies().containsAll(strategies);
183 return contains;
184 }
185
186 @Override
187 public Collection<StrategyDTO> getStrategies() {
188 if (strategies == null) {
189 strategies = new LinkedList<StrategyDTO>();
190 }
191 return strategies;
192 }
193
194 @Override
195 public void setStrategies(Collection<StrategyDTO> strategies) {
196 Collection<StrategyDTO> oldValue = getStrategies();
197 this.strategies = strategies;
198 firePropertyChange(PROPERTY_STRATEGIES, oldValue, strategies);
199 }
200
201 @Override
202 public LocationDTO getLocations(int index) {
203 LocationDTO o = getChild(locations, index);
204 return o;
205 }
206
207 @Override
208 public boolean isLocationsEmpty() {
209 return locations == null || locations.isEmpty();
210 }
211
212 @Override
213 public int sizeLocations() {
214 return locations == null ? 0 : locations.size();
215 }
216
217 @Override
218 public void addLocations(LocationDTO locations) {
219 getLocations().add(locations);
220 firePropertyChange(PROPERTY_LOCATIONS, null, locations);
221 }
222
223 @Override
224 public void addAllLocations(Collection<LocationDTO> locations) {
225 getLocations().addAll(locations);
226 firePropertyChange(PROPERTY_LOCATIONS, null, locations);
227 }
228
229 @Override
230 public boolean removeLocations(LocationDTO locations) {
231 boolean removed = getLocations().remove(locations);
232 if (removed) {
233 firePropertyChange(PROPERTY_LOCATIONS, locations, null);
234 }
235 return removed;
236 }
237
238 @Override
239 public boolean removeAllLocations(Collection<LocationDTO> locations) {
240 boolean removed = getLocations().removeAll(locations);
241 if (removed) {
242 firePropertyChange(PROPERTY_LOCATIONS, locations, null);
243 }
244 return removed;
245 }
246
247 @Override
248 public boolean containsLocations(LocationDTO locations) {
249 boolean contains = getLocations().contains(locations);
250 return contains;
251 }
252
253 @Override
254 public boolean containsAllLocations(Collection<LocationDTO> locations) {
255 boolean contains = getLocations().containsAll(locations);
256 return contains;
257 }
258
259 @Override
260 public List<LocationDTO> getLocations() {
261 if (locations == null) {
262 locations = new LinkedList<LocationDTO>();
263 }
264 return locations;
265 }
266
267 @Override
268 public void setLocations(List<LocationDTO> locations) {
269 List<LocationDTO> oldValue = getLocations();
270 this.locations = locations;
271 firePropertyChange(PROPERTY_LOCATIONS, oldValue, locations);
272 }
273
274 @Override
275 public ErrorDTO getErrors(int index) {
276 ErrorDTO o = getChild(errors, index);
277 return o;
278 }
279
280 @Override
281 public boolean isErrorsEmpty() {
282 return errors == null || errors.isEmpty();
283 }
284
285 @Override
286 public int sizeErrors() {
287 return errors == null ? 0 : errors.size();
288 }
289
290 @Override
291 public void addErrors(ErrorDTO errors) {
292 getErrors().add(errors);
293 firePropertyChange(PROPERTY_ERRORS, null, errors);
294 }
295
296 @Override
297 public void addAllErrors(Collection<ErrorDTO> errors) {
298 getErrors().addAll(errors);
299 firePropertyChange(PROPERTY_ERRORS, null, errors);
300 }
301
302 @Override
303 public boolean removeErrors(ErrorDTO errors) {
304 boolean removed = getErrors().remove(errors);
305 if (removed) {
306 firePropertyChange(PROPERTY_ERRORS, errors, null);
307 }
308 return removed;
309 }
310
311 @Override
312 public boolean removeAllErrors(Collection<ErrorDTO> errors) {
313 boolean removed = getErrors().removeAll(errors);
314 if (removed) {
315 firePropertyChange(PROPERTY_ERRORS, errors, null);
316 }
317 return removed;
318 }
319
320 @Override
321 public boolean containsErrors(ErrorDTO errors) {
322 boolean contains = getErrors().contains(errors);
323 return contains;
324 }
325
326 @Override
327 public boolean containsAllErrors(Collection<ErrorDTO> errors) {
328 boolean contains = getErrors().containsAll(errors);
329 return contains;
330 }
331
332 @Override
333 public Collection<ErrorDTO> getErrors() {
334 if (errors == null) {
335 errors = new LinkedList<ErrorDTO>();
336 }
337 return errors;
338 }
339
340 @Override
341 public void setErrors(Collection<ErrorDTO> errors) {
342 Collection<ErrorDTO> oldValue = getErrors();
343 this.errors = errors;
344 firePropertyChange(PROPERTY_ERRORS, oldValue, errors);
345 }
346
347 @Override
348 public PersonDTO getManagerPersons(int index) {
349 PersonDTO o = getChild(managerPersons, index);
350 return o;
351 }
352
353 @Override
354 public boolean isManagerPersonsEmpty() {
355 return managerPersons == null || managerPersons.isEmpty();
356 }
357
358 @Override
359 public int sizeManagerPersons() {
360 return managerPersons == null ? 0 : managerPersons.size();
361 }
362
363 @Override
364 public void addManagerPersons(PersonDTO managerPersons) {
365 getManagerPersons().add(managerPersons);
366 firePropertyChange(PROPERTY_MANAGER_PERSONS, null, managerPersons);
367 }
368
369 @Override
370 public void addAllManagerPersons(Collection<PersonDTO> managerPersons) {
371 getManagerPersons().addAll(managerPersons);
372 firePropertyChange(PROPERTY_MANAGER_PERSONS, null, managerPersons);
373 }
374
375 @Override
376 public boolean removeManagerPersons(PersonDTO managerPersons) {
377 boolean removed = getManagerPersons().remove(managerPersons);
378 if (removed) {
379 firePropertyChange(PROPERTY_MANAGER_PERSONS, managerPersons, null);
380 }
381 return removed;
382 }
383
384 @Override
385 public boolean removeAllManagerPersons(Collection<PersonDTO> managerPersons) {
386 boolean removed = getManagerPersons().removeAll(managerPersons);
387 if (removed) {
388 firePropertyChange(PROPERTY_MANAGER_PERSONS, managerPersons, null);
389 }
390 return removed;
391 }
392
393 @Override
394 public boolean containsManagerPersons(PersonDTO managerPersons) {
395 boolean contains = getManagerPersons().contains(managerPersons);
396 return contains;
397 }
398
399 @Override
400 public boolean containsAllManagerPersons(Collection<PersonDTO> managerPersons) {
401 boolean contains = getManagerPersons().containsAll(managerPersons);
402 return contains;
403 }
404
405 @Override
406 public Collection<PersonDTO> getManagerPersons() {
407 if (managerPersons == null) {
408 managerPersons = new LinkedList<PersonDTO>();
409 }
410 return managerPersons;
411 }
412
413 @Override
414 public void setManagerPersons(Collection<PersonDTO> managerPersons) {
415 Collection<PersonDTO> oldValue = getManagerPersons();
416 this.managerPersons = managerPersons;
417 firePropertyChange(PROPERTY_MANAGER_PERSONS, oldValue, managerPersons);
418 }
419
420 @Override
421 public PersonDTO getRecorderPersons(int index) {
422 PersonDTO o = getChild(recorderPersons, index);
423 return o;
424 }
425
426 @Override
427 public boolean isRecorderPersonsEmpty() {
428 return recorderPersons == null || recorderPersons.isEmpty();
429 }
430
431 @Override
432 public int sizeRecorderPersons() {
433 return recorderPersons == null ? 0 : recorderPersons.size();
434 }
435
436 @Override
437 public void addRecorderPersons(PersonDTO recorderPersons) {
438 getRecorderPersons().add(recorderPersons);
439 firePropertyChange(PROPERTY_RECORDER_PERSONS, null, recorderPersons);
440 }
441
442 @Override
443 public void addAllRecorderPersons(Collection<PersonDTO> recorderPersons) {
444 getRecorderPersons().addAll(recorderPersons);
445 firePropertyChange(PROPERTY_RECORDER_PERSONS, null, recorderPersons);
446 }
447
448 @Override
449 public boolean removeRecorderPersons(PersonDTO recorderPersons) {
450 boolean removed = getRecorderPersons().remove(recorderPersons);
451 if (removed) {
452 firePropertyChange(PROPERTY_RECORDER_PERSONS, recorderPersons, null);
453 }
454 return removed;
455 }
456
457 @Override
458 public boolean removeAllRecorderPersons(Collection<PersonDTO> recorderPersons) {
459 boolean removed = getRecorderPersons().removeAll(recorderPersons);
460 if (removed) {
461 firePropertyChange(PROPERTY_RECORDER_PERSONS, recorderPersons, null);
462 }
463 return removed;
464 }
465
466 @Override
467 public boolean containsRecorderPersons(PersonDTO recorderPersons) {
468 boolean contains = getRecorderPersons().contains(recorderPersons);
469 return contains;
470 }
471
472 @Override
473 public boolean containsAllRecorderPersons(Collection<PersonDTO> recorderPersons) {
474 boolean contains = getRecorderPersons().containsAll(recorderPersons);
475 return contains;
476 }
477
478 @Override
479 public Collection<PersonDTO> getRecorderPersons() {
480 if (recorderPersons == null) {
481 recorderPersons = new LinkedList<PersonDTO>();
482 }
483 return recorderPersons;
484 }
485
486 @Override
487 public void setRecorderPersons(Collection<PersonDTO> recorderPersons) {
488 Collection<PersonDTO> oldValue = getRecorderPersons();
489 this.recorderPersons = recorderPersons;
490 firePropertyChange(PROPERTY_RECORDER_PERSONS, oldValue, recorderPersons);
491 }
492
493 @Override
494 public DepartmentDTO getRecorderDepartments(int index) {
495 DepartmentDTO o = getChild(recorderDepartments, index);
496 return o;
497 }
498
499 @Override
500 public boolean isRecorderDepartmentsEmpty() {
501 return recorderDepartments == null || recorderDepartments.isEmpty();
502 }
503
504 @Override
505 public int sizeRecorderDepartments() {
506 return recorderDepartments == null ? 0 : recorderDepartments.size();
507 }
508
509 @Override
510 public void addRecorderDepartments(DepartmentDTO recorderDepartments) {
511 getRecorderDepartments().add(recorderDepartments);
512 firePropertyChange(PROPERTY_RECORDER_DEPARTMENTS, null, recorderDepartments);
513 }
514
515 @Override
516 public void addAllRecorderDepartments(Collection<DepartmentDTO> recorderDepartments) {
517 getRecorderDepartments().addAll(recorderDepartments);
518 firePropertyChange(PROPERTY_RECORDER_DEPARTMENTS, null, recorderDepartments);
519 }
520
521 @Override
522 public boolean removeRecorderDepartments(DepartmentDTO recorderDepartments) {
523 boolean removed = getRecorderDepartments().remove(recorderDepartments);
524 if (removed) {
525 firePropertyChange(PROPERTY_RECORDER_DEPARTMENTS, recorderDepartments, null);
526 }
527 return removed;
528 }
529
530 @Override
531 public boolean removeAllRecorderDepartments(Collection<DepartmentDTO> recorderDepartments) {
532 boolean removed = getRecorderDepartments().removeAll(recorderDepartments);
533 if (removed) {
534 firePropertyChange(PROPERTY_RECORDER_DEPARTMENTS, recorderDepartments, null);
535 }
536 return removed;
537 }
538
539 @Override
540 public boolean containsRecorderDepartments(DepartmentDTO recorderDepartments) {
541 boolean contains = getRecorderDepartments().contains(recorderDepartments);
542 return contains;
543 }
544
545 @Override
546 public boolean containsAllRecorderDepartments(Collection<DepartmentDTO> recorderDepartments) {
547 boolean contains = getRecorderDepartments().containsAll(recorderDepartments);
548 return contains;
549 }
550
551 @Override
552 public Collection<DepartmentDTO> getRecorderDepartments() {
553 if (recorderDepartments == null) {
554 recorderDepartments = new LinkedList<DepartmentDTO>();
555 }
556 return recorderDepartments;
557 }
558
559 @Override
560 public void setRecorderDepartments(Collection<DepartmentDTO> recorderDepartments) {
561 Collection<DepartmentDTO> oldValue = getRecorderDepartments();
562 this.recorderDepartments = recorderDepartments;
563 firePropertyChange(PROPERTY_RECORDER_DEPARTMENTS, oldValue, recorderDepartments);
564 }
565
566 }