Coverage Report - org.paneris.jammyjoes.model.generated.ShopOrderBase
 
Classes in this File Line Coverage Branch Coverage Complexity
ShopOrderBase
0%
0/408
0%
0/54
1.045
 
 1  
 // Do not edit this file!  It was generated by Melati POEM's DSD preprocessor.
 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  0
 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  0
     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  0
     return (ShopOrderTable)getTable();
 53  
   }
 54  
 
 55  
   private ShopOrderTable _getShopOrderTable() {
 56  0
     return (ShopOrderTable)getTable();
 57  
   }
 58  
 
 59  
   // Fields in this table 
 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  0
     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  0
     id = cooked;
 207  0
   }
 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  0
     readLock();
 224  0
     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  0
     _getShopOrderTable().getIdColumn().
 243  
       getType().assertValidCooked(cooked);
 244  0
     writeLock();
 245  0
     setId_unsafe(cooked);
 246  0
   }
 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  0
     setId(new Integer(cooked));
 264  0
   }
 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  0
     Column c = _getShopOrderTable().getIdColumn();
 279  0
     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  0
     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  0
     user = cooked;
 304  0
   }
 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  0
     readLock();
 319  0
     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  0
     setUser(raw == null ? null : 
 335  
         (User)getJammyjoesDatabaseTables().getUserTable().getUserObject(raw));
 336  0
   }
 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  0
     Integer troid = getUserTroid();
 353  0
     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  0
     _getShopOrderTable().
 370  
       getUserColumn().
 371  
         getType().assertValidCooked(cooked);
 372  0
     writeLock();
 373  0
     if (cooked == null)
 374  0
       setUser_unsafe(null);
 375  
     else {
 376  0
       cooked.existenceLock();
 377  0
       setUser_unsafe(cooked.troid());
 378  
     }
 379  0
   }
 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  0
     Column c = _getShopOrderTable().getUserColumn();
 394  0
     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  0
     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  0
     operator = cooked;
 419  0
   }
 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  0
     readLock();
 434  0
     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  0
     setOperator(raw == null ? null : 
 450  
         (User)getJammyjoesDatabaseTables().getUserTable().getUserObject(raw));
 451  0
   }
 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  0
     Integer troid = getOperatorTroid();
 468  0
     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  0
     _getShopOrderTable().
 485  
       getOperatorColumn().
 486  
         getType().assertValidCooked(cooked);
 487  0
     writeLock();
 488  0
     if (cooked == null)
 489  0
       setOperator_unsafe(null);
 490  
     else {
 491  0
       cooked.existenceLock();
 492  0
       setOperator_unsafe(cooked.troid());
 493  
     }
 494  0
   }
 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  0
     Column c = _getShopOrderTable().getOperatorColumn();
 509  0
     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  0
     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  0
     status = cooked;
 534  0
   }
 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  0
     readLock();
 549  0
     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  0
     setStatus(raw == null ? null : 
 565  
         getJammyjoesDatabaseTables().getOrderStatusTable().getOrderStatusObject(raw));
 566  0
   }
 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  0
     Integer troid = getStatusTroid();
 583  0
     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  0
     _getShopOrderTable().
 600  
       getStatusColumn().
 601  
         getType().assertValidCooked(cooked);
 602  0
     writeLock();
 603  0
     if (cooked == null)
 604  0
       setStatus_unsafe(null);
 605  
     else {
 606  0
       cooked.existenceLock();
 607  0
       setStatus_unsafe(cooked.troid());
 608  
     }
 609  0
   }
 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  0
     Column c = _getShopOrderTable().getStatusColumn();
 624  0
     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  0
     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  0
     type = cooked;
 649  0
   }
 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  0
     readLock();
 664  0
     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  0
     setType(raw == null ? null : 
 680  
         getJammyjoesDatabaseTables().getOrderTypeTable().getOrderTypeObject(raw));
 681  0
   }
 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  0
     Integer troid = getTypeTroid();
 698  0
     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  0
     _getShopOrderTable().
 715  
       getTypeColumn().
 716  
         getType().assertValidCooked(cooked);
 717  0
     writeLock();
 718  0
     if (cooked == null)
 719  0
       setType_unsafe(null);
 720  
     else {
 721  0
       cooked.existenceLock();
 722  0
       setType_unsafe(cooked.troid());
 723  
     }
 724  0
   }
 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  0
     Column c = _getShopOrderTable().getTypeColumn();
 739  0
     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  0
     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  0
     date = cooked;
 764  0
   }
 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  0
     readLock();
 783  0
     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  0
     _getShopOrderTable().getDateColumn().
 804  
       getType().assertValidCooked(cooked);
 805  0
     writeLock();
 806  0
     setDate_unsafe(cooked);
 807  0
   }
 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  0
     Column c = _getShopOrderTable().getDateColumn();
 822  0
     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  0
     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  0
     fufilleddate = cooked;
 847  0
   }
 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  0
     readLock();
 866  0
     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  0
     _getShopOrderTable().getFufilleddateColumn().
 887  
       getType().assertValidCooked(cooked);
 888  0
     writeLock();
 889  0
     setFufilleddate_unsafe(cooked);
 890  0
   }
 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  0
     Column c = _getShopOrderTable().getFufilleddateColumn();
 905  0
     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  0
     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  0
     comment = cooked;
 930  0
   }
 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  0
     readLock();
 949  0
     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  0
     _getShopOrderTable().getCommentColumn().
 970  
       getType().assertValidCooked(cooked);
 971  0
     writeLock();
 972  0
     setComment_unsafe(cooked);
 973  0
   }
 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  0
     Column c = _getShopOrderTable().getCommentColumn();
 988  0
     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  0
     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  0
     customerComment = cooked;
 1013  0
   }
 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  0
     readLock();
 1032  0
     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  0
     _getShopOrderTable().getCustomerCommentColumn().
 1053  
       getType().assertValidCooked(cooked);
 1054  0
     writeLock();
 1055  0
     setCustomerComment_unsafe(cooked);
 1056  0
   }
 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  0
     Column c = _getShopOrderTable().getCustomerCommentColumn();
 1071  0
     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  0
     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  0
     alert = cooked;
 1096  0
   }
 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  0
     readLock();
 1115  0
     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  0
     _getShopOrderTable().getAlertColumn().
 1136  
       getType().assertValidCooked(cooked);
 1137  0
     writeLock();
 1138  0
     setAlert_unsafe(cooked);
 1139  0
   }
 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  0
     setAlert(cooked ? Boolean.TRUE : Boolean.FALSE);
 1161  0
   }
 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  0
     Column c = _getShopOrderTable().getAlertColumn();
 1176  0
     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  0
     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  0
     message = cooked;
 1201  0
   }
 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  0
     readLock();
 1220  0
     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  0
     _getShopOrderTable().getMessageColumn().
 1241  
       getType().assertValidCooked(cooked);
 1242  0
     writeLock();
 1243  0
     setMessage_unsafe(cooked);
 1244  0
   }
 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  0
     Column c = _getShopOrderTable().getMessageColumn();
 1259  0
     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  0
     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  0
     amount = cooked;
 1284  0
   }
 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  0
     readLock();
 1303  0
     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  0
     _getShopOrderTable().getAmountColumn().
 1324  
       getType().assertValidCooked(cooked);
 1325  0
     writeLock();
 1326  0
     setAmount_unsafe(cooked);
 1327  0
   }
 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  0
     setAmount(new Double(cooked));
 1347  0
   }
 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  0
     Column c = _getShopOrderTable().getAmountColumn();
 1362  0
     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  0
     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  0
     delivery = cooked;
 1387  0
   }
 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  0
     readLock();
 1406  0
     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  0
     _getShopOrderTable().getDeliveryColumn().
 1427  
       getType().assertValidCooked(cooked);
 1428  0
     writeLock();
 1429  0
     setDelivery_unsafe(cooked);
 1430  0
   }
 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  0
     setDelivery(new Double(cooked));
 1450  0
   }
 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  0
     Column c = _getShopOrderTable().getDeliveryColumn();
 1465  0
     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  0
     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  0
     amountUK = cooked;
 1490  0
   }
 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  0
     readLock();
 1509  0
     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  0
     _getShopOrderTable().getAmountUKColumn().
 1530  
       getType().assertValidCooked(cooked);
 1531  0
     writeLock();
 1532  0
     setAmountUK_unsafe(cooked);
 1533  0
   }
 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  0
     setAmountUK(new Double(cooked));
 1553  0
   }
 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  0
     Column c = _getShopOrderTable().getAmountUKColumn();
 1568  0
     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  0
     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  0
     deliveryUK = cooked;
 1593  0
   }
 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  0
     readLock();
 1612  0
     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  0
     _getShopOrderTable().getDeliveryUKColumn().
 1633  
       getType().assertValidCooked(cooked);
 1634  0
     writeLock();
 1635  0
     setDeliveryUK_unsafe(cooked);
 1636  0
   }
 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  0
     setDeliveryUK(new Double(cooked));
 1656  0
   }
 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  0
     Column c = _getShopOrderTable().getDeliveryUKColumn();
 1671  0
     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  0
     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  0
     name = cooked;
 1696  0
   }
 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 
 1705  
   * @throws AccessPoemException 
 1706  
   *         if the current <code>AccessToken</code> 
 1707  
   *         does not confer write access rights 
 1708  
   * @return the value of the field <code>Name</code> for this 
 1709  
   *         <code>ShopOrder</code> <code>Persistent</code>  
 1710  
   */
 1711  
 
 1712  
   public String getName()
 1713  
       throws AccessPoemException {
 1714  0
     readLock();
 1715  0
     return getName_unsafe();
 1716  
   }
 1717  
 
 1718  
 
 1719  
  /**
 1720  
   * Sets the <code>Name</code> value, with checking, for this 
 1721  
   * <code>ShopOrder</code> <code>Persistent</code>.
 1722  
   * Field description: 
 1723  
   *   The user's real name 
 1724  
   * 
 1725  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 1726  
   * @param cooked  a validated <code>int</code> 
 1727  
   * @throws AccessPoemException 
 1728  
   *         if the current <code>AccessToken</code> 
 1729  
   *         does not confer write access rights
 1730  
   * @throws ValidationPoemException 
 1731  
   *         if the value is not valid
 1732  
   */
 1733  
   public void setName(String cooked)
 1734  
       throws AccessPoemException, ValidationPoemException {
 1735  0
     _getShopOrderTable().getNameColumn().
 1736  
       getType().assertValidCooked(cooked);
 1737  0
     writeLock();
 1738  0
     setName_unsafe(cooked);
 1739  0
   }
 1740  
 
 1741  
 
 1742  
  /**
 1743  
   * Retrieves the <code>Name</code> value as a <code>Field</code>
 1744  
   * from this <code>ShopOrder</code> <code>Persistent</code>.
 1745  
   * 
 1746  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 1747  
   * @throws AccessPoemException 
 1748  
   *         if the current <code>AccessToken</code> 
 1749  
   *         does not confer write access rights
 1750  
   * @return the String name
 1751  
   */
 1752  
   public Field getNameField() throws AccessPoemException {
 1753  0
     Column c = _getShopOrderTable().getNameColumn();
 1754  0
     return new Field(c.getRaw(this), c);
 1755  
   }
 1756  
 
 1757  
 
 1758  
  /**
 1759  
   * Retrieves the <code>DeliveryName</code> value, without locking, 
 1760  
   * for this <code>ShopOrder</code> <code>Persistent</code>.
 1761  
   *
 1762  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 1763  
   * @return the String deliveryName
 1764  
   */
 1765  
   public String getDeliveryName_unsafe() {
 1766  0
     return deliveryName;
 1767  
   }
 1768  
 
 1769  
 
 1770  
  /**
 1771  
   * Sets the <code>DeliveryName</code> value directly, without checking, 
 1772  
   * for this ShopOrder <code>Persistent</code>.
 1773  
   * 
 1774  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 1775  
   * @param cooked  the pre-validated value to set
 1776  
   */
 1777  
   public void setDeliveryName_unsafe(String cooked) {
 1778  0
     deliveryName = cooked;
 1779  0
   }
 1780  
 
 1781  
  /**
 1782  
   * Retrieves the DeliveryName value, with locking, for this 
 1783  
   * <code>ShopOrder</code> <code>Persistent</code>.
 1784  
   * Field description: 
 1785  
   *   The name of the persone to whom we are delivering 
 1786  
   * 
 1787  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 1788  
   * @throws AccessPoemException 
 1789  
   *         if the current <code>AccessToken</code> 
 1790  
   *         does not confer write access rights 
 1791  
   * @return the value of the field <code>DeliveryName</code> for this 
 1792  
   *         <code>ShopOrder</code> <code>Persistent</code>  
 1793  
   */
 1794  
 
 1795  
   public String getDeliveryName()
 1796  
       throws AccessPoemException {
 1797  0
     readLock();
 1798  0
     return getDeliveryName_unsafe();
 1799  
   }
 1800  
 
 1801  
 
 1802  
  /**
 1803  
   * Sets the <code>DeliveryName</code> value, with checking, for this 
 1804  
   * <code>ShopOrder</code> <code>Persistent</code>.
 1805  
   * Field description: 
 1806  
   *   The name of the persone to whom we are delivering 
 1807  
   * 
 1808  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 1809  
   * @param cooked  a validated <code>int</code> 
 1810  
   * @throws AccessPoemException 
 1811  
   *         if the current <code>AccessToken</code> 
 1812  
   *         does not confer write access rights
 1813  
   * @throws ValidationPoemException 
 1814  
   *         if the value is not valid
 1815  
   */
 1816  
   public void setDeliveryName(String cooked)
 1817  
       throws AccessPoemException, ValidationPoemException {
 1818  0
     _getShopOrderTable().getDeliveryNameColumn().
 1819  
       getType().assertValidCooked(cooked);
 1820  0
     writeLock();
 1821  0
     setDeliveryName_unsafe(cooked);
 1822  0
   }
 1823  
 
 1824  
 
 1825  
  /**
 1826  
   * Retrieves the <code>DeliveryName</code> value as a <code>Field</code>
 1827  
   * from this <code>ShopOrder</code> <code>Persistent</code>.
 1828  
   * 
 1829  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 1830  
   * @throws AccessPoemException 
 1831  
   *         if the current <code>AccessToken</code> 
 1832  
   *         does not confer write access rights
 1833  
   * @return the String deliveryName
 1834  
   */
 1835  
   public Field getDeliveryNameField() throws AccessPoemException {
 1836  0
     Column c = _getShopOrderTable().getDeliveryNameColumn();
 1837  0
     return new Field(c.getRaw(this), c);
 1838  
   }
 1839  
 
 1840  
 
 1841  
  /**
 1842  
   * Retrieves the <code>Email</code> value, without locking, 
 1843  
   * for this <code>ShopOrder</code> <code>Persistent</code>.
 1844  
   *
 1845  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 1846  
   * @return the String email
 1847  
   */
 1848  
   public String getEmail_unsafe() {
 1849  0
     return email;
 1850  
   }
 1851  
 
 1852  
 
 1853  
  /**
 1854  
   * Sets the <code>Email</code> value directly, without checking, 
 1855  
   * for this ShopOrder <code>Persistent</code>.
 1856  
   * 
 1857  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 1858  
   * @param cooked  the pre-validated value to set
 1859  
   */
 1860  
   public void setEmail_unsafe(String cooked) {
 1861  0
     email = cooked;
 1862  0
   }
 1863  
 
 1864  
  /**
 1865  
   * Retrieves the Email value, with locking, for this 
 1866  
   * <code>ShopOrder</code> <code>Persistent</code>.
 1867  
   * Field description: 
 1868  
   *   email 
 1869  
   * 
 1870  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 1871  
   * @throws AccessPoemException 
 1872  
   *         if the current <code>AccessToken</code> 
 1873  
   *         does not confer write access rights 
 1874  
   * @return the value of the field <code>Email</code> for this 
 1875  
   *         <code>ShopOrder</code> <code>Persistent</code>  
 1876  
   */
 1877  
 
 1878  
   public String getEmail()
 1879  
       throws AccessPoemException {
 1880  0
     readLock();
 1881  0
     return getEmail_unsafe();
 1882  
   }
 1883  
 
 1884  
 
 1885  
  /**
 1886  
   * Sets the <code>Email</code> value, with checking, for this 
 1887  
   * <code>ShopOrder</code> <code>Persistent</code>.
 1888  
   * Field description: 
 1889  
   *   email 
 1890  
   * 
 1891  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 1892  
   * @param cooked  a validated <code>int</code> 
 1893  
   * @throws AccessPoemException 
 1894  
   *         if the current <code>AccessToken</code> 
 1895  
   *         does not confer write access rights
 1896  
   * @throws ValidationPoemException 
 1897  
   *         if the value is not valid
 1898  
   */
 1899  
   public void setEmail(String cooked)
 1900  
       throws AccessPoemException, ValidationPoemException {
 1901  0
     _getShopOrderTable().getEmailColumn().
 1902  
       getType().assertValidCooked(cooked);
 1903  0
     writeLock();
 1904  0
     setEmail_unsafe(cooked);
 1905  0
   }
 1906  
 
 1907  
 
 1908  
  /**
 1909  
   * Retrieves the <code>Email</code> value as a <code>Field</code>
 1910  
   * from this <code>ShopOrder</code> <code>Persistent</code>.
 1911  
   * 
 1912  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 1913  
   * @throws AccessPoemException 
 1914  
   *         if the current <code>AccessToken</code> 
 1915  
   *         does not confer write access rights
 1916  
   * @return the String email
 1917  
   */
 1918  
   public Field getEmailField() throws AccessPoemException {
 1919  0
     Column c = _getShopOrderTable().getEmailColumn();
 1920  0
     return new Field(c.getRaw(this), c);
 1921  
   }
 1922  
 
 1923  
 
 1924  
  /**
 1925  
   * Retrieves the <code>Address</code> value, without locking, 
 1926  
   * for this <code>ShopOrder</code> <code>Persistent</code>.
 1927  
   *
 1928  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 1929  
   * @return the String address
 1930  
   */
 1931  
   public String getAddress_unsafe() {
 1932  0
     return address;
 1933  
   }
 1934  
 
 1935  
 
 1936  
  /**
 1937  
   * Sets the <code>Address</code> value directly, without checking, 
 1938  
   * for this ShopOrder <code>Persistent</code>.
 1939  
   * 
 1940  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 1941  
   * @param cooked  the pre-validated value to set
 1942  
   */
 1943  
   public void setAddress_unsafe(String cooked) {
 1944  0
     address = cooked;
 1945  0
   }
 1946  
 
 1947  
  /**
 1948  
   * Retrieves the Address value, with locking, for this 
 1949  
   * <code>ShopOrder</code> <code>Persistent</code>.
 1950  
   * 
 1951  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 1952  
   * @throws AccessPoemException 
 1953  
   *         if the current <code>AccessToken</code> 
 1954  
   *         does not confer write access rights 
 1955  
   * @return the value of the field <code>Address</code> for this 
 1956  
   *         <code>ShopOrder</code> <code>Persistent</code>  
 1957  
   */
 1958  
 
 1959  
   public String getAddress()
 1960  
       throws AccessPoemException {
 1961  0
     readLock();
 1962  0
     return getAddress_unsafe();
 1963  
   }
 1964  
 
 1965  
 
 1966  
  /**
 1967  
   * Sets the <code>Address</code> value, with checking, for this 
 1968  
   * <code>ShopOrder</code> <code>Persistent</code>.
 1969  
   * 
 1970  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 1971  
   * @param cooked  a validated <code>int</code> 
 1972  
   * @throws AccessPoemException 
 1973  
   *         if the current <code>AccessToken</code> 
 1974  
   *         does not confer write access rights
 1975  
   * @throws ValidationPoemException 
 1976  
   *         if the value is not valid
 1977  
   */
 1978  
   public void setAddress(String cooked)
 1979  
       throws AccessPoemException, ValidationPoemException {
 1980  0
     _getShopOrderTable().getAddressColumn().
 1981  
       getType().assertValidCooked(cooked);
 1982  0
     writeLock();
 1983  0
     setAddress_unsafe(cooked);
 1984  0
   }
 1985  
 
 1986  
 
 1987  
  /**
 1988  
   * Retrieves the <code>Address</code> value as a <code>Field</code>
 1989  
   * from this <code>ShopOrder</code> <code>Persistent</code>.
 1990  
   * 
 1991  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 1992  
   * @throws AccessPoemException 
 1993  
   *         if the current <code>AccessToken</code> 
 1994  
   *         does not confer write access rights
 1995  
   * @return the String address
 1996  
   */
 1997  
   public Field getAddressField() throws AccessPoemException {
 1998  0
     Column c = _getShopOrderTable().getAddressColumn();
 1999  0
     return new Field(c.getRaw(this), c);
 2000  
   }
 2001  
 
 2002  
 
 2003  
  /**
 2004  
   * Retrieves the <code>Town</code> value, without locking, 
 2005  
   * for this <code>ShopOrder</code> <code>Persistent</code>.
 2006  
   *
 2007  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2008  
   * @return the String town
 2009  
   */
 2010  
   public String getTown_unsafe() {
 2011  0
     return town;
 2012  
   }
 2013  
 
 2014  
 
 2015  
  /**
 2016  
   * Sets the <code>Town</code> value directly, without checking, 
 2017  
   * for this ShopOrder <code>Persistent</code>.
 2018  
   * 
 2019  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2020  
   * @param cooked  the pre-validated value to set
 2021  
   */
 2022  
   public void setTown_unsafe(String cooked) {
 2023  0
     town = cooked;
 2024  0
   }
 2025  
 
 2026  
  /**
 2027  
   * Retrieves the Town value, with locking, for this 
 2028  
   * <code>ShopOrder</code> <code>Persistent</code>.
 2029  
   * 
 2030  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 2031  
   * @throws AccessPoemException 
 2032  
   *         if the current <code>AccessToken</code> 
 2033  
   *         does not confer write access rights 
 2034  
   * @return the value of the field <code>Town</code> for this 
 2035  
   *         <code>ShopOrder</code> <code>Persistent</code>  
 2036  
   */
 2037  
 
 2038  
   public String getTown()
 2039  
       throws AccessPoemException {
 2040  0
     readLock();
 2041  0
     return getTown_unsafe();
 2042  
   }
 2043  
 
 2044  
 
 2045  
  /**
 2046  
   * Sets the <code>Town</code> value, with checking, for this 
 2047  
   * <code>ShopOrder</code> <code>Persistent</code>.
 2048  
   * 
 2049  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 2050  
   * @param cooked  a validated <code>int</code> 
 2051  
   * @throws AccessPoemException 
 2052  
   *         if the current <code>AccessToken</code> 
 2053  
   *         does not confer write access rights
 2054  
   * @throws ValidationPoemException 
 2055  
   *         if the value is not valid
 2056  
   */
 2057  
   public void setTown(String cooked)
 2058  
       throws AccessPoemException, ValidationPoemException {
 2059  0
     _getShopOrderTable().getTownColumn().
 2060  
       getType().assertValidCooked(cooked);
 2061  0
     writeLock();
 2062  0
     setTown_unsafe(cooked);
 2063  0
   }
 2064  
 
 2065  
 
 2066  
  /**
 2067  
   * Retrieves the <code>Town</code> value as a <code>Field</code>
 2068  
   * from this <code>ShopOrder</code> <code>Persistent</code>.
 2069  
   * 
 2070  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 2071  
   * @throws AccessPoemException 
 2072  
   *         if the current <code>AccessToken</code> 
 2073  
   *         does not confer write access rights
 2074  
   * @return the String town
 2075  
   */
 2076  
   public Field getTownField() throws AccessPoemException {
 2077  0
     Column c = _getShopOrderTable().getTownColumn();
 2078  0
     return new Field(c.getRaw(this), c);
 2079  
   }
 2080  
 
 2081  
 
 2082  
  /**
 2083  
   * Retrieves the <code>Tel</code> value, without locking, 
 2084  
   * for this <code>ShopOrder</code> <code>Persistent</code>.
 2085  
   *
 2086  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2087  
   * @return the String tel
 2088  
   */
 2089  
   public String getTel_unsafe() {
 2090  0
     return tel;
 2091  
   }
 2092  
 
 2093  
 
 2094  
  /**
 2095  
   * Sets the <code>Tel</code> value directly, without checking, 
 2096  
   * for this ShopOrder <code>Persistent</code>.
 2097  
   * 
 2098  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2099  
   * @param cooked  the pre-validated value to set
 2100  
   */
 2101  
   public void setTel_unsafe(String cooked) {
 2102  0
     tel = cooked;
 2103  0
   }
 2104  
 
 2105  
  /**
 2106  
   * Retrieves the Tel value, with locking, for this 
 2107  
   * <code>ShopOrder</code> <code>Persistent</code>.
 2108  
   * Field description: 
 2109  
   *   Order telephone number 
 2110  
   * 
 2111  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 2112  
   * @throws AccessPoemException 
 2113  
   *         if the current <code>AccessToken</code> 
 2114  
   *         does not confer write access rights 
 2115  
   * @return the value of the field <code>Tel</code> for this 
 2116  
   *         <code>ShopOrder</code> <code>Persistent</code>  
 2117  
   */
 2118  
 
 2119  
   public String getTel()
 2120  
       throws AccessPoemException {
 2121  0
     readLock();
 2122  0
     return getTel_unsafe();
 2123  
   }
 2124  
 
 2125  
 
 2126  
  /**
 2127  
   * Sets the <code>Tel</code> value, with checking, for this 
 2128  
   * <code>ShopOrder</code> <code>Persistent</code>.
 2129  
   * Field description: 
 2130  
   *   Order telephone number 
 2131  
   * 
 2132  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 2133  
   * @param cooked  a validated <code>int</code> 
 2134  
   * @throws AccessPoemException 
 2135  
   *         if the current <code>AccessToken</code> 
 2136  
   *         does not confer write access rights
 2137  
   * @throws ValidationPoemException 
 2138  
   *         if the value is not valid
 2139  
   */
 2140  
   public void setTel(String cooked)
 2141  
       throws AccessPoemException, ValidationPoemException {
 2142  0
     _getShopOrderTable().getTelColumn().
 2143  
       getType().assertValidCooked(cooked);
 2144  0
     writeLock();
 2145  0
     setTel_unsafe(cooked);
 2146  0
   }
 2147  
 
 2148  
 
 2149  
  /**
 2150  
   * Retrieves the <code>Tel</code> value as a <code>Field</code>
 2151  
   * from this <code>ShopOrder</code> <code>Persistent</code>.
 2152  
   * 
 2153  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 2154  
   * @throws AccessPoemException 
 2155  
   *         if the current <code>AccessToken</code> 
 2156  
   *         does not confer write access rights
 2157  
   * @return the String tel
 2158  
   */
 2159  
   public Field getTelField() throws AccessPoemException {
 2160  0
     Column c = _getShopOrderTable().getTelColumn();
 2161  0
     return new Field(c.getRaw(this), c);
 2162  
   }
 2163  
 
 2164  
 
 2165  
  /**
 2166  
   * Retrieves the <code>Postcode</code> value, without locking, 
 2167  
   * for this <code>ShopOrder</code> <code>Persistent</code>.
 2168  
   *
 2169  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2170  
   * @return the String postcode
 2171  
   */
 2172  
   public String getPostcode_unsafe() {
 2173  0
     return postcode;
 2174  
   }
 2175  
 
 2176  
 
 2177  
  /**
 2178  
   * Sets the <code>Postcode</code> value directly, without checking, 
 2179  
   * for this ShopOrder <code>Persistent</code>.
 2180  
   * 
 2181  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2182  
   * @param cooked  the pre-validated value to set
 2183  
   */
 2184  
   public void setPostcode_unsafe(String cooked) {
 2185  0
     postcode = cooked;
 2186  0
   }
 2187  
 
 2188  
  /**
 2189  
   * Retrieves the Postcode value, with locking, for this 
 2190  
   * <code>ShopOrder</code> <code>Persistent</code>.
 2191  
   * Field description: 
 2192  
   *   Order postcode 
 2193  
   * 
 2194  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 2195  
   * @throws AccessPoemException 
 2196  
   *         if the current <code>AccessToken</code> 
 2197  
   *         does not confer write access rights 
 2198  
   * @return the value of the field <code>Postcode</code> for this 
 2199  
   *         <code>ShopOrder</code> <code>Persistent</code>  
 2200  
   */
 2201  
 
 2202  
   public String getPostcode()
 2203  
       throws AccessPoemException {
 2204  0
     readLock();
 2205  0
     return getPostcode_unsafe();
 2206  
   }
 2207  
 
 2208  
 
 2209  
  /**
 2210  
   * Sets the <code>Postcode</code> value, with checking, for this 
 2211  
   * <code>ShopOrder</code> <code>Persistent</code>.
 2212  
   * Field description: 
 2213  
   *   Order postcode 
 2214  
   * 
 2215  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 2216  
   * @param cooked  a validated <code>int</code> 
 2217  
   * @throws AccessPoemException 
 2218  
   *         if the current <code>AccessToken</code> 
 2219  
   *         does not confer write access rights
 2220  
   * @throws ValidationPoemException 
 2221  
   *         if the value is not valid
 2222  
   */
 2223  
   public void setPostcode(String cooked)
 2224  
       throws AccessPoemException, ValidationPoemException {
 2225  0
     _getShopOrderTable().getPostcodeColumn().
 2226  
       getType().assertValidCooked(cooked);
 2227  0
     writeLock();
 2228  0
     setPostcode_unsafe(cooked);
 2229  0
   }
 2230  
 
 2231  
 
 2232  
  /**
 2233  
   * Retrieves the <code>Postcode</code> value as a <code>Field</code>
 2234  
   * from this <code>ShopOrder</code> <code>Persistent</code>.
 2235  
   * 
 2236  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 2237  
   * @throws AccessPoemException 
 2238  
   *         if the current <code>AccessToken</code> 
 2239  
   *         does not confer write access rights
 2240  
   * @return the String postcode
 2241  
   */
 2242  
   public Field getPostcodeField() throws AccessPoemException {
 2243  0
     Column c = _getShopOrderTable().getPostcodeColumn();
 2244  0
     return new Field(c.getRaw(this), c);
 2245  
   }
 2246  
 
 2247  
 
 2248  
  /**
 2249  
   * Retrieves the <code>Country</code> value, without locking, 
 2250  
   * for this <code>ShopOrder</code> <code>Persistent</code>.
 2251  
   *
 2252  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2253  
   * @return the String country
 2254  
   */
 2255  
   public String getCountry_unsafe() {
 2256  0
     return country;
 2257  
   }
 2258  
 
 2259  
 
 2260  
  /**
 2261  
   * Sets the <code>Country</code> value directly, without checking, 
 2262  
   * for this ShopOrder <code>Persistent</code>.
 2263  
   * 
 2264  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2265  
   * @param cooked  the pre-validated value to set
 2266  
   */
 2267  
   public void setCountry_unsafe(String cooked) {
 2268  0
     country = cooked;
 2269  0
   }
 2270  
 
 2271  
  /**
 2272  
   * Retrieves the Country value, with locking, for this 
 2273  
   * <code>ShopOrder</code> <code>Persistent</code>.
 2274  
   * 
 2275  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 2276  
   * @throws AccessPoemException 
 2277  
   *         if the current <code>AccessToken</code> 
 2278  
   *         does not confer write access rights 
 2279  
   * @return the value of the field <code>Country</code> for this 
 2280  
   *         <code>ShopOrder</code> <code>Persistent</code>  
 2281  
   */
 2282  
 
 2283  
   public String getCountry()
 2284  
       throws AccessPoemException {
 2285  0
     readLock();
 2286  0
     return getCountry_unsafe();
 2287  
   }
 2288  
 
 2289  
 
 2290  
  /**
 2291  
   * Sets the <code>Country</code> value, with checking, for this 
 2292  
   * <code>ShopOrder</code> <code>Persistent</code>.
 2293  
   * 
 2294  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 2295  
   * @param cooked  a validated <code>int</code> 
 2296  
   * @throws AccessPoemException 
 2297  
   *         if the current <code>AccessToken</code> 
 2298  
   *         does not confer write access rights
 2299  
   * @throws ValidationPoemException 
 2300  
   *         if the value is not valid
 2301  
   */
 2302  
   public void setCountry(String cooked)
 2303  
       throws AccessPoemException, ValidationPoemException {
 2304  0
     _getShopOrderTable().getCountryColumn().
 2305  
       getType().assertValidCooked(cooked);
 2306  0
     writeLock();
 2307  0
     setCountry_unsafe(cooked);
 2308  0
   }
 2309  
 
 2310  
 
 2311  
  /**
 2312  
   * Retrieves the <code>Country</code> value as a <code>Field</code>
 2313  
   * from this <code>ShopOrder</code> <code>Persistent</code>.
 2314  
   * 
 2315  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 2316  
   * @throws AccessPoemException 
 2317  
   *         if the current <code>AccessToken</code> 
 2318  
   *         does not confer write access rights
 2319  
   * @return the String country
 2320  
   */
 2321  
   public Field getCountryField() throws AccessPoemException {
 2322  0
     Column c = _getShopOrderTable().getCountryColumn();
 2323  0
     return new Field(c.getRaw(this), c);
 2324  
   }
 2325  
 
 2326  
 
 2327  
  /**
 2328  
   * Retrieves the <code>Currency</code> value, without locking, 
 2329  
   * for this <code>ShopOrder</code> <code>Persistent</code>.
 2330  
   *
 2331  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2332  
   * @return the Integer currency
 2333  
   */
 2334  
   public Integer getCurrency_unsafe() {
 2335  0
     return currency;
 2336  
   }
 2337  
 
 2338  
 
 2339  
  /**
 2340  
   * Sets the <code>Currency</code> value directly, without checking, 
 2341  
   * for this ShopOrder <code>Persistent</code>.
 2342  
   * 
 2343  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2344  
   * @param cooked  the pre-validated value to set
 2345  
   */
 2346  
   public void setCurrency_unsafe(Integer cooked) {
 2347  0
     currency = cooked;
 2348  0
   }
 2349  
 
 2350  
  /**
 2351  
   * Retrieves the Table Row Object ID. 
 2352  
   *
 2353  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 2354  
   * @throws AccessPoemException  
 2355  
   *         if the current <code>AccessToken</code> 
 2356  
   *         does not confer read access rights 
 2357  
   * @return the TROID as an <code>Integer</code> 
 2358  
   */
 2359  
 
 2360  
   public Integer getCurrencyTroid()
 2361  
       throws AccessPoemException {
 2362  0
     readLock();
 2363  0
     return getCurrency_unsafe();
 2364  
   }
 2365  
 
 2366  
 
 2367  
  /**
 2368  
   * Sets the Table Row Object ID. 
 2369  
   * 
 2370  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 2371  
   * @param raw  a Table Row Object Id 
 2372  
   * @throws AccessPoemException  
 2373  
   *         if the current <code>AccessToken</code> 
 2374  
   *         does not confer write access rights
 2375  
   */
 2376  
   public void setCurrencyTroid(Integer raw)
 2377  
       throws AccessPoemException {
 2378  0
     setCurrency(raw == null ? null : 
 2379  
         getJammyjoesDatabaseTables().getShopCurrencyTable().getShopCurrencyObject(raw));
 2380  0
   }
 2381  
 
 2382  
 
 2383  
  /**
 2384  
   * Retrieves the <code>Currency</code> object referred to.
 2385  
   *  
 2386  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 2387  
   * @throws AccessPoemException  
 2388  
   *         if the current <code>AccessToken</code> 
 2389  
   *         does not confer read access rights 
 2390  
   * @throws NoSuchRowPoemException  
 2391  
   *         if the <code>Persistent</code> has yet to be allocated a TROID 
 2392  
   * @return the <code>Currency</code> as a <code>ShopCurrency</code> 
 2393  
   */
 2394  
   public ShopCurrency getCurrency()
 2395  
       throws AccessPoemException, NoSuchRowPoemException {
 2396  0
     Integer troid = getCurrencyTroid();
 2397  0
     return troid == null ? null :
 2398  
         getJammyjoesDatabaseTables().getShopCurrencyTable().getShopCurrencyObject(troid);
 2399  
   }
 2400  
 
 2401  
 
 2402  
  /**
 2403  
   * Set the Currency.
 2404  
   * 
 2405  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 2406  
   * @param cooked  a validated <code>ShopCurrency</code>
 2407  
   * @throws AccessPoemException  
 2408  
   *         if the current <code>AccessToken</code> 
 2409  
   *         does not confer write access rights 
 2410  
   */
 2411  
   public void setCurrency(ShopCurrency cooked)
 2412  
       throws AccessPoemException {
 2413  0
     _getShopOrderTable().
 2414  
       getCurrencyColumn().
 2415  
         getType().assertValidCooked(cooked);
 2416  0
     writeLock();
 2417  0
     if (cooked == null)
 2418  0
       setCurrency_unsafe(null);
 2419  
     else {
 2420  0
       cooked.existenceLock();
 2421  0
       setCurrency_unsafe(cooked.troid());
 2422  
     }
 2423  0
   }
 2424  
 
 2425  
 
 2426  
  /**
 2427  
   * Retrieves the <code>Currency</code> value as a <code>Field</code>
 2428  
   * from this <code>ShopOrder</code> <code>Persistent</code>.
 2429  
   * 
 2430  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 2431  
   * @throws AccessPoemException 
 2432  
   *         if the current <code>AccessToken</code> 
 2433  
   *         does not confer write access rights
 2434  
   * @return the Integer currency
 2435  
   */
 2436  
   public Field getCurrencyField() throws AccessPoemException {
 2437  0
     Column c = _getShopOrderTable().getCurrencyColumn();
 2438  0
     return new Field(c.getRaw(this), c);
 2439  
   }
 2440  
 
 2441  
 
 2442  
  /**
 2443  
   * Retrieves the <code>Zone</code> value, without locking, 
 2444  
   * for this <code>ShopOrder</code> <code>Persistent</code>.
 2445  
   *
 2446  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2447  
   * @return the Integer zone
 2448  
   */
 2449  
   public Integer getZone_unsafe() {
 2450  0
     return zone;
 2451  
   }
 2452  
 
 2453  
 
 2454  
  /**
 2455  
   * Sets the <code>Zone</code> value directly, without checking, 
 2456  
   * for this ShopOrder <code>Persistent</code>.
 2457  
   * 
 2458  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2459  
   * @param cooked  the pre-validated value to set
 2460  
   */
 2461  
   public void setZone_unsafe(Integer cooked) {
 2462  0
     zone = cooked;
 2463  0
   }
 2464  
 
 2465  
  /**
 2466  
   * Retrieves the Table Row Object ID. 
 2467  
   *
 2468  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 2469  
   * @throws AccessPoemException  
 2470  
   *         if the current <code>AccessToken</code> 
 2471  
   *         does not confer read access rights 
 2472  
   * @return the TROID as an <code>Integer</code> 
 2473  
   */
 2474  
 
 2475  
   public Integer getZoneTroid()
 2476  
       throws AccessPoemException {
 2477  0
     readLock();
 2478  0
     return getZone_unsafe();
 2479  
   }
 2480  
 
 2481  
 
 2482  
  /**
 2483  
   * Sets the Table Row Object ID. 
 2484  
   * 
 2485  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 2486  
   * @param raw  a Table Row Object Id 
 2487  
   * @throws AccessPoemException  
 2488  
   *         if the current <code>AccessToken</code> 
 2489  
   *         does not confer write access rights
 2490  
   */
 2491  
   public void setZoneTroid(Integer raw)
 2492  
       throws AccessPoemException {
 2493  0
     setZone(raw == null ? null : 
 2494  
         getJammyjoesDatabaseTables().getDeliveryZoneTable().getDeliveryZoneObject(raw));
 2495  0
   }
 2496  
 
 2497  
 
 2498  
  /**
 2499  
   * Retrieves the <code>Zone</code> object referred to.
 2500  
   *  
 2501  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 2502  
   * @throws AccessPoemException  
 2503  
   *         if the current <code>AccessToken</code> 
 2504  
   *         does not confer read access rights 
 2505  
   * @throws NoSuchRowPoemException  
 2506  
   *         if the <code>Persistent</code> has yet to be allocated a TROID 
 2507  
   * @return the <code>Zone</code> as a <code>DeliveryZone</code> 
 2508  
   */
 2509  
   public DeliveryZone getZone()
 2510  
       throws AccessPoemException, NoSuchRowPoemException {
 2511  0
     Integer troid = getZoneTroid();
 2512  0
     return troid == null ? null :
 2513  
         getJammyjoesDatabaseTables().getDeliveryZoneTable().getDeliveryZoneObject(troid);
 2514  
   }
 2515  
 
 2516  
 
 2517  
  /**
 2518  
   * Set the Zone.
 2519  
   * 
 2520  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 2521  
   * @param cooked  a validated <code>DeliveryZone</code>
 2522  
   * @throws AccessPoemException  
 2523  
   *         if the current <code>AccessToken</code> 
 2524  
   *         does not confer write access rights 
 2525  
   */
 2526  
   public void setZone(DeliveryZone cooked)
 2527  
       throws AccessPoemException {
 2528  0
     _getShopOrderTable().
 2529  
       getZoneColumn().
 2530  
         getType().assertValidCooked(cooked);
 2531  0
     writeLock();
 2532  0
     if (cooked == null)
 2533  0
       setZone_unsafe(null);
 2534  
     else {
 2535  0
       cooked.existenceLock();
 2536  0
       setZone_unsafe(cooked.troid());
 2537  
     }
 2538  0
   }
 2539  
 
 2540  
 
 2541  
  /**
 2542  
   * Retrieves the <code>Zone</code> value as a <code>Field</code>
 2543  
   * from this <code>ShopOrder</code> <code>Persistent</code>.
 2544  
   * 
 2545  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 2546  
   * @throws AccessPoemException 
 2547  
   *         if the current <code>AccessToken</code> 
 2548  
   *         does not confer write access rights
 2549  
   * @return the Integer zone
 2550  
   */
 2551  
   public Field getZoneField() throws AccessPoemException {
 2552  0
     Column c = _getShopOrderTable().getZoneColumn();
 2553  0
     return new Field(c.getRaw(this), c);
 2554  
   }
 2555  
 
 2556  
 
 2557  
  /**
 2558  
   * Retrieves the <code>Wrapping</code> value, without locking, 
 2559  
   * for this <code>ShopOrder</code> <code>Persistent</code>.
 2560  
   *
 2561  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2562  
   * @return the Integer wrapping
 2563  
   */
 2564  
   public Integer getWrapping_unsafe() {
 2565  0
     return wrapping;
 2566  
   }
 2567  
 
 2568  
 
 2569  
  /**
 2570  
   * Sets the <code>Wrapping</code> value directly, without checking, 
 2571  
   * for this ShopOrder <code>Persistent</code>.
 2572  
   * 
 2573  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2574  
   * @param cooked  the pre-validated value to set
 2575  
   */
 2576  
   public void setWrapping_unsafe(Integer cooked) {
 2577  0
     wrapping = cooked;
 2578  0
   }
 2579  
 
 2580  
  /**
 2581  
   * Retrieves the Table Row Object ID. 
 2582  
   *
 2583  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 2584  
   * @throws AccessPoemException  
 2585  
   *         if the current <code>AccessToken</code> 
 2586  
   *         does not confer read access rights 
 2587  
   * @return the TROID as an <code>Integer</code> 
 2588  
   */
 2589  
 
 2590  
   public Integer getWrappingTroid()
 2591  
       throws AccessPoemException {
 2592  0
     readLock();
 2593  0
     return getWrapping_unsafe();
 2594  
   }
 2595  
 
 2596  
 
 2597  
  /**
 2598  
   * Sets the Table Row Object ID. 
 2599  
   * 
 2600  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 2601  
   * @param raw  a Table Row Object Id 
 2602  
   * @throws AccessPoemException  
 2603  
   *         if the current <code>AccessToken</code> 
 2604  
   *         does not confer write access rights
 2605  
   */
 2606  
   public void setWrappingTroid(Integer raw)
 2607  
       throws AccessPoemException {
 2608  0
     setWrapping(raw == null ? null : 
 2609  
         getJammyjoesDatabaseTables().getWrappingTable().getWrappingObject(raw));
 2610  0
   }
 2611  
 
 2612  
 
 2613  
  /**
 2614  
   * Retrieves the <code>Wrapping</code> object referred to.
 2615  
   *  
 2616  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 2617  
   * @throws AccessPoemException  
 2618  
   *         if the current <code>AccessToken</code> 
 2619  
   *         does not confer read access rights 
 2620  
   * @throws NoSuchRowPoemException  
 2621  
   *         if the <code>Persistent</code> has yet to be allocated a TROID 
 2622  
   * @return the <code>Wrapping</code> as a <code>Wrapping</code> 
 2623  
   */
 2624  
   public Wrapping getWrapping()
 2625  
       throws AccessPoemException, NoSuchRowPoemException {
 2626  0
     Integer troid = getWrappingTroid();
 2627  0
     return troid == null ? null :
 2628  
         getJammyjoesDatabaseTables().getWrappingTable().getWrappingObject(troid);
 2629  
   }
 2630  
 
 2631  
 
 2632  
  /**
 2633  
   * Set the Wrapping.
 2634  
   * 
 2635  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 2636  
   * @param cooked  a validated <code>Wrapping</code>
 2637  
   * @throws AccessPoemException  
 2638  
   *         if the current <code>AccessToken</code> 
 2639  
   *         does not confer write access rights 
 2640  
   */
 2641  
   public void setWrapping(Wrapping cooked)
 2642  
       throws AccessPoemException {
 2643  0
     _getShopOrderTable().
 2644  
       getWrappingColumn().
 2645  
         getType().assertValidCooked(cooked);
 2646  0
     writeLock();
 2647  0
     if (cooked == null)
 2648  0
       setWrapping_unsafe(null);
 2649  
     else {
 2650  0
       cooked.existenceLock();
 2651  0
       setWrapping_unsafe(cooked.troid());
 2652  
     }
 2653  0
   }
 2654  
 
 2655  
 
 2656  
  /**
 2657  
   * Retrieves the <code>Wrapping</code> value as a <code>Field</code>
 2658  
   * from this <code>ShopOrder</code> <code>Persistent</code>.
 2659  
   * 
 2660  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 2661  
   * @throws AccessPoemException 
 2662  
   *         if the current <code>AccessToken</code> 
 2663  
   *         does not confer write access rights
 2664  
   * @return the Integer wrapping
 2665  
   */
 2666  
   public Field getWrappingField() throws AccessPoemException {
 2667  0
     Column c = _getShopOrderTable().getWrappingColumn();
 2668  0
     return new Field(c.getRaw(this), c);
 2669  
   }
 2670  
 
 2671  
 
 2672  
  /**
 2673  
   * Retrieves the <code>Affiliate</code> value, without locking, 
 2674  
   * for this <code>ShopOrder</code> <code>Persistent</code>.
 2675  
   *
 2676  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2677  
   * @return the Integer affiliate
 2678  
   */
 2679  
   public Integer getAffiliate_unsafe() {
 2680  0
     return affiliate;
 2681  
   }
 2682  
 
 2683  
 
 2684  
  /**
 2685  
   * Sets the <code>Affiliate</code> value directly, without checking, 
 2686  
   * for this ShopOrder <code>Persistent</code>.
 2687  
   * 
 2688  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2689  
   * @param cooked  the pre-validated value to set
 2690  
   */
 2691  
   public void setAffiliate_unsafe(Integer cooked) {
 2692  0
     affiliate = cooked;
 2693  0
   }
 2694  
 
 2695  
  /**
 2696  
   * Retrieves the Table Row Object ID. 
 2697  
   *
 2698  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 2699  
   * @throws AccessPoemException  
 2700  
   *         if the current <code>AccessToken</code> 
 2701  
   *         does not confer read access rights 
 2702  
   * @return the TROID as an <code>Integer</code> 
 2703  
   */
 2704  
 
 2705  
   public Integer getAffiliateTroid()
 2706  
       throws AccessPoemException {
 2707  0
     readLock();
 2708  0
     return getAffiliate_unsafe();
 2709  
   }
 2710  
 
 2711  
 
 2712  
  /**
 2713  
   * Sets the Table Row Object ID. 
 2714  
   * 
 2715  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 2716  
   * @param raw  a Table Row Object Id 
 2717  
   * @throws AccessPoemException  
 2718  
   *         if the current <code>AccessToken</code> 
 2719  
   *         does not confer write access rights
 2720  
   */
 2721  
   public void setAffiliateTroid(Integer raw)
 2722  
       throws AccessPoemException {
 2723  0
     setAffiliate(raw == null ? null : 
 2724  
         getJammyjoesDatabaseTables().getAffiliateTable().getAffiliateObject(raw));
 2725  0
   }
 2726  
 
 2727  
 
 2728  
  /**
 2729  
   * Retrieves the <code>Affiliate</code> object referred to.
 2730  
   *  
 2731  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 2732  
   * @throws AccessPoemException  
 2733  
   *         if the current <code>AccessToken</code> 
 2734  
   *         does not confer read access rights 
 2735  
   * @throws NoSuchRowPoemException  
 2736  
   *         if the <code>Persistent</code> has yet to be allocated a TROID 
 2737  
   * @return the <code>Affiliate</code> as a <code>Affiliate</code> 
 2738  
   */
 2739  
   public Affiliate getAffiliate()
 2740  
       throws AccessPoemException, NoSuchRowPoemException {
 2741  0
     Integer troid = getAffiliateTroid();
 2742  0
     return troid == null ? null :
 2743  
         getJammyjoesDatabaseTables().getAffiliateTable().getAffiliateObject(troid);
 2744  
   }
 2745  
 
 2746  
 
 2747  
  /**
 2748  
   * Set the Affiliate.
 2749  
   * 
 2750  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 2751  
   * @param cooked  a validated <code>Affiliate</code>
 2752  
   * @throws AccessPoemException  
 2753  
   *         if the current <code>AccessToken</code> 
 2754  
   *         does not confer write access rights 
 2755  
   */
 2756  
   public void setAffiliate(Affiliate cooked)
 2757  
       throws AccessPoemException {
 2758  0
     _getShopOrderTable().
 2759  
       getAffiliateColumn().
 2760  
         getType().assertValidCooked(cooked);
 2761  0
     writeLock();
 2762  0
     if (cooked == null)
 2763  0
       setAffiliate_unsafe(null);
 2764  
     else {
 2765  0
       cooked.existenceLock();
 2766  0
       setAffiliate_unsafe(cooked.troid());
 2767  
     }
 2768  0
   }
 2769  
 
 2770  
 
 2771  
  /**
 2772  
   * Retrieves the <code>Affiliate</code> value as a <code>Field</code>
 2773  
   * from this <code>ShopOrder</code> <code>Persistent</code>.
 2774  
   * 
 2775  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 2776  
   * @throws AccessPoemException 
 2777  
   *         if the current <code>AccessToken</code> 
 2778  
   *         does not confer write access rights
 2779  
   * @return the Integer affiliate
 2780  
   */
 2781  
   public Field getAffiliateField() throws AccessPoemException {
 2782  0
     Column c = _getShopOrderTable().getAffiliateColumn();
 2783  0
     return new Field(c.getRaw(this), c);
 2784  
   }
 2785  
 
 2786  
 
 2787  
  /**
 2788  
   * Retrieves the <code>Affiliatepaid</code> value, without locking, 
 2789  
   * for this <code>ShopOrder</code> <code>Persistent</code>.
 2790  
   *
 2791  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2792  
   * @return the Boolean affiliatepaid
 2793  
   */
 2794  
   public Boolean getAffiliatepaid_unsafe() {
 2795  0
     return affiliatepaid;
 2796  
   }
 2797  
 
 2798  
 
 2799  
  /**
 2800  
   * Sets the <code>Affiliatepaid</code> value directly, without checking, 
 2801  
   * for this ShopOrder <code>Persistent</code>.
 2802  
   * 
 2803  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2804  
   * @param cooked  the pre-validated value to set
 2805  
   */
 2806  
   public void setAffiliatepaid_unsafe(Boolean cooked) {
 2807  0
     affiliatepaid = cooked;
 2808  0
   }
 2809  
 
 2810  
  /**
 2811  
   * Retrieves the Affiliatepaid value, with locking, for this 
 2812  
   * <code>ShopOrder</code> <code>Persistent</code>.
 2813  
   * Field description: 
 2814  
   *   Has the Affiliate been paid for this order? 
 2815  
   * 
 2816  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 2817  
   * @throws AccessPoemException 
 2818  
   *         if the current <code>AccessToken</code> 
 2819  
   *         does not confer write access rights 
 2820  
   * @return the value of the field <code>Affiliatepaid</code> for this 
 2821  
   *         <code>ShopOrder</code> <code>Persistent</code>  
 2822  
   */
 2823  
 
 2824  
   public Boolean getAffiliatepaid()
 2825  
       throws AccessPoemException {
 2826  0
     readLock();
 2827  0
     return getAffiliatepaid_unsafe();
 2828  
   }
 2829  
 
 2830  
 
 2831  
  /**
 2832  
   * Sets the <code>Affiliatepaid</code> value, with checking, for this 
 2833  
   * <code>ShopOrder</code> <code>Persistent</code>.
 2834  
   * Field description: 
 2835  
   *   Has the Affiliate been paid for this order? 
 2836  
   * 
 2837  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 2838  
   * @param cooked  a validated <code>int</code> 
 2839  
   * @throws AccessPoemException 
 2840  
   *         if the current <code>AccessToken</code> 
 2841  
   *         does not confer write access rights
 2842  
   * @throws ValidationPoemException 
 2843  
   *         if the value is not valid
 2844  
   */
 2845  
   public void setAffiliatepaid(Boolean cooked)
 2846  
       throws AccessPoemException, ValidationPoemException {
 2847  0
     _getShopOrderTable().getAffiliatepaidColumn().
 2848  
       getType().assertValidCooked(cooked);
 2849  0
     writeLock();
 2850  0
     setAffiliatepaid_unsafe(cooked);
 2851  0
   }
 2852  
 
 2853  
  /**
 2854  
   * Sets the <code>Affiliatepaid</code> value, with checking, 
 2855  
   * from a <code>boolean</code>, for this 
 2856  
   * <code>ShopOrder</code> <code>Persistent</code>.
 2857  
   * Field description: 
 2858  
   *   Has the Affiliate been paid for this order? 
 2859  
   * 
 2860  
   * 
 2861  
   * @generator org.melati.poem.prepro.BooleanFieldDef#generateBaseMethods 
 2862  
   * @param cooked  a <code>boolean</code> 
 2863  
   * @throws AccessPoemException 
 2864  
   *         if the current <code>AccessToken</code> 
 2865  
   *         does not confer write access rights
 2866  
   * @throws ValidationPoemException 
 2867  
   *         if the value is not valid
 2868  
   */
 2869  
 
 2870  
   public final void setAffiliatepaid(boolean cooked)
 2871  
       throws AccessPoemException, ValidationPoemException {
 2872  0
     setAffiliatepaid(cooked ? Boolean.TRUE : Boolean.FALSE);
 2873  0
   }
 2874  
 
 2875  
 
 2876  
  /**
 2877  
   * Retrieves the <code>Affiliatepaid</code> value as a <code>Field</code>
 2878  
   * from this <code>ShopOrder</code> <code>Persistent</code>.
 2879  
   * 
 2880  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 2881  
   * @throws AccessPoemException 
 2882  
   *         if the current <code>AccessToken</code> 
 2883  
   *         does not confer write access rights
 2884  
   * @return the Boolean affiliatepaid
 2885  
   */
 2886  
   public Field getAffiliatepaidField() throws AccessPoemException {
 2887  0
     Column c = _getShopOrderTable().getAffiliatepaidColumn();
 2888  0
     return new Field(c.getRaw(this), c);
 2889  
   }
 2890  
 
 2891  
 
 2892  
  /**
 2893  
   * Retrieves the <code>Comission</code> value, without locking, 
 2894  
   * for this <code>ShopOrder</code> <code>Persistent</code>.
 2895  
   *
 2896  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2897  
   * @return the Double comission
 2898  
   */
 2899  
   public Double getComission_unsafe() {
 2900  0
     return comission;
 2901  
   }
 2902  
 
 2903  
 
 2904  
  /**
 2905  
   * Sets the <code>Comission</code> value directly, without checking, 
 2906  
   * for this ShopOrder <code>Persistent</code>.
 2907  
   * 
 2908  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2909  
   * @param cooked  the pre-validated value to set
 2910  
   */
 2911  
   public void setComission_unsafe(Double cooked) {
 2912  0
     comission = cooked;
 2913  0
   }
 2914  
 
 2915  
  /**
 2916  
   * Retrieves the Comission value, with locking, for this 
 2917  
   * <code>ShopOrder</code> <code>Persistent</code>.
 2918  
   * Field description: 
 2919  
   *   The Commission Percentage to go to the Affiliate 
 2920  
   * 
 2921  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 2922  
   * @throws AccessPoemException 
 2923  
   *         if the current <code>AccessToken</code> 
 2924  
   *         does not confer write access rights 
 2925  
   * @return the value of the field <code>Comission</code> for this 
 2926  
   *         <code>ShopOrder</code> <code>Persistent</code>  
 2927  
   */
 2928  
 
 2929  
   public Double getComission()
 2930  
       throws AccessPoemException {
 2931  0
     readLock();
 2932  0
     return getComission_unsafe();
 2933  
   }
 2934  
 
 2935  
 
 2936  
  /**
 2937  
   * Sets the <code>Comission</code> value, with checking, for this 
 2938  
   * <code>ShopOrder</code> <code>Persistent</code>.
 2939  
   * Field description: 
 2940  
   *   The Commission Percentage to go to the Affiliate 
 2941  
   * 
 2942  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 2943  
   * @param cooked  a validated <code>int</code> 
 2944  
   * @throws AccessPoemException 
 2945  
   *         if the current <code>AccessToken</code> 
 2946  
   *         does not confer write access rights
 2947  
   * @throws ValidationPoemException 
 2948  
   *         if the value is not valid
 2949  
   */
 2950  
   public void setComission(Double cooked)
 2951  
       throws AccessPoemException, ValidationPoemException {
 2952  0
     _getShopOrderTable().getComissionColumn().
 2953  
       getType().assertValidCooked(cooked);
 2954  0
     writeLock();
 2955  0
     setComission_unsafe(cooked);
 2956  0
   }
 2957  
 
 2958  
  /**
 2959  
   * Sets the <code>Comission</code> value, with checking, for this <code>ShopOrder</code> <code>Persistent</code>.
 2960  
   * Field description: 
 2961  
   *   The Commission Percentage to go to the Affiliate 
 2962  
   * 
 2963  
   * 
 2964  
   * @generator org.melati.poem.prepro.DoubleFieldDef#generateBaseMethods 
 2965  
   * @param cooked  a validated <code>int</code> 
 2966  
   * @throws AccessPoemException 
 2967  
   *         if the current <code>AccessToken</code> 
 2968  
   *         does not confer write access rights
 2969  
   * @throws ValidationPoemException 
 2970  
   *         if the value is not valid
 2971  
   */
 2972  
 
 2973  
   public final void setComission(double cooked)
 2974  
       throws AccessPoemException, ValidationPoemException {
 2975  0
     setComission(new Double(cooked));
 2976  0
   }
 2977  
 
 2978  
 
 2979  
  /**
 2980  
   * Retrieves the <code>Comission</code> value as a <code>Field</code>
 2981  
   * from this <code>ShopOrder</code> <code>Persistent</code>.
 2982  
   * 
 2983  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 2984  
   * @throws AccessPoemException 
 2985  
   *         if the current <code>AccessToken</code> 
 2986  
   *         does not confer write access rights
 2987  
   * @return the Double comission
 2988  
   */
 2989  
   public Field getComissionField() throws AccessPoemException {
 2990  0
     Column c = _getShopOrderTable().getComissionColumn();
 2991  0
     return new Field(c.getRaw(this), c);
 2992  
   }
 2993  
 
 2994  
 
 2995  
  /**
 2996  
   * Retrieves the <code>Spam</code> value, without locking, 
 2997  
   * for this <code>ShopOrder</code> <code>Persistent</code>.
 2998  
   *
 2999  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 3000  
   * @return the Boolean spam
 3001  
   */
 3002  
   public Boolean getSpam_unsafe() {
 3003  0
     return spam;
 3004  
   }
 3005  
 
 3006  
 
 3007  
  /**
 3008  
   * Sets the <code>Spam</code> value directly, without checking, 
 3009  
   * for this ShopOrder <code>Persistent</code>.
 3010  
   * 
 3011  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 3012  
   * @param cooked  the pre-validated value to set
 3013  
   */
 3014  
   public void setSpam_unsafe(Boolean cooked) {
 3015  0
     spam = cooked;
 3016  0
   }
 3017  
 
 3018  
  /**
 3019  
   * Retrieves the Spam value, with locking, for this 
 3020  
   * <code>ShopOrder</code> <code>Persistent</code>.
 3021  
   * Field description: 
 3022  
   *   Does the user want to receive spam email? 
 3023  
   * 
 3024  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 3025  
   * @throws AccessPoemException 
 3026  
   *         if the current <code>AccessToken</code> 
 3027  
   *         does not confer write access rights 
 3028  
   * @return the value of the field <code>Spam</code> for this 
 3029  
   *         <code>ShopOrder</code> <code>Persistent</code>  
 3030  
   */
 3031  
 
 3032  
   public Boolean getSpam()
 3033  
       throws AccessPoemException {
 3034  0
     readLock();
 3035  0
     return getSpam_unsafe();
 3036  
   }
 3037  
 
 3038  
 
 3039  
  /**
 3040  
   * Sets the <code>Spam</code> value, with checking, for this 
 3041  
   * <code>ShopOrder</code> <code>Persistent</code>.
 3042  
   * Field description: 
 3043  
   *   Does the user want to receive spam email? 
 3044  
   * 
 3045  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 3046  
   * @param cooked  a validated <code>int</code> 
 3047  
   * @throws AccessPoemException 
 3048  
   *         if the current <code>AccessToken</code> 
 3049  
   *         does not confer write access rights
 3050  
   * @throws ValidationPoemException 
 3051  
   *         if the value is not valid
 3052  
   */
 3053  
   public void setSpam(Boolean cooked)
 3054  
       throws AccessPoemException, ValidationPoemException {
 3055  0
     _getShopOrderTable().getSpamColumn().
 3056  
       getType().assertValidCooked(cooked);
 3057  0
     writeLock();
 3058  0
     setSpam_unsafe(cooked);
 3059  0
   }
 3060  
 
 3061  
  /**
 3062  
   * Sets the <code>Spam</code> value, with checking, 
 3063  
   * from a <code>boolean</code>, for this 
 3064  
   * <code>ShopOrder</code> <code>Persistent</code>.
 3065  
   * Field description: 
 3066  
   *   Does the user want to receive spam email? 
 3067  
   * 
 3068  
   * 
 3069  
   * @generator org.melati.poem.prepro.BooleanFieldDef#generateBaseMethods 
 3070  
   * @param cooked  a <code>boolean</code> 
 3071  
   * @throws AccessPoemException 
 3072  
   *         if the current <code>AccessToken</code> 
 3073  
   *         does not confer write access rights
 3074  
   * @throws ValidationPoemException 
 3075  
   *         if the value is not valid
 3076  
   */
 3077  
 
 3078  
   public final void setSpam(boolean cooked)
 3079  
       throws AccessPoemException, ValidationPoemException {
 3080  0
     setSpam(cooked ? Boolean.TRUE : Boolean.FALSE);
 3081  0
   }
 3082  
 
 3083  
 
 3084  
  /**
 3085  
   * Retrieves the <code>Spam</code> value as a <code>Field</code>
 3086  
   * from this <code>ShopOrder</code> <code>Persistent</code>.
 3087  
   * 
 3088  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 3089  
   * @throws AccessPoemException 
 3090  
   *         if the current <code>AccessToken</code> 
 3091  
   *         does not confer write access rights
 3092  
   * @return the Boolean spam
 3093  
   */
 3094  
   public Field getSpamField() throws AccessPoemException {
 3095  0
     Column c = _getShopOrderTable().getSpamColumn();
 3096  0
     return new Field(c.getRaw(this), c);
 3097  
   }
 3098  
 }
 3099