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

import java.util.*;

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

public abstract class DBMortalPO extends DBAbstractMortality<DBMortal>
{
    private static final ConstructionControl CONSTRUCTION_CONTROL = new ConstructionControl();

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

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

    protected DBMortalPO( ConstructionControl pConstructionControl )
    {
        super( DBMortalMetaData.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<DBMortal>
    {
        public AttributeAccessor_RecordVersion()
        {
            super( "RecordVersion", "RecordVersion" );
        }

        protected RecordVersionHelper getRecordVersionHelper( DBMortal 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<DBMortal> implements NonImportableFeature
    {
        public AttributeAccessor_ID()
        {
            super( "ID", "id", true, _Long );
        }

        public Object getValueOnPO( DBMortal pPO )
        {
            return pPO.getID();
        }

        public void db_setValueOnPO( DBMortal pPO, Object pValue )
        {
            pPO.LLsetID( to_Long( pValue ) );
        }
    }

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

    protected LazyLoadToOneRegular<DBMortal, DBMortal> mParent = new LazyLoadToOneRegular<DBMortal, DBMortal>( (DBMortal) this, CD_Parent ); // Note: DBMortal is the related TO object

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

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

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

        public LazyLoadToOneRegular<DBMortal, DBMortal> getValueHolder( DBMortal pPO )
        {
            return pPO.mParent;
        }

        public Object getValueOnPO( DBMortal pPO )
        {
            return pPO.getParent();
        }

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

        public Object db_getValueOnPO( DBMortal pPO )
        {
            return pPO.mParent.db_getValue();
        }

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

        public boolean changedPOflagsPeerChangeNotification()
        {
            return true;
        }
    }

    public static final AttributeAccessorSCDtoManyRegular<DBMortal, DBMortal> CD_DBMortalSetForParent = new AttributeAccessor_DBMortalSetForParent();

    protected LazyLoadToManyRegular<DBMortal, DBMortal> mDBMortalSetForParent = new LazyLoadToManyRegular<DBMortal, DBMortal>( (DBMortal) this, CD_DBMortalSetForParent ); // Note: DBMortal is the related TO object

    public List<DBMortal> getDBMortalSetForParent()
    {
        return processLazyLoadAccess( mDBMortalSetForParent );
    }

    public void setDBMortalSetForParent( List<DBMortal> pDBMortalSetForParent )
    {
        processLazyLoadMutation( mDBMortalSetForParent, pDBMortalSetForParent );
    }

    public void addDBMortalSetForParent( DBMortal pDBMortalSetForParent )
    {
        processLazyLoadMutationAdd( mDBMortalSetForParent, pDBMortalSetForParent );
    }

    public void removeDBMortalSetForParent( DBMortal pDBMortalSetForParent )
    {
        processLazyLoadMutationRemove( mDBMortalSetForParent, pDBMortalSetForParent );
    }

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

        public LazyLoadToManyRegular<DBMortal, DBMortal> getValueHolder( DBMortal pPO )
        {
            return pPO.mDBMortalSetForParent;
        }

        public Object getValueOnPO( DBMortal pPO )
        {
            return pPO.getDBMortalSetForParent();
        }

        public void setValueOnPO( DBMortal pPO, Object pValue )
        {
            pPO.setDBMortalSetForParent( to_POs( pPO, DBMortal.class, pValue ) );
        }

        public void addValueOnPO( DBMortal pPO, Object pValue )
        {
            pPO.addDBMortalSetForParent( to_PO( pPO, DBMortal.class, pValue ) );
        }

        public void removeValueOnPO( DBMortal pPO, Object pValue )
        {
            pPO.removeDBMortalSetForParent( to_PO( pPO, DBMortal.class, pValue ) );
        }
    }

    static class MyMetaData extends DBAbstractMortalityMetaData<DBMortal>
    {
        public static final String OBJECT_NAME = "DBMortal";
        public static final String TABLE_NAME = "DBMortal";

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

                   CD_RecordVersion, //

                   CD_Parent, //

                   CD_DBMortalSetForParent );
            setIndexes( new Index( "DBMortalIDX1", null, true, CD_Name ) );
        }

        public Class getPOclass()
        {
            return DBMortal.class;
        }

        public DBMortal createNew( Transaction pTransaction )
        {
            return new DBMortal( pTransaction );
        }

        public DBMortal createPOfromFinder()
        {
            return new DBMortal( CONSTRUCTION_CONTROL );
        }

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

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