package org.litesoft.prioritizer.server.pos;

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

public abstract class StoryUpdateGO
        extends org.litesoft.orsup.nonpublic.PersistentObjectImpl<StoryUpdate>
        implements HasAttributes {
    private static final ConstructionControl CONSTRUCTION_CONTROL = new ConstructionControl();

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

    protected StoryUpdateGO( Transaction pTransaction ) {
        super( StoryUpdateMetaData.INSTANCE, pTransaction );
        mID = getNextSequenceNumber( getClass() );
        registerWithTransaction();
        setDefaults();
    }

    protected StoryUpdateGO( ConstructionControl pConstructionControl ) {
        super( StoryUpdateMetaData.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<StoryUpdate> {
        public AttributeAccessor_RecordVersion() {
            super( "RecordVersion", "RecordVersion" );
        }

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

    public static final AttributeAccessorSCD CD_Created = new AttributeAccessor_Created();

    final org.litesoft.orsup.lazyeval.LazyEvalSimpleTimestamp mCreated = new org.litesoft.orsup.lazyeval.LazyEvalSimpleTimestamp();

    public org.litesoft.core.simpletypes.temporal.SimpleTimestamp getCreated() {
        return mCreated.getSimpleTimestamp();
    }

    protected void LLsetCreated( org.litesoft.core.simpletypes.temporal.SimpleTimestamp pCreated ) {
        verifyMutability( CD_Created, mCreated.getSimpleTimestamp(), pCreated );
        mCreated.setSimpleTimestamp( pCreated );
    }

    private static class AttributeAccessor_Created
            extends AttributeAccessorSCDsimplePersistedSysSetOnly<StoryUpdate>
            implements NonImportableFeature {
        public AttributeAccessor_Created() {
            super( "Created", "Created", true, _SimpleTimestamp.RO() );
        }

        @Override
        public Object getValueOnPO( StoryUpdate pPO ) {
            return pPO.getCreated();
        }

        @Override
        public Object db_getValueOnPO( StoryUpdate pPO ) {
            return pPO.mCreated.get_java_sql_Timestamp();
        }

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

    public static final AttributeAccessorSCD CD_ID = new AttributeAccessor_ID();

    private Long mID;

    public Long getID() {
        return mID;
    }

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

    private static class AttributeAccessor_ID
            extends AttributeAccessorSCDsimplePersistedSysSetOnly<StoryUpdate>
            implements NonImportableFeature {
        public AttributeAccessor_ID() {
            super( "ID", "ID", false, _Long.AddOnly() );
        }

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

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

    public static final AttributeAccessorSCDtoOneRegular<StoryUpdate, User> CD_ByWhom = new AttributeAccessor_ByWhom();

    protected org.litesoft.orsup.lazyload.LazyLoadToOneRegular<StoryUpdate, User> mByWhom = //
            new org.litesoft.orsup.lazyload.LazyLoadToOneRegular<StoryUpdate, User>( (StoryUpdate) this, CD_ByWhom );

    public User getByWhom() {
        return processLazyLoadAccess( mByWhom );
    }

    public void setByWhom( User pByWhom ) {
        processLazyLoadMutation( mByWhom, pByWhom );
    }

    private static class AttributeAccessor_ByWhom
            extends AttributeAccessorSCDtoOneRegular<StoryUpdate, User> {
        public AttributeAccessor_ByWhom() {
            super( "ByWhom", "ByWhom_id", User.class, "ID", "StoryUpdates", false, true, Mutability.RW );
        }

        @Override
        public org.litesoft.orsup.lazyload.LazyLoadToOneRegular<StoryUpdate, User> getValueHolder( StoryUpdate pPO ) {
            return pPO.mByWhom;
        }

        @Override
        public Object getValueOnPO( StoryUpdate pPO ) {
            return pPO.getByWhom();
        }

        @Override
        public void setValueOnPO( StoryUpdate pPO, Object pValue ) {
            pPO.setByWhom( to_PO( pPO, User.class, pValue ) );
        }

        @Override
        public Object db_getValueOnPO( StoryUpdate pPO ) {
            return pPO.mByWhom.db_getValue();
        }

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

    public static final AttributeAccessorSCDtoOneRegular<StoryUpdate, Story> CD_Story = new AttributeAccessor_Story();

    protected org.litesoft.orsup.lazyload.LazyLoadToOneRegular<StoryUpdate, Story> mStory = //
            new org.litesoft.orsup.lazyload.LazyLoadToOneRegular<StoryUpdate, Story>( (StoryUpdate) this, CD_Story );

    public Story getStory() {
        return processLazyLoadAccess( mStory );
    }

    public void setStory( Story pStory ) {
        processLazyLoadMutation( mStory, pStory );
    }

    private static class AttributeAccessor_Story
            extends AttributeAccessorSCDtoOneRegular<StoryUpdate, Story> {
        public AttributeAccessor_Story() {
            super( "Story", "Story_id", Story.class, "ID", "Updates", false, true, Mutability.RW );
        }

        @Override
        public org.litesoft.orsup.lazyload.LazyLoadToOneRegular<StoryUpdate, Story> getValueHolder( StoryUpdate pPO ) {
            return pPO.mStory;
        }

        @Override
        public Object getValueOnPO( StoryUpdate pPO ) {
            return pPO.getStory();
        }

        @Override
        public void setValueOnPO( StoryUpdate pPO, Object pValue ) {
            pPO.setStory( to_PO( pPO, Story.class, pValue ) );
        }

        @Override
        public Object db_getValueOnPO( StoryUpdate pPO ) {
            return pPO.mStory.db_getValue();
        }

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

    public static final AttributeAccessorSCDtoManyRegular<StoryUpdate, StoryChange> CD_Changes = new AttributeAccessor_Changes();

    protected org.litesoft.orsup.lazyload.LazyLoadToManyRegular<StoryUpdate, StoryChange> mChanges = //
            new org.litesoft.orsup.lazyload.LazyLoadToManyRegular<StoryUpdate, StoryChange>( (StoryUpdate) this, CD_Changes );

    public java.util.List<StoryChange> getChanges() {
        return processLazyLoadAccess( mChanges );
    }

    public void setChanges( java.util.List<StoryChange> pChanges ) {
        processLazyLoadMutation( mChanges, pChanges );
    }

    public void addChanges( StoryChange pChanges ) {
        processLazyLoadMutationAdd( mChanges, pChanges );
    }

    public void removeChanges( StoryChange pChanges ) {
        processLazyLoadMutationRemove( mChanges, pChanges );
    }

    private static class AttributeAccessor_Changes
            extends AttributeAccessorSCDtoManyRegular<StoryUpdate, StoryChange> {
        public AttributeAccessor_Changes() {
            super( "Changes", "ID", StoryChange.class, "Update", null, Mutability.RW, false, true );
        }

        @Override
        public org.litesoft.orsup.lazyload.LazyLoadToManyRegular<StoryUpdate, StoryChange> getValueHolder( StoryUpdate pPO ) {
            return pPO.mChanges;
        }

        @Override
        public Object getValueOnPO( StoryUpdate pPO ) {
            return pPO.getChanges();
        }

        @Override
        public void setValueOnPO( StoryUpdate pPO, Object pValue ) {
            pPO.setChanges( to_POs( pPO, StoryChange.class, pValue ) );
        }

        @Override
        public void addValueOnPO( StoryUpdate pPO, Object pValue ) {
            pPO.addChanges( to_PO( pPO, StoryChange.class, pValue ) );
        }

        @Override
        public void removeValueOnPO( StoryUpdate pPO, Object pValue ) {
            pPO.removeChanges( to_PO( pPO, StoryChange.class, pValue ) );
        }
    }

    static class MyMetaData
            extends org.litesoft.orsup.nonpublic.PersistentObjectImplMetaData<StoryUpdate> {
        public static final String OBJECT_NAME = "StoryUpdate";
        public static final String TABLE_NAME = "StoryUpdate";

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

                   CD_RecordVersion, /* .. */

                   CD_ID, /* ............. */

                   // Injected
                   CD_Created, /* ........ Required */

                   // ToOne
                   CD_ByWhom, /* ......... Required */
                   CD_Story, /* .......... Required */

                   // ToMany
                   CD_Changes /* ......... */ );
            setIndexes( new Index( "StoryUpdate21AIDX2", null, false, CD_Story ), //
                        new Index( "StoryUpdate21AIDX1", null, false, CD_ByWhom ) );
        }

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

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

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

        @Override
        public String getDisplayValueFormat() {
            return null;
        }

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

        @Override
        public String getDefaultOrderByAttributeName() {
            return "!Created";
        }

        @Override
        public String getCreationTimestampAttributeName() {
            return CD_Created.getName();
        }

        @Override
        protected void setCreationTimestamp( StoryUpdate pPersistentObject, java.sql.Timestamp pTransactionTimeStamp ) {
            pPersistentObject.LLsetCreated( TypeConverter.to_SimpleTimestamp( pTransactionTimeStamp ) );
        }
    }
}