View Javadoc
1   package fr.ifremer.dali.ui.swing.content.manage.rule.program;
2   
3   /*
4    * #%L
5    * Dali :: UI
6    * $Id:$
7    * $HeadURL:$
8    * %%
9    * Copyright (C) 2014 - 2015 Ifremer
10   * %%
11   * This program is free software: you can redistribute it and/or modify
12   * it under the terms of the GNU Affero General Public License as published by
13   * the Free Software Foundation, either version 3 of the License, or
14   * (at your option) any later version.
15   * 
16   * This program is distributed in the hope that it will be useful,
17   * but WITHOUT ANY WARRANTY; without even the implied warranty of
18   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19   * GNU General Public License for more details.
20   * 
21   * You should have received a copy of the GNU Affero General Public License
22   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
23   * #L%
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   * <p>ControlProgramTableRowModel class.</p>
44   *
45   * @author Antoine
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       * <p>Constructor for ControlProgramTableRowModel.</p>
57       */
58      public ControlProgramTableRowModel() {
59          super(FROM_BEAN_BINDER, TO_BEAN_BINDER);
60      }
61  
62      /** {@inheritDoc} */
63      @Override
64      protected ProgramDTO newBean() {
65          return DaliBeanFactory.newProgramDTO();
66      }
67  
68      /** {@inheritDoc} */
69      @Override
70      public String getCode() {
71          return delegateObject.getCode();
72      }
73  
74      /** {@inheritDoc} */
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      /** {@inheritDoc} */
91      @Override
92      public String getName() {
93          return delegateObject.getName();
94      }
95  
96      /** {@inheritDoc} */
97      @Override
98      public void setName(String Name) {
99          delegateObject.setName(Name);
100     }
101 
102     /** {@inheritDoc} */
103     @Override
104     public String getComment() {
105         return delegateObject.getComment();
106     }
107 
108     /** {@inheritDoc} */
109     @Override
110     public void setComment(String Comment) {
111         delegateObject.setComment(Comment);
112     }
113 
114     /** {@inheritDoc} */
115     @Override
116     public StrategyDTO getStrategies(int index) {
117         return delegateObject.getStrategies(index);
118     }
119 
120     /** {@inheritDoc} */
121     @Override
122     public boolean isStrategiesEmpty() {
123         return delegateObject.isStrategiesEmpty();
124     }
125 
126     /** {@inheritDoc} */
127     @Override
128     public int sizeStrategies() {
129         return delegateObject.sizeStrategies();
130     }
131 
132     /** {@inheritDoc} */
133     @Override
134     public void addStrategies(StrategyDTO strategy) {
135         delegateObject.addStrategies(strategy);
136     }
137 
138     /** {@inheritDoc} */
139     @Override
140     public void addAllStrategies(Collection<StrategyDTO> strategy) {
141         delegateObject.addAllStrategies(strategy);
142     }
143 
144     /** {@inheritDoc} */
145     @Override
146     public boolean removeStrategies(StrategyDTO strategy) {
147         return delegateObject.removeStrategies(strategy);
148     }
149 
150     /** {@inheritDoc} */
151     @Override
152     public boolean removeAllStrategies(Collection<StrategyDTO> strategy) {
153         return delegateObject.removeAllStrategies(strategy);
154     }
155 
156     /** {@inheritDoc} */
157     @Override
158     public boolean containsStrategies(StrategyDTO strategy) {
159         return delegateObject.containsStrategies(strategy);
160     }
161 
162     /** {@inheritDoc} */
163     @Override
164     public boolean containsAllStrategies(Collection<StrategyDTO> strategy) {
165         return delegateObject.containsAllStrategies(strategy);
166     }
167 
168     /** {@inheritDoc} */
169     @Override
170     public Collection<StrategyDTO> getStrategies() {
171         return delegateObject.getStrategies();
172     }
173 
174     /** {@inheritDoc} */
175     @Override
176     public void setStrategies(Collection<StrategyDTO> strategy) {
177         delegateObject.setStrategies(strategy);
178     }
179 
180     /** {@inheritDoc} */
181     @Override
182     public LocationDTO getLocations(int index) {
183         return delegateObject.getLocations(index);
184     }
185 
186     /** {@inheritDoc} */
187     @Override
188     public boolean isLocationsEmpty() {
189         return delegateObject.isLocationsEmpty();
190     }
191 
192     /** {@inheritDoc} */
193     @Override
194     public int sizeLocations() {
195         return delegateObject.sizeLocations();
196     }
197 
198     /** {@inheritDoc} */
199     @Override
200     public void addLocations(LocationDTO location) {
201         delegateObject.addLocations(location);
202     }
203 
204     /** {@inheritDoc} */
205     @Override
206     public void addAllLocations(Collection<LocationDTO> location) {
207         delegateObject.addAllLocations(location);
208     }
209 
210     /** {@inheritDoc} */
211     @Override
212     public boolean removeLocations(LocationDTO location) {
213         return delegateObject.removeLocations(location);
214     }
215 
216     /** {@inheritDoc} */
217     @Override
218     public boolean removeAllLocations(Collection<LocationDTO> location) {
219         return delegateObject.removeAllLocations(location);
220     }
221 
222     /** {@inheritDoc} */
223     @Override
224     public boolean containsLocations(LocationDTO location) {
225         return delegateObject.containsLocations(location);
226     }
227 
228     /** {@inheritDoc} */
229     @Override
230     public boolean containsAllLocations(Collection<LocationDTO> location) {
231         return delegateObject.containsAllLocations(location);
232     }
233 
234     /** {@inheritDoc} */
235     @Override
236     public List<LocationDTO> getLocations() {
237         return delegateObject.getLocations();
238     }
239 
240     /** {@inheritDoc} */
241     @Override
242     public void setLocations(List<LocationDTO> location) {
243         delegateObject.setLocations(location);
244     }
245 
246     /** {@inheritDoc} */
247     @Override
248     public StatusDTO getStatus() {
249         return delegateObject.getStatus();
250     }
251 
252     /** {@inheritDoc} */
253     @Override
254     public void setStatus(StatusDTO status) {
255         delegateObject.setStatus(status);
256     }
257 
258     /** {@inheritDoc} */
259     @Override
260     public boolean isStrategiesLoaded() {
261         return delegateObject.isStrategiesLoaded();
262     }
263 
264     /** {@inheritDoc} */
265     @Override
266     public void setStrategiesLoaded(boolean strategiesLoaded) {
267         delegateObject.setStrategiesLoaded(strategiesLoaded);
268     }
269 
270     /** {@inheritDoc} */
271     @Override
272     public boolean isLocationsLoaded() {
273         return delegateObject.isLocationsLoaded();
274     }
275 
276     /** {@inheritDoc} */
277     @Override
278     public void setLocationsLoaded(boolean locationsLoaded) {
279         delegateObject.setLocationsLoaded(locationsLoaded);
280     }
281 
282     /** {@inheritDoc} */
283     @Override
284     public boolean isDirty() {
285         return delegateObject.isDirty();
286     }
287 
288     /** {@inheritDoc} */
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     /** {@inheritDoc} */
305     @Override
306     public ErrorDTO getErrors(int index) {
307         return delegateObject.getErrors(index);
308     }
309 
310     /** {@inheritDoc} */
311     @Override
312     public boolean isErrorsEmpty() {
313         return delegateObject.isErrorsEmpty();
314     }
315 
316     /** {@inheritDoc} */
317     @Override
318     public int sizeErrors() {
319         return delegateObject.sizeErrors();
320     }
321 
322     /** {@inheritDoc} */
323     @Override
324     public void addErrors(ErrorDTO errors) {
325         delegateObject.addErrors(errors);
326     }
327 
328     /** {@inheritDoc} */
329     @Override
330     public void addAllErrors(Collection<ErrorDTO> errors) {
331         delegateObject.addAllErrors(errors);
332     }
333 
334     /** {@inheritDoc} */
335     @Override
336     public boolean removeErrors(ErrorDTO errors) {
337         return delegateObject.removeErrors(errors);
338     }
339 
340     /** {@inheritDoc} */
341     @Override
342     public boolean removeAllErrors(Collection<ErrorDTO> errors) {
343         return delegateObject.removeAllErrors(errors);
344     }
345 
346     /** {@inheritDoc} */
347     @Override
348     public boolean containsErrors(ErrorDTO errors) {
349         return delegateObject.containsErrors(errors);
350     }
351 
352     /** {@inheritDoc} */
353     @Override
354     public boolean containsAllErrors(Collection<ErrorDTO> errors) {
355         return delegateObject.containsAllErrors(errors);
356     }
357 
358     /** {@inheritDoc} */
359     @Override
360     public Collection<ErrorDTO> getErrors() {
361         return delegateObject.getErrors();
362     }
363 
364     /** {@inheritDoc} */
365     @Override
366     public void setErrors(Collection<ErrorDTO> errors) {
367         delegateObject.setErrors(errors);
368     }
369 
370     /** {@inheritDoc} */
371     @Override
372     public PersonDTO getManagerPersons(int index) {
373         return delegateObject.getManagerPersons(index);
374     }
375 
376     /** {@inheritDoc} */
377     @Override
378     public boolean isManagerPersonsEmpty() {
379         return delegateObject.isManagerPersonsEmpty();
380     }
381 
382     /** {@inheritDoc} */
383     @Override
384     public int sizeManagerPersons() {
385         return delegateObject.sizeManagerPersons();
386     }
387 
388     /** {@inheritDoc} */
389     @Override
390     public void addManagerPersons(PersonDTO managerPersons) {
391         delegateObject.addManagerPersons(managerPersons);
392     }
393 
394     /** {@inheritDoc} */
395     @Override
396     public void addAllManagerPersons(Collection<PersonDTO> managerPersons) {
397         delegateObject.addAllManagerPersons(managerPersons);
398     }
399 
400     /** {@inheritDoc} */
401     @Override
402     public boolean removeManagerPersons(PersonDTO managerPersons) {
403         return delegateObject.removeManagerPersons(managerPersons);
404     }
405 
406     /** {@inheritDoc} */
407     @Override
408     public boolean removeAllManagerPersons(Collection<PersonDTO> managerPersons) {
409         return delegateObject.removeAllManagerPersons(managerPersons);
410     }
411 
412     /** {@inheritDoc} */
413     @Override
414     public boolean containsManagerPersons(PersonDTO managerPersons) {
415         return delegateObject.containsManagerPersons(managerPersons);
416     }
417 
418     /** {@inheritDoc} */
419     @Override
420     public boolean containsAllManagerPersons(Collection<PersonDTO> managerPersons) {
421         return delegateObject.containsAllManagerPersons(managerPersons);
422     }
423 
424     /** {@inheritDoc} */
425     @Override
426     public Collection<PersonDTO> getManagerPersons() {
427         return delegateObject.getManagerPersons();
428     }
429 
430     /** {@inheritDoc} */
431     @Override
432     public void setManagerPersons(Collection<PersonDTO> managerPersons) {
433         delegateObject.setManagerPersons(managerPersons);
434     }
435 
436     /** {@inheritDoc} */
437     @Override
438     public PersonDTO getRecorderPersons(int index) {
439         return delegateObject.getRecorderPersons(index);
440     }
441 
442     /** {@inheritDoc} */
443     @Override
444     public boolean isRecorderPersonsEmpty() {
445         return delegateObject.isRecorderPersonsEmpty();
446     }
447 
448     /** {@inheritDoc} */
449     @Override
450     public int sizeRecorderPersons() {
451         return delegateObject.sizeRecorderPersons();
452     }
453 
454     /** {@inheritDoc} */
455     @Override
456     public void addRecorderPersons(PersonDTO recorderPersons) {
457         delegateObject.addRecorderPersons(recorderPersons);
458     }
459 
460     /** {@inheritDoc} */
461     @Override
462     public void addAllRecorderPersons(Collection<PersonDTO> recorderPersons) {
463         delegateObject.addAllRecorderPersons(recorderPersons);
464     }
465 
466     /** {@inheritDoc} */
467     @Override
468     public boolean removeRecorderPersons(PersonDTO recorderPersons) {
469         return delegateObject.removeRecorderPersons(recorderPersons);
470     }
471 
472     /** {@inheritDoc} */
473     @Override
474     public boolean removeAllRecorderPersons(Collection<PersonDTO> recorderPersons) {
475         return delegateObject.removeAllRecorderPersons(recorderPersons);
476     }
477 
478     /** {@inheritDoc} */
479     @Override
480     public boolean containsRecorderPersons(PersonDTO recorderPersons) {
481         return delegateObject.containsRecorderPersons(recorderPersons);
482     }
483 
484     /** {@inheritDoc} */
485     @Override
486     public boolean containsAllRecorderPersons(Collection<PersonDTO> recorderPersons) {
487         return delegateObject.containsAllRecorderPersons(recorderPersons);
488     }
489 
490     /** {@inheritDoc} */
491     @Override
492     public Collection<PersonDTO> getRecorderPersons() {
493         return delegateObject.getRecorderPersons();
494     }
495 
496     /** {@inheritDoc} */
497     @Override
498     public void setRecorderPersons(Collection<PersonDTO> recorderPersons) {
499         delegateObject.setRecorderPersons(recorderPersons);
500     }
501 
502     /** {@inheritDoc} */
503     @Override
504     public DepartmentDTO getRecorderDepartments(int index) {
505         return delegateObject.getRecorderDepartments(index);
506     }
507 
508     /** {@inheritDoc} */
509     @Override
510     public boolean isRecorderDepartmentsEmpty() {
511         return delegateObject.isRecorderDepartmentsEmpty();
512     }
513 
514     /** {@inheritDoc} */
515     @Override
516     public int sizeRecorderDepartments() {
517         return delegateObject.sizeRecorderDepartments();
518     }
519 
520     /** {@inheritDoc} */
521     @Override
522     public void addRecorderDepartments(DepartmentDTO recorderDepartments) {
523         delegateObject.addRecorderDepartments(recorderDepartments);
524     }
525 
526     /** {@inheritDoc} */
527     @Override
528     public void addAllRecorderDepartments(Collection<DepartmentDTO> recorderDepartments) {
529         delegateObject.addAllRecorderDepartments(recorderDepartments);
530     }
531 
532     /** {@inheritDoc} */
533     @Override
534     public boolean removeRecorderDepartments(DepartmentDTO recorderDepartments) {
535         return delegateObject.removeRecorderDepartments(recorderDepartments);
536     }
537 
538     /** {@inheritDoc} */
539     @Override
540     public boolean removeAllRecorderDepartments(Collection<DepartmentDTO> recorderDepartments) {
541         return delegateObject.removeAllRecorderDepartments(recorderDepartments);
542     }
543 
544     /** {@inheritDoc} */
545     @Override
546     public boolean containsRecorderDepartments(DepartmentDTO recorderDepartments) {
547         return delegateObject.containsRecorderDepartments(recorderDepartments);
548     }
549 
550     /** {@inheritDoc} */
551     @Override
552     public boolean containsAllRecorderDepartments(Collection<DepartmentDTO> recorderDepartments) {
553         return delegateObject.containsAllRecorderDepartments(recorderDepartments);
554     }
555 
556     /** {@inheritDoc} */
557     @Override
558     public Collection<DepartmentDTO> getRecorderDepartments() {
559         return delegateObject.getRecorderDepartments();
560     }
561 
562     /** {@inheritDoc} */
563     @Override
564     public void setRecorderDepartments(Collection<DepartmentDTO> recorderDepartments) {
565         delegateObject.setRecorderDepartments(recorderDepartments);
566     }
567 
568     /** {@inheritDoc} */
569     @Override
570     public boolean isNewCode() {
571         return delegateObject.isNewCode();
572     }
573 
574     /** {@inheritDoc} */
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 }