View Javadoc

1   // Do not edit this file!  It was generated by Melati POEM's DSD preprocessor.
2   
3   package org.paneris.bibliomania.generated;
4   
5   
6   import java.sql.Timestamp;
7   import java.util.Collections;
8   import java.util.Enumeration;
9   import java.util.List;
10  import org.melati.poem.AccessPoemException;
11  import org.melati.poem.CachedSelection;
12  import org.melati.poem.Column;
13  import org.melati.poem.Field;
14  import org.melati.poem.JdbcPersistent;
15  import org.melati.poem.NoSuchRowPoemException;
16  import org.melati.poem.ValidationPoemException;
17  import org.melati.poem.util.EmptyEnumeration;
18  import org.paneris.bibliomania.BibliomaniaDatabaseTables;
19  import org.paneris.bibliomania.Country;
20  import org.paneris.bibliomania.Currency;
21  import org.paneris.bibliomania.OrderStatus;
22  import org.paneris.bibliomania.ShopOrder;
23  import org.paneris.bibliomania.ShopOrderItem;
24  import org.paneris.bibliomania.ShopOrderTable;
25  import org.paneris.bibliomania.User;
26  
27  
28  /**
29   * Melati POEM generated abstract base class for a <code>Persistent</code> 
30   * <code>ShopOrder</code> Object.
31   *
32   * see org.melati.poem.prepro.TableDef#generatePersistentBaseJava 
33   */
34  public abstract class ShopOrderBase extends JdbcPersistent {
35  
36  
37   /**
38    * Retrieves the Database object.
39    * 
40    * see org.melati.poem.prepro.TableDef#generatePersistentBaseJava 
41    * @return the database
42    */
43    public BibliomaniaDatabaseTables getBibliomaniaDatabaseTables() {
44      return (BibliomaniaDatabaseTables)getDatabase();
45    }
46  
47  
48   /**
49    * Retrieves the  <code>ShopOrderTable</code> table 
50    * which this <code>Persistent</code> is from.
51    * 
52    * see org.melati.poem.prepro.TableDef#generatePersistentBaseJava 
53    * @return the ShopOrderTable
54    */
55    @SuppressWarnings("unchecked")
56    public ShopOrderTable<ShopOrder> getShopOrderTable() {
57      return (ShopOrderTable<ShopOrder>)getTable();
58    }
59  
60    @SuppressWarnings("unchecked")
61    private ShopOrderTable<ShopOrder> _getShopOrderTable() {
62      return (ShopOrderTable<ShopOrder>)getTable();
63    }
64  
65    // Fields in this table 
66   /**
67    * id 
68    */
69    protected Integer id;
70   /**
71    * User 
72    */
73    protected Integer user;
74   /**
75    * Status - The status of this order 
76    */
77    protected Integer status;
78   /**
79    * Date - The date that this order was placed (leave blank to autocomplete) 
80    */
81    protected Timestamp date;
82   /**
83    * Fufilled Date - The date that this order was fufilled (leave blank to 
84    * autocomplete) 
85    */
86    protected Timestamp fufilleddate;
87   /**
88    * Comment - Any comments reguarding this order 
89    */
90    protected String comment;
91   /**
92    * Total Amount (in customer's currency) - The total amount of the order (in 
93    * customer's currency) 
94    */
95    protected Double amount;
96   /**
97    * Total Delivery (in customer's currency) - The total delivery charge for 
98    * the order (in customer's currency) 
99    */
100   protected Double delivery;
101  /**
102   * Total Amount (UK Sterling Equivalent) - The total amount of the order (UK 
103   * Sterling Equivalent) 
104   */
105   protected Double amountUK;
106  /**
107   * Total Delivery (UK Sterling Equivalent) - The total delivery charge for 
108   * the order (UK Sterling Equivalent) 
109   */
110   protected Double deliveryUK;
111  /**
112   * Full name - The user's real name 
113   */
114   protected String name;
115  /**
116   * email - email 
117   */
118   protected String email;
119  /**
120   * Address 
121   */
122   protected String address;
123  /**
124   * Town / City 
125   */
126   protected String town;
127  /**
128   * County / State 
129   */
130   protected String county;
131  /**
132   * Telephone - Order telephone number 
133   */
134   protected String tel;
135  /**
136   * Postcode - Order postcode 
137   */
138   protected String postcode;
139  /**
140   * Country 
141   */
142   protected Integer country;
143  /**
144   * currency - The currency for this order 
145   */
146   protected Integer currency;
147 
148 
149  /**
150   * Retrieves the <code>Id</code> value, without locking, 
151   * for this <code>ShopOrder</code> <code>Persistent</code>.
152   *
153   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
154   * @return the Integer id
155   */
156   public Integer getId_unsafe() {
157     return id;
158   }
159 
160 
161  /**
162   * Sets the <code>Id</code> value directly, without checking, 
163   * for this ShopOrder <code>Persistent</code>.
164   * 
165   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
166   * @param cooked  the pre-validated value to set
167   */
168   public void setId_unsafe(Integer cooked) {
169     id = cooked;
170   }
171 
172  /**
173   * Retrieves the Id value, with locking, for this 
174   * <code>ShopOrder</code> <code>Persistent</code>.
175   * 
176   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
177   * @throws AccessPoemException 
178   *         if the current <code>AccessToken</code> 
179   *         does not confer write access rights 
180   * @return the value of the field <code>Id</code> for this 
181   *         <code>ShopOrder</code> <code>Persistent</code>  
182   */
183 
184   public Integer getId()
185       throws AccessPoemException {
186     readLock();
187     return getId_unsafe();
188   }
189 
190 
191  /**
192   * Sets the <code>Id</code> value, with checking, for this 
193   * <code>ShopOrder</code> <code>Persistent</code>.
194   * 
195   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
196   * @param cooked  a validated <code>int</code> 
197   * @throws AccessPoemException 
198   *         if the current <code>AccessToken</code> 
199   *         does not confer write access rights
200   * @throws ValidationPoemException 
201   *         if the value is not valid
202   */
203   public void setId(Integer cooked)
204       throws AccessPoemException, ValidationPoemException {
205     _getShopOrderTable().getIdColumn().
206       getType().assertValidCooked(cooked);
207     writeLock();
208     setId_unsafe(cooked);
209   }
210 
211  /**
212   * Sets the <code>Id</code> value, with checking, for this 
213   * <code>ShopOrder</code> <code>Persistent</code>.
214   * 
215   * Generated by org.melati.poem.prepro.IntegerFieldDef#generateBaseMethods 
216   * @param cooked  a validated <code>int</code>
217   * @throws AccessPoemException 
218   *         if the current <code>AccessToken</code> 
219   *         does not confer write access rights
220   * @throws ValidationPoemException 
221   *         if the value is not valid
222   */
223 
224   public final void setId(int cooked)
225       throws AccessPoemException, ValidationPoemException {
226     setId(new Integer(cooked));
227   }
228 
229 
230  /**
231   * Retrieves the <code>Id</code> value as a <code>Field</code>
232   * from this <code>ShopOrder</code> <code>Persistent</code>.
233   * 
234   * see org.melati.poem.prepro.FieldDef#generateFieldCreator 
235   * @throws AccessPoemException 
236   *         if the current <code>AccessToken</code> 
237   *         does not confer write access rights
238   * @return the Integer id
239   */
240   public Field<Integer> getIdField() throws AccessPoemException {
241     Column<Integer> c = _getShopOrderTable().getIdColumn();
242     return new Field<Integer>((Integer)c.getRaw(this), c);
243   }
244 
245 
246  /**
247   * Retrieves the <code>User</code> value, without locking, 
248   * for this <code>ShopOrder</code> <code>Persistent</code>.
249   *
250   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
251   * @return the Integer user
252   */
253   public Integer getUser_unsafe() {
254     return user;
255   }
256 
257 
258  /**
259   * Sets the <code>User</code> value directly, without checking, 
260   * for this ShopOrder <code>Persistent</code>.
261   * 
262   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
263   * @param cooked  the pre-validated value to set
264   */
265   public void setUser_unsafe(Integer cooked) {
266     user = cooked;
267   }
268 
269  /**
270   * Retrieves the Table Row Object ID. 
271   *
272   * Generated by org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
273   * @throws AccessPoemException  
274   *         if the current <code>AccessToken</code> 
275   *         does not confer read access rights 
276   * @return the TROID as an <code>Integer</code> 
277   */
278 
279   public Integer getUserTroid()
280       throws AccessPoemException {
281     readLock();
282     return getUser_unsafe();
283   }
284 
285 
286  /**
287   * Sets the Table Row Object ID. 
288   * 
289   * Generated by org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
290   * @param raw  a Table Row Object Id 
291   * @throws AccessPoemException  
292   *         if the current <code>AccessToken</code> 
293   *         does not confer write access rights
294   */
295   public void setUserTroid(Integer raw)
296       throws AccessPoemException {
297     setUser(raw == null ? null : 
298         (User)getBibliomaniaDatabaseTables().getUserTable().getUserObject(raw));
299   }
300 
301 
302  /**
303   * Retrieves the <code>User</code> object referred to.
304   *  
305   * Generated by org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
306   * @throws AccessPoemException  
307   *         if the current <code>AccessToken</code> 
308   *         does not confer read access rights 
309   * @throws NoSuchRowPoemException  
310   *         if the <code>Persistent</code> has yet to be allocated a TROID 
311   * @return the <code>User</code> as a <code>User</code> 
312   */
313   public User getUser()
314       throws AccessPoemException, NoSuchRowPoemException {
315     Integer troid = getUserTroid();
316     return troid == null ? null :
317         (User)getBibliomaniaDatabaseTables().getUserTable().getUserObject(troid);
318   }
319 
320 
321  /**
322   * Set the User.
323   * 
324   * Generated by org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
325   * @param cooked  a validated <code>User</code>
326   * @throws AccessPoemException  
327   *         if the current <code>AccessToken</code> 
328   *         does not confer write access rights 
329   */
330   public void setUser(User cooked)
331       throws AccessPoemException {
332     _getShopOrderTable().
333       getUserColumn().
334         getType().assertValidCooked(cooked);
335     writeLock();
336     if (cooked == null)
337       setUser_unsafe(null);
338     else {
339       cooked.existenceLock();
340       setUser_unsafe(cooked.troid());
341     }
342   }
343 
344 
345  /**
346   * Retrieves the <code>User</code> value as a <code>Field</code>
347   * from this <code>ShopOrder</code> <code>Persistent</code>.
348   * 
349   * see org.melati.poem.prepro.FieldDef#generateFieldCreator 
350   * @throws AccessPoemException 
351   *         if the current <code>AccessToken</code> 
352   *         does not confer write access rights
353   * @return the Integer user
354   */
355   public Field<Integer> getUserField() throws AccessPoemException {
356     Column<Integer> c = _getShopOrderTable().getUserColumn();
357     return new Field<Integer>((Integer)c.getRaw(this), c);
358   }
359 
360 
361  /**
362   * Retrieves the <code>Status</code> value, without locking, 
363   * for this <code>ShopOrder</code> <code>Persistent</code>.
364   *
365   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
366   * @return the Integer status
367   */
368   public Integer getStatus_unsafe() {
369     return status;
370   }
371 
372 
373  /**
374   * Sets the <code>Status</code> value directly, without checking, 
375   * for this ShopOrder <code>Persistent</code>.
376   * 
377   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
378   * @param cooked  the pre-validated value to set
379   */
380   public void setStatus_unsafe(Integer cooked) {
381     status = cooked;
382   }
383 
384  /**
385   * Retrieves the Table Row Object ID. 
386   *
387   * Generated by org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
388   * @throws AccessPoemException  
389   *         if the current <code>AccessToken</code> 
390   *         does not confer read access rights 
391   * @return the TROID as an <code>Integer</code> 
392   */
393 
394   public Integer getStatusTroid()
395       throws AccessPoemException {
396     readLock();
397     return getStatus_unsafe();
398   }
399 
400 
401  /**
402   * Sets the Table Row Object ID. 
403   * 
404   * Generated by org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
405   * @param raw  a Table Row Object Id 
406   * @throws AccessPoemException  
407   *         if the current <code>AccessToken</code> 
408   *         does not confer write access rights
409   */
410   public void setStatusTroid(Integer raw)
411       throws AccessPoemException {
412     setStatus(raw == null ? null : 
413         getBibliomaniaDatabaseTables().getOrderStatusTable().getOrderStatusObject(raw));
414   }
415 
416 
417  /**
418   * Retrieves the <code>Status</code> object referred to.
419   *  
420   * Generated by org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
421   * @throws AccessPoemException  
422   *         if the current <code>AccessToken</code> 
423   *         does not confer read access rights 
424   * @throws NoSuchRowPoemException  
425   *         if the <code>Persistent</code> has yet to be allocated a TROID 
426   * @return the <code>Status</code> as a <code>OrderStatus</code> 
427   */
428   public OrderStatus getStatus()
429       throws AccessPoemException, NoSuchRowPoemException {
430     Integer troid = getStatusTroid();
431     return troid == null ? null :
432         getBibliomaniaDatabaseTables().getOrderStatusTable().getOrderStatusObject(troid);
433   }
434 
435 
436  /**
437   * Set the Status.
438   * 
439   * Generated by org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
440   * @param cooked  a validated <code>OrderStatus</code>
441   * @throws AccessPoemException  
442   *         if the current <code>AccessToken</code> 
443   *         does not confer write access rights 
444   */
445   public void setStatus(OrderStatus cooked)
446       throws AccessPoemException {
447     _getShopOrderTable().
448       getStatusColumn().
449         getType().assertValidCooked(cooked);
450     writeLock();
451     if (cooked == null)
452       setStatus_unsafe(null);
453     else {
454       cooked.existenceLock();
455       setStatus_unsafe(cooked.troid());
456     }
457   }
458 
459 
460  /**
461   * Retrieves the <code>Status</code> value as a <code>Field</code>
462   * from this <code>ShopOrder</code> <code>Persistent</code>.
463   * 
464   * see org.melati.poem.prepro.FieldDef#generateFieldCreator 
465   * @throws AccessPoemException 
466   *         if the current <code>AccessToken</code> 
467   *         does not confer write access rights
468   * @return the Integer status
469   */
470   public Field<Integer> getStatusField() throws AccessPoemException {
471     Column<Integer> c = _getShopOrderTable().getStatusColumn();
472     return new Field<Integer>((Integer)c.getRaw(this), c);
473   }
474 
475 
476  /**
477   * Retrieves the <code>Date</code> value, without locking, 
478   * for this <code>ShopOrder</code> <code>Persistent</code>.
479   *
480   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
481   * @return the Timestamp date
482   */
483   public Timestamp getDate_unsafe() {
484     return date;
485   }
486 
487 
488  /**
489   * Sets the <code>Date</code> value directly, without checking, 
490   * for this ShopOrder <code>Persistent</code>.
491   * 
492   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
493   * @param cooked  the pre-validated value to set
494   */
495   public void setDate_unsafe(Timestamp cooked) {
496     date = cooked;
497   }
498 
499  /**
500   * Retrieves the Date value, with locking, for this 
501   * <code>ShopOrder</code> <code>Persistent</code>.
502   * Field description: 
503   *   The date that this order was placed (leave blank to autocomplete) 
504   * 
505   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
506   * @throws AccessPoemException 
507   *         if the current <code>AccessToken</code> 
508   *         does not confer write access rights 
509   * @return the value of the field <code>Date</code> for this 
510   *         <code>ShopOrder</code> <code>Persistent</code>  
511   */
512 
513   public Timestamp getDate()
514       throws AccessPoemException {
515     readLock();
516     return getDate_unsafe();
517   }
518 
519 
520  /**
521   * Sets the <code>Date</code> value, with checking, for this 
522   * <code>ShopOrder</code> <code>Persistent</code>.
523   * Field description: 
524   *   The date that this order was placed (leave blank to autocomplete) 
525   * 
526   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
527   * @param cooked  a validated <code>int</code> 
528   * @throws AccessPoemException 
529   *         if the current <code>AccessToken</code> 
530   *         does not confer write access rights
531   * @throws ValidationPoemException 
532   *         if the value is not valid
533   */
534   public void setDate(Timestamp cooked)
535       throws AccessPoemException, ValidationPoemException {
536     _getShopOrderTable().getDateColumn().
537       getType().assertValidCooked(cooked);
538     writeLock();
539     setDate_unsafe(cooked);
540   }
541 
542 
543  /**
544   * Retrieves the <code>Date</code> value as a <code>Field</code>
545   * from this <code>ShopOrder</code> <code>Persistent</code>.
546   * 
547   * see org.melati.poem.prepro.FieldDef#generateFieldCreator 
548   * @throws AccessPoemException 
549   *         if the current <code>AccessToken</code> 
550   *         does not confer write access rights
551   * @return the Timestamp date
552   */
553   public Field<Timestamp> getDateField() throws AccessPoemException {
554     Column<Timestamp> c = _getShopOrderTable().getDateColumn();
555     return new Field<Timestamp>((Timestamp)c.getRaw(this), c);
556   }
557 
558 
559  /**
560   * Retrieves the <code>Fufilleddate</code> value, without locking, 
561   * for this <code>ShopOrder</code> <code>Persistent</code>.
562   *
563   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
564   * @return the Timestamp fufilleddate
565   */
566   public Timestamp getFufilleddate_unsafe() {
567     return fufilleddate;
568   }
569 
570 
571  /**
572   * Sets the <code>Fufilleddate</code> value directly, without checking, 
573   * for this ShopOrder <code>Persistent</code>.
574   * 
575   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
576   * @param cooked  the pre-validated value to set
577   */
578   public void setFufilleddate_unsafe(Timestamp cooked) {
579     fufilleddate = cooked;
580   }
581 
582  /**
583   * Retrieves the Fufilleddate value, with locking, for this 
584   * <code>ShopOrder</code> <code>Persistent</code>.
585   * Field description: 
586   *   The date that this order was fufilled (leave blank to autocomplete) 
587   * 
588   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
589   * @throws AccessPoemException 
590   *         if the current <code>AccessToken</code> 
591   *         does not confer write access rights 
592   * @return the value of the field <code>Fufilleddate</code> for this 
593   *         <code>ShopOrder</code> <code>Persistent</code>  
594   */
595 
596   public Timestamp getFufilleddate()
597       throws AccessPoemException {
598     readLock();
599     return getFufilleddate_unsafe();
600   }
601 
602 
603  /**
604   * Sets the <code>Fufilleddate</code> value, with checking, for this 
605   * <code>ShopOrder</code> <code>Persistent</code>.
606   * Field description: 
607   *   The date that this order was fufilled (leave blank to autocomplete) 
608   * 
609   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
610   * @param cooked  a validated <code>int</code> 
611   * @throws AccessPoemException 
612   *         if the current <code>AccessToken</code> 
613   *         does not confer write access rights
614   * @throws ValidationPoemException 
615   *         if the value is not valid
616   */
617   public void setFufilleddate(Timestamp cooked)
618       throws AccessPoemException, ValidationPoemException {
619     _getShopOrderTable().getFufilleddateColumn().
620       getType().assertValidCooked(cooked);
621     writeLock();
622     setFufilleddate_unsafe(cooked);
623   }
624 
625 
626  /**
627   * Retrieves the <code>Fufilleddate</code> value as a <code>Field</code>
628   * from this <code>ShopOrder</code> <code>Persistent</code>.
629   * 
630   * see org.melati.poem.prepro.FieldDef#generateFieldCreator 
631   * @throws AccessPoemException 
632   *         if the current <code>AccessToken</code> 
633   *         does not confer write access rights
634   * @return the Timestamp fufilleddate
635   */
636   public Field<Timestamp> getFufilleddateField() throws AccessPoemException {
637     Column<Timestamp> c = _getShopOrderTable().getFufilleddateColumn();
638     return new Field<Timestamp>((Timestamp)c.getRaw(this), c);
639   }
640 
641 
642  /**
643   * Retrieves the <code>Comment</code> value, without locking, 
644   * for this <code>ShopOrder</code> <code>Persistent</code>.
645   *
646   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
647   * @return the String comment
648   */
649   public String getComment_unsafe() {
650     return comment;
651   }
652 
653 
654  /**
655   * Sets the <code>Comment</code> value directly, without checking, 
656   * for this ShopOrder <code>Persistent</code>.
657   * 
658   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
659   * @param cooked  the pre-validated value to set
660   */
661   public void setComment_unsafe(String cooked) {
662     comment = cooked;
663   }
664 
665  /**
666   * Retrieves the Comment value, with locking, for this 
667   * <code>ShopOrder</code> <code>Persistent</code>.
668   * Field description: 
669   *   Any comments reguarding this order 
670   * 
671   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
672   * @throws AccessPoemException 
673   *         if the current <code>AccessToken</code> 
674   *         does not confer write access rights 
675   * @return the value of the field <code>Comment</code> for this 
676   *         <code>ShopOrder</code> <code>Persistent</code>  
677   */
678 
679   public String getComment()
680       throws AccessPoemException {
681     readLock();
682     return getComment_unsafe();
683   }
684 
685 
686  /**
687   * Sets the <code>Comment</code> value, with checking, for this 
688   * <code>ShopOrder</code> <code>Persistent</code>.
689   * Field description: 
690   *   Any comments reguarding this order 
691   * 
692   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
693   * @param cooked  a validated <code>int</code> 
694   * @throws AccessPoemException 
695   *         if the current <code>AccessToken</code> 
696   *         does not confer write access rights
697   * @throws ValidationPoemException 
698   *         if the value is not valid
699   */
700   public void setComment(String cooked)
701       throws AccessPoemException, ValidationPoemException {
702     _getShopOrderTable().getCommentColumn().
703       getType().assertValidCooked(cooked);
704     writeLock();
705     setComment_unsafe(cooked);
706   }
707 
708 
709  /**
710   * Retrieves the <code>Comment</code> value as a <code>Field</code>
711   * from this <code>ShopOrder</code> <code>Persistent</code>.
712   * 
713   * see org.melati.poem.prepro.FieldDef#generateFieldCreator 
714   * @throws AccessPoemException 
715   *         if the current <code>AccessToken</code> 
716   *         does not confer write access rights
717   * @return the String comment
718   */
719   public Field<String> getCommentField() throws AccessPoemException {
720     Column<String> c = _getShopOrderTable().getCommentColumn();
721     return new Field<String>((String)c.getRaw(this), c);
722   }
723 
724 
725  /**
726   * Retrieves the <code>Amount</code> value, without locking, 
727   * for this <code>ShopOrder</code> <code>Persistent</code>.
728   *
729   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
730   * @return the Double amount
731   */
732   public Double getAmount_unsafe() {
733     return amount;
734   }
735 
736 
737  /**
738   * Sets the <code>Amount</code> value directly, without checking, 
739   * for this ShopOrder <code>Persistent</code>.
740   * 
741   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
742   * @param cooked  the pre-validated value to set
743   */
744   public void setAmount_unsafe(Double cooked) {
745     amount = cooked;
746   }
747 
748  /**
749   * Retrieves the Amount value, with locking, for this 
750   * <code>ShopOrder</code> <code>Persistent</code>.
751   * Field description: 
752   *   The total amount of the order (in customer's currency) 
753   * 
754   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
755   * @throws AccessPoemException 
756   *         if the current <code>AccessToken</code> 
757   *         does not confer write access rights 
758   * @return the value of the field <code>Amount</code> for this 
759   *         <code>ShopOrder</code> <code>Persistent</code>  
760   */
761 
762   public Double getAmount()
763       throws AccessPoemException {
764     readLock();
765     return getAmount_unsafe();
766   }
767 
768 
769  /**
770   * Sets the <code>Amount</code> value, with checking, for this 
771   * <code>ShopOrder</code> <code>Persistent</code>.
772   * Field description: 
773   *   The total amount of the order (in customer's currency) 
774   * 
775   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
776   * @param cooked  a validated <code>int</code> 
777   * @throws AccessPoemException 
778   *         if the current <code>AccessToken</code> 
779   *         does not confer write access rights
780   * @throws ValidationPoemException 
781   *         if the value is not valid
782   */
783   public void setAmount(Double cooked)
784       throws AccessPoemException, ValidationPoemException {
785     _getShopOrderTable().getAmountColumn().
786       getType().assertValidCooked(cooked);
787     writeLock();
788     setAmount_unsafe(cooked);
789   }
790 
791  /**
792   * Sets the <code>Amount</code> value, with checking, for this <code>ShopOrder</code> <code>Persistent</code>.
793   * Field description: 
794   *   The total amount of the order (in customer's currency) 
795   * 
796   * 
797   * Generated by org.melati.poem.prepro.DoubleFieldDef#generateBaseMethods 
798   * @param cooked  a validated <code>int</code> 
799   * @throws AccessPoemException 
800   *         if the current <code>AccessToken</code> 
801   *         does not confer write access rights
802   * @throws ValidationPoemException 
803   *         if the value is not valid
804   */
805 
806   public final void setAmount(double cooked)
807       throws AccessPoemException, ValidationPoemException {
808     setAmount(new Double(cooked));
809   }
810 
811 
812  /**
813   * Retrieves the <code>Amount</code> value as a <code>Field</code>
814   * from this <code>ShopOrder</code> <code>Persistent</code>.
815   * 
816   * see org.melati.poem.prepro.FieldDef#generateFieldCreator 
817   * @throws AccessPoemException 
818   *         if the current <code>AccessToken</code> 
819   *         does not confer write access rights
820   * @return the Double amount
821   */
822   public Field<Double> getAmountField() throws AccessPoemException {
823     Column<Double> c = _getShopOrderTable().getAmountColumn();
824     return new Field<Double>((Double)c.getRaw(this), c);
825   }
826 
827 
828  /**
829   * Retrieves the <code>Delivery</code> value, without locking, 
830   * for this <code>ShopOrder</code> <code>Persistent</code>.
831   *
832   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
833   * @return the Double delivery
834   */
835   public Double getDelivery_unsafe() {
836     return delivery;
837   }
838 
839 
840  /**
841   * Sets the <code>Delivery</code> value directly, without checking, 
842   * for this ShopOrder <code>Persistent</code>.
843   * 
844   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
845   * @param cooked  the pre-validated value to set
846   */
847   public void setDelivery_unsafe(Double cooked) {
848     delivery = cooked;
849   }
850 
851  /**
852   * Retrieves the Delivery value, with locking, for this 
853   * <code>ShopOrder</code> <code>Persistent</code>.
854   * Field description: 
855   *   The total delivery charge for the order (in customer's currency) 
856   * 
857   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
858   * @throws AccessPoemException 
859   *         if the current <code>AccessToken</code> 
860   *         does not confer write access rights 
861   * @return the value of the field <code>Delivery</code> for this 
862   *         <code>ShopOrder</code> <code>Persistent</code>  
863   */
864 
865   public Double getDelivery()
866       throws AccessPoemException {
867     readLock();
868     return getDelivery_unsafe();
869   }
870 
871 
872  /**
873   * Sets the <code>Delivery</code> value, with checking, for this 
874   * <code>ShopOrder</code> <code>Persistent</code>.
875   * Field description: 
876   *   The total delivery charge for the order (in customer's currency) 
877   * 
878   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
879   * @param cooked  a validated <code>int</code> 
880   * @throws AccessPoemException 
881   *         if the current <code>AccessToken</code> 
882   *         does not confer write access rights
883   * @throws ValidationPoemException 
884   *         if the value is not valid
885   */
886   public void setDelivery(Double cooked)
887       throws AccessPoemException, ValidationPoemException {
888     _getShopOrderTable().getDeliveryColumn().
889       getType().assertValidCooked(cooked);
890     writeLock();
891     setDelivery_unsafe(cooked);
892   }
893 
894  /**
895   * Sets the <code>Delivery</code> value, with checking, for this <code>ShopOrder</code> <code>Persistent</code>.
896   * Field description: 
897   *   The total delivery charge for the order (in customer's currency) 
898   * 
899   * 
900   * Generated by org.melati.poem.prepro.DoubleFieldDef#generateBaseMethods 
901   * @param cooked  a validated <code>int</code> 
902   * @throws AccessPoemException 
903   *         if the current <code>AccessToken</code> 
904   *         does not confer write access rights
905   * @throws ValidationPoemException 
906   *         if the value is not valid
907   */
908 
909   public final void setDelivery(double cooked)
910       throws AccessPoemException, ValidationPoemException {
911     setDelivery(new Double(cooked));
912   }
913 
914 
915  /**
916   * Retrieves the <code>Delivery</code> value as a <code>Field</code>
917   * from this <code>ShopOrder</code> <code>Persistent</code>.
918   * 
919   * see org.melati.poem.prepro.FieldDef#generateFieldCreator 
920   * @throws AccessPoemException 
921   *         if the current <code>AccessToken</code> 
922   *         does not confer write access rights
923   * @return the Double delivery
924   */
925   public Field<Double> getDeliveryField() throws AccessPoemException {
926     Column<Double> c = _getShopOrderTable().getDeliveryColumn();
927     return new Field<Double>((Double)c.getRaw(this), c);
928   }
929 
930 
931  /**
932   * Retrieves the <code>AmountUK</code> value, without locking, 
933   * for this <code>ShopOrder</code> <code>Persistent</code>.
934   *
935   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
936   * @return the Double amountUK
937   */
938   public Double getAmountUK_unsafe() {
939     return amountUK;
940   }
941 
942 
943  /**
944   * Sets the <code>AmountUK</code> value directly, without checking, 
945   * for this ShopOrder <code>Persistent</code>.
946   * 
947   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
948   * @param cooked  the pre-validated value to set
949   */
950   public void setAmountUK_unsafe(Double cooked) {
951     amountUK = cooked;
952   }
953 
954  /**
955   * Retrieves the AmountUK value, with locking, for this 
956   * <code>ShopOrder</code> <code>Persistent</code>.
957   * Field description: 
958   *   The total amount of the order (UK Sterling Equivalent) 
959   * 
960   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
961   * @throws AccessPoemException 
962   *         if the current <code>AccessToken</code> 
963   *         does not confer write access rights 
964   * @return the value of the field <code>AmountUK</code> for this 
965   *         <code>ShopOrder</code> <code>Persistent</code>  
966   */
967 
968   public Double getAmountUK()
969       throws AccessPoemException {
970     readLock();
971     return getAmountUK_unsafe();
972   }
973 
974 
975  /**
976   * Sets the <code>AmountUK</code> value, with checking, for this 
977   * <code>ShopOrder</code> <code>Persistent</code>.
978   * Field description: 
979   *   The total amount of the order (UK Sterling Equivalent) 
980   * 
981   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
982   * @param cooked  a validated <code>int</code> 
983   * @throws AccessPoemException 
984   *         if the current <code>AccessToken</code> 
985   *         does not confer write access rights
986   * @throws ValidationPoemException 
987   *         if the value is not valid
988   */
989   public void setAmountUK(Double cooked)
990       throws AccessPoemException, ValidationPoemException {
991     _getShopOrderTable().getAmountUKColumn().
992       getType().assertValidCooked(cooked);
993     writeLock();
994     setAmountUK_unsafe(cooked);
995   }
996 
997  /**
998   * Sets the <code>AmountUK</code> value, with checking, for this <code>ShopOrder</code> <code>Persistent</code>.
999   * Field description: 
1000   *   The total amount of the order (UK Sterling Equivalent) 
1001   * 
1002   * 
1003   * Generated by org.melati.poem.prepro.DoubleFieldDef#generateBaseMethods 
1004   * @param cooked  a validated <code>int</code> 
1005   * @throws AccessPoemException 
1006   *         if the current <code>AccessToken</code> 
1007   *         does not confer write access rights
1008   * @throws ValidationPoemException 
1009   *         if the value is not valid
1010   */
1011 
1012   public final void setAmountUK(double cooked)
1013       throws AccessPoemException, ValidationPoemException {
1014     setAmountUK(new Double(cooked));
1015   }
1016 
1017 
1018  /**
1019   * Retrieves the <code>AmountUK</code> value as a <code>Field</code>
1020   * from this <code>ShopOrder</code> <code>Persistent</code>.
1021   * 
1022   * see org.melati.poem.prepro.FieldDef#generateFieldCreator 
1023   * @throws AccessPoemException 
1024   *         if the current <code>AccessToken</code> 
1025   *         does not confer write access rights
1026   * @return the Double amountUK
1027   */
1028   public Field<Double> getAmountUKField() throws AccessPoemException {
1029     Column<Double> c = _getShopOrderTable().getAmountUKColumn();
1030     return new Field<Double>((Double)c.getRaw(this), c);
1031   }
1032 
1033 
1034  /**
1035   * Retrieves the <code>DeliveryUK</code> value, without locking, 
1036   * for this <code>ShopOrder</code> <code>Persistent</code>.
1037   *
1038   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
1039   * @return the Double deliveryUK
1040   */
1041   public Double getDeliveryUK_unsafe() {
1042     return deliveryUK;
1043   }
1044 
1045 
1046  /**
1047   * Sets the <code>DeliveryUK</code> value directly, without checking, 
1048   * for this ShopOrder <code>Persistent</code>.
1049   * 
1050   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
1051   * @param cooked  the pre-validated value to set
1052   */
1053   public void setDeliveryUK_unsafe(Double cooked) {
1054     deliveryUK = cooked;
1055   }
1056 
1057  /**
1058   * Retrieves the DeliveryUK value, with locking, for this 
1059   * <code>ShopOrder</code> <code>Persistent</code>.
1060   * Field description: 
1061   *   The total delivery charge for the order (UK Sterling Equivalent) 
1062   * 
1063   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
1064   * @throws AccessPoemException 
1065   *         if the current <code>AccessToken</code> 
1066   *         does not confer write access rights 
1067   * @return the value of the field <code>DeliveryUK</code> for this 
1068   *         <code>ShopOrder</code> <code>Persistent</code>  
1069   */
1070 
1071   public Double getDeliveryUK()
1072       throws AccessPoemException {
1073     readLock();
1074     return getDeliveryUK_unsafe();
1075   }
1076 
1077 
1078  /**
1079   * Sets the <code>DeliveryUK</code> value, with checking, for this 
1080   * <code>ShopOrder</code> <code>Persistent</code>.
1081   * Field description: 
1082   *   The total delivery charge for the order (UK Sterling Equivalent) 
1083   * 
1084   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
1085   * @param cooked  a validated <code>int</code> 
1086   * @throws AccessPoemException 
1087   *         if the current <code>AccessToken</code> 
1088   *         does not confer write access rights
1089   * @throws ValidationPoemException 
1090   *         if the value is not valid
1091   */
1092   public void setDeliveryUK(Double cooked)
1093       throws AccessPoemException, ValidationPoemException {
1094     _getShopOrderTable().getDeliveryUKColumn().
1095       getType().assertValidCooked(cooked);
1096     writeLock();
1097     setDeliveryUK_unsafe(cooked);
1098   }
1099 
1100  /**
1101   * Sets the <code>DeliveryUK</code> value, with checking, for this <code>ShopOrder</code> <code>Persistent</code>.
1102   * Field description: 
1103   *   The total delivery charge for the order (UK Sterling Equivalent) 
1104   * 
1105   * 
1106   * Generated by org.melati.poem.prepro.DoubleFieldDef#generateBaseMethods 
1107   * @param cooked  a validated <code>int</code> 
1108   * @throws AccessPoemException 
1109   *         if the current <code>AccessToken</code> 
1110   *         does not confer write access rights
1111   * @throws ValidationPoemException 
1112   *         if the value is not valid
1113   */
1114 
1115   public final void setDeliveryUK(double cooked)
1116       throws AccessPoemException, ValidationPoemException {
1117     setDeliveryUK(new Double(cooked));
1118   }
1119 
1120 
1121  /**
1122   * Retrieves the <code>DeliveryUK</code> value as a <code>Field</code>
1123   * from this <code>ShopOrder</code> <code>Persistent</code>.
1124   * 
1125   * see org.melati.poem.prepro.FieldDef#generateFieldCreator 
1126   * @throws AccessPoemException 
1127   *         if the current <code>AccessToken</code> 
1128   *         does not confer write access rights
1129   * @return the Double deliveryUK
1130   */
1131   public Field<Double> getDeliveryUKField() throws AccessPoemException {
1132     Column<Double> c = _getShopOrderTable().getDeliveryUKColumn();
1133     return new Field<Double>((Double)c.getRaw(this), c);
1134   }
1135 
1136 
1137  /**
1138   * Retrieves the <code>Name</code> value, without locking, 
1139   * for this <code>ShopOrder</code> <code>Persistent</code>.
1140   *
1141   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
1142   * @return the String name
1143   */
1144   public String getName_unsafe() {
1145     return name;
1146   }
1147 
1148 
1149  /**
1150   * Sets the <code>Name</code> value directly, without checking, 
1151   * for this ShopOrder <code>Persistent</code>.
1152   * 
1153   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
1154   * @param cooked  the pre-validated value to set
1155   */
1156   public void setName_unsafe(String cooked) {
1157     name = cooked;
1158   }
1159 
1160  /**
1161   * Retrieves the Name value, with locking, for this 
1162   * <code>ShopOrder</code> <code>Persistent</code>.
1163   * Field description: 
1164   *   The user's real name 
1165   * 
1166   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
1167   * @throws AccessPoemException 
1168   *         if the current <code>AccessToken</code> 
1169   *         does not confer write access rights 
1170   * @return the value of the field <code>Name</code> for this 
1171   *         <code>ShopOrder</code> <code>Persistent</code>  
1172   */
1173 
1174   public String getName()
1175       throws AccessPoemException {
1176     readLock();
1177     return getName_unsafe();
1178   }
1179 
1180 
1181  /**
1182   * Sets the <code>Name</code> value, with checking, for this 
1183   * <code>ShopOrder</code> <code>Persistent</code>.
1184   * Field description: 
1185   *   The user's real name 
1186   * 
1187   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
1188   * @param cooked  a validated <code>int</code> 
1189   * @throws AccessPoemException 
1190   *         if the current <code>AccessToken</code> 
1191   *         does not confer write access rights
1192   * @throws ValidationPoemException 
1193   *         if the value is not valid
1194   */
1195   public void setName(String cooked)
1196       throws AccessPoemException, ValidationPoemException {
1197     _getShopOrderTable().getNameColumn().
1198       getType().assertValidCooked(cooked);
1199     writeLock();
1200     setName_unsafe(cooked);
1201   }
1202 
1203 
1204  /**
1205   * Retrieves the <code>Name</code> value as a <code>Field</code>
1206   * from this <code>ShopOrder</code> <code>Persistent</code>.
1207   * 
1208   * see org.melati.poem.prepro.FieldDef#generateFieldCreator 
1209   * @throws AccessPoemException 
1210   *         if the current <code>AccessToken</code> 
1211   *         does not confer write access rights
1212   * @return the String name
1213   */
1214   public Field<String> getNameField() throws AccessPoemException {
1215     Column<String> c = _getShopOrderTable().getNameColumn();
1216     return new Field<String>((String)c.getRaw(this), c);
1217   }
1218 
1219 
1220  /**
1221   * Retrieves the <code>Email</code> value, without locking, 
1222   * for this <code>ShopOrder</code> <code>Persistent</code>.
1223   *
1224   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
1225   * @return the String email
1226   */
1227   public String getEmail_unsafe() {
1228     return email;
1229   }
1230 
1231 
1232  /**
1233   * Sets the <code>Email</code> value directly, without checking, 
1234   * for this ShopOrder <code>Persistent</code>.
1235   * 
1236   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
1237   * @param cooked  the pre-validated value to set
1238   */
1239   public void setEmail_unsafe(String cooked) {
1240     email = cooked;
1241   }
1242 
1243  /**
1244   * Retrieves the Email value, with locking, for this 
1245   * <code>ShopOrder</code> <code>Persistent</code>.
1246   * Field description: 
1247   *   email 
1248   * 
1249   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
1250   * @throws AccessPoemException 
1251   *         if the current <code>AccessToken</code> 
1252   *         does not confer write access rights 
1253   * @return the value of the field <code>Email</code> for this 
1254   *         <code>ShopOrder</code> <code>Persistent</code>  
1255   */
1256 
1257   public String getEmail()
1258       throws AccessPoemException {
1259     readLock();
1260     return getEmail_unsafe();
1261   }
1262 
1263 
1264  /**
1265   * Sets the <code>Email</code> value, with checking, for this 
1266   * <code>ShopOrder</code> <code>Persistent</code>.
1267   * Field description: 
1268   *   email 
1269   * 
1270   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
1271   * @param cooked  a validated <code>int</code> 
1272   * @throws AccessPoemException 
1273   *         if the current <code>AccessToken</code> 
1274   *         does not confer write access rights
1275   * @throws ValidationPoemException 
1276   *         if the value is not valid
1277   */
1278   public void setEmail(String cooked)
1279       throws AccessPoemException, ValidationPoemException {
1280     _getShopOrderTable().getEmailColumn().
1281       getType().assertValidCooked(cooked);
1282     writeLock();
1283     setEmail_unsafe(cooked);
1284   }
1285 
1286 
1287  /**
1288   * Retrieves the <code>Email</code> value as a <code>Field</code>
1289   * from this <code>ShopOrder</code> <code>Persistent</code>.
1290   * 
1291   * see org.melati.poem.prepro.FieldDef#generateFieldCreator 
1292   * @throws AccessPoemException 
1293   *         if the current <code>AccessToken</code> 
1294   *         does not confer write access rights
1295   * @return the String email
1296   */
1297   public Field<String> getEmailField() throws AccessPoemException {
1298     Column<String> c = _getShopOrderTable().getEmailColumn();
1299     return new Field<String>((String)c.getRaw(this), c);
1300   }
1301 
1302 
1303  /**
1304   * Retrieves the <code>Address</code> value, without locking, 
1305   * for this <code>ShopOrder</code> <code>Persistent</code>.
1306   *
1307   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
1308   * @return the String address
1309   */
1310   public String getAddress_unsafe() {
1311     return address;
1312   }
1313 
1314 
1315  /**
1316   * Sets the <code>Address</code> value directly, without checking, 
1317   * for this ShopOrder <code>Persistent</code>.
1318   * 
1319   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
1320   * @param cooked  the pre-validated value to set
1321   */
1322   public void setAddress_unsafe(String cooked) {
1323     address = cooked;
1324   }
1325 
1326  /**
1327   * Retrieves the Address value, with locking, for this 
1328   * <code>ShopOrder</code> <code>Persistent</code>.
1329   * 
1330   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
1331   * @throws AccessPoemException 
1332   *         if the current <code>AccessToken</code> 
1333   *         does not confer write access rights 
1334   * @return the value of the field <code>Address</code> for this 
1335   *         <code>ShopOrder</code> <code>Persistent</code>  
1336   */
1337 
1338   public String getAddress()
1339       throws AccessPoemException {
1340     readLock();
1341     return getAddress_unsafe();
1342   }
1343 
1344 
1345  /**
1346   * Sets the <code>Address</code> value, with checking, for this 
1347   * <code>ShopOrder</code> <code>Persistent</code>.
1348   * 
1349   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
1350   * @param cooked  a validated <code>int</code> 
1351   * @throws AccessPoemException 
1352   *         if the current <code>AccessToken</code> 
1353   *         does not confer write access rights
1354   * @throws ValidationPoemException 
1355   *         if the value is not valid
1356   */
1357   public void setAddress(String cooked)
1358       throws AccessPoemException, ValidationPoemException {
1359     _getShopOrderTable().getAddressColumn().
1360       getType().assertValidCooked(cooked);
1361     writeLock();
1362     setAddress_unsafe(cooked);
1363   }
1364 
1365 
1366  /**
1367   * Retrieves the <code>Address</code> value as a <code>Field</code>
1368   * from this <code>ShopOrder</code> <code>Persistent</code>.
1369   * 
1370   * see org.melati.poem.prepro.FieldDef#generateFieldCreator 
1371   * @throws AccessPoemException 
1372   *         if the current <code>AccessToken</code> 
1373   *         does not confer write access rights
1374   * @return the String address
1375   */
1376   public Field<String> getAddressField() throws AccessPoemException {
1377     Column<String> c = _getShopOrderTable().getAddressColumn();
1378     return new Field<String>((String)c.getRaw(this), c);
1379   }
1380 
1381 
1382  /**
1383   * Retrieves the <code>Town</code> value, without locking, 
1384   * for this <code>ShopOrder</code> <code>Persistent</code>.
1385   *
1386   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
1387   * @return the String town
1388   */
1389   public String getTown_unsafe() {
1390     return town;
1391   }
1392 
1393 
1394  /**
1395   * Sets the <code>Town</code> value directly, without checking, 
1396   * for this ShopOrder <code>Persistent</code>.
1397   * 
1398   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
1399   * @param cooked  the pre-validated value to set
1400   */
1401   public void setTown_unsafe(String cooked) {
1402     town = cooked;
1403   }
1404 
1405  /**
1406   * Retrieves the Town value, with locking, for this 
1407   * <code>ShopOrder</code> <code>Persistent</code>.
1408   * 
1409   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
1410   * @throws AccessPoemException 
1411   *         if the current <code>AccessToken</code> 
1412   *         does not confer write access rights 
1413   * @return the value of the field <code>Town</code> for this 
1414   *         <code>ShopOrder</code> <code>Persistent</code>  
1415   */
1416 
1417   public String getTown()
1418       throws AccessPoemException {
1419     readLock();
1420     return getTown_unsafe();
1421   }
1422 
1423 
1424  /**
1425   * Sets the <code>Town</code> value, with checking, for this 
1426   * <code>ShopOrder</code> <code>Persistent</code>.
1427   * 
1428   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
1429   * @param cooked  a validated <code>int</code> 
1430   * @throws AccessPoemException 
1431   *         if the current <code>AccessToken</code> 
1432   *         does not confer write access rights
1433   * @throws ValidationPoemException 
1434   *         if the value is not valid
1435   */
1436   public void setTown(String cooked)
1437       throws AccessPoemException, ValidationPoemException {
1438     _getShopOrderTable().getTownColumn().
1439       getType().assertValidCooked(cooked);
1440     writeLock();
1441     setTown_unsafe(cooked);
1442   }
1443 
1444 
1445  /**
1446   * Retrieves the <code>Town</code> value as a <code>Field</code>
1447   * from this <code>ShopOrder</code> <code>Persistent</code>.
1448   * 
1449   * see org.melati.poem.prepro.FieldDef#generateFieldCreator 
1450   * @throws AccessPoemException 
1451   *         if the current <code>AccessToken</code> 
1452   *         does not confer write access rights
1453   * @return the String town
1454   */
1455   public Field<String> getTownField() throws AccessPoemException {
1456     Column<String> c = _getShopOrderTable().getTownColumn();
1457     return new Field<String>((String)c.getRaw(this), c);
1458   }
1459 
1460 
1461  /**
1462   * Retrieves the <code>County</code> value, without locking, 
1463   * for this <code>ShopOrder</code> <code>Persistent</code>.
1464   *
1465   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
1466   * @return the String county
1467   */
1468   public String getCounty_unsafe() {
1469     return county;
1470   }
1471 
1472 
1473  /**
1474   * Sets the <code>County</code> value directly, without checking, 
1475   * for this ShopOrder <code>Persistent</code>.
1476   * 
1477   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
1478   * @param cooked  the pre-validated value to set
1479   */
1480   public void setCounty_unsafe(String cooked) {
1481     county = cooked;
1482   }
1483 
1484  /**
1485   * Retrieves the County value, with locking, for this 
1486   * <code>ShopOrder</code> <code>Persistent</code>.
1487   * 
1488   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
1489   * @throws AccessPoemException 
1490   *         if the current <code>AccessToken</code> 
1491   *         does not confer write access rights 
1492   * @return the value of the field <code>County</code> for this 
1493   *         <code>ShopOrder</code> <code>Persistent</code>  
1494   */
1495 
1496   public String getCounty()
1497       throws AccessPoemException {
1498     readLock();
1499     return getCounty_unsafe();
1500   }
1501 
1502 
1503  /**
1504   * Sets the <code>County</code> value, with checking, for this 
1505   * <code>ShopOrder</code> <code>Persistent</code>.
1506   * 
1507   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
1508   * @param cooked  a validated <code>int</code> 
1509   * @throws AccessPoemException 
1510   *         if the current <code>AccessToken</code> 
1511   *         does not confer write access rights
1512   * @throws ValidationPoemException 
1513   *         if the value is not valid
1514   */
1515   public void setCounty(String cooked)
1516       throws AccessPoemException, ValidationPoemException {
1517     _getShopOrderTable().getCountyColumn().
1518       getType().assertValidCooked(cooked);
1519     writeLock();
1520     setCounty_unsafe(cooked);
1521   }
1522 
1523 
1524  /**
1525   * Retrieves the <code>County</code> value as a <code>Field</code>
1526   * from this <code>ShopOrder</code> <code>Persistent</code>.
1527   * 
1528   * see org.melati.poem.prepro.FieldDef#generateFieldCreator 
1529   * @throws AccessPoemException 
1530   *         if the current <code>AccessToken</code> 
1531   *         does not confer write access rights
1532   * @return the String county
1533   */
1534   public Field<String> getCountyField() throws AccessPoemException {
1535     Column<String> c = _getShopOrderTable().getCountyColumn();
1536     return new Field<String>((String)c.getRaw(this), c);
1537   }
1538 
1539 
1540  /**
1541   * Retrieves the <code>Tel</code> value, without locking, 
1542   * for this <code>ShopOrder</code> <code>Persistent</code>.
1543   *
1544   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
1545   * @return the String tel
1546   */
1547   public String getTel_unsafe() {
1548     return tel;
1549   }
1550 
1551 
1552  /**
1553   * Sets the <code>Tel</code> value directly, without checking, 
1554   * for this ShopOrder <code>Persistent</code>.
1555   * 
1556   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
1557   * @param cooked  the pre-validated value to set
1558   */
1559   public void setTel_unsafe(String cooked) {
1560     tel = cooked;
1561   }
1562 
1563  /**
1564   * Retrieves the Tel value, with locking, for this 
1565   * <code>ShopOrder</code> <code>Persistent</code>.
1566   * Field description: 
1567   *   Order telephone number 
1568   * 
1569   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
1570   * @throws AccessPoemException 
1571   *         if the current <code>AccessToken</code> 
1572   *         does not confer write access rights 
1573   * @return the value of the field <code>Tel</code> for this 
1574   *         <code>ShopOrder</code> <code>Persistent</code>  
1575   */
1576 
1577   public String getTel()
1578       throws AccessPoemException {
1579     readLock();
1580     return getTel_unsafe();
1581   }
1582 
1583 
1584  /**
1585   * Sets the <code>Tel</code> value, with checking, for this 
1586   * <code>ShopOrder</code> <code>Persistent</code>.
1587   * Field description: 
1588   *   Order telephone number 
1589   * 
1590   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
1591   * @param cooked  a validated <code>int</code> 
1592   * @throws AccessPoemException 
1593   *         if the current <code>AccessToken</code> 
1594   *         does not confer write access rights
1595   * @throws ValidationPoemException 
1596   *         if the value is not valid
1597   */
1598   public void setTel(String cooked)
1599       throws AccessPoemException, ValidationPoemException {
1600     _getShopOrderTable().getTelColumn().
1601       getType().assertValidCooked(cooked);
1602     writeLock();
1603     setTel_unsafe(cooked);
1604   }
1605 
1606 
1607  /**
1608   * Retrieves the <code>Tel</code> value as a <code>Field</code>
1609   * from this <code>ShopOrder</code> <code>Persistent</code>.
1610   * 
1611   * see org.melati.poem.prepro.FieldDef#generateFieldCreator 
1612   * @throws AccessPoemException 
1613   *         if the current <code>AccessToken</code> 
1614   *         does not confer write access rights
1615   * @return the String tel
1616   */
1617   public Field<String> getTelField() throws AccessPoemException {
1618     Column<String> c = _getShopOrderTable().getTelColumn();
1619     return new Field<String>((String)c.getRaw(this), c);
1620   }
1621 
1622 
1623  /**
1624   * Retrieves the <code>Postcode</code> value, without locking, 
1625   * for this <code>ShopOrder</code> <code>Persistent</code>.
1626   *
1627   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
1628   * @return the String postcode
1629   */
1630   public String getPostcode_unsafe() {
1631     return postcode;
1632   }
1633 
1634 
1635  /**
1636   * Sets the <code>Postcode</code> value directly, without checking, 
1637   * for this ShopOrder <code>Persistent</code>.
1638   * 
1639   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
1640   * @param cooked  the pre-validated value to set
1641   */
1642   public void setPostcode_unsafe(String cooked) {
1643     postcode = cooked;
1644   }
1645 
1646  /**
1647   * Retrieves the Postcode value, with locking, for this 
1648   * <code>ShopOrder</code> <code>Persistent</code>.
1649   * Field description: 
1650   *   Order postcode 
1651   * 
1652   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
1653   * @throws AccessPoemException 
1654   *         if the current <code>AccessToken</code> 
1655   *         does not confer write access rights 
1656   * @return the value of the field <code>Postcode</code> for this 
1657   *         <code>ShopOrder</code> <code>Persistent</code>  
1658   */
1659 
1660   public String getPostcode()
1661       throws AccessPoemException {
1662     readLock();
1663     return getPostcode_unsafe();
1664   }
1665 
1666 
1667  /**
1668   * Sets the <code>Postcode</code> value, with checking, for this 
1669   * <code>ShopOrder</code> <code>Persistent</code>.
1670   * Field description: 
1671   *   Order postcode 
1672   * 
1673   * Generated by org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
1674   * @param cooked  a validated <code>int</code> 
1675   * @throws AccessPoemException 
1676   *         if the current <code>AccessToken</code> 
1677   *         does not confer write access rights
1678   * @throws ValidationPoemException 
1679   *         if the value is not valid
1680   */
1681   public void setPostcode(String cooked)
1682       throws AccessPoemException, ValidationPoemException {
1683     _getShopOrderTable().getPostcodeColumn().
1684       getType().assertValidCooked(cooked);
1685     writeLock();
1686     setPostcode_unsafe(cooked);
1687   }
1688 
1689 
1690  /**
1691   * Retrieves the <code>Postcode</code> value as a <code>Field</code>
1692   * from this <code>ShopOrder</code> <code>Persistent</code>.
1693   * 
1694   * see org.melati.poem.prepro.FieldDef#generateFieldCreator 
1695   * @throws AccessPoemException 
1696   *         if the current <code>AccessToken</code> 
1697   *         does not confer write access rights
1698   * @return the String postcode
1699   */
1700   public Field<String> getPostcodeField() throws AccessPoemException {
1701     Column<String> c = _getShopOrderTable().getPostcodeColumn();
1702     return new Field<String>((String)c.getRaw(this), c);
1703   }
1704 
1705 
1706  /**
1707   * Retrieves the <code>Country</code> value, without locking, 
1708   * for this <code>ShopOrder</code> <code>Persistent</code>.
1709   *
1710   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
1711   * @return the Integer country
1712   */
1713   public Integer getCountry_unsafe() {
1714     return country;
1715   }
1716 
1717 
1718  /**
1719   * Sets the <code>Country</code> value directly, without checking, 
1720   * for this ShopOrder <code>Persistent</code>.
1721   * 
1722   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
1723   * @param cooked  the pre-validated value to set
1724   */
1725   public void setCountry_unsafe(Integer cooked) {
1726     country = cooked;
1727   }
1728 
1729  /**
1730   * Retrieves the Table Row Object ID. 
1731   *
1732   * Generated by org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
1733   * @throws AccessPoemException  
1734   *         if the current <code>AccessToken</code> 
1735   *         does not confer read access rights 
1736   * @return the TROID as an <code>Integer</code> 
1737   */
1738 
1739   public Integer getCountryTroid()
1740       throws AccessPoemException {
1741     readLock();
1742     return getCountry_unsafe();
1743   }
1744 
1745 
1746  /**
1747   * Sets the Table Row Object ID. 
1748   * 
1749   * Generated by org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
1750   * @param raw  a Table Row Object Id 
1751   * @throws AccessPoemException  
1752   *         if the current <code>AccessToken</code> 
1753   *         does not confer write access rights
1754   */
1755   public void setCountryTroid(Integer raw)
1756       throws AccessPoemException {
1757     setCountry(raw == null ? null : 
1758         getBibliomaniaDatabaseTables().getCountryTable().getCountryObject(raw));
1759   }
1760 
1761 
1762  /**
1763   * Retrieves the <code>Country</code> object referred to.
1764   *  
1765   * Generated by org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
1766   * @throws AccessPoemException  
1767   *         if the current <code>AccessToken</code> 
1768   *         does not confer read access rights 
1769   * @throws NoSuchRowPoemException  
1770   *         if the <code>Persistent</code> has yet to be allocated a TROID 
1771   * @return the <code>Country</code> as a <code>Country</code> 
1772   */
1773   public Country getCountry()
1774       throws AccessPoemException, NoSuchRowPoemException {
1775     Integer troid = getCountryTroid();
1776     return troid == null ? null :
1777         getBibliomaniaDatabaseTables().getCountryTable().getCountryObject(troid);
1778   }
1779 
1780 
1781  /**
1782   * Set the Country.
1783   * 
1784   * Generated by org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
1785   * @param cooked  a validated <code>Country</code>
1786   * @throws AccessPoemException  
1787   *         if the current <code>AccessToken</code> 
1788   *         does not confer write access rights 
1789   */
1790   public void setCountry(Country cooked)
1791       throws AccessPoemException {
1792     _getShopOrderTable().
1793       getCountryColumn().
1794         getType().assertValidCooked(cooked);
1795     writeLock();
1796     if (cooked == null)
1797       setCountry_unsafe(null);
1798     else {
1799       cooked.existenceLock();
1800       setCountry_unsafe(cooked.troid());
1801     }
1802   }
1803 
1804 
1805  /**
1806   * Retrieves the <code>Country</code> value as a <code>Field</code>
1807   * from this <code>ShopOrder</code> <code>Persistent</code>.
1808   * 
1809   * see org.melati.poem.prepro.FieldDef#generateFieldCreator 
1810   * @throws AccessPoemException 
1811   *         if the current <code>AccessToken</code> 
1812   *         does not confer write access rights
1813   * @return the Integer country
1814   */
1815   public Field<Integer> getCountryField() throws AccessPoemException {
1816     Column<Integer> c = _getShopOrderTable().getCountryColumn();
1817     return new Field<Integer>((Integer)c.getRaw(this), c);
1818   }
1819 
1820 
1821  /**
1822   * Retrieves the <code>Currency</code> value, without locking, 
1823   * for this <code>ShopOrder</code> <code>Persistent</code>.
1824   *
1825   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
1826   * @return the Integer currency
1827   */
1828   public Integer getCurrency_unsafe() {
1829     return currency;
1830   }
1831 
1832 
1833  /**
1834   * Sets the <code>Currency</code> value directly, without checking, 
1835   * for this ShopOrder <code>Persistent</code>.
1836   * 
1837   * see org.melati.poem.prepro.FieldDef#generateBaseMethods 
1838   * @param cooked  the pre-validated value to set
1839   */
1840   public void setCurrency_unsafe(Integer cooked) {
1841     currency = cooked;
1842   }
1843 
1844  /**
1845   * Retrieves the Table Row Object ID. 
1846   *
1847   * Generated by org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
1848   * @throws AccessPoemException  
1849   *         if the current <code>AccessToken</code> 
1850   *         does not confer read access rights 
1851   * @return the TROID as an <code>Integer</code> 
1852   */
1853 
1854   public Integer getCurrencyTroid()
1855       throws AccessPoemException {
1856     readLock();
1857     return getCurrency_unsafe();
1858   }
1859 
1860 
1861  /**
1862   * Sets the Table Row Object ID. 
1863   * 
1864   * Generated by org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
1865   * @param raw  a Table Row Object Id 
1866   * @throws AccessPoemException  
1867   *         if the current <code>AccessToken</code> 
1868   *         does not confer write access rights
1869   */
1870   public void setCurrencyTroid(Integer raw)
1871       throws AccessPoemException {
1872     setCurrency(raw == null ? null : 
1873         getBibliomaniaDatabaseTables().getCurrencyTable().getCurrencyObject(raw));
1874   }
1875 
1876 
1877  /**
1878   * Retrieves the <code>Currency</code> object referred to.
1879   *  
1880   * Generated by org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
1881   * @throws AccessPoemException  
1882   *         if the current <code>AccessToken</code> 
1883   *         does not confer read access rights 
1884   * @throws NoSuchRowPoemException  
1885   *         if the <code>Persistent</code> has yet to be allocated a TROID 
1886   * @return the <code>Currency</code> as a <code>Currency</code> 
1887   */
1888   public Currency getCurrency()
1889       throws AccessPoemException, NoSuchRowPoemException {
1890     Integer troid = getCurrencyTroid();
1891     return troid == null ? null :
1892         getBibliomaniaDatabaseTables().getCurrencyTable().getCurrencyObject(troid);
1893   }
1894 
1895 
1896  /**
1897   * Set the Currency.
1898   * 
1899   * Generated by org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
1900   * @param cooked  a validated <code>Currency</code>
1901   * @throws AccessPoemException  
1902   *         if the current <code>AccessToken</code> 
1903   *         does not confer write access rights 
1904   */
1905   public void setCurrency(Currency cooked)
1906       throws AccessPoemException {
1907     _getShopOrderTable().
1908       getCurrencyColumn().
1909         getType().assertValidCooked(cooked);
1910     writeLock();
1911     if (cooked == null)
1912       setCurrency_unsafe(null);
1913     else {
1914       cooked.existenceLock();
1915       setCurrency_unsafe(cooked.troid());
1916     }
1917   }
1918 
1919 
1920  /**
1921   * Retrieves the <code>Currency</code> value as a <code>Field</code>
1922   * from this <code>ShopOrder</code> <code>Persistent</code>.
1923   * 
1924   * see org.melati.poem.prepro.FieldDef#generateFieldCreator 
1925   * @throws AccessPoemException 
1926   *         if the current <code>AccessToken</code> 
1927   *         does not confer write access rights
1928   * @return the Integer currency
1929   */
1930   public Field<Integer> getCurrencyField() throws AccessPoemException {
1931     Column<Integer> c = _getShopOrderTable().getCurrencyColumn();
1932     return new Field<Integer>((Integer)c.getRaw(this), c);
1933   }
1934 
1935   private CachedSelection<ShopOrderItem> orderShopOrderItems = null;
1936   /** References to this ShopOrder in the ShopOrderItem table via its order field.*/
1937   @SuppressWarnings("unchecked")
1938   public Enumeration<ShopOrderItem> getOrderShopOrderItems() {
1939     if (getTroid() == null)
1940       return new EmptyEnumeration<ShopOrderItem>();
1941     else {
1942       if (orderShopOrderItems == null)
1943         orderShopOrderItems =
1944           getBibliomaniaDatabaseTables().getShopOrderItemTable().getOrderColumn().cachedSelectionWhereEq(getTroid());
1945       return orderShopOrderItems.objects();
1946     }
1947   }
1948 
1949 
1950   /** References to this ShopOrder in the ShopOrderItem table via its order field, as a List.*/
1951   public List<ShopOrderItem> getOrderShopOrderItemList() {
1952     return Collections.list(getOrderShopOrderItems());
1953   }
1954 
1955 
1956 
1957 }
1958