View Javadoc
1   package fr.ifremer.dali.ui.swing.content.manage.referential.taxon.table;
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.ErrorAware;
28  import fr.ifremer.dali.dto.ErrorDTO;
29  import fr.ifremer.dali.dto.referential.CitationDTO;
30  import fr.ifremer.dali.dto.referential.TaxonDTO;
31  import fr.ifremer.dali.dto.referential.TaxonGroupDTO;
32  import fr.ifremer.dali.dto.referential.TaxonomicLevelDTO;
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.ArrayList;
39  import java.util.Collection;
40  import java.util.Date;
41  import java.util.List;
42  
43  /**
44   * <p>TaxonTableRowModel class.</p>
45   *
46   * @author Antoine
47   */
48  public class TaxonTableRowModel extends AbstractDaliRowUIModel<TaxonDTO, TaxonTableRowModel> implements TaxonDTO, ErrorAware {
49  
50      private static final Binder<TaxonDTO, TaxonTableRowModel> FROM_BEAN_BINDER =
51              BinderFactory.newBinder(TaxonDTO.class, TaxonTableRowModel.class);
52  
53      private static final Binder<TaxonTableRowModel, TaxonDTO> TO_BEAN_BINDER =
54              BinderFactory.newBinder(TaxonTableRowModel.class, TaxonDTO.class);
55  
56      private final List<ErrorDTO> errors;
57  
58      /**
59       * <p>Constructor for TaxonTableRowModel.</p>
60       */
61      public TaxonTableRowModel() {
62          this(false);
63      }
64  
65      /**
66       * <p>Constructor for TaxonTableRowModel.</p>
67       *
68       * @param readOnly a boolean.
69       */
70      public TaxonTableRowModel(boolean readOnly) {
71          super(FROM_BEAN_BINDER, TO_BEAN_BINDER);
72          errors = new ArrayList<>();
73          setReadOnly(readOnly);
74      }
75  
76      /** {@inheritDoc} */
77      @Override
78      public boolean isEditable() {
79          return !isReadOnly() && super.isEditable();
80      }
81  
82      /** {@inheritDoc} */
83      @Override
84      protected TaxonDTO newBean() {
85          return DaliBeanFactory.newTaxonDTO();
86      }
87  
88      /** {@inheritDoc} */
89      @Override
90      public String getComment() {
91          return delegateObject.getComment();
92      }
93  
94      /** {@inheritDoc} */
95      @Override
96      public void setComment(String comment) {
97          delegateObject.setComment(comment);
98      }
99  
100     /** {@inheritDoc} */
101     @Override
102     public boolean isTemporary() {
103         return delegateObject.isTemporary();
104     }
105 
106     /** {@inheritDoc} */
107     @Override
108     public void setTemporary(boolean temporary) {
109         delegateObject.setTemporary(temporary);
110     }
111 
112     /** {@inheritDoc} */
113     @Override
114     public boolean isObsolete() {
115         return delegateObject.isObsolete();
116     }
117 
118     /** {@inheritDoc} */
119     @Override
120     public void setObsolete(boolean obsolete) {
121         delegateObject.setObsolete(obsolete);
122     }
123 
124     /** {@inheritDoc} */
125     @Override
126     public boolean isVirtual() {
127         return delegateObject.isVirtual();
128     }
129 
130     /** {@inheritDoc} */
131     @Override
132     public void setVirtual(boolean virtual) {
133         delegateObject.setVirtual(virtual);
134     }
135 
136     /** {@inheritDoc} */
137     @Override
138     public boolean isReferent() {
139         return delegateObject.isReferent();
140     }
141 
142     /** {@inheritDoc} */
143     @Override
144     public void setReferent(boolean referent) {
145         delegateObject.setReferent(referent);
146     }
147 
148     /** {@inheritDoc} */
149     @Override
150     public CitationDTO getCitation() {
151         return delegateObject.getCitation();
152     }
153 
154     /** {@inheritDoc} */
155     @Override
156     public void setCitation(CitationDTO citation) {
157         delegateObject.setCitation(citation);
158     }
159 
160     /** {@inheritDoc} */
161     @Override
162     public Integer getReferenceTaxonId() {
163         return delegateObject.getReferenceTaxonId();
164     }
165 
166     /** {@inheritDoc} */
167     @Override
168     public void setReferenceTaxonId(Integer referenceTaxonId) {
169         delegateObject.setReferenceTaxonId(referenceTaxonId);
170     }
171 
172     /** {@inheritDoc} */
173     @Override
174     public Integer getParentTaxonId() {
175         return delegateObject.getParentTaxonId();
176     }
177 
178     /** {@inheritDoc} */
179     @Override
180     public void setParentTaxonId(Integer parentTaxonId) {
181         delegateObject.setParentTaxonId(parentTaxonId);
182     }
183 
184     /** {@inheritDoc} */
185     @Override
186     public TaxonGroupDTO getTaxonGroups(int index) {
187         return delegateObject.getTaxonGroups(index);
188     }
189 
190     /** {@inheritDoc} */
191     @Override
192     public boolean isTaxonGroupsEmpty() {
193         return delegateObject.isTaxonGroupsEmpty();
194     }
195 
196     /** {@inheritDoc} */
197     @Override
198     public int sizeTaxonGroups() {
199         return delegateObject.sizeTaxonGroups();
200     }
201 
202     /** {@inheritDoc} */
203     @Override
204     public void addTaxonGroups(TaxonGroupDTO taxonGroup) {
205         delegateObject.addTaxonGroups(taxonGroup);
206     }
207 
208     /** {@inheritDoc} */
209     @Override
210     public void addAllTaxonGroups(Collection<TaxonGroupDTO> taxonGroup) {
211         delegateObject.addAllTaxonGroups(taxonGroup);
212     }
213 
214     /** {@inheritDoc} */
215     @Override
216     public boolean removeTaxonGroups(TaxonGroupDTO taxonGroup) {
217         return delegateObject.removeTaxonGroups(taxonGroup);
218     }
219 
220     /** {@inheritDoc} */
221     @Override
222     public boolean removeAllTaxonGroups(Collection<TaxonGroupDTO> taxonGroup) {
223         return delegateObject.removeAllTaxonGroups(taxonGroup);
224     }
225 
226     /** {@inheritDoc} */
227     @Override
228     public boolean containsTaxonGroups(TaxonGroupDTO taxonGroup) {
229         return delegateObject.containsTaxonGroups(taxonGroup);
230     }
231 
232     /** {@inheritDoc} */
233     @Override
234     public boolean containsAllTaxonGroups(Collection<TaxonGroupDTO> taxonGroup) {
235         return delegateObject.containsAllTaxonGroups(taxonGroup);
236     }
237 
238     /** {@inheritDoc} */
239     @Override
240     public List<TaxonGroupDTO> getTaxonGroups() {
241         return delegateObject.getTaxonGroups();
242     }
243 
244     /** {@inheritDoc} */
245     @Override
246     public void setTaxonGroups(List<TaxonGroupDTO> taxonGroup) {
247         delegateObject.setTaxonGroups(taxonGroup);
248     }
249 
250     /** {@inheritDoc} */
251     @Override
252     public TaxonDTO getParentTaxon() {
253         return delegateObject.getParentTaxon();
254     }
255 
256     /** {@inheritDoc} */
257     @Override
258     public void setParentTaxon(TaxonDTO parentTaxon) {
259         delegateObject.setParentTaxon(parentTaxon);
260     }
261 
262     /** {@inheritDoc} */
263     @Override
264     public TaxonDTO getReferenceTaxon() {
265         return delegateObject.getReferenceTaxon();
266     }
267 
268     /** {@inheritDoc} */
269     @Override
270     public void setReferenceTaxon(TaxonDTO referenceTaxon) {
271         delegateObject.setReferenceTaxon(referenceTaxon);
272     }
273 
274     /** {@inheritDoc} */
275     @Override
276     public TaxonDTO getCompositeTaxons(int index) {
277         return delegateObject.getCompositeTaxons(index);
278     }
279 
280     /** {@inheritDoc} */
281     @Override
282     public boolean isCompositeTaxonsEmpty() {
283         return delegateObject.isCompositeTaxonsEmpty();
284     }
285 
286     /** {@inheritDoc} */
287     @Override
288     public int sizeCompositeTaxons() {
289         return delegateObject.sizeCompositeTaxons();
290     }
291 
292     /** {@inheritDoc} */
293     @Override
294     public void addCompositeTaxons(TaxonDTO compositeTaxons) {
295         delegateObject.addCompositeTaxons(compositeTaxons);
296     }
297 
298     /** {@inheritDoc} */
299     @Override
300     public void addAllCompositeTaxons(Collection<TaxonDTO> compositeTaxons) {
301         delegateObject.addAllCompositeTaxons(compositeTaxons);
302     }
303 
304     /** {@inheritDoc} */
305     @Override
306     public boolean removeCompositeTaxons(TaxonDTO compositeTaxons) {
307         return delegateObject.removeCompositeTaxons(compositeTaxons);
308     }
309 
310     /** {@inheritDoc} */
311     @Override
312     public boolean removeAllCompositeTaxons(Collection<TaxonDTO> compositeTaxons) {
313         return delegateObject.removeAllCompositeTaxons(compositeTaxons);
314     }
315 
316     /** {@inheritDoc} */
317     @Override
318     public boolean containsCompositeTaxons(TaxonDTO compositeTaxons) {
319         return delegateObject.containsCompositeTaxons(compositeTaxons);
320     }
321 
322     /** {@inheritDoc} */
323     @Override
324     public boolean containsAllCompositeTaxons(Collection<TaxonDTO> compositeTaxons) {
325         return delegateObject.containsAllCompositeTaxons(compositeTaxons);
326     }
327 
328     /** {@inheritDoc} */
329     @Override
330     public Collection<TaxonDTO> getCompositeTaxons() {
331         return delegateObject.getCompositeTaxons();
332     }
333 
334     /** {@inheritDoc} */
335     @Override
336     public void setCompositeTaxons(Collection<TaxonDTO> compositeTaxons) {
337         delegateObject.setCompositeTaxons(compositeTaxons);
338     }
339 
340     /** {@inheritDoc} */
341     @Override
342     public TaxonomicLevelDTO getLevel() {
343         return delegateObject.getLevel();
344     }
345 
346     /** {@inheritDoc} */
347     @Override
348     public void setLevel(TaxonomicLevelDTO level) {
349         delegateObject.setLevel(level);
350     }
351 
352     /** {@inheritDoc} */
353     @Override
354     public String getName() {
355         return delegateObject.getName();
356     }
357 
358     /** {@inheritDoc} */
359     @Override
360     public void setName(String name) {
361         delegateObject.setName(name);
362     }
363 
364     /** {@inheritDoc} */
365     @Override
366     public StatusDTO getStatus() {
367         return delegateObject.getStatus();
368     }
369 
370     /** {@inheritDoc} */
371     @Override
372     public void setStatus(StatusDTO status) {
373         delegateObject.setStatus(status);
374     }
375 
376     /** {@inheritDoc} */
377     @Override
378     public boolean isDirty() {
379         return delegateObject.isDirty();
380     }
381 
382     /** {@inheritDoc} */
383     @Override
384     public void setDirty(boolean dirty) {
385         delegateObject.setDirty(dirty);
386     }
387 
388     @Override
389     public boolean isReadOnly() {
390         return delegateObject.isReadOnly();
391     }
392 
393     @Override
394     public void setReadOnly(boolean readOnly) {
395         delegateObject.setReadOnly(readOnly);
396     }
397 
398     @Override
399     public Date getCreationDate() {
400         return delegateObject.getCreationDate();
401     }
402 
403     @Override
404     public void setCreationDate(Date date) {
405         delegateObject.setCreationDate(date);
406     }
407 
408     @Override
409     public Date getUpdateDate() {
410         return delegateObject.getUpdateDate();
411     }
412 
413     @Override
414     public void setUpdateDate(Date date) {
415         delegateObject.setUpdateDate(date);
416     }
417 
418     /** {@inheritDoc} */
419     @Override
420     public String getTaxRef() {
421         return delegateObject.getTaxRef();
422     }
423 
424     /** {@inheritDoc} */
425     @Override
426     public void setTaxRef(String taxRef) {
427         delegateObject.setTaxRef(taxRef);
428     }
429 
430     /** {@inheritDoc} */
431     @Override
432     public String getWormsRef() {
433         return delegateObject.getWormsRef();
434     }
435 
436     /** {@inheritDoc} */
437     @Override
438     public void setWormsRef(String wormsRef) {
439         delegateObject.setWormsRef(wormsRef);
440     }
441 
442     /** {@inheritDoc} */
443     @Override
444     public Collection<ErrorDTO> getErrors() {
445         return errors;
446     }
447 }