Coverage Report - org.paneris.jammyjoes.model.generated.ProductBase
 
Classes in this File Line Coverage Branch Coverage Complexity
ProductBase
0%
0/510
0%
0/48
1.031
 
 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 org.melati.poem.AccessPoemException;
 7  
 import org.melati.poem.Column;
 8  
 import org.melati.poem.Field;
 9  
 import org.melati.poem.JdbcPersistent;
 10  
 import org.melati.poem.NoSuchRowPoemException;
 11  
 import org.melati.poem.ValidationPoemException;
 12  
 import org.paneris.jammyjoes.model.Award;
 13  
 import org.paneris.jammyjoes.model.JammyjoesDatabaseTables;
 14  
 import org.paneris.jammyjoes.model.Manufacturer;
 15  
 import org.paneris.jammyjoes.model.ProductStatus;
 16  
 import org.paneris.jammyjoes.model.ProductTable;
 17  
 import org.paneris.jammyjoes.model.Sex;
 18  
 import org.paneris.jammyjoes.model.Supplier;
 19  
 import org.paneris.jammyjoes.model.Type;
 20  
 
 21  
 
 22  
 /**
 23  
  * Melati POEM generated abstract base class for a <code>Persistent</code> 
 24  
  * <code>Product</code> Object.
 25  
  *
 26  
  * @generator org.melati.poem.prepro.TableDef#generatePersistentBaseJava 
 27  
  */
 28  0
 public abstract class ProductBase extends JdbcPersistent {
 29  
 
 30  
 
 31  
  /**
 32  
   * Retrieves the Database object.
 33  
   * 
 34  
   * @generator org.melati.poem.prepro.TableDef#generatePersistentBaseJava 
 35  
   * @return the database
 36  
   */
 37  
   public JammyjoesDatabaseTables getJammyjoesDatabaseTables() {
 38  0
     return (JammyjoesDatabaseTables)getDatabase();
 39  
   }
 40  
 
 41  
 
 42  
  /**
 43  
   * Retrieves the  <code>ProductTable</code> table 
 44  
   * which this <code>Persistent</code> is from.
 45  
   * 
 46  
   * @generator org.melati.poem.prepro.TableDef#generatePersistentBaseJava 
 47  
   * @return the ProductTable
 48  
   */
 49  
   public ProductTable getProductTable() {
 50  0
     return (ProductTable)getTable();
 51  
   }
 52  
 
 53  
   private ProductTable _getProductTable() {
 54  0
     return (ProductTable)getTable();
 55  
   }
 56  
 
 57  
   // Fields in this table 
 58  
  /**
 59  
   * id 
 60  
   */
 61  
   protected Integer id;
 62  
  /**
 63  
   * Product Name 
 64  
   */
 65  
   protected String name;
 66  
  /**
 67  
   * status 
 68  
   */
 69  
   protected Integer status;
 70  
  /**
 71  
   * type 
 72  
   */
 73  
   protected Integer type;
 74  
  /**
 75  
   * type2 - You can add this product to another category here 
 76  
   */
 77  
   protected Integer type2;
 78  
  /**
 79  
   * Gender - Is this toy is targeted at boys or girls? 
 80  
   */
 81  
   protected Integer sex;
 82  
  /**
 83  
   * Description 
 84  
   */
 85  
   protected String description;
 86  
  /**
 87  
   * Supplier 
 88  
   */
 89  
   protected Integer supplier;
 90  
  /**
 91  
   * Manufacturer 
 92  
   */
 93  
   protected Integer manufacturer;
 94  
  /**
 95  
   * Supplier's Product Code 
 96  
   */
 97  
   protected String suppliercode;
 98  
  /**
 99  
   * Cost Price 
 100  
   */
 101  
   protected Double costprice;
 102  
  /**
 103  
   * Retail Price inc VAT (if VAT is payable) 
 104  
   */
 105  
   protected Double retailpriceincvat;
 106  
  /**
 107  
   * Exempt from VAT? 
 108  
   */
 109  
   protected Boolean vatexempt;
 110  
  /**
 111  
   * Pre Discount Price inc VAT - To put items in the sale, enter the original 
 112  
   * price here, and put the Sale price into the Retail Price inc VAT field 
 113  
   */
 114  
   protected Double saleprice;
 115  
  /**
 116  
   * Retail Price ex VAT 
 117  
   */
 118  
   protected Double retailprice;
 119  
  /**
 120  
   * Margin / Markup 
 121  
   */
 122  
   protected Double margin;
 123  
  /**
 124  
   * Margin Percent 
 125  
   */
 126  
   protected Double marginpercent;
 127  
  /**
 128  
   * Markup Percent 
 129  
   */
 130  
   protected Double markuppercent;
 131  
  /**
 132  
   * Delivery Cost 
 133  
   */
 134  
   protected Double deliverycost;
 135  
  /**
 136  
   * Minimum Age 
 137  
   */
 138  
   protected Integer minage;
 139  
  /**
 140  
   * Maximum Age 
 141  
   */
 142  
   protected Integer maxage;
 143  
  /**
 144  
   * Number of Pieces 
 145  
   */
 146  
   protected Integer pieces;
 147  
  /**
 148  
   * Stock Level 
 149  
   */
 150  
   protected Integer stocklevel;
 151  
  /**
 152  
   * Reorder Level - The level at which stock needs to fall to before 
 153  
   * JammyJoes normally orders 
 154  
   */
 155  
   protected Integer reorderlevel;
 156  
  /**
 157  
   * Reorder Quantity - The quantity that JammyJoes normally orders 
 158  
   */
 159  
   protected Integer reorderquantity;
 160  
  /**
 161  
   * Minimum Order Quantity - The minimum quantity that can be ordered 
 162  
   */
 163  
   protected Integer minimumorder;
 164  
  /**
 165  
   * Lead Time (Days) 
 166  
   */
 167  
   protected Integer leadtime;
 168  
  /**
 169  
   * Weight in Grammes 
 170  
   */
 171  
   protected Double weight;
 172  
  /**
 173  
   * Width (or size) in cm 
 174  
   */
 175  
   protected Double width;
 176  
  /**
 177  
   * Height in cm 
 178  
   */
 179  
   protected Double height;
 180  
  /**
 181  
   * Depth in cm 
 182  
   */
 183  
   protected Double depth;
 184  
  /**
 185  
   * Small Picture 
 186  
   */
 187  
   protected String picture;
 188  
  /**
 189  
   * Big Picture 
 190  
   */
 191  
   protected String picture2;
 192  
  /**
 193  
   * Use in Catalogue? 
 194  
   */
 195  
   protected Boolean catalogue;
 196  
  /**
 197  
   * Deleted? 
 198  
   */
 199  
   protected Boolean deleted;
 200  
  /**
 201  
   * award 
 202  
   */
 203  
   protected Integer award;
 204  
  /**
 205  
   * On-order Level - Not currently used 
 206  
   */
 207  
   protected Integer onorderquantity;
 208  
 
 209  
 
 210  
  /**
 211  
   * Retrieves the <code>Id</code> value, without locking, 
 212  
   * for this <code>Product</code> <code>Persistent</code>.
 213  
   *
 214  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 215  
   * @return the Integer id
 216  
   */
 217  
   public Integer getId_unsafe() {
 218  0
     return id;
 219  
   }
 220  
 
 221  
 
 222  
  /**
 223  
   * Sets the <code>Id</code> value directly, without checking, 
 224  
   * for this Product <code>Persistent</code>.
 225  
   * 
 226  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 227  
   * @param cooked  the pre-validated value to set
 228  
   */
 229  
   public void setId_unsafe(Integer cooked) {
 230  0
     id = cooked;
 231  0
   }
 232  
 
 233  
  /**
 234  
   * Retrieves the Id value, with locking, for this 
 235  
   * <code>Product</code> <code>Persistent</code>.
 236  
   * 
 237  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 238  
   * @throws AccessPoemException 
 239  
   *         if the current <code>AccessToken</code> 
 240  
   *         does not confer write access rights 
 241  
   * @return the value of the field <code>Id</code> for this 
 242  
   *         <code>Product</code> <code>Persistent</code>  
 243  
   */
 244  
 
 245  
   public Integer getId()
 246  
       throws AccessPoemException {
 247  0
     readLock();
 248  0
     return getId_unsafe();
 249  
   }
 250  
 
 251  
 
 252  
  /**
 253  
   * Sets the <code>Id</code> value, with checking, for this 
 254  
   * <code>Product</code> <code>Persistent</code>.
 255  
   * 
 256  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 257  
   * @param cooked  a validated <code>int</code> 
 258  
   * @throws AccessPoemException 
 259  
   *         if the current <code>AccessToken</code> 
 260  
   *         does not confer write access rights
 261  
   * @throws ValidationPoemException 
 262  
   *         if the value is not valid
 263  
   */
 264  
   public void setId(Integer cooked)
 265  
       throws AccessPoemException, ValidationPoemException {
 266  0
     _getProductTable().getIdColumn().
 267  
       getType().assertValidCooked(cooked);
 268  0
     writeLock();
 269  0
     setId_unsafe(cooked);
 270  0
   }
 271  
 
 272  
  /**
 273  
   * Sets the <code>Id</code> value, with checking, for this 
 274  
   * <code>Product</code> <code>Persistent</code>.
 275  
   * 
 276  
   * @generator org.melati.poem.prepro.IntegerFieldDef#generateBaseMethods 
 277  
   * @param cooked  a validated <code>int</code>
 278  
   * @throws AccessPoemException 
 279  
   *         if the current <code>AccessToken</code> 
 280  
   *         does not confer write access rights
 281  
   * @throws ValidationPoemException 
 282  
   *         if the value is not valid
 283  
   */
 284  
 
 285  
   public final void setId(int cooked)
 286  
       throws AccessPoemException, ValidationPoemException {
 287  0
     setId(new Integer(cooked));
 288  0
   }
 289  
 
 290  
 
 291  
  /**
 292  
   * Retrieves the <code>Id</code> value as a <code>Field</code>
 293  
   * from this <code>Product</code> <code>Persistent</code>.
 294  
   * 
 295  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 296  
   * @throws AccessPoemException 
 297  
   *         if the current <code>AccessToken</code> 
 298  
   *         does not confer write access rights
 299  
   * @return the Integer id
 300  
   */
 301  
   public Field getIdField() throws AccessPoemException {
 302  0
     Column c = _getProductTable().getIdColumn();
 303  0
     return new Field(c.getRaw(this), c);
 304  
   }
 305  
 
 306  
 
 307  
  /**
 308  
   * Retrieves the <code>Name</code> value, without locking, 
 309  
   * for this <code>Product</code> <code>Persistent</code>.
 310  
   *
 311  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 312  
   * @return the String name
 313  
   */
 314  
   public String getName_unsafe() {
 315  0
     return name;
 316  
   }
 317  
 
 318  
 
 319  
  /**
 320  
   * Sets the <code>Name</code> value directly, without checking, 
 321  
   * for this Product <code>Persistent</code>.
 322  
   * 
 323  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 324  
   * @param cooked  the pre-validated value to set
 325  
   */
 326  
   public void setName_unsafe(String cooked) {
 327  0
     name = cooked;
 328  0
   }
 329  
 
 330  
  /**
 331  
   * Retrieves the Name value, with locking, for this 
 332  
   * <code>Product</code> <code>Persistent</code>.
 333  
   * 
 334  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 335  
   * @throws AccessPoemException 
 336  
   *         if the current <code>AccessToken</code> 
 337  
   *         does not confer write access rights 
 338  
   * @return the value of the field <code>Name</code> for this 
 339  
   *         <code>Product</code> <code>Persistent</code>  
 340  
   */
 341  
 
 342  
   public String getName()
 343  
       throws AccessPoemException {
 344  0
     readLock();
 345  0
     return getName_unsafe();
 346  
   }
 347  
 
 348  
 
 349  
  /**
 350  
   * Sets the <code>Name</code> value, with checking, for this 
 351  
   * <code>Product</code> <code>Persistent</code>.
 352  
   * 
 353  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 354  
   * @param cooked  a validated <code>int</code> 
 355  
   * @throws AccessPoemException 
 356  
   *         if the current <code>AccessToken</code> 
 357  
   *         does not confer write access rights
 358  
   * @throws ValidationPoemException 
 359  
   *         if the value is not valid
 360  
   */
 361  
   public void setName(String cooked)
 362  
       throws AccessPoemException, ValidationPoemException {
 363  0
     _getProductTable().getNameColumn().
 364  
       getType().assertValidCooked(cooked);
 365  0
     writeLock();
 366  0
     setName_unsafe(cooked);
 367  0
   }
 368  
 
 369  
 
 370  
  /**
 371  
   * Retrieves the <code>Name</code> value as a <code>Field</code>
 372  
   * from this <code>Product</code> <code>Persistent</code>.
 373  
   * 
 374  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 375  
   * @throws AccessPoemException 
 376  
   *         if the current <code>AccessToken</code> 
 377  
   *         does not confer write access rights
 378  
   * @return the String name
 379  
   */
 380  
   public Field getNameField() throws AccessPoemException {
 381  0
     Column c = _getProductTable().getNameColumn();
 382  0
     return new Field(c.getRaw(this), c);
 383  
   }
 384  
 
 385  
 
 386  
  /**
 387  
   * Retrieves the <code>Status</code> value, without locking, 
 388  
   * for this <code>Product</code> <code>Persistent</code>.
 389  
   *
 390  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 391  
   * @return the Integer status
 392  
   */
 393  
   public Integer getStatus_unsafe() {
 394  0
     return status;
 395  
   }
 396  
 
 397  
 
 398  
  /**
 399  
   * Sets the <code>Status</code> value directly, without checking, 
 400  
   * for this Product <code>Persistent</code>.
 401  
   * 
 402  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 403  
   * @param cooked  the pre-validated value to set
 404  
   */
 405  
   public void setStatus_unsafe(Integer cooked) {
 406  0
     status = cooked;
 407  0
   }
 408  
 
 409  
  /**
 410  
   * Retrieves the Table Row Object ID. 
 411  
   *
 412  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 413  
   * @throws AccessPoemException  
 414  
   *         if the current <code>AccessToken</code> 
 415  
   *         does not confer read access rights 
 416  
   * @return the TROID as an <code>Integer</code> 
 417  
   */
 418  
 
 419  
   public Integer getStatusTroid()
 420  
       throws AccessPoemException {
 421  0
     readLock();
 422  0
     return getStatus_unsafe();
 423  
   }
 424  
 
 425  
 
 426  
  /**
 427  
   * Sets the Table Row Object ID. 
 428  
   * 
 429  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 430  
   * @param raw  a Table Row Object Id 
 431  
   * @throws AccessPoemException  
 432  
   *         if the current <code>AccessToken</code> 
 433  
   *         does not confer write access rights
 434  
   */
 435  
   public void setStatusTroid(Integer raw)
 436  
       throws AccessPoemException {
 437  0
     setStatus(raw == null ? null : 
 438  
         getJammyjoesDatabaseTables().getProductStatusTable().getProductStatusObject(raw));
 439  0
   }
 440  
 
 441  
 
 442  
  /**
 443  
   * Retrieves the <code>Status</code> object referred to.
 444  
   *  
 445  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 446  
   * @throws AccessPoemException  
 447  
   *         if the current <code>AccessToken</code> 
 448  
   *         does not confer read access rights 
 449  
   * @throws NoSuchRowPoemException  
 450  
   *         if the <code>Persistent</code> has yet to be allocated a TROID 
 451  
   * @return the <code>Status</code> as a <code>ProductStatus</code> 
 452  
   */
 453  
   public ProductStatus getStatus()
 454  
       throws AccessPoemException, NoSuchRowPoemException {
 455  0
     Integer troid = getStatusTroid();
 456  0
     return troid == null ? null :
 457  
         getJammyjoesDatabaseTables().getProductStatusTable().getProductStatusObject(troid);
 458  
   }
 459  
 
 460  
 
 461  
  /**
 462  
   * Set the Status.
 463  
   * 
 464  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 465  
   * @param cooked  a validated <code>ProductStatus</code>
 466  
   * @throws AccessPoemException  
 467  
   *         if the current <code>AccessToken</code> 
 468  
   *         does not confer write access rights 
 469  
   */
 470  
   public void setStatus(ProductStatus cooked)
 471  
       throws AccessPoemException {
 472  0
     _getProductTable().
 473  
       getStatusColumn().
 474  
         getType().assertValidCooked(cooked);
 475  0
     writeLock();
 476  0
     if (cooked == null)
 477  0
       setStatus_unsafe(null);
 478  
     else {
 479  0
       cooked.existenceLock();
 480  0
       setStatus_unsafe(cooked.troid());
 481  
     }
 482  0
   }
 483  
 
 484  
 
 485  
  /**
 486  
   * Retrieves the <code>Status</code> value as a <code>Field</code>
 487  
   * from this <code>Product</code> <code>Persistent</code>.
 488  
   * 
 489  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 490  
   * @throws AccessPoemException 
 491  
   *         if the current <code>AccessToken</code> 
 492  
   *         does not confer write access rights
 493  
   * @return the Integer status
 494  
   */
 495  
   public Field getStatusField() throws AccessPoemException {
 496  0
     Column c = _getProductTable().getStatusColumn();
 497  0
     return new Field(c.getRaw(this), c);
 498  
   }
 499  
 
 500  
 
 501  
  /**
 502  
   * Retrieves the <code>Type</code> value, without locking, 
 503  
   * for this <code>Product</code> <code>Persistent</code>.
 504  
   *
 505  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 506  
   * @return the Integer type
 507  
   */
 508  
   public Integer getType_unsafe() {
 509  0
     return type;
 510  
   }
 511  
 
 512  
 
 513  
  /**
 514  
   * Sets the <code>Type</code> value directly, without checking, 
 515  
   * for this Product <code>Persistent</code>.
 516  
   * 
 517  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 518  
   * @param cooked  the pre-validated value to set
 519  
   */
 520  
   public void setType_unsafe(Integer cooked) {
 521  0
     type = cooked;
 522  0
   }
 523  
 
 524  
  /**
 525  
   * Retrieves the Table Row Object ID. 
 526  
   *
 527  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 528  
   * @throws AccessPoemException  
 529  
   *         if the current <code>AccessToken</code> 
 530  
   *         does not confer read access rights 
 531  
   * @return the TROID as an <code>Integer</code> 
 532  
   */
 533  
 
 534  
   public Integer getTypeTroid()
 535  
       throws AccessPoemException {
 536  0
     readLock();
 537  0
     return getType_unsafe();
 538  
   }
 539  
 
 540  
 
 541  
  /**
 542  
   * Sets the Table Row Object ID. 
 543  
   * 
 544  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 545  
   * @param raw  a Table Row Object Id 
 546  
   * @throws AccessPoemException  
 547  
   *         if the current <code>AccessToken</code> 
 548  
   *         does not confer write access rights
 549  
   */
 550  
   public void setTypeTroid(Integer raw)
 551  
       throws AccessPoemException {
 552  0
     setType(raw == null ? null : 
 553  
         getJammyjoesDatabaseTables().getTypeTable().getTypeObject(raw));
 554  0
   }
 555  
 
 556  
 
 557  
  /**
 558  
   * Retrieves the <code>Type</code> object referred to.
 559  
   *  
 560  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 561  
   * @throws AccessPoemException  
 562  
   *         if the current <code>AccessToken</code> 
 563  
   *         does not confer read access rights 
 564  
   * @throws NoSuchRowPoemException  
 565  
   *         if the <code>Persistent</code> has yet to be allocated a TROID 
 566  
   * @return the <code>Type</code> as a <code>Type</code> 
 567  
   */
 568  
   public Type getType()
 569  
       throws AccessPoemException, NoSuchRowPoemException {
 570  0
     Integer troid = getTypeTroid();
 571  0
     return troid == null ? null :
 572  
         getJammyjoesDatabaseTables().getTypeTable().getTypeObject(troid);
 573  
   }
 574  
 
 575  
 
 576  
  /**
 577  
   * Set the Type.
 578  
   * 
 579  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 580  
   * @param cooked  a validated <code>Type</code>
 581  
   * @throws AccessPoemException  
 582  
   *         if the current <code>AccessToken</code> 
 583  
   *         does not confer write access rights 
 584  
   */
 585  
   public void setType(Type cooked)
 586  
       throws AccessPoemException {
 587  0
     _getProductTable().
 588  
       getTypeColumn().
 589  
         getType().assertValidCooked(cooked);
 590  0
     writeLock();
 591  0
     if (cooked == null)
 592  0
       setType_unsafe(null);
 593  
     else {
 594  0
       cooked.existenceLock();
 595  0
       setType_unsafe(cooked.troid());
 596  
     }
 597  0
   }
 598  
 
 599  
 
 600  
  /**
 601  
   * Retrieves the <code>Type</code> value as a <code>Field</code>
 602  
   * from this <code>Product</code> <code>Persistent</code>.
 603  
   * 
 604  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 605  
   * @throws AccessPoemException 
 606  
   *         if the current <code>AccessToken</code> 
 607  
   *         does not confer write access rights
 608  
   * @return the Integer type
 609  
   */
 610  
   public Field getTypeField() throws AccessPoemException {
 611  0
     Column c = _getProductTable().getTypeColumn();
 612  0
     return new Field(c.getRaw(this), c);
 613  
   }
 614  
 
 615  
 
 616  
  /**
 617  
   * Retrieves the <code>Type2</code> value, without locking, 
 618  
   * for this <code>Product</code> <code>Persistent</code>.
 619  
   *
 620  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 621  
   * @return the Integer type2
 622  
   */
 623  
   public Integer getType2_unsafe() {
 624  0
     return type2;
 625  
   }
 626  
 
 627  
 
 628  
  /**
 629  
   * Sets the <code>Type2</code> value directly, without checking, 
 630  
   * for this Product <code>Persistent</code>.
 631  
   * 
 632  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 633  
   * @param cooked  the pre-validated value to set
 634  
   */
 635  
   public void setType2_unsafe(Integer cooked) {
 636  0
     type2 = cooked;
 637  0
   }
 638  
 
 639  
  /**
 640  
   * Retrieves the Table Row Object ID. 
 641  
   *
 642  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 643  
   * @throws AccessPoemException  
 644  
   *         if the current <code>AccessToken</code> 
 645  
   *         does not confer read access rights 
 646  
   * @return the TROID as an <code>Integer</code> 
 647  
   */
 648  
 
 649  
   public Integer getType2Troid()
 650  
       throws AccessPoemException {
 651  0
     readLock();
 652  0
     return getType2_unsafe();
 653  
   }
 654  
 
 655  
 
 656  
  /**
 657  
   * Sets the Table Row Object ID. 
 658  
   * 
 659  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 660  
   * @param raw  a Table Row Object Id 
 661  
   * @throws AccessPoemException  
 662  
   *         if the current <code>AccessToken</code> 
 663  
   *         does not confer write access rights
 664  
   */
 665  
   public void setType2Troid(Integer raw)
 666  
       throws AccessPoemException {
 667  0
     setType2(raw == null ? null : 
 668  
         getJammyjoesDatabaseTables().getTypeTable().getTypeObject(raw));
 669  0
   }
 670  
 
 671  
 
 672  
  /**
 673  
   * Retrieves the <code>Type2</code> object referred to.
 674  
   *  
 675  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 676  
   * @throws AccessPoemException  
 677  
   *         if the current <code>AccessToken</code> 
 678  
   *         does not confer read access rights 
 679  
   * @throws NoSuchRowPoemException  
 680  
   *         if the <code>Persistent</code> has yet to be allocated a TROID 
 681  
   * @return the <code>Type2</code> as a <code>Type</code> 
 682  
   */
 683  
   public Type getType2()
 684  
       throws AccessPoemException, NoSuchRowPoemException {
 685  0
     Integer troid = getType2Troid();
 686  0
     return troid == null ? null :
 687  
         getJammyjoesDatabaseTables().getTypeTable().getTypeObject(troid);
 688  
   }
 689  
 
 690  
 
 691  
  /**
 692  
   * Set the Type2.
 693  
   * 
 694  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 695  
   * @param cooked  a validated <code>Type</code>
 696  
   * @throws AccessPoemException  
 697  
   *         if the current <code>AccessToken</code> 
 698  
   *         does not confer write access rights 
 699  
   */
 700  
   public void setType2(Type cooked)
 701  
       throws AccessPoemException {
 702  0
     _getProductTable().
 703  
       getType2Column().
 704  
         getType().assertValidCooked(cooked);
 705  0
     writeLock();
 706  0
     if (cooked == null)
 707  0
       setType2_unsafe(null);
 708  
     else {
 709  0
       cooked.existenceLock();
 710  0
       setType2_unsafe(cooked.troid());
 711  
     }
 712  0
   }
 713  
 
 714  
 
 715  
  /**
 716  
   * Retrieves the <code>Type2</code> value as a <code>Field</code>
 717  
   * from this <code>Product</code> <code>Persistent</code>.
 718  
   * 
 719  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 720  
   * @throws AccessPoemException 
 721  
   *         if the current <code>AccessToken</code> 
 722  
   *         does not confer write access rights
 723  
   * @return the Integer type2
 724  
   */
 725  
   public Field getType2Field() throws AccessPoemException {
 726  0
     Column c = _getProductTable().getType2Column();
 727  0
     return new Field(c.getRaw(this), c);
 728  
   }
 729  
 
 730  
 
 731  
  /**
 732  
   * Retrieves the <code>Sex</code> value, without locking, 
 733  
   * for this <code>Product</code> <code>Persistent</code>.
 734  
   *
 735  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 736  
   * @return the Integer sex
 737  
   */
 738  
   public Integer getSex_unsafe() {
 739  0
     return sex;
 740  
   }
 741  
 
 742  
 
 743  
  /**
 744  
   * Sets the <code>Sex</code> value directly, without checking, 
 745  
   * for this Product <code>Persistent</code>.
 746  
   * 
 747  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 748  
   * @param cooked  the pre-validated value to set
 749  
   */
 750  
   public void setSex_unsafe(Integer cooked) {
 751  0
     sex = cooked;
 752  0
   }
 753  
 
 754  
  /**
 755  
   * Retrieves the Table Row Object ID. 
 756  
   *
 757  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 758  
   * @throws AccessPoemException  
 759  
   *         if the current <code>AccessToken</code> 
 760  
   *         does not confer read access rights 
 761  
   * @return the TROID as an <code>Integer</code> 
 762  
   */
 763  
 
 764  
   public Integer getSexTroid()
 765  
       throws AccessPoemException {
 766  0
     readLock();
 767  0
     return getSex_unsafe();
 768  
   }
 769  
 
 770  
 
 771  
  /**
 772  
   * Sets the Table Row Object ID. 
 773  
   * 
 774  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 775  
   * @param raw  a Table Row Object Id 
 776  
   * @throws AccessPoemException  
 777  
   *         if the current <code>AccessToken</code> 
 778  
   *         does not confer write access rights
 779  
   */
 780  
   public void setSexTroid(Integer raw)
 781  
       throws AccessPoemException {
 782  0
     setSex(raw == null ? null : 
 783  
         getJammyjoesDatabaseTables().getSexTable().getSexObject(raw));
 784  0
   }
 785  
 
 786  
 
 787  
  /**
 788  
   * Retrieves the <code>Sex</code> object referred to.
 789  
   *  
 790  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 791  
   * @throws AccessPoemException  
 792  
   *         if the current <code>AccessToken</code> 
 793  
   *         does not confer read access rights 
 794  
   * @throws NoSuchRowPoemException  
 795  
   *         if the <code>Persistent</code> has yet to be allocated a TROID 
 796  
   * @return the <code>Sex</code> as a <code>Sex</code> 
 797  
   */
 798  
   public Sex getSex()
 799  
       throws AccessPoemException, NoSuchRowPoemException {
 800  0
     Integer troid = getSexTroid();
 801  0
     return troid == null ? null :
 802  
         getJammyjoesDatabaseTables().getSexTable().getSexObject(troid);
 803  
   }
 804  
 
 805  
 
 806  
  /**
 807  
   * Set the Sex.
 808  
   * 
 809  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 810  
   * @param cooked  a validated <code>Sex</code>
 811  
   * @throws AccessPoemException  
 812  
   *         if the current <code>AccessToken</code> 
 813  
   *         does not confer write access rights 
 814  
   */
 815  
   public void setSex(Sex cooked)
 816  
       throws AccessPoemException {
 817  0
     _getProductTable().
 818  
       getSexColumn().
 819  
         getType().assertValidCooked(cooked);
 820  0
     writeLock();
 821  0
     if (cooked == null)
 822  0
       setSex_unsafe(null);
 823  
     else {
 824  0
       cooked.existenceLock();
 825  0
       setSex_unsafe(cooked.troid());
 826  
     }
 827  0
   }
 828  
 
 829  
 
 830  
  /**
 831  
   * Retrieves the <code>Sex</code> value as a <code>Field</code>
 832  
   * from this <code>Product</code> <code>Persistent</code>.
 833  
   * 
 834  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 835  
   * @throws AccessPoemException 
 836  
   *         if the current <code>AccessToken</code> 
 837  
   *         does not confer write access rights
 838  
   * @return the Integer sex
 839  
   */
 840  
   public Field getSexField() throws AccessPoemException {
 841  0
     Column c = _getProductTable().getSexColumn();
 842  0
     return new Field(c.getRaw(this), c);
 843  
   }
 844  
 
 845  
 
 846  
  /**
 847  
   * Retrieves the <code>Description</code> value, without locking, 
 848  
   * for this <code>Product</code> <code>Persistent</code>.
 849  
   *
 850  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 851  
   * @return the String description
 852  
   */
 853  
   public String getDescription_unsafe() {
 854  0
     return description;
 855  
   }
 856  
 
 857  
 
 858  
  /**
 859  
   * Sets the <code>Description</code> value directly, without checking, 
 860  
   * for this Product <code>Persistent</code>.
 861  
   * 
 862  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 863  
   * @param cooked  the pre-validated value to set
 864  
   */
 865  
   public void setDescription_unsafe(String cooked) {
 866  0
     description = cooked;
 867  0
   }
 868  
 
 869  
  /**
 870  
   * Retrieves the Description value, with locking, for this 
 871  
   * <code>Product</code> <code>Persistent</code>.
 872  
   * 
 873  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 874  
   * @throws AccessPoemException 
 875  
   *         if the current <code>AccessToken</code> 
 876  
   *         does not confer write access rights 
 877  
   * @return the value of the field <code>Description</code> for this 
 878  
   *         <code>Product</code> <code>Persistent</code>  
 879  
   */
 880  
 
 881  
   public String getDescription()
 882  
       throws AccessPoemException {
 883  0
     readLock();
 884  0
     return getDescription_unsafe();
 885  
   }
 886  
 
 887  
 
 888  
  /**
 889  
   * Sets the <code>Description</code> value, with checking, for this 
 890  
   * <code>Product</code> <code>Persistent</code>.
 891  
   * 
 892  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 893  
   * @param cooked  a validated <code>int</code> 
 894  
   * @throws AccessPoemException 
 895  
   *         if the current <code>AccessToken</code> 
 896  
   *         does not confer write access rights
 897  
   * @throws ValidationPoemException 
 898  
   *         if the value is not valid
 899  
   */
 900  
   public void setDescription(String cooked)
 901  
       throws AccessPoemException, ValidationPoemException {
 902  0
     _getProductTable().getDescriptionColumn().
 903  
       getType().assertValidCooked(cooked);
 904  0
     writeLock();
 905  0
     setDescription_unsafe(cooked);
 906  0
   }
 907  
 
 908  
 
 909  
  /**
 910  
   * Retrieves the <code>Description</code> value as a <code>Field</code>
 911  
   * from this <code>Product</code> <code>Persistent</code>.
 912  
   * 
 913  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 914  
   * @throws AccessPoemException 
 915  
   *         if the current <code>AccessToken</code> 
 916  
   *         does not confer write access rights
 917  
   * @return the String description
 918  
   */
 919  
   public Field getDescriptionField() throws AccessPoemException {
 920  0
     Column c = _getProductTable().getDescriptionColumn();
 921  0
     return new Field(c.getRaw(this), c);
 922  
   }
 923  
 
 924  
 
 925  
  /**
 926  
   * Retrieves the <code>Supplier</code> value, without locking, 
 927  
   * for this <code>Product</code> <code>Persistent</code>.
 928  
   *
 929  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 930  
   * @return the Integer supplier
 931  
   */
 932  
   public Integer getSupplier_unsafe() {
 933  0
     return supplier;
 934  
   }
 935  
 
 936  
 
 937  
  /**
 938  
   * Sets the <code>Supplier</code> value directly, without checking, 
 939  
   * for this Product <code>Persistent</code>.
 940  
   * 
 941  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 942  
   * @param cooked  the pre-validated value to set
 943  
   */
 944  
   public void setSupplier_unsafe(Integer cooked) {
 945  0
     supplier = cooked;
 946  0
   }
 947  
 
 948  
  /**
 949  
   * Retrieves the Table Row Object ID. 
 950  
   *
 951  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 952  
   * @throws AccessPoemException  
 953  
   *         if the current <code>AccessToken</code> 
 954  
   *         does not confer read access rights 
 955  
   * @return the TROID as an <code>Integer</code> 
 956  
   */
 957  
 
 958  
   public Integer getSupplierTroid()
 959  
       throws AccessPoemException {
 960  0
     readLock();
 961  0
     return getSupplier_unsafe();
 962  
   }
 963  
 
 964  
 
 965  
  /**
 966  
   * Sets the Table Row Object ID. 
 967  
   * 
 968  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 969  
   * @param raw  a Table Row Object Id 
 970  
   * @throws AccessPoemException  
 971  
   *         if the current <code>AccessToken</code> 
 972  
   *         does not confer write access rights
 973  
   */
 974  
   public void setSupplierTroid(Integer raw)
 975  
       throws AccessPoemException {
 976  0
     setSupplier(raw == null ? null : 
 977  
         getJammyjoesDatabaseTables().getSupplierTable().getSupplierObject(raw));
 978  0
   }
 979  
 
 980  
 
 981  
  /**
 982  
   * Retrieves the <code>Supplier</code> object referred to.
 983  
   *  
 984  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 985  
   * @throws AccessPoemException  
 986  
   *         if the current <code>AccessToken</code> 
 987  
   *         does not confer read access rights 
 988  
   * @throws NoSuchRowPoemException  
 989  
   *         if the <code>Persistent</code> has yet to be allocated a TROID 
 990  
   * @return the <code>Supplier</code> as a <code>Supplier</code> 
 991  
   */
 992  
   public Supplier getSupplier()
 993  
       throws AccessPoemException, NoSuchRowPoemException {
 994  0
     Integer troid = getSupplierTroid();
 995  0
     return troid == null ? null :
 996  
         getJammyjoesDatabaseTables().getSupplierTable().getSupplierObject(troid);
 997  
   }
 998  
 
 999  
 
 1000  
  /**
 1001  
   * Set the Supplier.
 1002  
   * 
 1003  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 1004  
   * @param cooked  a validated <code>Supplier</code>
 1005  
   * @throws AccessPoemException  
 1006  
   *         if the current <code>AccessToken</code> 
 1007  
   *         does not confer write access rights 
 1008  
   */
 1009  
   public void setSupplier(Supplier cooked)
 1010  
       throws AccessPoemException {
 1011  0
     _getProductTable().
 1012  
       getSupplierColumn().
 1013  
         getType().assertValidCooked(cooked);
 1014  0
     writeLock();
 1015  0
     if (cooked == null)
 1016  0
       setSupplier_unsafe(null);
 1017  
     else {
 1018  0
       cooked.existenceLock();
 1019  0
       setSupplier_unsafe(cooked.troid());
 1020  
     }
 1021  0
   }
 1022  
 
 1023  
 
 1024  
  /**
 1025  
   * Retrieves the <code>Supplier</code> value as a <code>Field</code>
 1026  
   * from this <code>Product</code> <code>Persistent</code>.
 1027  
   * 
 1028  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 1029  
   * @throws AccessPoemException 
 1030  
   *         if the current <code>AccessToken</code> 
 1031  
   *         does not confer write access rights
 1032  
   * @return the Integer supplier
 1033  
   */
 1034  
   public Field getSupplierField() throws AccessPoemException {
 1035  0
     Column c = _getProductTable().getSupplierColumn();
 1036  0
     return new Field(c.getRaw(this), c);
 1037  
   }
 1038  
 
 1039  
 
 1040  
  /**
 1041  
   * Retrieves the <code>Manufacturer</code> value, without locking, 
 1042  
   * for this <code>Product</code> <code>Persistent</code>.
 1043  
   *
 1044  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 1045  
   * @return the Integer manufacturer
 1046  
   */
 1047  
   public Integer getManufacturer_unsafe() {
 1048  0
     return manufacturer;
 1049  
   }
 1050  
 
 1051  
 
 1052  
  /**
 1053  
   * Sets the <code>Manufacturer</code> value directly, without checking, 
 1054  
   * for this Product <code>Persistent</code>.
 1055  
   * 
 1056  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 1057  
   * @param cooked  the pre-validated value to set
 1058  
   */
 1059  
   public void setManufacturer_unsafe(Integer cooked) {
 1060  0
     manufacturer = cooked;
 1061  0
   }
 1062  
 
 1063  
  /**
 1064  
   * Retrieves the Table Row Object ID. 
 1065  
   *
 1066  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 1067  
   * @throws AccessPoemException  
 1068  
   *         if the current <code>AccessToken</code> 
 1069  
   *         does not confer read access rights 
 1070  
   * @return the TROID as an <code>Integer</code> 
 1071  
   */
 1072  
 
 1073  
   public Integer getManufacturerTroid()
 1074  
       throws AccessPoemException {
 1075  0
     readLock();
 1076  0
     return getManufacturer_unsafe();
 1077  
   }
 1078  
 
 1079  
 
 1080  
  /**
 1081  
   * Sets the Table Row Object ID. 
 1082  
   * 
 1083  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 1084  
   * @param raw  a Table Row Object Id 
 1085  
   * @throws AccessPoemException  
 1086  
   *         if the current <code>AccessToken</code> 
 1087  
   *         does not confer write access rights
 1088  
   */
 1089  
   public void setManufacturerTroid(Integer raw)
 1090  
       throws AccessPoemException {
 1091  0
     setManufacturer(raw == null ? null : 
 1092  
         getJammyjoesDatabaseTables().getManufacturerTable().getManufacturerObject(raw));
 1093  0
   }
 1094  
 
 1095  
 
 1096  
  /**
 1097  
   * Retrieves the <code>Manufacturer</code> object referred to.
 1098  
   *  
 1099  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 1100  
   * @throws AccessPoemException  
 1101  
   *         if the current <code>AccessToken</code> 
 1102  
   *         does not confer read access rights 
 1103  
   * @throws NoSuchRowPoemException  
 1104  
   *         if the <code>Persistent</code> has yet to be allocated a TROID 
 1105  
   * @return the <code>Manufacturer</code> as a <code>Manufacturer</code> 
 1106  
   */
 1107  
   public Manufacturer getManufacturer()
 1108  
       throws AccessPoemException, NoSuchRowPoemException {
 1109  0
     Integer troid = getManufacturerTroid();
 1110  0
     return troid == null ? null :
 1111  
         getJammyjoesDatabaseTables().getManufacturerTable().getManufacturerObject(troid);
 1112  
   }
 1113  
 
 1114  
 
 1115  
  /**
 1116  
   * Set the Manufacturer.
 1117  
   * 
 1118  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 1119  
   * @param cooked  a validated <code>Manufacturer</code>
 1120  
   * @throws AccessPoemException  
 1121  
   *         if the current <code>AccessToken</code> 
 1122  
   *         does not confer write access rights 
 1123  
   */
 1124  
   public void setManufacturer(Manufacturer cooked)
 1125  
       throws AccessPoemException {
 1126  0
     _getProductTable().
 1127  
       getManufacturerColumn().
 1128  
         getType().assertValidCooked(cooked);
 1129  0
     writeLock();
 1130  0
     if (cooked == null)
 1131  0
       setManufacturer_unsafe(null);
 1132  
     else {
 1133  0
       cooked.existenceLock();
 1134  0
       setManufacturer_unsafe(cooked.troid());
 1135  
     }
 1136  0
   }
 1137  
 
 1138  
 
 1139  
  /**
 1140  
   * Retrieves the <code>Manufacturer</code> value as a <code>Field</code>
 1141  
   * from this <code>Product</code> <code>Persistent</code>.
 1142  
   * 
 1143  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 1144  
   * @throws AccessPoemException 
 1145  
   *         if the current <code>AccessToken</code> 
 1146  
   *         does not confer write access rights
 1147  
   * @return the Integer manufacturer
 1148  
   */
 1149  
   public Field getManufacturerField() throws AccessPoemException {
 1150  0
     Column c = _getProductTable().getManufacturerColumn();
 1151  0
     return new Field(c.getRaw(this), c);
 1152  
   }
 1153  
 
 1154  
 
 1155  
  /**
 1156  
   * Retrieves the <code>Suppliercode</code> value, without locking, 
 1157  
   * for this <code>Product</code> <code>Persistent</code>.
 1158  
   *
 1159  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 1160  
   * @return the String suppliercode
 1161  
   */
 1162  
   public String getSuppliercode_unsafe() {
 1163  0
     return suppliercode;
 1164  
   }
 1165  
 
 1166  
 
 1167  
  /**
 1168  
   * Sets the <code>Suppliercode</code> value directly, without checking, 
 1169  
   * for this Product <code>Persistent</code>.
 1170  
   * 
 1171  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 1172  
   * @param cooked  the pre-validated value to set
 1173  
   */
 1174  
   public void setSuppliercode_unsafe(String cooked) {
 1175  0
     suppliercode = cooked;
 1176  0
   }
 1177  
 
 1178  
  /**
 1179  
   * Retrieves the Suppliercode value, with locking, for this 
 1180  
   * <code>Product</code> <code>Persistent</code>.
 1181  
   * 
 1182  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 1183  
   * @throws AccessPoemException 
 1184  
   *         if the current <code>AccessToken</code> 
 1185  
   *         does not confer write access rights 
 1186  
   * @return the value of the field <code>Suppliercode</code> for this 
 1187  
   *         <code>Product</code> <code>Persistent</code>  
 1188  
   */
 1189  
 
 1190  
   public String getSuppliercode()
 1191  
       throws AccessPoemException {
 1192  0
     readLock();
 1193  0
     return getSuppliercode_unsafe();
 1194  
   }
 1195  
 
 1196  
 
 1197  
  /**
 1198  
   * Sets the <code>Suppliercode</code> value, with checking, for this 
 1199  
   * <code>Product</code> <code>Persistent</code>.
 1200  
   * 
 1201  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 1202  
   * @param cooked  a validated <code>int</code> 
 1203  
   * @throws AccessPoemException 
 1204  
   *         if the current <code>AccessToken</code> 
 1205  
   *         does not confer write access rights
 1206  
   * @throws ValidationPoemException 
 1207  
   *         if the value is not valid
 1208  
   */
 1209  
   public void setSuppliercode(String cooked)
 1210  
       throws AccessPoemException, ValidationPoemException {
 1211  0
     _getProductTable().getSuppliercodeColumn().
 1212  
       getType().assertValidCooked(cooked);
 1213  0
     writeLock();
 1214  0
     setSuppliercode_unsafe(cooked);
 1215  0
   }
 1216  
 
 1217  
 
 1218  
  /**
 1219  
   * Retrieves the <code>Suppliercode</code> value as a <code>Field</code>
 1220  
   * from this <code>Product</code> <code>Persistent</code>.
 1221  
   * 
 1222  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 1223  
   * @throws AccessPoemException 
 1224  
   *         if the current <code>AccessToken</code> 
 1225  
   *         does not confer write access rights
 1226  
   * @return the String suppliercode
 1227  
   */
 1228  
   public Field getSuppliercodeField() throws AccessPoemException {
 1229  0
     Column c = _getProductTable().getSuppliercodeColumn();
 1230  0
     return new Field(c.getRaw(this), c);
 1231  
   }
 1232  
 
 1233  
 
 1234  
  /**
 1235  
   * Retrieves the <code>Costprice</code> value, without locking, 
 1236  
   * for this <code>Product</code> <code>Persistent</code>.
 1237  
   *
 1238  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 1239  
   * @return the Double costprice
 1240  
   */
 1241  
   public Double getCostprice_unsafe() {
 1242  0
     return costprice;
 1243  
   }
 1244  
 
 1245  
 
 1246  
  /**
 1247  
   * Sets the <code>Costprice</code> value directly, without checking, 
 1248  
   * for this Product <code>Persistent</code>.
 1249  
   * 
 1250  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 1251  
   * @param cooked  the pre-validated value to set
 1252  
   */
 1253  
   public void setCostprice_unsafe(Double cooked) {
 1254  0
     costprice = cooked;
 1255  0
   }
 1256  
 
 1257  
  /**
 1258  
   * Retrieves the Costprice value, with locking, for this 
 1259  
   * <code>Product</code> <code>Persistent</code>.
 1260  
   * 
 1261  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 1262  
   * @throws AccessPoemException 
 1263  
   *         if the current <code>AccessToken</code> 
 1264  
   *         does not confer write access rights 
 1265  
   * @return the value of the field <code>Costprice</code> for this 
 1266  
   *         <code>Product</code> <code>Persistent</code>  
 1267  
   */
 1268  
 
 1269  
   public Double getCostprice()
 1270  
       throws AccessPoemException {
 1271  0
     readLock();
 1272  0
     return getCostprice_unsafe();
 1273  
   }
 1274  
 
 1275  
 
 1276  
  /**
 1277  
   * Sets the <code>Costprice</code> value, with checking, for this 
 1278  
   * <code>Product</code> <code>Persistent</code>.
 1279  
   * 
 1280  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 1281  
   * @param cooked  a validated <code>int</code> 
 1282  
   * @throws AccessPoemException 
 1283  
   *         if the current <code>AccessToken</code> 
 1284  
   *         does not confer write access rights
 1285  
   * @throws ValidationPoemException 
 1286  
   *         if the value is not valid
 1287  
   */
 1288  
   public void setCostprice(Double cooked)
 1289  
       throws AccessPoemException, ValidationPoemException {
 1290  0
     _getProductTable().getCostpriceColumn().
 1291  
       getType().assertValidCooked(cooked);
 1292  0
     writeLock();
 1293  0
     setCostprice_unsafe(cooked);
 1294  0
   }
 1295  
 
 1296  
  /**
 1297  
   * Sets the <code>Costprice</code> value, with checking, for this <code>Product</code> <code>Persistent</code>.
 1298  
   * 
 1299  
   * @generator org.melati.poem.prepro.DoubleFieldDef#generateBaseMethods 
 1300  
   * @param cooked  a validated <code>int</code> 
 1301  
   * @throws AccessPoemException 
 1302  
   *         if the current <code>AccessToken</code> 
 1303  
   *         does not confer write access rights
 1304  
   * @throws ValidationPoemException 
 1305  
   *         if the value is not valid
 1306  
   */
 1307  
 
 1308  
   public final void setCostprice(double cooked)
 1309  
       throws AccessPoemException, ValidationPoemException {
 1310  0
     setCostprice(new Double(cooked));
 1311  0
   }
 1312  
 
 1313  
 
 1314  
  /**
 1315  
   * Retrieves the <code>Costprice</code> value as a <code>Field</code>
 1316  
   * from this <code>Product</code> <code>Persistent</code>.
 1317  
   * 
 1318  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 1319  
   * @throws AccessPoemException 
 1320  
   *         if the current <code>AccessToken</code> 
 1321  
   *         does not confer write access rights
 1322  
   * @return the Double costprice
 1323  
   */
 1324  
   public Field getCostpriceField() throws AccessPoemException {
 1325  0
     Column c = _getProductTable().getCostpriceColumn();
 1326  0
     return new Field(c.getRaw(this), c);
 1327  
   }
 1328  
 
 1329  
 
 1330  
  /**
 1331  
   * Retrieves the <code>Retailpriceincvat</code> value, without locking, 
 1332  
   * for this <code>Product</code> <code>Persistent</code>.
 1333  
   *
 1334  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 1335  
   * @return the Double retailpriceincvat
 1336  
   */
 1337  
   public Double getRetailpriceincvat_unsafe() {
 1338  0
     return retailpriceincvat;
 1339  
   }
 1340  
 
 1341  
 
 1342  
  /**
 1343  
   * Sets the <code>Retailpriceincvat</code> value directly, without checking, 
 1344  
   * for this Product <code>Persistent</code>.
 1345  
   * 
 1346  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 1347  
   * @param cooked  the pre-validated value to set
 1348  
   */
 1349  
   public void setRetailpriceincvat_unsafe(Double cooked) {
 1350  0
     retailpriceincvat = cooked;
 1351  0
   }
 1352  
 
 1353  
  /**
 1354  
   * Retrieves the Retailpriceincvat value, with locking, for this 
 1355  
   * <code>Product</code> <code>Persistent</code>.
 1356  
   * 
 1357  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 1358  
   * @throws AccessPoemException 
 1359  
   *         if the current <code>AccessToken</code> 
 1360  
   *         does not confer write access rights 
 1361  
   * @return the value of the field <code>Retailpriceincvat</code> for this 
 1362  
   *         <code>Product</code> <code>Persistent</code>  
 1363  
   */
 1364  
 
 1365  
   public Double getRetailpriceincvat()
 1366  
       throws AccessPoemException {
 1367  0
     readLock();
 1368  0
     return getRetailpriceincvat_unsafe();
 1369  
   }
 1370  
 
 1371  
 
 1372  
  /**
 1373  
   * Sets the <code>Retailpriceincvat</code> value, with checking, for this 
 1374  
   * <code>Product</code> <code>Persistent</code>.
 1375  
   * 
 1376  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 1377  
   * @param cooked  a validated <code>int</code> 
 1378  
   * @throws AccessPoemException 
 1379  
   *         if the current <code>AccessToken</code> 
 1380  
   *         does not confer write access rights
 1381  
   * @throws ValidationPoemException 
 1382  
   *         if the value is not valid
 1383  
   */
 1384  
   public void setRetailpriceincvat(Double cooked)
 1385  
       throws AccessPoemException, ValidationPoemException {
 1386  0
     _getProductTable().getRetailpriceincvatColumn().
 1387  
       getType().assertValidCooked(cooked);
 1388  0
     writeLock();
 1389  0
     setRetailpriceincvat_unsafe(cooked);
 1390  0
   }
 1391  
 
 1392  
  /**
 1393  
   * Sets the <code>Retailpriceincvat</code> value, with checking, for this <code>Product</code> <code>Persistent</code>.
 1394  
   * 
 1395  
   * @generator org.melati.poem.prepro.DoubleFieldDef#generateBaseMethods 
 1396  
   * @param cooked  a validated <code>int</code> 
 1397  
   * @throws AccessPoemException 
 1398  
   *         if the current <code>AccessToken</code> 
 1399  
   *         does not confer write access rights
 1400  
   * @throws ValidationPoemException 
 1401  
   *         if the value is not valid
 1402  
   */
 1403  
 
 1404  
   public final void setRetailpriceincvat(double cooked)
 1405  
       throws AccessPoemException, ValidationPoemException {
 1406  0
     setRetailpriceincvat(new Double(cooked));
 1407  0
   }
 1408  
 
 1409  
 
 1410  
  /**
 1411  
   * Retrieves the <code>Retailpriceincvat</code> value as a <code>Field</code>
 1412  
   * from this <code>Product</code> <code>Persistent</code>.
 1413  
   * 
 1414  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 1415  
   * @throws AccessPoemException 
 1416  
   *         if the current <code>AccessToken</code> 
 1417  
   *         does not confer write access rights
 1418  
   * @return the Double retailpriceincvat
 1419  
   */
 1420  
   public Field getRetailpriceincvatField() throws AccessPoemException {
 1421  0
     Column c = _getProductTable().getRetailpriceincvatColumn();
 1422  0
     return new Field(c.getRaw(this), c);
 1423  
   }
 1424  
 
 1425  
 
 1426  
  /**
 1427  
   * Retrieves the <code>Vatexempt</code> value, without locking, 
 1428  
   * for this <code>Product</code> <code>Persistent</code>.
 1429  
   *
 1430  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 1431  
   * @return the Boolean vatexempt
 1432  
   */
 1433  
   public Boolean getVatexempt_unsafe() {
 1434  0
     return vatexempt;
 1435  
   }
 1436  
 
 1437  
 
 1438  
  /**
 1439  
   * Sets the <code>Vatexempt</code> value directly, without checking, 
 1440  
   * for this Product <code>Persistent</code>.
 1441  
   * 
 1442  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 1443  
   * @param cooked  the pre-validated value to set
 1444  
   */
 1445  
   public void setVatexempt_unsafe(Boolean cooked) {
 1446  0
     vatexempt = cooked;
 1447  0
   }
 1448  
 
 1449  
  /**
 1450  
   * Retrieves the Vatexempt value, with locking, for this 
 1451  
   * <code>Product</code> <code>Persistent</code>.
 1452  
   * 
 1453  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 1454  
   * @throws AccessPoemException 
 1455  
   *         if the current <code>AccessToken</code> 
 1456  
   *         does not confer write access rights 
 1457  
   * @return the value of the field <code>Vatexempt</code> for this 
 1458  
   *         <code>Product</code> <code>Persistent</code>  
 1459  
   */
 1460  
 
 1461  
   public Boolean getVatexempt()
 1462  
       throws AccessPoemException {
 1463  0
     readLock();
 1464  0
     return getVatexempt_unsafe();
 1465  
   }
 1466  
 
 1467  
 
 1468  
  /**
 1469  
   * Sets the <code>Vatexempt</code> value, with checking, for this 
 1470  
   * <code>Product</code> <code>Persistent</code>.
 1471  
   * 
 1472  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 1473  
   * @param cooked  a validated <code>int</code> 
 1474  
   * @throws AccessPoemException 
 1475  
   *         if the current <code>AccessToken</code> 
 1476  
   *         does not confer write access rights
 1477  
   * @throws ValidationPoemException 
 1478  
   *         if the value is not valid
 1479  
   */
 1480  
   public void setVatexempt(Boolean cooked)
 1481  
       throws AccessPoemException, ValidationPoemException {
 1482  0
     _getProductTable().getVatexemptColumn().
 1483  
       getType().assertValidCooked(cooked);
 1484  0
     writeLock();
 1485  0
     setVatexempt_unsafe(cooked);
 1486  0
   }
 1487  
 
 1488  
  /**
 1489  
   * Sets the <code>Vatexempt</code> value, with checking, 
 1490  
   * from a <code>boolean</code>, for this 
 1491  
   * <code>Product</code> <code>Persistent</code>.
 1492  
   * 
 1493  
   * @generator org.melati.poem.prepro.BooleanFieldDef#generateBaseMethods 
 1494  
   * @param cooked  a <code>boolean</code> 
 1495  
   * @throws AccessPoemException 
 1496  
   *         if the current <code>AccessToken</code> 
 1497  
   *         does not confer write access rights
 1498  
   * @throws ValidationPoemException 
 1499  
   *         if the value is not valid
 1500  
   */
 1501  
 
 1502  
   public final void setVatexempt(boolean cooked)
 1503  
       throws AccessPoemException, ValidationPoemException {
 1504  0
     setVatexempt(cooked ? Boolean.TRUE : Boolean.FALSE);
 1505  0
   }
 1506  
 
 1507  
 
 1508  
  /**
 1509  
   * Retrieves the <code>Vatexempt</code> value as a <code>Field</code>
 1510  
   * from this <code>Product</code> <code>Persistent</code>.
 1511  
   * 
 1512  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 1513  
   * @throws AccessPoemException 
 1514  
   *         if the current <code>AccessToken</code> 
 1515  
   *         does not confer write access rights
 1516  
   * @return the Boolean vatexempt
 1517  
   */
 1518  
   public Field getVatexemptField() throws AccessPoemException {
 1519  0
     Column c = _getProductTable().getVatexemptColumn();
 1520  0
     return new Field(c.getRaw(this), c);
 1521  
   }
 1522  
 
 1523  
 
 1524  
  /**
 1525  
   * Retrieves the <code>Saleprice</code> value, without locking, 
 1526  
   * for this <code>Product</code> <code>Persistent</code>.
 1527  
   *
 1528  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 1529  
   * @return the Double saleprice
 1530  
   */
 1531  
   public Double getSaleprice_unsafe() {
 1532  0
     return saleprice;
 1533  
   }
 1534  
 
 1535  
 
 1536  
  /**
 1537  
   * Sets the <code>Saleprice</code> value directly, without checking, 
 1538  
   * for this Product <code>Persistent</code>.
 1539  
   * 
 1540  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 1541  
   * @param cooked  the pre-validated value to set
 1542  
   */
 1543  
   public void setSaleprice_unsafe(Double cooked) {
 1544  0
     saleprice = cooked;
 1545  0
   }
 1546  
 
 1547  
  /**
 1548  
   * Retrieves the Saleprice value, with locking, for this 
 1549  
   * <code>Product</code> <code>Persistent</code>.
 1550  
   * Field description: 
 1551  
   *   To put items in the sale, enter the original price here, and put the 
 1552  
   *   Sale price into the Retail Price inc VAT field 
 1553  
   * 
 1554  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 1555  
   * @throws AccessPoemException 
 1556  
   *         if the current <code>AccessToken</code> 
 1557  
   *         does not confer write access rights 
 1558  
   * @return the value of the field <code>Saleprice</code> for this 
 1559  
   *         <code>Product</code> <code>Persistent</code>  
 1560  
   */
 1561  
 
 1562  
   public Double getSaleprice()
 1563  
       throws AccessPoemException {
 1564  0
     readLock();
 1565  0
     return getSaleprice_unsafe();
 1566  
   }
 1567  
 
 1568  
 
 1569  
  /**
 1570  
   * Sets the <code>Saleprice</code> value, with checking, for this 
 1571  
   * <code>Product</code> <code>Persistent</code>.
 1572  
   * Field description: 
 1573  
   *   To put items in the sale, enter the original price here, and put the 
 1574  
   *   Sale price into the Retail Price inc VAT field 
 1575  
   * 
 1576  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 1577  
   * @param cooked  a validated <code>int</code> 
 1578  
   * @throws AccessPoemException 
 1579  
   *         if the current <code>AccessToken</code> 
 1580  
   *         does not confer write access rights
 1581  
   * @throws ValidationPoemException 
 1582  
   *         if the value is not valid
 1583  
   */
 1584  
   public void setSaleprice(Double cooked)
 1585  
       throws AccessPoemException, ValidationPoemException {
 1586  0
     _getProductTable().getSalepriceColumn().
 1587  
       getType().assertValidCooked(cooked);
 1588  0
     writeLock();
 1589  0
     setSaleprice_unsafe(cooked);
 1590  0
   }
 1591  
 
 1592  
  /**
 1593  
   * Sets the <code>Saleprice</code> value, with checking, for this <code>Product</code> <code>Persistent</code>.
 1594  
   * Field description: 
 1595  
   *   To put items in the sale, enter the original price here, and put the 
 1596  
   *   Sale price into the Retail Price inc VAT field 
 1597  
   * 
 1598  
   * 
 1599  
   * @generator org.melati.poem.prepro.DoubleFieldDef#generateBaseMethods 
 1600  
   * @param cooked  a validated <code>int</code> 
 1601  
   * @throws AccessPoemException 
 1602  
   *         if the current <code>AccessToken</code> 
 1603  
   *         does not confer write access rights
 1604  
   * @throws ValidationPoemException 
 1605  
   *         if the value is not valid
 1606  
   */
 1607  
 
 1608  
   public final void setSaleprice(double cooked)
 1609  
       throws AccessPoemException, ValidationPoemException {
 1610  0
     setSaleprice(new Double(cooked));
 1611  0
   }
 1612  
 
 1613  
 
 1614  
  /**
 1615  
   * Retrieves the <code>Saleprice</code> value as a <code>Field</code>
 1616  
   * from this <code>Product</code> <code>Persistent</code>.
 1617  
   * 
 1618  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 1619  
   * @throws AccessPoemException 
 1620  
   *         if the current <code>AccessToken</code> 
 1621  
   *         does not confer write access rights
 1622  
   * @return the Double saleprice
 1623  
   */
 1624  
   public Field getSalepriceField() throws AccessPoemException {
 1625  0
     Column c = _getProductTable().getSalepriceColumn();
 1626  0
     return new Field(c.getRaw(this), c);
 1627  
   }
 1628  
 
 1629  
 
 1630  
  /**
 1631  
   * Retrieves the <code>Retailprice</code> value, without locking, 
 1632  
   * for this <code>Product</code> <code>Persistent</code>.
 1633  
   *
 1634  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 1635  
   * @return the Double retailprice
 1636  
   */
 1637  
   public Double getRetailprice_unsafe() {
 1638  0
     return retailprice;
 1639  
   }
 1640  
 
 1641  
 
 1642  
  /**
 1643  
   * Sets the <code>Retailprice</code> value directly, without checking, 
 1644  
   * for this Product <code>Persistent</code>.
 1645  
   * 
 1646  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 1647  
   * @param cooked  the pre-validated value to set
 1648  
   */
 1649  
   public void setRetailprice_unsafe(Double cooked) {
 1650  0
     retailprice = cooked;
 1651  0
   }
 1652  
 
 1653  
  /**
 1654  
   * Retrieves the Retailprice value, with locking, for this 
 1655  
   * <code>Product</code> <code>Persistent</code>.
 1656  
   * 
 1657  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 1658  
   * @throws AccessPoemException 
 1659  
   *         if the current <code>AccessToken</code> 
 1660  
   *         does not confer write access rights 
 1661  
   * @return the value of the field <code>Retailprice</code> for this 
 1662  
   *         <code>Product</code> <code>Persistent</code>  
 1663  
   */
 1664  
 
 1665  
   public Double getRetailprice()
 1666  
       throws AccessPoemException {
 1667  0
     readLock();
 1668  0
     return getRetailprice_unsafe();
 1669  
   }
 1670  
 
 1671  
 
 1672  
  /**
 1673  
   * Sets the <code>Retailprice</code> value, with checking, for this 
 1674  
   * <code>Product</code> <code>Persistent</code>.
 1675  
   * 
 1676  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 1677  
   * @param cooked  a validated <code>int</code> 
 1678  
   * @throws AccessPoemException 
 1679  
   *         if the current <code>AccessToken</code> 
 1680  
   *         does not confer write access rights
 1681  
   * @throws ValidationPoemException 
 1682  
   *         if the value is not valid
 1683  
   */
 1684  
   public void setRetailprice(Double cooked)
 1685  
       throws AccessPoemException, ValidationPoemException {
 1686  0
     _getProductTable().getRetailpriceColumn().
 1687  
       getType().assertValidCooked(cooked);
 1688  0
     writeLock();
 1689  0
     setRetailprice_unsafe(cooked);
 1690  0
   }
 1691  
 
 1692  
  /**
 1693  
   * Sets the <code>Retailprice</code> value, with checking, for this <code>Product</code> <code>Persistent</code>.
 1694  
   * 
 1695  
   * @generator org.melati.poem.prepro.DoubleFieldDef#generateBaseMethods 
 1696  
   * @param cooked  a validated <code>int</code> 
 1697  
   * @throws AccessPoemException 
 1698  
   *         if the current <code>AccessToken</code> 
 1699  
   *         does not confer write access rights
 1700  
   * @throws ValidationPoemException 
 1701  
   *         if the value is not valid
 1702  
   */
 1703  
 
 1704  
   public final void setRetailprice(double cooked)
 1705  
       throws AccessPoemException, ValidationPoemException {
 1706  0
     setRetailprice(new Double(cooked));
 1707  0
   }
 1708  
 
 1709  
 
 1710  
  /**
 1711  
   * Retrieves the <code>Retailprice</code> value as a <code>Field</code>
 1712  
   * from this <code>Product</code> <code>Persistent</code>.
 1713  
   * 
 1714  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 1715  
   * @throws AccessPoemException 
 1716  
   *         if the current <code>AccessToken</code> 
 1717  
   *         does not confer write access rights
 1718  
   * @return the Double retailprice
 1719  
   */
 1720  
   public Field getRetailpriceField() throws AccessPoemException {
 1721  0
     Column c = _getProductTable().getRetailpriceColumn();
 1722  0
     return new Field(c.getRaw(this), c);
 1723  
   }
 1724  
 
 1725  
 
 1726  
  /**
 1727  
   * Retrieves the <code>Margin</code> value, without locking, 
 1728  
   * for this <code>Product</code> <code>Persistent</code>.
 1729  
   *
 1730  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 1731  
   * @return the Double margin
 1732  
   */
 1733  
   public Double getMargin_unsafe() {
 1734  0
     return margin;
 1735  
   }
 1736  
 
 1737  
 
 1738  
  /**
 1739  
   * Sets the <code>Margin</code> value directly, without checking, 
 1740  
   * for this Product <code>Persistent</code>.
 1741  
   * 
 1742  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 1743  
   * @param cooked  the pre-validated value to set
 1744  
   */
 1745  
   public void setMargin_unsafe(Double cooked) {
 1746  0
     margin = cooked;
 1747  0
   }
 1748  
 
 1749  
  /**
 1750  
   * Retrieves the Margin value, with locking, for this 
 1751  
   * <code>Product</code> <code>Persistent</code>.
 1752  
   * 
 1753  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 1754  
   * @throws AccessPoemException 
 1755  
   *         if the current <code>AccessToken</code> 
 1756  
   *         does not confer write access rights 
 1757  
   * @return the value of the field <code>Margin</code> for this 
 1758  
   *         <code>Product</code> <code>Persistent</code>  
 1759  
   */
 1760  
 
 1761  
   public Double getMargin()
 1762  
       throws AccessPoemException {
 1763  0
     readLock();
 1764  0
     return getMargin_unsafe();
 1765  
   }
 1766  
 
 1767  
 
 1768  
  /**
 1769  
   * Sets the <code>Margin</code> value, with checking, for this 
 1770  
   * <code>Product</code> <code>Persistent</code>.
 1771  
   * 
 1772  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 1773  
   * @param cooked  a validated <code>int</code> 
 1774  
   * @throws AccessPoemException 
 1775  
   *         if the current <code>AccessToken</code> 
 1776  
   *         does not confer write access rights
 1777  
   * @throws ValidationPoemException 
 1778  
   *         if the value is not valid
 1779  
   */
 1780  
   public void setMargin(Double cooked)
 1781  
       throws AccessPoemException, ValidationPoemException {
 1782  0
     _getProductTable().getMarginColumn().
 1783  
       getType().assertValidCooked(cooked);
 1784  0
     writeLock();
 1785  0
     setMargin_unsafe(cooked);
 1786  0
   }
 1787  
 
 1788  
  /**
 1789  
   * Sets the <code>Margin</code> value, with checking, for this <code>Product</code> <code>Persistent</code>.
 1790  
   * 
 1791  
   * @generator org.melati.poem.prepro.DoubleFieldDef#generateBaseMethods 
 1792  
   * @param cooked  a validated <code>int</code> 
 1793  
   * @throws AccessPoemException 
 1794  
   *         if the current <code>AccessToken</code> 
 1795  
   *         does not confer write access rights
 1796  
   * @throws ValidationPoemException 
 1797  
   *         if the value is not valid
 1798  
   */
 1799  
 
 1800  
   public final void setMargin(double cooked)
 1801  
       throws AccessPoemException, ValidationPoemException {
 1802  0
     setMargin(new Double(cooked));
 1803  0
   }
 1804  
 
 1805  
 
 1806  
  /**
 1807  
   * Retrieves the <code>Margin</code> value as a <code>Field</code>
 1808  
   * from this <code>Product</code> <code>Persistent</code>.
 1809  
   * 
 1810  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 1811  
   * @throws AccessPoemException 
 1812  
   *         if the current <code>AccessToken</code> 
 1813  
   *         does not confer write access rights
 1814  
   * @return the Double margin
 1815  
   */
 1816  
   public Field getMarginField() throws AccessPoemException {
 1817  0
     Column c = _getProductTable().getMarginColumn();
 1818  0
     return new Field(c.getRaw(this), c);
 1819  
   }
 1820  
 
 1821  
 
 1822  
  /**
 1823  
   * Retrieves the <code>Marginpercent</code> value, without locking, 
 1824  
   * for this <code>Product</code> <code>Persistent</code>.
 1825  
   *
 1826  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 1827  
   * @return the Double marginpercent
 1828  
   */
 1829  
   public Double getMarginpercent_unsafe() {
 1830  0
     return marginpercent;
 1831  
   }
 1832  
 
 1833  
 
 1834  
  /**
 1835  
   * Sets the <code>Marginpercent</code> value directly, without checking, 
 1836  
   * for this Product <code>Persistent</code>.
 1837  
   * 
 1838  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 1839  
   * @param cooked  the pre-validated value to set
 1840  
   */
 1841  
   public void setMarginpercent_unsafe(Double cooked) {
 1842  0
     marginpercent = cooked;
 1843  0
   }
 1844  
 
 1845  
  /**
 1846  
   * Retrieves the Marginpercent value, with locking, for this 
 1847  
   * <code>Product</code> <code>Persistent</code>.
 1848  
   * 
 1849  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 1850  
   * @throws AccessPoemException 
 1851  
   *         if the current <code>AccessToken</code> 
 1852  
   *         does not confer write access rights 
 1853  
   * @return the value of the field <code>Marginpercent</code> for this 
 1854  
   *         <code>Product</code> <code>Persistent</code>  
 1855  
   */
 1856  
 
 1857  
   public Double getMarginpercent()
 1858  
       throws AccessPoemException {
 1859  0
     readLock();
 1860  0
     return getMarginpercent_unsafe();
 1861  
   }
 1862  
 
 1863  
 
 1864  
  /**
 1865  
   * Sets the <code>Marginpercent</code> value, with checking, for this 
 1866  
   * <code>Product</code> <code>Persistent</code>.
 1867  
   * 
 1868  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 1869  
   * @param cooked  a validated <code>int</code> 
 1870  
   * @throws AccessPoemException 
 1871  
   *         if the current <code>AccessToken</code> 
 1872  
   *         does not confer write access rights
 1873  
   * @throws ValidationPoemException 
 1874  
   *         if the value is not valid
 1875  
   */
 1876  
   public void setMarginpercent(Double cooked)
 1877  
       throws AccessPoemException, ValidationPoemException {
 1878  0
     _getProductTable().getMarginpercentColumn().
 1879  
       getType().assertValidCooked(cooked);
 1880  0
     writeLock();
 1881  0
     setMarginpercent_unsafe(cooked);
 1882  0
   }
 1883  
 
 1884  
  /**
 1885  
   * Sets the <code>Marginpercent</code> value, with checking, for this <code>Product</code> <code>Persistent</code>.
 1886  
   * 
 1887  
   * @generator org.melati.poem.prepro.DoubleFieldDef#generateBaseMethods 
 1888  
   * @param cooked  a validated <code>int</code> 
 1889  
   * @throws AccessPoemException 
 1890  
   *         if the current <code>AccessToken</code> 
 1891  
   *         does not confer write access rights
 1892  
   * @throws ValidationPoemException 
 1893  
   *         if the value is not valid
 1894  
   */
 1895  
 
 1896  
   public final void setMarginpercent(double cooked)
 1897  
       throws AccessPoemException, ValidationPoemException {
 1898  0
     setMarginpercent(new Double(cooked));
 1899  0
   }
 1900  
 
 1901  
 
 1902  
  /**
 1903  
   * Retrieves the <code>Marginpercent</code> value as a <code>Field</code>
 1904  
   * from this <code>Product</code> <code>Persistent</code>.
 1905  
   * 
 1906  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 1907  
   * @throws AccessPoemException 
 1908  
   *         if the current <code>AccessToken</code> 
 1909  
   *         does not confer write access rights
 1910  
   * @return the Double marginpercent
 1911  
   */
 1912  
   public Field getMarginpercentField() throws AccessPoemException {
 1913  0
     Column c = _getProductTable().getMarginpercentColumn();
 1914  0
     return new Field(c.getRaw(this), c);
 1915  
   }
 1916  
 
 1917  
 
 1918  
  /**
 1919  
   * Retrieves the <code>Markuppercent</code> value, without locking, 
 1920  
   * for this <code>Product</code> <code>Persistent</code>.
 1921  
   *
 1922  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 1923  
   * @return the Double markuppercent
 1924  
   */
 1925  
   public Double getMarkuppercent_unsafe() {
 1926  0
     return markuppercent;
 1927  
   }
 1928  
 
 1929  
 
 1930  
  /**
 1931  
   * Sets the <code>Markuppercent</code> value directly, without checking, 
 1932  
   * for this Product <code>Persistent</code>.
 1933  
   * 
 1934  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 1935  
   * @param cooked  the pre-validated value to set
 1936  
   */
 1937  
   public void setMarkuppercent_unsafe(Double cooked) {
 1938  0
     markuppercent = cooked;
 1939  0
   }
 1940  
 
 1941  
  /**
 1942  
   * Retrieves the Markuppercent value, with locking, for this 
 1943  
   * <code>Product</code> <code>Persistent</code>.
 1944  
   * 
 1945  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 1946  
   * @throws AccessPoemException 
 1947  
   *         if the current <code>AccessToken</code> 
 1948  
   *         does not confer write access rights 
 1949  
   * @return the value of the field <code>Markuppercent</code> for this 
 1950  
   *         <code>Product</code> <code>Persistent</code>  
 1951  
   */
 1952  
 
 1953  
   public Double getMarkuppercent()
 1954  
       throws AccessPoemException {
 1955  0
     readLock();
 1956  0
     return getMarkuppercent_unsafe();
 1957  
   }
 1958  
 
 1959  
 
 1960  
  /**
 1961  
   * Sets the <code>Markuppercent</code> value, with checking, for this 
 1962  
   * <code>Product</code> <code>Persistent</code>.
 1963  
   * 
 1964  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 1965  
   * @param cooked  a validated <code>int</code> 
 1966  
   * @throws AccessPoemException 
 1967  
   *         if the current <code>AccessToken</code> 
 1968  
   *         does not confer write access rights
 1969  
   * @throws ValidationPoemException 
 1970  
   *         if the value is not valid
 1971  
   */
 1972  
   public void setMarkuppercent(Double cooked)
 1973  
       throws AccessPoemException, ValidationPoemException {
 1974  0
     _getProductTable().getMarkuppercentColumn().
 1975  
       getType().assertValidCooked(cooked);
 1976  0
     writeLock();
 1977  0
     setMarkuppercent_unsafe(cooked);
 1978  0
   }
 1979  
 
 1980  
  /**
 1981  
   * Sets the <code>Markuppercent</code> value, with checking, for this <code>Product</code> <code>Persistent</code>.
 1982  
   * 
 1983  
   * @generator org.melati.poem.prepro.DoubleFieldDef#generateBaseMethods 
 1984  
   * @param cooked  a validated <code>int</code> 
 1985  
   * @throws AccessPoemException 
 1986  
   *         if the current <code>AccessToken</code> 
 1987  
   *         does not confer write access rights
 1988  
   * @throws ValidationPoemException 
 1989  
   *         if the value is not valid
 1990  
   */
 1991  
 
 1992  
   public final void setMarkuppercent(double cooked)
 1993  
       throws AccessPoemException, ValidationPoemException {
 1994  0
     setMarkuppercent(new Double(cooked));
 1995  0
   }
 1996  
 
 1997  
 
 1998  
  /**
 1999  
   * Retrieves the <code>Markuppercent</code> value as a <code>Field</code>
 2000  
   * from this <code>Product</code> <code>Persistent</code>.
 2001  
   * 
 2002  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 2003  
   * @throws AccessPoemException 
 2004  
   *         if the current <code>AccessToken</code> 
 2005  
   *         does not confer write access rights
 2006  
   * @return the Double markuppercent
 2007  
   */
 2008  
   public Field getMarkuppercentField() throws AccessPoemException {
 2009  0
     Column c = _getProductTable().getMarkuppercentColumn();
 2010  0
     return new Field(c.getRaw(this), c);
 2011  
   }
 2012  
 
 2013  
 
 2014  
  /**
 2015  
   * Retrieves the <code>Deliverycost</code> value, without locking, 
 2016  
   * for this <code>Product</code> <code>Persistent</code>.
 2017  
   *
 2018  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2019  
   * @return the Double deliverycost
 2020  
   */
 2021  
   public Double getDeliverycost_unsafe() {
 2022  0
     return deliverycost;
 2023  
   }
 2024  
 
 2025  
 
 2026  
  /**
 2027  
   * Sets the <code>Deliverycost</code> value directly, without checking, 
 2028  
   * for this Product <code>Persistent</code>.
 2029  
   * 
 2030  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2031  
   * @param cooked  the pre-validated value to set
 2032  
   */
 2033  
   public void setDeliverycost_unsafe(Double cooked) {
 2034  0
     deliverycost = cooked;
 2035  0
   }
 2036  
 
 2037  
  /**
 2038  
   * Retrieves the Deliverycost value, with locking, for this 
 2039  
   * <code>Product</code> <code>Persistent</code>.
 2040  
   * 
 2041  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 2042  
   * @throws AccessPoemException 
 2043  
   *         if the current <code>AccessToken</code> 
 2044  
   *         does not confer write access rights 
 2045  
   * @return the value of the field <code>Deliverycost</code> for this 
 2046  
   *         <code>Product</code> <code>Persistent</code>  
 2047  
   */
 2048  
 
 2049  
   public Double getDeliverycost()
 2050  
       throws AccessPoemException {
 2051  0
     readLock();
 2052  0
     return getDeliverycost_unsafe();
 2053  
   }
 2054  
 
 2055  
 
 2056  
  /**
 2057  
   * Sets the <code>Deliverycost</code> value, with checking, for this 
 2058  
   * <code>Product</code> <code>Persistent</code>.
 2059  
   * 
 2060  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 2061  
   * @param cooked  a validated <code>int</code> 
 2062  
   * @throws AccessPoemException 
 2063  
   *         if the current <code>AccessToken</code> 
 2064  
   *         does not confer write access rights
 2065  
   * @throws ValidationPoemException 
 2066  
   *         if the value is not valid
 2067  
   */
 2068  
   public void setDeliverycost(Double cooked)
 2069  
       throws AccessPoemException, ValidationPoemException {
 2070  0
     _getProductTable().getDeliverycostColumn().
 2071  
       getType().assertValidCooked(cooked);
 2072  0
     writeLock();
 2073  0
     setDeliverycost_unsafe(cooked);
 2074  0
   }
 2075  
 
 2076  
  /**
 2077  
   * Sets the <code>Deliverycost</code> value, with checking, for this <code>Product</code> <code>Persistent</code>.
 2078  
   * 
 2079  
   * @generator org.melati.poem.prepro.DoubleFieldDef#generateBaseMethods 
 2080  
   * @param cooked  a validated <code>int</code> 
 2081  
   * @throws AccessPoemException 
 2082  
   *         if the current <code>AccessToken</code> 
 2083  
   *         does not confer write access rights
 2084  
   * @throws ValidationPoemException 
 2085  
   *         if the value is not valid
 2086  
   */
 2087  
 
 2088  
   public final void setDeliverycost(double cooked)
 2089  
       throws AccessPoemException, ValidationPoemException {
 2090  0
     setDeliverycost(new Double(cooked));
 2091  0
   }
 2092  
 
 2093  
 
 2094  
  /**
 2095  
   * Retrieves the <code>Deliverycost</code> value as a <code>Field</code>
 2096  
   * from this <code>Product</code> <code>Persistent</code>.
 2097  
   * 
 2098  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 2099  
   * @throws AccessPoemException 
 2100  
   *         if the current <code>AccessToken</code> 
 2101  
   *         does not confer write access rights
 2102  
   * @return the Double deliverycost
 2103  
   */
 2104  
   public Field getDeliverycostField() throws AccessPoemException {
 2105  0
     Column c = _getProductTable().getDeliverycostColumn();
 2106  0
     return new Field(c.getRaw(this), c);
 2107  
   }
 2108  
 
 2109  
 
 2110  
  /**
 2111  
   * Retrieves the <code>Minage</code> value, without locking, 
 2112  
   * for this <code>Product</code> <code>Persistent</code>.
 2113  
   *
 2114  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2115  
   * @return the Integer minage
 2116  
   */
 2117  
   public Integer getMinage_unsafe() {
 2118  0
     return minage;
 2119  
   }
 2120  
 
 2121  
 
 2122  
  /**
 2123  
   * Sets the <code>Minage</code> value directly, without checking, 
 2124  
   * for this Product <code>Persistent</code>.
 2125  
   * 
 2126  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2127  
   * @param cooked  the pre-validated value to set
 2128  
   */
 2129  
   public void setMinage_unsafe(Integer cooked) {
 2130  0
     minage = cooked;
 2131  0
   }
 2132  
 
 2133  
  /**
 2134  
   * Retrieves the Minage value, with locking, for this 
 2135  
   * <code>Product</code> <code>Persistent</code>.
 2136  
   * 
 2137  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 2138  
   * @throws AccessPoemException 
 2139  
   *         if the current <code>AccessToken</code> 
 2140  
   *         does not confer write access rights 
 2141  
   * @return the value of the field <code>Minage</code> for this 
 2142  
   *         <code>Product</code> <code>Persistent</code>  
 2143  
   */
 2144  
 
 2145  
   public Integer getMinage()
 2146  
       throws AccessPoemException {
 2147  0
     readLock();
 2148  0
     return getMinage_unsafe();
 2149  
   }
 2150  
 
 2151  
 
 2152  
  /**
 2153  
   * Sets the <code>Minage</code> value, with checking, for this 
 2154  
   * <code>Product</code> <code>Persistent</code>.
 2155  
   * 
 2156  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 2157  
   * @param cooked  a validated <code>int</code> 
 2158  
   * @throws AccessPoemException 
 2159  
   *         if the current <code>AccessToken</code> 
 2160  
   *         does not confer write access rights
 2161  
   * @throws ValidationPoemException 
 2162  
   *         if the value is not valid
 2163  
   */
 2164  
   public void setMinage(Integer cooked)
 2165  
       throws AccessPoemException, ValidationPoemException {
 2166  0
     _getProductTable().getMinageColumn().
 2167  
       getType().assertValidCooked(cooked);
 2168  0
     writeLock();
 2169  0
     setMinage_unsafe(cooked);
 2170  0
   }
 2171  
 
 2172  
  /**
 2173  
   * Sets the <code>Minage</code> value, with checking, for this 
 2174  
   * <code>Product</code> <code>Persistent</code>.
 2175  
   * 
 2176  
   * @generator org.melati.poem.prepro.IntegerFieldDef#generateBaseMethods 
 2177  
   * @param cooked  a validated <code>int</code>
 2178  
   * @throws AccessPoemException 
 2179  
   *         if the current <code>AccessToken</code> 
 2180  
   *         does not confer write access rights
 2181  
   * @throws ValidationPoemException 
 2182  
   *         if the value is not valid
 2183  
   */
 2184  
 
 2185  
   public final void setMinage(int cooked)
 2186  
       throws AccessPoemException, ValidationPoemException {
 2187  0
     setMinage(new Integer(cooked));
 2188  0
   }
 2189  
 
 2190  
 
 2191  
  /**
 2192  
   * Retrieves the <code>Minage</code> value as a <code>Field</code>
 2193  
   * from this <code>Product</code> <code>Persistent</code>.
 2194  
   * 
 2195  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 2196  
   * @throws AccessPoemException 
 2197  
   *         if the current <code>AccessToken</code> 
 2198  
   *         does not confer write access rights
 2199  
   * @return the Integer minage
 2200  
   */
 2201  
   public Field getMinageField() throws AccessPoemException {
 2202  0
     Column c = _getProductTable().getMinageColumn();
 2203  0
     return new Field(c.getRaw(this), c);
 2204  
   }
 2205  
 
 2206  
 
 2207  
  /**
 2208  
   * Retrieves the <code>Maxage</code> value, without locking, 
 2209  
   * for this <code>Product</code> <code>Persistent</code>.
 2210  
   *
 2211  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2212  
   * @return the Integer maxage
 2213  
   */
 2214  
   public Integer getMaxage_unsafe() {
 2215  0
     return maxage;
 2216  
   }
 2217  
 
 2218  
 
 2219  
  /**
 2220  
   * Sets the <code>Maxage</code> value directly, without checking, 
 2221  
   * for this Product <code>Persistent</code>.
 2222  
   * 
 2223  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2224  
   * @param cooked  the pre-validated value to set
 2225  
   */
 2226  
   public void setMaxage_unsafe(Integer cooked) {
 2227  0
     maxage = cooked;
 2228  0
   }
 2229  
 
 2230  
  /**
 2231  
   * Retrieves the Maxage value, with locking, for this 
 2232  
   * <code>Product</code> <code>Persistent</code>.
 2233  
   * 
 2234  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 2235  
   * @throws AccessPoemException 
 2236  
   *         if the current <code>AccessToken</code> 
 2237  
   *         does not confer write access rights 
 2238  
   * @return the value of the field <code>Maxage</code> for this 
 2239  
   *         <code>Product</code> <code>Persistent</code>  
 2240  
   */
 2241  
 
 2242  
   public Integer getMaxage()
 2243  
       throws AccessPoemException {
 2244  0
     readLock();
 2245  0
     return getMaxage_unsafe();
 2246  
   }
 2247  
 
 2248  
 
 2249  
  /**
 2250  
   * Sets the <code>Maxage</code> value, with checking, for this 
 2251  
   * <code>Product</code> <code>Persistent</code>.
 2252  
   * 
 2253  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 2254  
   * @param cooked  a validated <code>int</code> 
 2255  
   * @throws AccessPoemException 
 2256  
   *         if the current <code>AccessToken</code> 
 2257  
   *         does not confer write access rights
 2258  
   * @throws ValidationPoemException 
 2259  
   *         if the value is not valid
 2260  
   */
 2261  
   public void setMaxage(Integer cooked)
 2262  
       throws AccessPoemException, ValidationPoemException {
 2263  0
     _getProductTable().getMaxageColumn().
 2264  
       getType().assertValidCooked(cooked);
 2265  0
     writeLock();
 2266  0
     setMaxage_unsafe(cooked);
 2267  0
   }
 2268  
 
 2269  
  /**
 2270  
   * Sets the <code>Maxage</code> value, with checking, for this 
 2271  
   * <code>Product</code> <code>Persistent</code>.
 2272  
   * 
 2273  
   * @generator org.melati.poem.prepro.IntegerFieldDef#generateBaseMethods 
 2274  
   * @param cooked  a validated <code>int</code>
 2275  
   * @throws AccessPoemException 
 2276  
   *         if the current <code>AccessToken</code> 
 2277  
   *         does not confer write access rights
 2278  
   * @throws ValidationPoemException 
 2279  
   *         if the value is not valid
 2280  
   */
 2281  
 
 2282  
   public final void setMaxage(int cooked)
 2283  
       throws AccessPoemException, ValidationPoemException {
 2284  0
     setMaxage(new Integer(cooked));
 2285  0
   }
 2286  
 
 2287  
 
 2288  
  /**
 2289  
   * Retrieves the <code>Maxage</code> value as a <code>Field</code>
 2290  
   * from this <code>Product</code> <code>Persistent</code>.
 2291  
   * 
 2292  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 2293  
   * @throws AccessPoemException 
 2294  
   *         if the current <code>AccessToken</code> 
 2295  
   *         does not confer write access rights
 2296  
   * @return the Integer maxage
 2297  
   */
 2298  
   public Field getMaxageField() throws AccessPoemException {
 2299  0
     Column c = _getProductTable().getMaxageColumn();
 2300  0
     return new Field(c.getRaw(this), c);
 2301  
   }
 2302  
 
 2303  
 
 2304  
  /**
 2305  
   * Retrieves the <code>Pieces</code> value, without locking, 
 2306  
   * for this <code>Product</code> <code>Persistent</code>.
 2307  
   *
 2308  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2309  
   * @return the Integer pieces
 2310  
   */
 2311  
   public Integer getPieces_unsafe() {
 2312  0
     return pieces;
 2313  
   }
 2314  
 
 2315  
 
 2316  
  /**
 2317  
   * Sets the <code>Pieces</code> value directly, without checking, 
 2318  
   * for this Product <code>Persistent</code>.
 2319  
   * 
 2320  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2321  
   * @param cooked  the pre-validated value to set
 2322  
   */
 2323  
   public void setPieces_unsafe(Integer cooked) {
 2324  0
     pieces = cooked;
 2325  0
   }
 2326  
 
 2327  
  /**
 2328  
   * Retrieves the Pieces value, with locking, for this 
 2329  
   * <code>Product</code> <code>Persistent</code>.
 2330  
   * 
 2331  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 2332  
   * @throws AccessPoemException 
 2333  
   *         if the current <code>AccessToken</code> 
 2334  
   *         does not confer write access rights 
 2335  
   * @return the value of the field <code>Pieces</code> for this 
 2336  
   *         <code>Product</code> <code>Persistent</code>  
 2337  
   */
 2338  
 
 2339  
   public Integer getPieces()
 2340  
       throws AccessPoemException {
 2341  0
     readLock();
 2342  0
     return getPieces_unsafe();
 2343  
   }
 2344  
 
 2345  
 
 2346  
  /**
 2347  
   * Sets the <code>Pieces</code> value, with checking, for this 
 2348  
   * <code>Product</code> <code>Persistent</code>.
 2349  
   * 
 2350  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 2351  
   * @param cooked  a validated <code>int</code> 
 2352  
   * @throws AccessPoemException 
 2353  
   *         if the current <code>AccessToken</code> 
 2354  
   *         does not confer write access rights
 2355  
   * @throws ValidationPoemException 
 2356  
   *         if the value is not valid
 2357  
   */
 2358  
   public void setPieces(Integer cooked)
 2359  
       throws AccessPoemException, ValidationPoemException {
 2360  0
     _getProductTable().getPiecesColumn().
 2361  
       getType().assertValidCooked(cooked);
 2362  0
     writeLock();
 2363  0
     setPieces_unsafe(cooked);
 2364  0
   }
 2365  
 
 2366  
  /**
 2367  
   * Sets the <code>Pieces</code> value, with checking, for this 
 2368  
   * <code>Product</code> <code>Persistent</code>.
 2369  
   * 
 2370  
   * @generator org.melati.poem.prepro.IntegerFieldDef#generateBaseMethods 
 2371  
   * @param cooked  a validated <code>int</code>
 2372  
   * @throws AccessPoemException 
 2373  
   *         if the current <code>AccessToken</code> 
 2374  
   *         does not confer write access rights
 2375  
   * @throws ValidationPoemException 
 2376  
   *         if the value is not valid
 2377  
   */
 2378  
 
 2379  
   public final void setPieces(int cooked)
 2380  
       throws AccessPoemException, ValidationPoemException {
 2381  0
     setPieces(new Integer(cooked));
 2382  0
   }
 2383  
 
 2384  
 
 2385  
  /**
 2386  
   * Retrieves the <code>Pieces</code> value as a <code>Field</code>
 2387  
   * from this <code>Product</code> <code>Persistent</code>.
 2388  
   * 
 2389  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 2390  
   * @throws AccessPoemException 
 2391  
   *         if the current <code>AccessToken</code> 
 2392  
   *         does not confer write access rights
 2393  
   * @return the Integer pieces
 2394  
   */
 2395  
   public Field getPiecesField() throws AccessPoemException {
 2396  0
     Column c = _getProductTable().getPiecesColumn();
 2397  0
     return new Field(c.getRaw(this), c);
 2398  
   }
 2399  
 
 2400  
 
 2401  
  /**
 2402  
   * Retrieves the <code>Stocklevel</code> value, without locking, 
 2403  
   * for this <code>Product</code> <code>Persistent</code>.
 2404  
   *
 2405  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2406  
   * @return the Integer stocklevel
 2407  
   */
 2408  
   public Integer getStocklevel_unsafe() {
 2409  0
     return stocklevel;
 2410  
   }
 2411  
 
 2412  
 
 2413  
  /**
 2414  
   * Sets the <code>Stocklevel</code> value directly, without checking, 
 2415  
   * for this Product <code>Persistent</code>.
 2416  
   * 
 2417  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2418  
   * @param cooked  the pre-validated value to set
 2419  
   */
 2420  
   public void setStocklevel_unsafe(Integer cooked) {
 2421  0
     stocklevel = cooked;
 2422  0
   }
 2423  
 
 2424  
  /**
 2425  
   * Retrieves the Stocklevel value, with locking, for this 
 2426  
   * <code>Product</code> <code>Persistent</code>.
 2427  
   * 
 2428  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 2429  
   * @throws AccessPoemException 
 2430  
   *         if the current <code>AccessToken</code> 
 2431  
   *         does not confer write access rights 
 2432  
   * @return the value of the field <code>Stocklevel</code> for this 
 2433  
   *         <code>Product</code> <code>Persistent</code>  
 2434  
   */
 2435  
 
 2436  
   public Integer getStocklevel()
 2437  
       throws AccessPoemException {
 2438  0
     readLock();
 2439  0
     return getStocklevel_unsafe();
 2440  
   }
 2441  
 
 2442  
 
 2443  
  /**
 2444  
   * Sets the <code>Stocklevel</code> value, with checking, for this 
 2445  
   * <code>Product</code> <code>Persistent</code>.
 2446  
   * 
 2447  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 2448  
   * @param cooked  a validated <code>int</code> 
 2449  
   * @throws AccessPoemException 
 2450  
   *         if the current <code>AccessToken</code> 
 2451  
   *         does not confer write access rights
 2452  
   * @throws ValidationPoemException 
 2453  
   *         if the value is not valid
 2454  
   */
 2455  
   public void setStocklevel(Integer cooked)
 2456  
       throws AccessPoemException, ValidationPoemException {
 2457  0
     _getProductTable().getStocklevelColumn().
 2458  
       getType().assertValidCooked(cooked);
 2459  0
     writeLock();
 2460  0
     setStocklevel_unsafe(cooked);
 2461  0
   }
 2462  
 
 2463  
  /**
 2464  
   * Sets the <code>Stocklevel</code> value, with checking, for this 
 2465  
   * <code>Product</code> <code>Persistent</code>.
 2466  
   * 
 2467  
   * @generator org.melati.poem.prepro.IntegerFieldDef#generateBaseMethods 
 2468  
   * @param cooked  a validated <code>int</code>
 2469  
   * @throws AccessPoemException 
 2470  
   *         if the current <code>AccessToken</code> 
 2471  
   *         does not confer write access rights
 2472  
   * @throws ValidationPoemException 
 2473  
   *         if the value is not valid
 2474  
   */
 2475  
 
 2476  
   public final void setStocklevel(int cooked)
 2477  
       throws AccessPoemException, ValidationPoemException {
 2478  0
     setStocklevel(new Integer(cooked));
 2479  0
   }
 2480  
 
 2481  
 
 2482  
  /**
 2483  
   * Retrieves the <code>Stocklevel</code> value as a <code>Field</code>
 2484  
   * from this <code>Product</code> <code>Persistent</code>.
 2485  
   * 
 2486  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 2487  
   * @throws AccessPoemException 
 2488  
   *         if the current <code>AccessToken</code> 
 2489  
   *         does not confer write access rights
 2490  
   * @return the Integer stocklevel
 2491  
   */
 2492  
   public Field getStocklevelField() throws AccessPoemException {
 2493  0
     Column c = _getProductTable().getStocklevelColumn();
 2494  0
     return new Field(c.getRaw(this), c);
 2495  
   }
 2496  
 
 2497  
 
 2498  
  /**
 2499  
   * Retrieves the <code>Reorderlevel</code> value, without locking, 
 2500  
   * for this <code>Product</code> <code>Persistent</code>.
 2501  
   *
 2502  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2503  
   * @return the Integer reorderlevel
 2504  
   */
 2505  
   public Integer getReorderlevel_unsafe() {
 2506  0
     return reorderlevel;
 2507  
   }
 2508  
 
 2509  
 
 2510  
  /**
 2511  
   * Sets the <code>Reorderlevel</code> value directly, without checking, 
 2512  
   * for this Product <code>Persistent</code>.
 2513  
   * 
 2514  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2515  
   * @param cooked  the pre-validated value to set
 2516  
   */
 2517  
   public void setReorderlevel_unsafe(Integer cooked) {
 2518  0
     reorderlevel = cooked;
 2519  0
   }
 2520  
 
 2521  
  /**
 2522  
   * Retrieves the Reorderlevel value, with locking, for this 
 2523  
   * <code>Product</code> <code>Persistent</code>.
 2524  
   * Field description: 
 2525  
   *   The level at which stock needs to fall to before JammyJoes normally 
 2526  
   *   orders 
 2527  
   * 
 2528  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 2529  
   * @throws AccessPoemException 
 2530  
   *         if the current <code>AccessToken</code> 
 2531  
   *         does not confer write access rights 
 2532  
   * @return the value of the field <code>Reorderlevel</code> for this 
 2533  
   *         <code>Product</code> <code>Persistent</code>  
 2534  
   */
 2535  
 
 2536  
   public Integer getReorderlevel()
 2537  
       throws AccessPoemException {
 2538  0
     readLock();
 2539  0
     return getReorderlevel_unsafe();
 2540  
   }
 2541  
 
 2542  
 
 2543  
  /**
 2544  
   * Sets the <code>Reorderlevel</code> value, with checking, for this 
 2545  
   * <code>Product</code> <code>Persistent</code>.
 2546  
   * Field description: 
 2547  
   *   The level at which stock needs to fall to before JammyJoes normally 
 2548  
   *   orders 
 2549  
   * 
 2550  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 2551  
   * @param cooked  a validated <code>int</code> 
 2552  
   * @throws AccessPoemException 
 2553  
   *         if the current <code>AccessToken</code> 
 2554  
   *         does not confer write access rights
 2555  
   * @throws ValidationPoemException 
 2556  
   *         if the value is not valid
 2557  
   */
 2558  
   public void setReorderlevel(Integer cooked)
 2559  
       throws AccessPoemException, ValidationPoemException {
 2560  0
     _getProductTable().getReorderlevelColumn().
 2561  
       getType().assertValidCooked(cooked);
 2562  0
     writeLock();
 2563  0
     setReorderlevel_unsafe(cooked);
 2564  0
   }
 2565  
 
 2566  
  /**
 2567  
   * Sets the <code>Reorderlevel</code> value, with checking, for this 
 2568  
   * <code>Product</code> <code>Persistent</code>.
 2569  
   * Field description: 
 2570  
   *   The level at which stock needs to fall to before JammyJoes normally 
 2571  
   *   orders 
 2572  
   * 
 2573  
   * 
 2574  
   * @generator org.melati.poem.prepro.IntegerFieldDef#generateBaseMethods 
 2575  
   * @param cooked  a validated <code>int</code>
 2576  
   * @throws AccessPoemException 
 2577  
   *         if the current <code>AccessToken</code> 
 2578  
   *         does not confer write access rights
 2579  
   * @throws ValidationPoemException 
 2580  
   *         if the value is not valid
 2581  
   */
 2582  
 
 2583  
   public final void setReorderlevel(int cooked)
 2584  
       throws AccessPoemException, ValidationPoemException {
 2585  0
     setReorderlevel(new Integer(cooked));
 2586  0
   }
 2587  
 
 2588  
 
 2589  
  /**
 2590  
   * Retrieves the <code>Reorderlevel</code> value as a <code>Field</code>
 2591  
   * from this <code>Product</code> <code>Persistent</code>.
 2592  
   * 
 2593  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 2594  
   * @throws AccessPoemException 
 2595  
   *         if the current <code>AccessToken</code> 
 2596  
   *         does not confer write access rights
 2597  
   * @return the Integer reorderlevel
 2598  
   */
 2599  
   public Field getReorderlevelField() throws AccessPoemException {
 2600  0
     Column c = _getProductTable().getReorderlevelColumn();
 2601  0
     return new Field(c.getRaw(this), c);
 2602  
   }
 2603  
 
 2604  
 
 2605  
  /**
 2606  
   * Retrieves the <code>Reorderquantity</code> value, without locking, 
 2607  
   * for this <code>Product</code> <code>Persistent</code>.
 2608  
   *
 2609  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2610  
   * @return the Integer reorderquantity
 2611  
   */
 2612  
   public Integer getReorderquantity_unsafe() {
 2613  0
     return reorderquantity;
 2614  
   }
 2615  
 
 2616  
 
 2617  
  /**
 2618  
   * Sets the <code>Reorderquantity</code> value directly, without checking, 
 2619  
   * for this Product <code>Persistent</code>.
 2620  
   * 
 2621  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2622  
   * @param cooked  the pre-validated value to set
 2623  
   */
 2624  
   public void setReorderquantity_unsafe(Integer cooked) {
 2625  0
     reorderquantity = cooked;
 2626  0
   }
 2627  
 
 2628  
  /**
 2629  
   * Retrieves the Reorderquantity value, with locking, for this 
 2630  
   * <code>Product</code> <code>Persistent</code>.
 2631  
   * Field description: 
 2632  
   *   The quantity that JammyJoes normally orders 
 2633  
   * 
 2634  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 2635  
   * @throws AccessPoemException 
 2636  
   *         if the current <code>AccessToken</code> 
 2637  
   *         does not confer write access rights 
 2638  
   * @return the value of the field <code>Reorderquantity</code> for this 
 2639  
   *         <code>Product</code> <code>Persistent</code>  
 2640  
   */
 2641  
 
 2642  
   public Integer getReorderquantity()
 2643  
       throws AccessPoemException {
 2644  0
     readLock();
 2645  0
     return getReorderquantity_unsafe();
 2646  
   }
 2647  
 
 2648  
 
 2649  
  /**
 2650  
   * Sets the <code>Reorderquantity</code> value, with checking, for this 
 2651  
   * <code>Product</code> <code>Persistent</code>.
 2652  
   * Field description: 
 2653  
   *   The quantity that JammyJoes normally orders 
 2654  
   * 
 2655  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 2656  
   * @param cooked  a validated <code>int</code> 
 2657  
   * @throws AccessPoemException 
 2658  
   *         if the current <code>AccessToken</code> 
 2659  
   *         does not confer write access rights
 2660  
   * @throws ValidationPoemException 
 2661  
   *         if the value is not valid
 2662  
   */
 2663  
   public void setReorderquantity(Integer cooked)
 2664  
       throws AccessPoemException, ValidationPoemException {
 2665  0
     _getProductTable().getReorderquantityColumn().
 2666  
       getType().assertValidCooked(cooked);
 2667  0
     writeLock();
 2668  0
     setReorderquantity_unsafe(cooked);
 2669  0
   }
 2670  
 
 2671  
  /**
 2672  
   * Sets the <code>Reorderquantity</code> value, with checking, for this 
 2673  
   * <code>Product</code> <code>Persistent</code>.
 2674  
   * Field description: 
 2675  
   *   The quantity that JammyJoes normally orders 
 2676  
   * 
 2677  
   * 
 2678  
   * @generator org.melati.poem.prepro.IntegerFieldDef#generateBaseMethods 
 2679  
   * @param cooked  a validated <code>int</code>
 2680  
   * @throws AccessPoemException 
 2681  
   *         if the current <code>AccessToken</code> 
 2682  
   *         does not confer write access rights
 2683  
   * @throws ValidationPoemException 
 2684  
   *         if the value is not valid
 2685  
   */
 2686  
 
 2687  
   public final void setReorderquantity(int cooked)
 2688  
       throws AccessPoemException, ValidationPoemException {
 2689  0
     setReorderquantity(new Integer(cooked));
 2690  0
   }
 2691  
 
 2692  
 
 2693  
  /**
 2694  
   * Retrieves the <code>Reorderquantity</code> value as a <code>Field</code>
 2695  
   * from this <code>Product</code> <code>Persistent</code>.
 2696  
   * 
 2697  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 2698  
   * @throws AccessPoemException 
 2699  
   *         if the current <code>AccessToken</code> 
 2700  
   *         does not confer write access rights
 2701  
   * @return the Integer reorderquantity
 2702  
   */
 2703  
   public Field getReorderquantityField() throws AccessPoemException {
 2704  0
     Column c = _getProductTable().getReorderquantityColumn();
 2705  0
     return new Field(c.getRaw(this), c);
 2706  
   }
 2707  
 
 2708  
 
 2709  
  /**
 2710  
   * Retrieves the <code>Minimumorder</code> value, without locking, 
 2711  
   * for this <code>Product</code> <code>Persistent</code>.
 2712  
   *
 2713  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2714  
   * @return the Integer minimumorder
 2715  
   */
 2716  
   public Integer getMinimumorder_unsafe() {
 2717  0
     return minimumorder;
 2718  
   }
 2719  
 
 2720  
 
 2721  
  /**
 2722  
   * Sets the <code>Minimumorder</code> value directly, without checking, 
 2723  
   * for this Product <code>Persistent</code>.
 2724  
   * 
 2725  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2726  
   * @param cooked  the pre-validated value to set
 2727  
   */
 2728  
   public void setMinimumorder_unsafe(Integer cooked) {
 2729  0
     minimumorder = cooked;
 2730  0
   }
 2731  
 
 2732  
  /**
 2733  
   * Retrieves the Minimumorder value, with locking, for this 
 2734  
   * <code>Product</code> <code>Persistent</code>.
 2735  
   * Field description: 
 2736  
   *   The minimum quantity that can be ordered 
 2737  
   * 
 2738  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 2739  
   * @throws AccessPoemException 
 2740  
   *         if the current <code>AccessToken</code> 
 2741  
   *         does not confer write access rights 
 2742  
   * @return the value of the field <code>Minimumorder</code> for this 
 2743  
   *         <code>Product</code> <code>Persistent</code>  
 2744  
   */
 2745  
 
 2746  
   public Integer getMinimumorder()
 2747  
       throws AccessPoemException {
 2748  0
     readLock();
 2749  0
     return getMinimumorder_unsafe();
 2750  
   }
 2751  
 
 2752  
 
 2753  
  /**
 2754  
   * Sets the <code>Minimumorder</code> value, with checking, for this 
 2755  
   * <code>Product</code> <code>Persistent</code>.
 2756  
   * Field description: 
 2757  
   *   The minimum quantity that can be ordered 
 2758  
   * 
 2759  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 2760  
   * @param cooked  a validated <code>int</code> 
 2761  
   * @throws AccessPoemException 
 2762  
   *         if the current <code>AccessToken</code> 
 2763  
   *         does not confer write access rights
 2764  
   * @throws ValidationPoemException 
 2765  
   *         if the value is not valid
 2766  
   */
 2767  
   public void setMinimumorder(Integer cooked)
 2768  
       throws AccessPoemException, ValidationPoemException {
 2769  0
     _getProductTable().getMinimumorderColumn().
 2770  
       getType().assertValidCooked(cooked);
 2771  0
     writeLock();
 2772  0
     setMinimumorder_unsafe(cooked);
 2773  0
   }
 2774  
 
 2775  
  /**
 2776  
   * Sets the <code>Minimumorder</code> value, with checking, for this 
 2777  
   * <code>Product</code> <code>Persistent</code>.
 2778  
   * Field description: 
 2779  
   *   The minimum quantity that can be ordered 
 2780  
   * 
 2781  
   * 
 2782  
   * @generator org.melati.poem.prepro.IntegerFieldDef#generateBaseMethods 
 2783  
   * @param cooked  a validated <code>int</code>
 2784  
   * @throws AccessPoemException 
 2785  
   *         if the current <code>AccessToken</code> 
 2786  
   *         does not confer write access rights
 2787  
   * @throws ValidationPoemException 
 2788  
   *         if the value is not valid
 2789  
   */
 2790  
 
 2791  
   public final void setMinimumorder(int cooked)
 2792  
       throws AccessPoemException, ValidationPoemException {
 2793  0
     setMinimumorder(new Integer(cooked));
 2794  0
   }
 2795  
 
 2796  
 
 2797  
  /**
 2798  
   * Retrieves the <code>Minimumorder</code> value as a <code>Field</code>
 2799  
   * from this <code>Product</code> <code>Persistent</code>.
 2800  
   * 
 2801  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 2802  
   * @throws AccessPoemException 
 2803  
   *         if the current <code>AccessToken</code> 
 2804  
   *         does not confer write access rights
 2805  
   * @return the Integer minimumorder
 2806  
   */
 2807  
   public Field getMinimumorderField() throws AccessPoemException {
 2808  0
     Column c = _getProductTable().getMinimumorderColumn();
 2809  0
     return new Field(c.getRaw(this), c);
 2810  
   }
 2811  
 
 2812  
 
 2813  
  /**
 2814  
   * Retrieves the <code>Leadtime</code> value, without locking, 
 2815  
   * for this <code>Product</code> <code>Persistent</code>.
 2816  
   *
 2817  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2818  
   * @return the Integer leadtime
 2819  
   */
 2820  
   public Integer getLeadtime_unsafe() {
 2821  0
     return leadtime;
 2822  
   }
 2823  
 
 2824  
 
 2825  
  /**
 2826  
   * Sets the <code>Leadtime</code> value directly, without checking, 
 2827  
   * for this Product <code>Persistent</code>.
 2828  
   * 
 2829  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2830  
   * @param cooked  the pre-validated value to set
 2831  
   */
 2832  
   public void setLeadtime_unsafe(Integer cooked) {
 2833  0
     leadtime = cooked;
 2834  0
   }
 2835  
 
 2836  
  /**
 2837  
   * Retrieves the Leadtime value, with locking, for this 
 2838  
   * <code>Product</code> <code>Persistent</code>.
 2839  
   * 
 2840  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 2841  
   * @throws AccessPoemException 
 2842  
   *         if the current <code>AccessToken</code> 
 2843  
   *         does not confer write access rights 
 2844  
   * @return the value of the field <code>Leadtime</code> for this 
 2845  
   *         <code>Product</code> <code>Persistent</code>  
 2846  
   */
 2847  
 
 2848  
   public Integer getLeadtime()
 2849  
       throws AccessPoemException {
 2850  0
     readLock();
 2851  0
     return getLeadtime_unsafe();
 2852  
   }
 2853  
 
 2854  
 
 2855  
  /**
 2856  
   * Sets the <code>Leadtime</code> value, with checking, for this 
 2857  
   * <code>Product</code> <code>Persistent</code>.
 2858  
   * 
 2859  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 2860  
   * @param cooked  a validated <code>int</code> 
 2861  
   * @throws AccessPoemException 
 2862  
   *         if the current <code>AccessToken</code> 
 2863  
   *         does not confer write access rights
 2864  
   * @throws ValidationPoemException 
 2865  
   *         if the value is not valid
 2866  
   */
 2867  
   public void setLeadtime(Integer cooked)
 2868  
       throws AccessPoemException, ValidationPoemException {
 2869  0
     _getProductTable().getLeadtimeColumn().
 2870  
       getType().assertValidCooked(cooked);
 2871  0
     writeLock();
 2872  0
     setLeadtime_unsafe(cooked);
 2873  0
   }
 2874  
 
 2875  
  /**
 2876  
   * Sets the <code>Leadtime</code> value, with checking, for this 
 2877  
   * <code>Product</code> <code>Persistent</code>.
 2878  
   * 
 2879  
   * @generator org.melati.poem.prepro.IntegerFieldDef#generateBaseMethods 
 2880  
   * @param cooked  a validated <code>int</code>
 2881  
   * @throws AccessPoemException 
 2882  
   *         if the current <code>AccessToken</code> 
 2883  
   *         does not confer write access rights
 2884  
   * @throws ValidationPoemException 
 2885  
   *         if the value is not valid
 2886  
   */
 2887  
 
 2888  
   public final void setLeadtime(int cooked)
 2889  
       throws AccessPoemException, ValidationPoemException {
 2890  0
     setLeadtime(new Integer(cooked));
 2891  0
   }
 2892  
 
 2893  
 
 2894  
  /**
 2895  
   * Retrieves the <code>Leadtime</code> value as a <code>Field</code>
 2896  
   * from this <code>Product</code> <code>Persistent</code>.
 2897  
   * 
 2898  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 2899  
   * @throws AccessPoemException 
 2900  
   *         if the current <code>AccessToken</code> 
 2901  
   *         does not confer write access rights
 2902  
   * @return the Integer leadtime
 2903  
   */
 2904  
   public Field getLeadtimeField() throws AccessPoemException {
 2905  0
     Column c = _getProductTable().getLeadtimeColumn();
 2906  0
     return new Field(c.getRaw(this), c);
 2907  
   }
 2908  
 
 2909  
 
 2910  
  /**
 2911  
   * Retrieves the <code>Weight</code> value, without locking, 
 2912  
   * for this <code>Product</code> <code>Persistent</code>.
 2913  
   *
 2914  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2915  
   * @return the Double weight
 2916  
   */
 2917  
   public Double getWeight_unsafe() {
 2918  0
     return weight;
 2919  
   }
 2920  
 
 2921  
 
 2922  
  /**
 2923  
   * Sets the <code>Weight</code> value directly, without checking, 
 2924  
   * for this Product <code>Persistent</code>.
 2925  
   * 
 2926  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 2927  
   * @param cooked  the pre-validated value to set
 2928  
   */
 2929  
   public void setWeight_unsafe(Double cooked) {
 2930  0
     weight = cooked;
 2931  0
   }
 2932  
 
 2933  
  /**
 2934  
   * Retrieves the Weight value, with locking, for this 
 2935  
   * <code>Product</code> <code>Persistent</code>.
 2936  
   * 
 2937  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 2938  
   * @throws AccessPoemException 
 2939  
   *         if the current <code>AccessToken</code> 
 2940  
   *         does not confer write access rights 
 2941  
   * @return the value of the field <code>Weight</code> for this 
 2942  
   *         <code>Product</code> <code>Persistent</code>  
 2943  
   */
 2944  
 
 2945  
   public Double getWeight()
 2946  
       throws AccessPoemException {
 2947  0
     readLock();
 2948  0
     return getWeight_unsafe();
 2949  
   }
 2950  
 
 2951  
 
 2952  
  /**
 2953  
   * Sets the <code>Weight</code> value, with checking, for this 
 2954  
   * <code>Product</code> <code>Persistent</code>.
 2955  
   * 
 2956  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 2957  
   * @param cooked  a validated <code>int</code> 
 2958  
   * @throws AccessPoemException 
 2959  
   *         if the current <code>AccessToken</code> 
 2960  
   *         does not confer write access rights
 2961  
   * @throws ValidationPoemException 
 2962  
   *         if the value is not valid
 2963  
   */
 2964  
   public void setWeight(Double cooked)
 2965  
       throws AccessPoemException, ValidationPoemException {
 2966  0
     _getProductTable().getWeightColumn().
 2967  
       getType().assertValidCooked(cooked);
 2968  0
     writeLock();
 2969  0
     setWeight_unsafe(cooked);
 2970  0
   }
 2971  
 
 2972  
  /**
 2973  
   * Sets the <code>Weight</code> value, with checking, for this <code>Product</code> <code>Persistent</code>.
 2974  
   * 
 2975  
   * @generator org.melati.poem.prepro.DoubleFieldDef#generateBaseMethods 
 2976  
   * @param cooked  a validated <code>int</code> 
 2977  
   * @throws AccessPoemException 
 2978  
   *         if the current <code>AccessToken</code> 
 2979  
   *         does not confer write access rights
 2980  
   * @throws ValidationPoemException 
 2981  
   *         if the value is not valid
 2982  
   */
 2983  
 
 2984  
   public final void setWeight(double cooked)
 2985  
       throws AccessPoemException, ValidationPoemException {
 2986  0
     setWeight(new Double(cooked));
 2987  0
   }
 2988  
 
 2989  
 
 2990  
  /**
 2991  
   * Retrieves the <code>Weight</code> value as a <code>Field</code>
 2992  
   * from this <code>Product</code> <code>Persistent</code>.
 2993  
   * 
 2994  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 2995  
   * @throws AccessPoemException 
 2996  
   *         if the current <code>AccessToken</code> 
 2997  
   *         does not confer write access rights
 2998  
   * @return the Double weight
 2999  
   */
 3000  
   public Field getWeightField() throws AccessPoemException {
 3001  0
     Column c = _getProductTable().getWeightColumn();
 3002  0
     return new Field(c.getRaw(this), c);
 3003  
   }
 3004  
 
 3005  
 
 3006  
  /**
 3007  
   * Retrieves the <code>Width</code> value, without locking, 
 3008  
   * for this <code>Product</code> <code>Persistent</code>.
 3009  
   *
 3010  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 3011  
   * @return the Double width
 3012  
   */
 3013  
   public Double getWidth_unsafe() {
 3014  0
     return width;
 3015  
   }
 3016  
 
 3017  
 
 3018  
  /**
 3019  
   * Sets the <code>Width</code> value directly, without checking, 
 3020  
   * for this Product <code>Persistent</code>.
 3021  
   * 
 3022  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 3023  
   * @param cooked  the pre-validated value to set
 3024  
   */
 3025  
   public void setWidth_unsafe(Double cooked) {
 3026  0
     width = cooked;
 3027  0
   }
 3028  
 
 3029  
  /**
 3030  
   * Retrieves the Width value, with locking, for this 
 3031  
   * <code>Product</code> <code>Persistent</code>.
 3032  
   * 
 3033  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 3034  
   * @throws AccessPoemException 
 3035  
   *         if the current <code>AccessToken</code> 
 3036  
   *         does not confer write access rights 
 3037  
   * @return the value of the field <code>Width</code> for this 
 3038  
   *         <code>Product</code> <code>Persistent</code>  
 3039  
   */
 3040  
 
 3041  
   public Double getWidth()
 3042  
       throws AccessPoemException {
 3043  0
     readLock();
 3044  0
     return getWidth_unsafe();
 3045  
   }
 3046  
 
 3047  
 
 3048  
  /**
 3049  
   * Sets the <code>Width</code> value, with checking, for this 
 3050  
   * <code>Product</code> <code>Persistent</code>.
 3051  
   * 
 3052  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 3053  
   * @param cooked  a validated <code>int</code> 
 3054  
   * @throws AccessPoemException 
 3055  
   *         if the current <code>AccessToken</code> 
 3056  
   *         does not confer write access rights
 3057  
   * @throws ValidationPoemException 
 3058  
   *         if the value is not valid
 3059  
   */
 3060  
   public void setWidth(Double cooked)
 3061  
       throws AccessPoemException, ValidationPoemException {
 3062  0
     _getProductTable().getWidthColumn().
 3063  
       getType().assertValidCooked(cooked);
 3064  0
     writeLock();
 3065  0
     setWidth_unsafe(cooked);
 3066  0
   }
 3067  
 
 3068  
  /**
 3069  
   * Sets the <code>Width</code> value, with checking, for this <code>Product</code> <code>Persistent</code>.
 3070  
   * 
 3071  
   * @generator org.melati.poem.prepro.DoubleFieldDef#generateBaseMethods 
 3072  
   * @param cooked  a validated <code>int</code> 
 3073  
   * @throws AccessPoemException 
 3074  
   *         if the current <code>AccessToken</code> 
 3075  
   *         does not confer write access rights
 3076  
   * @throws ValidationPoemException 
 3077  
   *         if the value is not valid
 3078  
   */
 3079  
 
 3080  
   public final void setWidth(double cooked)
 3081  
       throws AccessPoemException, ValidationPoemException {
 3082  0
     setWidth(new Double(cooked));
 3083  0
   }
 3084  
 
 3085  
 
 3086  
  /**
 3087  
   * Retrieves the <code>Width</code> value as a <code>Field</code>
 3088  
   * from this <code>Product</code> <code>Persistent</code>.
 3089  
   * 
 3090  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 3091  
   * @throws AccessPoemException 
 3092  
   *         if the current <code>AccessToken</code> 
 3093  
   *         does not confer write access rights
 3094  
   * @return the Double width
 3095  
   */
 3096  
   public Field getWidthField() throws AccessPoemException {
 3097  0
     Column c = _getProductTable().getWidthColumn();
 3098  0
     return new Field(c.getRaw(this), c);
 3099  
   }
 3100  
 
 3101  
 
 3102  
  /**
 3103  
   * Retrieves the <code>Height</code> value, without locking, 
 3104  
   * for this <code>Product</code> <code>Persistent</code>.
 3105  
   *
 3106  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 3107  
   * @return the Double height
 3108  
   */
 3109  
   public Double getHeight_unsafe() {
 3110  0
     return height;
 3111  
   }
 3112  
 
 3113  
 
 3114  
  /**
 3115  
   * Sets the <code>Height</code> value directly, without checking, 
 3116  
   * for this Product <code>Persistent</code>.
 3117  
   * 
 3118  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 3119  
   * @param cooked  the pre-validated value to set
 3120  
   */
 3121  
   public void setHeight_unsafe(Double cooked) {
 3122  0
     height = cooked;
 3123  0
   }
 3124  
 
 3125  
  /**
 3126  
   * Retrieves the Height value, with locking, for this 
 3127  
   * <code>Product</code> <code>Persistent</code>.
 3128  
   * 
 3129  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 3130  
   * @throws AccessPoemException 
 3131  
   *         if the current <code>AccessToken</code> 
 3132  
   *         does not confer write access rights 
 3133  
   * @return the value of the field <code>Height</code> for this 
 3134  
   *         <code>Product</code> <code>Persistent</code>  
 3135  
   */
 3136  
 
 3137  
   public Double getHeight()
 3138  
       throws AccessPoemException {
 3139  0
     readLock();
 3140  0
     return getHeight_unsafe();
 3141  
   }
 3142  
 
 3143  
 
 3144  
  /**
 3145  
   * Sets the <code>Height</code> value, with checking, for this 
 3146  
   * <code>Product</code> <code>Persistent</code>.
 3147  
   * 
 3148  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 3149  
   * @param cooked  a validated <code>int</code> 
 3150  
   * @throws AccessPoemException 
 3151  
   *         if the current <code>AccessToken</code> 
 3152  
   *         does not confer write access rights
 3153  
   * @throws ValidationPoemException 
 3154  
   *         if the value is not valid
 3155  
   */
 3156  
   public void setHeight(Double cooked)
 3157  
       throws AccessPoemException, ValidationPoemException {
 3158  0
     _getProductTable().getHeightColumn().
 3159  
       getType().assertValidCooked(cooked);
 3160  0
     writeLock();
 3161  0
     setHeight_unsafe(cooked);
 3162  0
   }
 3163  
 
 3164  
  /**
 3165  
   * Sets the <code>Height</code> value, with checking, for this <code>Product</code> <code>Persistent</code>.
 3166  
   * 
 3167  
   * @generator org.melati.poem.prepro.DoubleFieldDef#generateBaseMethods 
 3168  
   * @param cooked  a validated <code>int</code> 
 3169  
   * @throws AccessPoemException 
 3170  
   *         if the current <code>AccessToken</code> 
 3171  
   *         does not confer write access rights
 3172  
   * @throws ValidationPoemException 
 3173  
   *         if the value is not valid
 3174  
   */
 3175  
 
 3176  
   public final void setHeight(double cooked)
 3177  
       throws AccessPoemException, ValidationPoemException {
 3178  0
     setHeight(new Double(cooked));
 3179  0
   }
 3180  
 
 3181  
 
 3182  
  /**
 3183  
   * Retrieves the <code>Height</code> value as a <code>Field</code>
 3184  
   * from this <code>Product</code> <code>Persistent</code>.
 3185  
   * 
 3186  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 3187  
   * @throws AccessPoemException 
 3188  
   *         if the current <code>AccessToken</code> 
 3189  
   *         does not confer write access rights
 3190  
   * @return the Double height
 3191  
   */
 3192  
   public Field getHeightField() throws AccessPoemException {
 3193  0
     Column c = _getProductTable().getHeightColumn();
 3194  0
     return new Field(c.getRaw(this), c);
 3195  
   }
 3196  
 
 3197  
 
 3198  
  /**
 3199  
   * Retrieves the <code>Depth</code> value, without locking, 
 3200  
   * for this <code>Product</code> <code>Persistent</code>.
 3201  
   *
 3202  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 3203  
   * @return the Double depth
 3204  
   */
 3205  
   public Double getDepth_unsafe() {
 3206  0
     return depth;
 3207  
   }
 3208  
 
 3209  
 
 3210  
  /**
 3211  
   * Sets the <code>Depth</code> value directly, without checking, 
 3212  
   * for this Product <code>Persistent</code>.
 3213  
   * 
 3214  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 3215  
   * @param cooked  the pre-validated value to set
 3216  
   */
 3217  
   public void setDepth_unsafe(Double cooked) {
 3218  0
     depth = cooked;
 3219  0
   }
 3220  
 
 3221  
  /**
 3222  
   * Retrieves the Depth value, with locking, for this 
 3223  
   * <code>Product</code> <code>Persistent</code>.
 3224  
   * 
 3225  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 3226  
   * @throws AccessPoemException 
 3227  
   *         if the current <code>AccessToken</code> 
 3228  
   *         does not confer write access rights 
 3229  
   * @return the value of the field <code>Depth</code> for this 
 3230  
   *         <code>Product</code> <code>Persistent</code>  
 3231  
   */
 3232  
 
 3233  
   public Double getDepth()
 3234  
       throws AccessPoemException {
 3235  0
     readLock();
 3236  0
     return getDepth_unsafe();
 3237  
   }
 3238  
 
 3239  
 
 3240  
  /**
 3241  
   * Sets the <code>Depth</code> value, with checking, for this 
 3242  
   * <code>Product</code> <code>Persistent</code>.
 3243  
   * 
 3244  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 3245  
   * @param cooked  a validated <code>int</code> 
 3246  
   * @throws AccessPoemException 
 3247  
   *         if the current <code>AccessToken</code> 
 3248  
   *         does not confer write access rights
 3249  
   * @throws ValidationPoemException 
 3250  
   *         if the value is not valid
 3251  
   */
 3252  
   public void setDepth(Double cooked)
 3253  
       throws AccessPoemException, ValidationPoemException {
 3254  0
     _getProductTable().getDepthColumn().
 3255  
       getType().assertValidCooked(cooked);
 3256  0
     writeLock();
 3257  0
     setDepth_unsafe(cooked);
 3258  0
   }
 3259  
 
 3260  
  /**
 3261  
   * Sets the <code>Depth</code> value, with checking, for this <code>Product</code> <code>Persistent</code>.
 3262  
   * 
 3263  
   * @generator org.melati.poem.prepro.DoubleFieldDef#generateBaseMethods 
 3264  
   * @param cooked  a validated <code>int</code> 
 3265  
   * @throws AccessPoemException 
 3266  
   *         if the current <code>AccessToken</code> 
 3267  
   *         does not confer write access rights
 3268  
   * @throws ValidationPoemException 
 3269  
   *         if the value is not valid
 3270  
   */
 3271  
 
 3272  
   public final void setDepth(double cooked)
 3273  
       throws AccessPoemException, ValidationPoemException {
 3274  0
     setDepth(new Double(cooked));
 3275  0
   }
 3276  
 
 3277  
 
 3278  
  /**
 3279  
   * Retrieves the <code>Depth</code> value as a <code>Field</code>
 3280  
   * from this <code>Product</code> <code>Persistent</code>.
 3281  
   * 
 3282  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 3283  
   * @throws AccessPoemException 
 3284  
   *         if the current <code>AccessToken</code> 
 3285  
   *         does not confer write access rights
 3286  
   * @return the Double depth
 3287  
   */
 3288  
   public Field getDepthField() throws AccessPoemException {
 3289  0
     Column c = _getProductTable().getDepthColumn();
 3290  0
     return new Field(c.getRaw(this), c);
 3291  
   }
 3292  
 
 3293  
 
 3294  
  /**
 3295  
   * Retrieves the <code>Picture</code> value, without locking, 
 3296  
   * for this <code>Product</code> <code>Persistent</code>.
 3297  
   *
 3298  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 3299  
   * @return the String picture
 3300  
   */
 3301  
   public String getPicture_unsafe() {
 3302  0
     return picture;
 3303  
   }
 3304  
 
 3305  
 
 3306  
  /**
 3307  
   * Sets the <code>Picture</code> value directly, without checking, 
 3308  
   * for this Product <code>Persistent</code>.
 3309  
   * 
 3310  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 3311  
   * @param cooked  the pre-validated value to set
 3312  
   */
 3313  
   public void setPicture_unsafe(String cooked) {
 3314  0
     picture = cooked;
 3315  0
   }
 3316  
 
 3317  
  /**
 3318  
   * Retrieves the Picture value, with locking, for this 
 3319  
   * <code>Product</code> <code>Persistent</code>.
 3320  
   * 
 3321  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 3322  
   * @throws AccessPoemException 
 3323  
   *         if the current <code>AccessToken</code> 
 3324  
   *         does not confer write access rights 
 3325  
   * @return the value of the field <code>Picture</code> for this 
 3326  
   *         <code>Product</code> <code>Persistent</code>  
 3327  
   */
 3328  
 
 3329  
   public String getPicture()
 3330  
       throws AccessPoemException {
 3331  0
     readLock();
 3332  0
     return getPicture_unsafe();
 3333  
   }
 3334  
 
 3335  
 
 3336  
  /**
 3337  
   * Sets the <code>Picture</code> value, with checking, for this 
 3338  
   * <code>Product</code> <code>Persistent</code>.
 3339  
   * 
 3340  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 3341  
   * @param cooked  a validated <code>int</code> 
 3342  
   * @throws AccessPoemException 
 3343  
   *         if the current <code>AccessToken</code> 
 3344  
   *         does not confer write access rights
 3345  
   * @throws ValidationPoemException 
 3346  
   *         if the value is not valid
 3347  
   */
 3348  
   public void setPicture(String cooked)
 3349  
       throws AccessPoemException, ValidationPoemException {
 3350  0
     _getProductTable().getPictureColumn().
 3351  
       getType().assertValidCooked(cooked);
 3352  0
     writeLock();
 3353  0
     setPicture_unsafe(cooked);
 3354  0
   }
 3355  
 
 3356  
 
 3357  
  /**
 3358  
   * Retrieves the <code>Picture</code> value as a <code>Field</code>
 3359  
   * from this <code>Product</code> <code>Persistent</code>.
 3360  
   * 
 3361  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 3362  
   * @throws AccessPoemException 
 3363  
   *         if the current <code>AccessToken</code> 
 3364  
   *         does not confer write access rights
 3365  
   * @return the String picture
 3366  
   */
 3367  
   public Field getPictureField() throws AccessPoemException {
 3368  0
     Column c = _getProductTable().getPictureColumn();
 3369  0
     return new Field(c.getRaw(this), c);
 3370  
   }
 3371  
 
 3372  
 
 3373  
  /**
 3374  
   * Retrieves the <code>Picture2</code> value, without locking, 
 3375  
   * for this <code>Product</code> <code>Persistent</code>.
 3376  
   *
 3377  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 3378  
   * @return the String picture2
 3379  
   */
 3380  
   public String getPicture2_unsafe() {
 3381  0
     return picture2;
 3382  
   }
 3383  
 
 3384  
 
 3385  
  /**
 3386  
   * Sets the <code>Picture2</code> value directly, without checking, 
 3387  
   * for this Product <code>Persistent</code>.
 3388  
   * 
 3389  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 3390  
   * @param cooked  the pre-validated value to set
 3391  
   */
 3392  
   public void setPicture2_unsafe(String cooked) {
 3393  0
     picture2 = cooked;
 3394  0
   }
 3395  
 
 3396  
  /**
 3397  
   * Retrieves the Picture2 value, with locking, for this 
 3398  
   * <code>Product</code> <code>Persistent</code>.
 3399  
   * 
 3400  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 3401  
   * @throws AccessPoemException 
 3402  
   *         if the current <code>AccessToken</code> 
 3403  
   *         does not confer write access rights 
 3404  
   * @return the value of the field <code>Picture2</code> for this 
 3405  
   *         <code>Product</code> <code>Persistent</code>  
 3406  
   */
 3407  
 
 3408  
   public String getPicture2()
 3409  
       throws AccessPoemException {
 3410  0
     readLock();
 3411  0
     return getPicture2_unsafe();
 3412  
   }
 3413  
 
 3414  
 
 3415  
  /**
 3416  
   * Sets the <code>Picture2</code> value, with checking, for this 
 3417  
   * <code>Product</code> <code>Persistent</code>.
 3418  
   * 
 3419  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 3420  
   * @param cooked  a validated <code>int</code> 
 3421  
   * @throws AccessPoemException 
 3422  
   *         if the current <code>AccessToken</code> 
 3423  
   *         does not confer write access rights
 3424  
   * @throws ValidationPoemException 
 3425  
   *         if the value is not valid
 3426  
   */
 3427  
   public void setPicture2(String cooked)
 3428  
       throws AccessPoemException, ValidationPoemException {
 3429  0
     _getProductTable().getPicture2Column().
 3430  
       getType().assertValidCooked(cooked);
 3431  0
     writeLock();
 3432  0
     setPicture2_unsafe(cooked);
 3433  0
   }
 3434  
 
 3435  
 
 3436  
  /**
 3437  
   * Retrieves the <code>Picture2</code> value as a <code>Field</code>
 3438  
   * from this <code>Product</code> <code>Persistent</code>.
 3439  
   * 
 3440  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 3441  
   * @throws AccessPoemException 
 3442  
   *         if the current <code>AccessToken</code> 
 3443  
   *         does not confer write access rights
 3444  
   * @return the String picture2
 3445  
   */
 3446  
   public Field getPicture2Field() throws AccessPoemException {
 3447  0
     Column c = _getProductTable().getPicture2Column();
 3448  0
     return new Field(c.getRaw(this), c);
 3449  
   }
 3450  
 
 3451  
 
 3452  
  /**
 3453  
   * Retrieves the <code>Catalogue</code> value, without locking, 
 3454  
   * for this <code>Product</code> <code>Persistent</code>.
 3455  
   *
 3456  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 3457  
   * @return the Boolean catalogue
 3458  
   */
 3459  
   public Boolean getCatalogue_unsafe() {
 3460  0
     return catalogue;
 3461  
   }
 3462  
 
 3463  
 
 3464  
  /**
 3465  
   * Sets the <code>Catalogue</code> value directly, without checking, 
 3466  
   * for this Product <code>Persistent</code>.
 3467  
   * 
 3468  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 3469  
   * @param cooked  the pre-validated value to set
 3470  
   */
 3471  
   public void setCatalogue_unsafe(Boolean cooked) {
 3472  0
     catalogue = cooked;
 3473  0
   }
 3474  
 
 3475  
  /**
 3476  
   * Retrieves the Catalogue value, with locking, for this 
 3477  
   * <code>Product</code> <code>Persistent</code>.
 3478  
   * 
 3479  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 3480  
   * @throws AccessPoemException 
 3481  
   *         if the current <code>AccessToken</code> 
 3482  
   *         does not confer write access rights 
 3483  
   * @return the value of the field <code>Catalogue</code> for this 
 3484  
   *         <code>Product</code> <code>Persistent</code>  
 3485  
   */
 3486  
 
 3487  
   public Boolean getCatalogue()
 3488  
       throws AccessPoemException {
 3489  0
     readLock();
 3490  0
     return getCatalogue_unsafe();
 3491  
   }
 3492  
 
 3493  
 
 3494  
  /**
 3495  
   * Sets the <code>Catalogue</code> value, with checking, for this 
 3496  
   * <code>Product</code> <code>Persistent</code>.
 3497  
   * 
 3498  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 3499  
   * @param cooked  a validated <code>int</code> 
 3500  
   * @throws AccessPoemException 
 3501  
   *         if the current <code>AccessToken</code> 
 3502  
   *         does not confer write access rights
 3503  
   * @throws ValidationPoemException 
 3504  
   *         if the value is not valid
 3505  
   */
 3506  
   public void setCatalogue(Boolean cooked)
 3507  
       throws AccessPoemException, ValidationPoemException {
 3508  0
     _getProductTable().getCatalogueColumn().
 3509  
       getType().assertValidCooked(cooked);
 3510  0
     writeLock();
 3511  0
     setCatalogue_unsafe(cooked);
 3512  0
   }
 3513  
 
 3514  
  /**
 3515  
   * Sets the <code>Catalogue</code> value, with checking, 
 3516  
   * from a <code>boolean</code>, for this 
 3517  
   * <code>Product</code> <code>Persistent</code>.
 3518  
   * 
 3519  
   * @generator org.melati.poem.prepro.BooleanFieldDef#generateBaseMethods 
 3520  
   * @param cooked  a <code>boolean</code> 
 3521  
   * @throws AccessPoemException 
 3522  
   *         if the current <code>AccessToken</code> 
 3523  
   *         does not confer write access rights
 3524  
   * @throws ValidationPoemException 
 3525  
   *         if the value is not valid
 3526  
   */
 3527  
 
 3528  
   public final void setCatalogue(boolean cooked)
 3529  
       throws AccessPoemException, ValidationPoemException {
 3530  0
     setCatalogue(cooked ? Boolean.TRUE : Boolean.FALSE);
 3531  0
   }
 3532  
 
 3533  
 
 3534  
  /**
 3535  
   * Retrieves the <code>Catalogue</code> value as a <code>Field</code>
 3536  
   * from this <code>Product</code> <code>Persistent</code>.
 3537  
   * 
 3538  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 3539  
   * @throws AccessPoemException 
 3540  
   *         if the current <code>AccessToken</code> 
 3541  
   *         does not confer write access rights
 3542  
   * @return the Boolean catalogue
 3543  
   */
 3544  
   public Field getCatalogueField() throws AccessPoemException {
 3545  0
     Column c = _getProductTable().getCatalogueColumn();
 3546  0
     return new Field(c.getRaw(this), c);
 3547  
   }
 3548  
 
 3549  
 
 3550  
  /**
 3551  
   * Retrieves the <code>Deleted</code> value, without locking, 
 3552  
   * for this <code>Product</code> <code>Persistent</code>.
 3553  
   *
 3554  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 3555  
   * @return the Boolean deleted
 3556  
   */
 3557  
   public Boolean getDeleted_unsafe() {
 3558  0
     return deleted;
 3559  
   }
 3560  
 
 3561  
 
 3562  
  /**
 3563  
   * Sets the <code>Deleted</code> value directly, without checking, 
 3564  
   * for this Product <code>Persistent</code>.
 3565  
   * 
 3566  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 3567  
   * @param cooked  the pre-validated value to set
 3568  
   */
 3569  
   public void setDeleted_unsafe(Boolean cooked) {
 3570  0
     deleted = cooked;
 3571  0
   }
 3572  
 
 3573  
  /**
 3574  
   * Retrieves the Deleted value, with locking, for this 
 3575  
   * <code>Product</code> <code>Persistent</code>.
 3576  
   * 
 3577  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 3578  
   * @throws AccessPoemException 
 3579  
   *         if the current <code>AccessToken</code> 
 3580  
   *         does not confer write access rights 
 3581  
   * @return the value of the field <code>Deleted</code> for this 
 3582  
   *         <code>Product</code> <code>Persistent</code>  
 3583  
   */
 3584  
 
 3585  
   public Boolean getDeleted()
 3586  
       throws AccessPoemException {
 3587  0
     readLock();
 3588  0
     return getDeleted_unsafe();
 3589  
   }
 3590  
 
 3591  
 
 3592  
  /**
 3593  
   * Sets the <code>Deleted</code> value, with checking, for this 
 3594  
   * <code>Product</code> <code>Persistent</code>.
 3595  
   * 
 3596  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 3597  
   * @param cooked  a validated <code>int</code> 
 3598  
   * @throws AccessPoemException 
 3599  
   *         if the current <code>AccessToken</code> 
 3600  
   *         does not confer write access rights
 3601  
   * @throws ValidationPoemException 
 3602  
   *         if the value is not valid
 3603  
   */
 3604  
   public void setDeleted(Boolean cooked)
 3605  
       throws AccessPoemException, ValidationPoemException {
 3606  0
     _getProductTable().getDeletedColumn().
 3607  
       getType().assertValidCooked(cooked);
 3608  0
     writeLock();
 3609  0
     setDeleted_unsafe(cooked);
 3610  0
   }
 3611  
 
 3612  
  /**
 3613  
   * Sets the <code>Deleted</code> value, with checking, 
 3614  
   * from a <code>boolean</code>, for this 
 3615  
   * <code>Product</code> <code>Persistent</code>.
 3616  
   * 
 3617  
   * @generator org.melati.poem.prepro.BooleanFieldDef#generateBaseMethods 
 3618  
   * @param cooked  a <code>boolean</code> 
 3619  
   * @throws AccessPoemException 
 3620  
   *         if the current <code>AccessToken</code> 
 3621  
   *         does not confer write access rights
 3622  
   * @throws ValidationPoemException 
 3623  
   *         if the value is not valid
 3624  
   */
 3625  
 
 3626  
   public final void setDeleted(boolean cooked)
 3627  
       throws AccessPoemException, ValidationPoemException {
 3628  0
     setDeleted(cooked ? Boolean.TRUE : Boolean.FALSE);
 3629  0
   }
 3630  
 
 3631  
 
 3632  
  /**
 3633  
   * Retrieves the <code>Deleted</code> value as a <code>Field</code>
 3634  
   * from this <code>Product</code> <code>Persistent</code>.
 3635  
   * 
 3636  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 3637  
   * @throws AccessPoemException 
 3638  
   *         if the current <code>AccessToken</code> 
 3639  
   *         does not confer write access rights
 3640  
   * @return the Boolean deleted
 3641  
   */
 3642  
   public Field getDeletedField() throws AccessPoemException {
 3643  0
     Column c = _getProductTable().getDeletedColumn();
 3644  0
     return new Field(c.getRaw(this), c);
 3645  
   }
 3646  
 
 3647  
 
 3648  
  /**
 3649  
   * Retrieves the <code>Award</code> value, without locking, 
 3650  
   * for this <code>Product</code> <code>Persistent</code>.
 3651  
   *
 3652  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 3653  
   * @return the Integer award
 3654  
   */
 3655  
   public Integer getAward_unsafe() {
 3656  0
     return award;
 3657  
   }
 3658  
 
 3659  
 
 3660  
  /**
 3661  
   * Sets the <code>Award</code> value directly, without checking, 
 3662  
   * for this Product <code>Persistent</code>.
 3663  
   * 
 3664  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 3665  
   * @param cooked  the pre-validated value to set
 3666  
   */
 3667  
   public void setAward_unsafe(Integer cooked) {
 3668  0
     award = cooked;
 3669  0
   }
 3670  
 
 3671  
  /**
 3672  
   * Retrieves the Table Row Object ID. 
 3673  
   *
 3674  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 3675  
   * @throws AccessPoemException  
 3676  
   *         if the current <code>AccessToken</code> 
 3677  
   *         does not confer read access rights 
 3678  
   * @return the TROID as an <code>Integer</code> 
 3679  
   */
 3680  
 
 3681  
   public Integer getAwardTroid()
 3682  
       throws AccessPoemException {
 3683  0
     readLock();
 3684  0
     return getAward_unsafe();
 3685  
   }
 3686  
 
 3687  
 
 3688  
  /**
 3689  
   * Sets the Table Row Object ID. 
 3690  
   * 
 3691  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 3692  
   * @param raw  a Table Row Object Id 
 3693  
   * @throws AccessPoemException  
 3694  
   *         if the current <code>AccessToken</code> 
 3695  
   *         does not confer write access rights
 3696  
   */
 3697  
   public void setAwardTroid(Integer raw)
 3698  
       throws AccessPoemException {
 3699  0
     setAward(raw == null ? null : 
 3700  
         getJammyjoesDatabaseTables().getAwardTable().getAwardObject(raw));
 3701  0
   }
 3702  
 
 3703  
 
 3704  
  /**
 3705  
   * Retrieves the <code>Award</code> object referred to.
 3706  
   *  
 3707  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 3708  
   * @throws AccessPoemException  
 3709  
   *         if the current <code>AccessToken</code> 
 3710  
   *         does not confer read access rights 
 3711  
   * @throws NoSuchRowPoemException  
 3712  
   *         if the <code>Persistent</code> has yet to be allocated a TROID 
 3713  
   * @return the <code>Award</code> as a <code>Award</code> 
 3714  
   */
 3715  
   public Award getAward()
 3716  
       throws AccessPoemException, NoSuchRowPoemException {
 3717  0
     Integer troid = getAwardTroid();
 3718  0
     return troid == null ? null :
 3719  
         getJammyjoesDatabaseTables().getAwardTable().getAwardObject(troid);
 3720  
   }
 3721  
 
 3722  
 
 3723  
  /**
 3724  
   * Set the Award.
 3725  
   * 
 3726  
   * @generator org.melati.poem.prepro.ReferenceFieldDef#generateBaseMethods 
 3727  
   * @param cooked  a validated <code>Award</code>
 3728  
   * @throws AccessPoemException  
 3729  
   *         if the current <code>AccessToken</code> 
 3730  
   *         does not confer write access rights 
 3731  
   */
 3732  
   public void setAward(Award cooked)
 3733  
       throws AccessPoemException {
 3734  0
     _getProductTable().
 3735  
       getAwardColumn().
 3736  
         getType().assertValidCooked(cooked);
 3737  0
     writeLock();
 3738  0
     if (cooked == null)
 3739  0
       setAward_unsafe(null);
 3740  
     else {
 3741  0
       cooked.existenceLock();
 3742  0
       setAward_unsafe(cooked.troid());
 3743  
     }
 3744  0
   }
 3745  
 
 3746  
 
 3747  
  /**
 3748  
   * Retrieves the <code>Award</code> value as a <code>Field</code>
 3749  
   * from this <code>Product</code> <code>Persistent</code>.
 3750  
   * 
 3751  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 3752  
   * @throws AccessPoemException 
 3753  
   *         if the current <code>AccessToken</code> 
 3754  
   *         does not confer write access rights
 3755  
   * @return the Integer award
 3756  
   */
 3757  
   public Field getAwardField() throws AccessPoemException {
 3758  0
     Column c = _getProductTable().getAwardColumn();
 3759  0
     return new Field(c.getRaw(this), c);
 3760  
   }
 3761  
 
 3762  
 
 3763  
  /**
 3764  
   * Retrieves the <code>Onorderquantity</code> value, without locking, 
 3765  
   * for this <code>Product</code> <code>Persistent</code>.
 3766  
   *
 3767  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 3768  
   * @return the Integer onorderquantity
 3769  
   */
 3770  
   public Integer getOnorderquantity_unsafe() {
 3771  0
     return onorderquantity;
 3772  
   }
 3773  
 
 3774  
 
 3775  
  /**
 3776  
   * Sets the <code>Onorderquantity</code> value directly, without checking, 
 3777  
   * for this Product <code>Persistent</code>.
 3778  
   * 
 3779  
   * @generator org.melati.poem.prepro.FieldDef#generateBaseMethods 
 3780  
   * @param cooked  the pre-validated value to set
 3781  
   */
 3782  
   public void setOnorderquantity_unsafe(Integer cooked) {
 3783  0
     onorderquantity = cooked;
 3784  0
   }
 3785  
 
 3786  
  /**
 3787  
   * Retrieves the Onorderquantity value, with locking, for this 
 3788  
   * <code>Product</code> <code>Persistent</code>.
 3789  
   * Field description: 
 3790  
   *   Not currently used 
 3791  
   * 
 3792  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods 
 3793  
   * @throws AccessPoemException 
 3794  
   *         if the current <code>AccessToken</code> 
 3795  
   *         does not confer write access rights 
 3796  
   * @return the value of the field <code>Onorderquantity</code> for this 
 3797  
   *         <code>Product</code> <code>Persistent</code>  
 3798  
   */
 3799  
 
 3800  
   public Integer getOnorderquantity()
 3801  
       throws AccessPoemException {
 3802  0
     readLock();
 3803  0
     return getOnorderquantity_unsafe();
 3804  
   }
 3805  
 
 3806  
 
 3807  
  /**
 3808  
   * Sets the <code>Onorderquantity</code> value, with checking, for this 
 3809  
   * <code>Product</code> <code>Persistent</code>.
 3810  
   * Field description: 
 3811  
   *   Not currently used 
 3812  
   * 
 3813  
   * @generator org.melati.poem.prepro.AtomFieldDef#generateBaseMethods  
 3814  
   * @param cooked  a validated <code>int</code> 
 3815  
   * @throws AccessPoemException 
 3816  
   *         if the current <code>AccessToken</code> 
 3817  
   *         does not confer write access rights
 3818  
   * @throws ValidationPoemException 
 3819  
   *         if the value is not valid
 3820  
   */
 3821  
   public void setOnorderquantity(Integer cooked)
 3822  
       throws AccessPoemException, ValidationPoemException {
 3823  0
     _getProductTable().getOnorderquantityColumn().
 3824  
       getType().assertValidCooked(cooked);
 3825  0
     writeLock();
 3826  0
     setOnorderquantity_unsafe(cooked);
 3827  0
   }
 3828  
 
 3829  
  /**
 3830  
   * Sets the <code>Onorderquantity</code> value, with checking, for this 
 3831  
   * <code>Product</code> <code>Persistent</code>.
 3832  
   * Field description: 
 3833  
   *   Not currently used 
 3834  
   * 
 3835  
   * 
 3836  
   * @generator org.melati.poem.prepro.IntegerFieldDef#generateBaseMethods 
 3837  
   * @param cooked  a validated <code>int</code>
 3838  
   * @throws AccessPoemException 
 3839  
   *         if the current <code>AccessToken</code> 
 3840  
   *         does not confer write access rights
 3841  
   * @throws ValidationPoemException 
 3842  
   *         if the value is not valid
 3843  
   */
 3844  
 
 3845  
   public final void setOnorderquantity(int cooked)
 3846  
       throws AccessPoemException, ValidationPoemException {
 3847  0
     setOnorderquantity(new Integer(cooked));
 3848  0
   }
 3849  
 
 3850  
 
 3851  
  /**
 3852  
   * Retrieves the <code>Onorderquantity</code> value as a <code>Field</code>
 3853  
   * from this <code>Product</code> <code>Persistent</code>.
 3854  
   * 
 3855  
   * @generator org.melati.poem.prepro.FieldDef#generateFieldCreator 
 3856  
   * @throws AccessPoemException 
 3857  
   *         if the current <code>AccessToken</code> 
 3858  
   *         does not confer write access rights
 3859  
   * @return the Integer onorderquantity
 3860  
   */
 3861  
   public Field getOnorderquantityField() throws AccessPoemException {
 3862  0
     Column c = _getProductTable().getOnorderquantityColumn();
 3863  0
     return new Field(c.getRaw(this), c);
 3864  
   }
 3865  
 }
 3866