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