// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.or;

import java.util.*;

import org.litesoft.bo.attributes.*;
import org.litesoft.core.simpletypes.temporal.*;
import org.litesoft.core.util.*;
import org.litesoft.orsup.base.*;
import org.litesoft.orsup.lazyeval.*;
import org.litesoft.orsup.lazyload.*;
import org.litesoft.orsup.nonpublic.*;
import org.litesoft.orsup.otherattributeaccessors.*;
import org.litesoft.orsup.selection.*;
import org.litesoft.orsup.transact.*;
import org.litesoft.util.*;

public abstract class DBAttributeSamplesPO extends PersistentObjectImpl<DBAttributeSamples>
{
    private static final ConstructionControl CONSTRUCTION_CONTROL = new ConstructionControl();

    public static SimpleFromIdentifier from()
    {
        return DBAttributeSamplesMetaData.INSTANCE;
    }

    protected DBAttributeSamplesPO( Transaction pTransaction ) // Only used for New
    {
        super( DBAttributeSamplesMetaData.INSTANCE, pTransaction );
        mID = getNextSequenceNumber( getClass() );
        registerWithTransaction();
    }

    protected DBAttributeSamplesPO( ConstructionControl pConstructionControl )
    {
        super( DBAttributeSamplesMetaData.INSTANCE, CONSTRUCTION_CONTROL, pConstructionControl );
    }

    public static final AttributeAccessorSCD CD_RecordVersion = new AttributeAccessor_RecordVersion();

    protected final RecordVersionHelper mRecordVersion = new RecordVersionHelper();

    public Long getRecordVersion()
    {
        return mRecordVersion.getRecordVersion();
    }

    private static class AttributeAccessor_RecordVersion extends AttributeAccessorSCD_RecordVersion<DBAttributeSamples>
    {
        public AttributeAccessor_RecordVersion()
        {
            super( "RecordVersion", "RecordVersion" );
        }

        @Override
        protected RecordVersionHelper getRecordVersionHelper( DBAttributeSamples pPO )
        {
            return pPO.mRecordVersion;
        }
    }

    public static final AttributeAccessorSCD CD_ID = new AttributeAccessor_ID();

    private Long mID = null;

    public Long getID()
    {
        return mID;
    }

    protected void LLsetID( Long pID )
    {
        verifyMutability( CD_ID, mID, pID );
        mID = pID;
    }

    private static class AttributeAccessor_ID extends AttributeAccessorSCDsimplePersistedReadOnly<DBAttributeSamples> implements NonImportableFeature
    {
        public AttributeAccessor_ID()
        {
            super( "ID", "id", true, _Long );
        }

        @Override
        public Object getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.getID();
        }

        @Override
        public void db_setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.LLsetID( to_Long( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_Name = new AttributeAccessor_Name();

    private String mName;

    public String getName()
    {
        return mName;
    }

    public void setName( String pName )
    {
        verifyMutability( CD_Name, mName, pName );
        mName = pName;
    }

    private static class AttributeAccessor_Name extends AttributeAccessorSCDsimplePersistedRegular<DBAttributeSamples>
    {
        public AttributeAccessor_Name()
        {
            super( "Name", "Name", true, _String.with( MaxLength.of( 45 ) ) );
        }

        @Override
        public Object getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.getName();
        }

        @Override
        public void setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.setName( to_String( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_Password = new AttributeAccessor_Password();

    private String mPassword;

    public String getPassword()
    {
        return mPassword;
    }

    public void setPassword( String pPassword )
    {
        verifyMutability( CD_Password, mPassword, pPassword );
        mPassword = pPassword;
    }

    private static class AttributeAccessor_Password extends AttributeAccessorSCDsimplePersistedRegular<DBAttributeSamples>
    {
        public AttributeAccessor_Password()
        {
            super( "Password", "Password", true, _Password.with( MaxLength.of( 20 ) ) );
        }

        @Override
        public Object getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.getPassword();
        }

        @Override
        public void setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.setPassword( to_String( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_Status = new AttributeAccessor_Status();

    public static final AttributeSampleStatus DEFAULT_Status = AttributeSampleStatus.values()[0];

    private String mStatus = DEFAULT_Status.toString();

    public AttributeSampleStatus getStatus()
    {
        return AttributeSampleStatus.valueOf( mStatus );
    }

    public void setStatus( AttributeSampleStatus pStatus )
    {
        verifyMutability( CD_Status, mStatus, pStatus );
        mStatus = (pStatus != null) ? pStatus.toString() : DEFAULT_Status.toString();
    }

    public void setStatus( String pStatus )
    {
        setStatus( (pStatus != null) ? AttributeSampleStatus.valueOf( pStatus ) : DEFAULT_Status );
    }

    private static class AttributeAccessor_Status extends AttributeAccessorSCDenumPersistedRegular<DBAttributeSamples>
    {
        public AttributeAccessor_Status()
        {
            super( "Status", "Status", true, _String.with( UiHint.RadioGroup ) );
        }

        @Override
        public Object getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.getStatus();
        }

        @Override
        public void setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.setStatus( to_String( pValue ) );
        }

        @Override
        public Object[] getValidOptions()
        {
            return AttributeSampleStatus.values();
        }
    }

    public static final AttributeAccessorSCD CD_Constrained = new AttributeAccessor_Constrained();

    public static final AttributeSampleStatus DEFAULT_Constrained = AttributeSampleStatus.values()[0];

    private String mConstrained = DEFAULT_Constrained.toString();

    public String getConstrained()
    {
        return mConstrained;
    }

    public void setConstrained( AttributeSampleStatus pConstrained )
    {
        verifyMutability( CD_Constrained, mConstrained, pConstrained );
        mConstrained = (pConstrained != null) ? pConstrained.toString() : DEFAULT_Constrained.toString();
    }

    public void setConstrained( String pConstrained )
    {
        setConstrained( (pConstrained != null) ? AttributeSampleStatus.valueOf( pConstrained ) : DEFAULT_Constrained );
    }

    private static class AttributeAccessor_Constrained extends AttributeAccessorSCDsimplePersistedRegular<DBAttributeSamples>
    {
        public AttributeAccessor_Constrained()
        {
            super( "Constrained", "Constrained", true, _String.with( MaxLength.of( 20 ) ) );
        }

        @Override
        public Object getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.getConstrained();
        }

        @Override
        public void setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.setConstrained( to_String( pValue ) );
        }

        @Override
        public Object[] getValidOptions()
        {
            return AttributeSampleStatus.values();
        }
    }

    public static final AttributeAccessorSCD CD_Alias = new AttributeAccessor_Alias();

    private String mAlias;

    public String getAlias()
    {
        return mAlias;
    }

    public void setAlias( String pAlias )
    {
        verifyMutability( CD_Alias, mAlias, pAlias );
        mAlias = pAlias;
    }

    private static class AttributeAccessor_Alias extends AttributeAccessorSCDsimplePersistedRegular<DBAttributeSamples> implements CharacterCaseIgnored
    {
        public AttributeAccessor_Alias()
        {
            super( "Alias", "Alias", false, _String.with( MaxLength.of( 45 ), //
                                                          Case.Ignored ) );
        }

        @Override
        public Object getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.getAlias();
        }

        @Override
        public void setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.setAlias( to_String( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_URL = new AttributeAccessor_URL();

    private String mURL;

    public String getURL()
    {
        return mURL;
    }

    public void setURL( String pURL )
    {
        verifyMutability( CD_URL, mURL, pURL );
        mURL = pURL;
    }

    private static class AttributeAccessor_URL extends AttributeAccessorSCDsimplePersistedRegular<DBAttributeSamples>
    {
        public AttributeAccessor_URL()
        {
            super( "URL", "URL", false, _String.with( MaxLength.of( 255 ) ) );
        }

        @Override
        public Object getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.getURL();
        }

        @Override
        public void setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.setURL( to_String( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_Description = new AttributeAccessor_Description();

    private String mDescription;

    public String getDescription()
    {
        return mDescription;
    }

    public void setDescription( String pDescription )
    {
        verifyMutability( CD_Description, mDescription, pDescription );
        mDescription = pDescription;
    }

    private static class AttributeAccessor_Description extends AttributeAccessorSCDsimplePersistedRegular<DBAttributeSamples>
    {
        public AttributeAccessor_Description()
        {
            super( "Description", "Description", false, _Text );
        }

        @Override
        public Object getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.getDescription();
        }

        @Override
        public void setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.setDescription( to_String( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_Number = new AttributeAccessor_Number();

    private String mNumber;

    public String getNumber()
    {
        return mNumber;
    }

    public void setNumber( String pNumber )
    {
        verifyMutability( CD_Number, mNumber, pNumber );
        mNumber = pNumber;
    }

    private static class AttributeAccessor_Number extends AttributeAccessorSCDsimplePersistedRegular<DBAttributeSamples>
    {
        public AttributeAccessor_Number()
        {
            super( "Number", "Number", true, _String.with( MaxLength.of( 25 ), //
                                                           UiHint.RightAligned ) );
        }

        @Override
        public Object getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.getNumber();
        }

        @Override
        public void setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.setNumber( to_String( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_Shipped = new AttributeAccessor_Shipped();

    private Boolean mShipped;

    public Boolean getShipped()
    {
        return mShipped;
    }

    public void setShipped( Boolean pShipped )
    {
        verifyMutability( CD_Shipped, mShipped, pShipped );
        mShipped = pShipped;
    }

    private static class AttributeAccessor_Shipped extends AttributeAccessorSCDsimplePersistedRegular<DBAttributeSamples>
    {
        public AttributeAccessor_Shipped()
        {
            super( "Shipped", "Shipped", false, _Boolean.with( BooleanDisplayOptions.of( "Shipped/Processing" ) ) );
        }

        @Override
        public Object getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.getShipped();
        }

        @Override
        public void setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.setShipped( to_boolean( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_Paid = new AttributeAccessor_Paid();

    private boolean mPaid;

    public boolean getPaid()
    {
        return mPaid;
    }

    public void setPaid( boolean pPaid )
    {
        verifyMutability( CD_Paid, mPaid, pPaid );
        mPaid = pPaid;
    }

    private static class AttributeAccessor_Paid extends AttributeAccessorSCDsimplePersistedRegular<DBAttributeSamples>
    {
        public AttributeAccessor_Paid()
        {
            super( "Paid", "Paid", false, _Primitive_boolean );
        }

        @Override
        public Object getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.getPaid();
        }

        @Override
        public void setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.setPaid( to_boolean( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_Member = new AttributeAccessor_Member();

    private Boolean mMember = false;

    public Boolean getMember()
    {
        return mMember;
    }

    public void setMember( Boolean pMember )
    {
        verifyMutability( CD_Member, mMember, pMember );
        mMember = (pMember != null) && pMember;
    }

    private static class AttributeAccessor_Member extends AttributeAccessorSCDsimplePersistedRegular<DBAttributeSamples>
    {
        public AttributeAccessor_Member()
        {
            super( "Member", "Member", true, _Boolean );
        }

        @Override
        public Object getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.getMember();
        }

        @Override
        public void setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.setMember( to_Boolean( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_TimeScheduled = new AttributeAccessor_TimeScheduled();

    final LazyEvalSimpleTime mTimeScheduled = new LazyEvalSimpleTime();

    public SimpleTime getTimeScheduled()
    {
        return mTimeScheduled.getSimpleTime();
    }

    public void setTimeScheduled( SimpleTime pTimeScheduled )
    {
        verifyMutability( CD_TimeScheduled, mTimeScheduled.getSimpleTime(), pTimeScheduled );
        mTimeScheduled.setSimpleTime( pTimeScheduled );
    }

    private static class AttributeAccessor_TimeScheduled extends AttributeAccessorSCDsimplePersistedRegular<DBAttributeSamples>
    {
        public AttributeAccessor_TimeScheduled()
        {
            super( "TimeScheduled", "TimeScheduled", false, _SimpleTime );
        }

        @Override
        public Object getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.getTimeScheduled();
        }

        @Override
        public void setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.setTimeScheduled( to_SimpleTime( TimeRes.ToMIN, pValue ) );
        }

        @Override
        public Object db_getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.mTimeScheduled.get_java_sql_Time();
        }

        @Override
        public void db_setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.mTimeScheduled.set_java_sql_Time( to_SqlTime( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_DateOrdered = new AttributeAccessor_DateOrdered();

    LazyEvalSimpleDate mDateOrdered = new LazyEvalSimpleDate();

    public CalendarYMD getDateOrdered()
    {
        return mDateOrdered.getCalendarYMD();
    }

    public void setDateOrdered( CalendarYMD pDateOrdered )
    {
        verifyMutability( CD_DateOrdered, mDateOrdered.getCalendarYMD(), pDateOrdered );
        mDateOrdered.setCalendarYMD( pDateOrdered );
    }

    private static class AttributeAccessor_DateOrdered extends AttributeAccessorSCDsimplePersistedRegular<DBAttributeSamples>
    {
        public AttributeAccessor_DateOrdered()
        {
            super( "DateOrdered", "DateOrdered", false, _SimpleDate );
        }

        @Override
        public Object getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.getDateOrdered();
        }

        @Override
        public void setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.setDateOrdered( to_SimpleDate( pPO.mDateOrdered.getDateRes(), pValue ) );
        }

        @Override
        public Object db_getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.mDateOrdered.getPersistFormSimpleDate();
        }

        @Override
        public void db_setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.mDateOrdered.setPersistFormSimpleDate( to_String( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_OrderProcessed = new AttributeAccessor_OrderProcessed();

    final LazyEvalSimpleTimestamp mOrderProcessed = new LazyEvalSimpleTimestamp();

    public SimpleTimestamp getOrderProcessed()
    {
        return mOrderProcessed.getSimpleTimestamp();
    }

    public void setOrderProcessed( SimpleTimestamp pOrderProcessed )
    {
        verifyMutability( CD_OrderProcessed, mOrderProcessed.getSimpleTimestamp(), pOrderProcessed );
        mOrderProcessed.setSimpleTimestamp( pOrderProcessed );
    }

    private static class AttributeAccessor_OrderProcessed extends AttributeAccessorSCDsimplePersistedRegular<DBAttributeSamples>
    {
        public AttributeAccessor_OrderProcessed()
        {
            super( "OrderProcessed", "OrderProcessed", false, _SimpleTimestamp );
        }

        @Override
        public Object getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.getOrderProcessed();
        }

        @Override
        public void setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.setOrderProcessed( to_SimpleTimestamp( TimeRes.ToMSEC, pValue ) );
        }

        @Override
        public Object db_getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.mOrderProcessed.get_java_sql_Timestamp();
        }

        @Override
        public void db_setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.mOrderProcessed.set_java_sql_Timestamp( to_Timestamp( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_Friends = new AttributeAccessor_Friends();

    private Long mFriends = null;

    public Long getFriends()
    {
        return mFriends;
    }

    public void setFriends( Long pFriends )
    {
        verifyMutability( CD_Friends, mFriends, pFriends );
        mFriends = pFriends;
    }

    private static class AttributeAccessor_Friends extends AttributeAccessorSCDsimplePersistedRegular<DBAttributeSamples>
    {
        public AttributeAccessor_Friends()
        {
            super( "Friends", "Friends", false, _Long.with( MaxLength.of( 8 ) ) );
        }

        @Override
        public Object getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.getFriends();
        }

        @Override
        public void setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.setFriends( to_Long( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_AcreageFloat = new AttributeAccessor_AcreageFloat();

    private Float mAcreageFloat = null;

    public Float getAcreageFloat()
    {
        return mAcreageFloat;
    }

    public void setAcreageFloat( Float pAcreageFloat )
    {
        verifyMutability( CD_AcreageFloat, mAcreageFloat, pAcreageFloat );
        mAcreageFloat = pAcreageFloat;
    }

    private static class AttributeAccessor_AcreageFloat extends AttributeAccessorSCDsimplePersistedRegular<DBAttributeSamples>
    {
        public AttributeAccessor_AcreageFloat()
        {
            super( "AcreageFloat", "AcreageFloat", true, _Float.with( MaxLength.of( 16 ), //
                                                                      FormatControl.of( "#.#" ), //
                                                                      MinDisplayDecimalPlaces.of( 2 ) ) );
        }

        @Override
        public Object getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.getAcreageFloat();
        }

        @Override
        public void setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.setAcreageFloat( to_Float( pValue ) );
        }
    }

    public static final AttributeAccessorSCD CD_AcreageDouble = new AttributeAccessor_AcreageDouble();

    private Double mAcreageDouble = null;

    public Double getAcreageDouble()
    {
        return mAcreageDouble;
    }

    public void setAcreageDouble( Double pAcreageDouble )
    {
        verifyMutability( CD_AcreageDouble, mAcreageDouble, pAcreageDouble );
        mAcreageDouble = pAcreageDouble;
    }

    private static class AttributeAccessor_AcreageDouble extends AttributeAccessorSCDsimplePersistedRegular<DBAttributeSamples>
    {
        public AttributeAccessor_AcreageDouble()
        {
            super( "AcreageDouble", "AcreageDouble", false, _Double.with( MaxLength.of( 16 ), //
                                                                          FormatControl.of( "#.#" ), //
                                                                          MinDisplayDecimalPlaces.of( 2 ) ) );
        }

        @Override
        public Object getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.getAcreageDouble();
        }

        @Override
        public void setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.setAcreageDouble( to_Double( pValue ) );
        }
    }

    public static final AttributeAccessorSCDtoOneRegular<DBAttributeSamples, DBAttributeSamples> CD_Parent = new AttributeAccessor_Parent();

    protected LazyLoadToOneRegular<DBAttributeSamples, DBAttributeSamples> mParent = //
            new LazyLoadToOneRegular<DBAttributeSamples, DBAttributeSamples>( (DBAttributeSamples) this, CD_Parent );

    public DBAttributeSamples getParent()
    {
        return processLazyLoadAccess( mParent );
    }

    public void setParent( DBAttributeSamples pParent )
    {
        processLazyLoadMutation( mParent, pParent );
    }

    private static class AttributeAccessor_Parent extends AttributeAccessorSCDtoOneRegular<DBAttributeSamples, DBAttributeSamples>
    {
        public AttributeAccessor_Parent()
        {
            super( "Parent", "parent_id", DBAttributeSamples.class, "ID", "DBAttributeSamplesSetForParent", false, false, Mutability.RW );
        }

        @Override
        public LazyLoadToOneRegular<DBAttributeSamples, DBAttributeSamples> getValueHolder( DBAttributeSamples pPO )
        {
            return pPO.mParent;
        }

        @Override
        public Object getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.getParent();
        }

        @Override
        public void setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.setParent( to_PO( pPO, DBAttributeSamples.class, pValue ) );
        }

        @Override
        public Object db_getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.mParent.db_getValue();
        }

        @Override
        public void db_setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.mParent.db_setValue( to_Long( pValue ) );
        }
    }

    public static final AttributeAccessorSCDtoManyRegular<DBAttributeSamples, DBAttributeSamples> CD_DBAttributeSamplesSetForParent = new AttributeAccessor_DBAttributeSamplesSetForParent();

    protected LazyLoadToManyRegular<DBAttributeSamples, DBAttributeSamples> mDBAttributeSamplesSetForParent = //
            new LazyLoadToManyRegular<DBAttributeSamples, DBAttributeSamples>( (DBAttributeSamples) this, CD_DBAttributeSamplesSetForParent );

    public List<DBAttributeSamples> getDBAttributeSamplesSetForParent()
    {
        return processLazyLoadAccess( mDBAttributeSamplesSetForParent );
    }

    public void setDBAttributeSamplesSetForParent( List<DBAttributeSamples> pDBAttributeSamplesSetForParent )
    {
        processLazyLoadMutation( mDBAttributeSamplesSetForParent, pDBAttributeSamplesSetForParent );
    }

    public void addDBAttributeSamplesSetForParent( DBAttributeSamples pDBAttributeSamplesSetForParent )
    {
        processLazyLoadMutationAdd( mDBAttributeSamplesSetForParent, pDBAttributeSamplesSetForParent );
    }

    public void removeDBAttributeSamplesSetForParent( DBAttributeSamples pDBAttributeSamplesSetForParent )
    {
        processLazyLoadMutationRemove( mDBAttributeSamplesSetForParent, pDBAttributeSamplesSetForParent );
    }

    private static class AttributeAccessor_DBAttributeSamplesSetForParent extends AttributeAccessorSCDtoManyRegular<DBAttributeSamples, DBAttributeSamples>
    {
        public AttributeAccessor_DBAttributeSamplesSetForParent()
        {
            super( "DBAttributeSamplesSetForParent", "ID", DBAttributeSamples.class, "Parent", "Name", Mutability.RW, false, true );
        }

        @Override
        public LazyLoadToManyRegular<DBAttributeSamples, DBAttributeSamples> getValueHolder( DBAttributeSamples pPO )
        {
            return pPO.mDBAttributeSamplesSetForParent;
        }

        @Override
        public Object getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.getDBAttributeSamplesSetForParent();
        }

        @Override
        public void setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.setDBAttributeSamplesSetForParent( to_POs( pPO, DBAttributeSamples.class, pValue ) );
        }

        @Override
        public void addValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.addDBAttributeSamplesSetForParent( to_PO( pPO, DBAttributeSamples.class, pValue ) );
        }

        @Override
        public void removeValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.removeDBAttributeSamplesSetForParent( to_PO( pPO, DBAttributeSamples.class, pValue ) );
        }
    }

    public static final AttributeAccessorSCDtoOneVirtual<DBAttributeSamples, DBAttributeSamples> CD_VirtualSample = new AttributeAccessor_VirtualSample();

    abstract public DBAttributeSamples getVirtualSample();

    abstract protected void LLclearVirtualSample();

    abstract protected void LLsetVirtualSample( DBAttributeSamples pVirtualSample );

    public final void setVirtualSample( DBAttributeSamples pVirtualSample )
    {
        verifyMutability( CD_VirtualSample, getVirtualSample(), pVirtualSample );
        LLsetVirtualSample( pVirtualSample );
    }

    private static class AttributeAccessor_VirtualSample extends AttributeAccessorSCDtoOneVirtual<DBAttributeSamples, DBAttributeSamples>
    {
        public AttributeAccessor_VirtualSample()
        {
            super( "VirtualSample", DBAttributeSamples.class, false, Mutability.RW );
        }

        @Override
        public Object getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.getVirtualSample();
        }

        @Override
        public void setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.setVirtualSample( to_PO( pPO, DBAttributeSamples.class, pValue ) );
        }

        @Override
        protected void LL_clearVirtualValueOnPO( DBAttributeSamples pPO )
        {
            pPO.LLclearVirtualSample();
        }
    }

    public static final AttributeAccessorSCD CD_VirtualFriends = new AttributeAccessor_VirtualFriends();

    abstract public Long getVirtualFriends();

    abstract protected void LLclearVirtualFriends();

    abstract protected void LLsetVirtualFriends( Long pVirtualFriends );

    public void setVirtualFriends( Long pVirtualFriends )
    {
        verifyMutability( CD_VirtualFriends, getVirtualFriends(), pVirtualFriends );
        LLsetVirtualFriends( pVirtualFriends );
    }

    private static class AttributeAccessor_VirtualFriends extends AttributeAccessorSCDsimpleVirtualRegular<DBAttributeSamples>
    {
        public AttributeAccessor_VirtualFriends()
        {
            super( "VirtualFriends", false, _Long.with( MaxLength.of( 8 ) ) );
        }

        @Override
        public Object getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.getVirtualFriends();
        }

        @Override
        public void setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.setVirtualFriends( to_Long( pValue ) );
        }

        @Override
        protected void LL_clearVirtualValueOnPO( DBAttributeSamples pPO )
        {
            pPO.LLclearVirtualFriends();
        }
    }

    public static final AttributeAccessorSCDtoBlob<DBAttributeSamples> CD_Attachment = new AttributeAccessor_Attachment();

    protected BlobHandler<DBAttributeSamples> mAttachment = new BlobHandler<DBAttributeSamples>( (DBAttributeSamples) this, CD_Attachment );

    public SizeableStreamAccessor getAttachmentAccessor()
    {
        return mAttachment;
    }

    private static class AttributeAccessor_Attachment extends AttributeAccessorSCDtoBlob<DBAttributeSamples>
    {
        public AttributeAccessor_Attachment()
        {
            super( "Attachment", "attachment_id", false, Mutability.RW );
        }

        @Override
        public BlobHandler<DBAttributeSamples> getValueHolder( DBAttributeSamples pPO )
        {
            return pPO.mAttachment;
        }

        @Override
        public Object db_getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.mAttachment.db_getValue();
        }

        @Override
        public void db_setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.mAttachment.db_setValue( to_Long( pValue ) );
        }
    }

    public static final AttributeAccessorSCDtoOneRegular<DBAttributeSamples, DBSampleImage> CD_ImageOne = new AttributeAccessor_ImageOne();

    protected LazyLoadToOneRegular<DBAttributeSamples, DBSampleImage> mImageOne = new LazyLoadToOneRegular<DBAttributeSamples, DBSampleImage>( (DBAttributeSamples) this, CD_ImageOne );

    public DBSampleImage getImageOne()
    {
        return processLazyLoadAccess( mImageOne );
    }

    public void setImageOne( DBSampleImage pImageOne )
    {
        processLazyLoadMutation( mImageOne, pImageOne );
    }

    private static class AttributeAccessor_ImageOne extends AttributeAccessorSCDtoOneRegular<DBAttributeSamples, DBSampleImage>
    {
        public AttributeAccessor_ImageOne()
        {
            super( "ImageOne", "ImageOne_id", DBSampleImage.class, "ID", "DBAttributeSamplesSetForImageOne", false, false, Mutability.RW );
        }

        @Override
        public LazyLoadToOneRegular<DBAttributeSamples, DBSampleImage> getValueHolder( DBAttributeSamples pPO )
        {
            return pPO.mImageOne;
        }

        @Override
        public Object getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.getImageOne();
        }

        @Override
        public void setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.setImageOne( to_PO( pPO, DBSampleImage.class, pValue ) );
        }

        @Override
        public Object db_getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.mImageOne.db_getValue();
        }

        @Override
        public void db_setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.mImageOne.db_setValue( to_Long( pValue ) );
        }

        @Override
        public boolean changedPOflagsPeerChanged()
        {
            return true;
        }
    }

    public static final AttributeAccessorSCDtoOneRegular<DBAttributeSamples, DBSampleImage> CD_ImageTwo = new AttributeAccessor_ImageTwo();

    protected LazyLoadToOneRegular<DBAttributeSamples, DBSampleImage> mImageTwo = new LazyLoadToOneRegular<DBAttributeSamples, DBSampleImage>( (DBAttributeSamples) this, CD_ImageTwo );

    public DBSampleImage getImageTwo()
    {
        return processLazyLoadAccess( mImageTwo );
    }

    public void setImageTwo( DBSampleImage pImageTwo )
    {
        processLazyLoadMutation( mImageTwo, pImageTwo );
    }

    private static class AttributeAccessor_ImageTwo extends AttributeAccessorSCDtoOneRegular<DBAttributeSamples, DBSampleImage>
    {
        public AttributeAccessor_ImageTwo()
        {
            super( "ImageTwo", "ImageTwo_id", DBSampleImage.class, "ID", "DBAttributeSamplesSetForImageTwo", false, false, Mutability.RW );
        }

        @Override
        public LazyLoadToOneRegular<DBAttributeSamples, DBSampleImage> getValueHolder( DBAttributeSamples pPO )
        {
            return pPO.mImageTwo;
        }

        @Override
        public Object getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.getImageTwo();
        }

        @Override
        public void setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.setImageTwo( to_PO( pPO, DBSampleImage.class, pValue ) );
        }

        @Override
        public Object db_getValueOnPO( DBAttributeSamples pPO )
        {
            return pPO.mImageTwo.db_getValue();
        }

        @Override
        public void db_setValueOnPO( DBAttributeSamples pPO, Object pValue )
        {
            pPO.mImageTwo.db_setValue( to_Long( pValue ) );
        }

        @Override
        public boolean changedPOflagsPeerChanged()
        {
            return true;
        }
    }

    static class MyMetaData extends PersistentObjectImplMetaData<DBAttributeSamples>
    {
        public static final String OBJECT_NAME = "DBAttributeSamples";
        public static final String TABLE_NAME = "DBAttributeSamples";

        MyMetaData()
        {
            super( MyMetaData.OBJECT_NAME, MyMetaData.TABLE_NAME, //
                   new AttributeAccessorKeySet( CD_ID ), //
                   CD_ID, //

                   CD_AcreageDouble, //
                   CD_AcreageFloat, //
                   CD_Alias, //
                   CD_Attachment, //
                   CD_Constrained, //
                   CD_DateOrdered, //
                   CD_Description, //
                   CD_Friends, //
                   CD_Member, //
                   CD_Name, //
                   CD_Number, //
                   CD_OrderProcessed, //
                   CD_Paid, //
                   CD_Password, //
                   CD_RecordVersion, //
                   CD_Shipped, //
                   CD_Status, //
                   CD_TimeScheduled, //
                   CD_URL, //
                   CD_VirtualFriends, //

                   CD_Parent, //
                   CD_VirtualSample, //
                   CD_ImageOne, //
                   CD_ImageTwo, //

                   CD_DBAttributeSamplesSetForParent );
            setIndexes( new Index( "DBAttributeSamplesIDX1", null, true, CD_Name ) );
        }

        @Override
        public Class getPOclass()
        {
            return DBAttributeSamples.class;
        }

        @Override
        public DBAttributeSamples createNew( Transaction pTransaction )
        {
            return new DBAttributeSamples( pTransaction );
        }

        @Override
        public DBAttributeSamples createPOfromFinder()
        {
            return new DBAttributeSamples( CONSTRUCTION_CONTROL );
        }

        @Override
        public String getRecordVersionAttributeName()
        {
            return CD_RecordVersion.getName();
        }

        @Override
        public String getDisplayValueFormat()
        {
            return "${Name}";
        }
    }
}