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