package org.litesoft.datt.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 ReportRestrictedResourceCommonGO
        extends Report<ReportRestrictedResourceCommon>
        implements HasAttributes {
    private static final ConstructionControl CONSTRUCTION_CONTROL = new ConstructionControl();

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

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

    protected ReportRestrictedResourceCommonGO( ConstructionControl pConstructionControl ) {
        super( ReportRestrictedResourceCommonMetaData.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<ReportRestrictedResourceCommon> {
        public AttributeAccessor_RecordVersion() {
            super( "RecordVersion", "RecordVersion" );
        }

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

    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<ReportRestrictedResourceCommon>
            implements NonImportableFeature {
        public AttributeAccessor_ID() {
            super( "ID", "ID", false, _Long.AddOnly() );
        }

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

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

    public static final AttributeAccessorSCDtoOneCommonPaired<ReportRestrictedResourceCommon> CD_SpecificReport = new AttributeAccessor_SpecificReport();

    protected org.litesoft.orsup.lazyload.LazyLoadToOneCommonPaired<ReportRestrictedResourceCommon> mSpecificReport = //
            new org.litesoft.orsup.lazyload.LazyLoadToOneCommonPaired<ReportRestrictedResourceCommon>( (ReportRestrictedResourceCommon) this, CD_SpecificReport );

    public org.litesoft.orsup.nonpublic.PersistentObjectImpl getSpecificReport() {
        return processLazyLoadAccess( mSpecificReport );
    }

    public void setSpecificReport( org.litesoft.orsup.nonpublic.PersistentObjectImpl pSpecificReport ) {
        processLazyLoadMutation( mSpecificReport, pSpecificReport );
    }

    protected void replacingSpecificReport( org.litesoft.orsup.nonpublic.PersistentObjectImpl pOldSpecificReport,
                                            org.litesoft.orsup.nonpublic.PersistentObjectImpl pNewSpecificReport ) {
    }

    private static class AttributeAccessor_SpecificReport
            extends AttributeAccessorSCDtoOneCommonPaired<ReportRestrictedResourceCommon> {
        public AttributeAccessor_SpecificReport() {
            super( "SpecificReport", "SpecificReport" );
        }

        @Override
        public org.litesoft.orsup.lazyload.LazyLoadToOneCommonPaired<ReportRestrictedResourceCommon> getValueHolder( ReportRestrictedResourceCommon pPO ) {
            return pPO.mSpecificReport;
        }

        @Override
        public Object getValueOnPO( ReportRestrictedResourceCommon pPO ) {
            return pPO.getSpecificReport();
        }

        @Override
        public void setValueOnPO( ReportRestrictedResourceCommon pPO, Object pValue ) {
            pPO.setSpecificReport( (org.litesoft.orsup.nonpublic.PersistentObjectImpl) pValue );
        }

        @Override
        public void pairReplaced( ReportRestrictedResourceCommon pPO, org.litesoft.orsup.nonpublic.PersistentObjectImpl pOldSpecificReport,
                                  org.litesoft.orsup.nonpublic.PersistentObjectImpl pNewSpecificReport ) {
            pPO.replacingSpecificReport( pOldSpecificReport, pNewSpecificReport );
        }
    }

    public static final AttributeAccessorSCDtoOneRegular<ReportRestrictedResourceCommon, RestrictedResource> CD_RestrictedResource =
            new AttributeAccessor_RestrictedResource();

    protected org.litesoft.orsup.lazyload.LazyLoadToOneRegular<ReportRestrictedResourceCommon, RestrictedResource> mRestrictedResource = //
            new org.litesoft.orsup.lazyload.LazyLoadToOneRegular<ReportRestrictedResourceCommon, RestrictedResource>( (ReportRestrictedResourceCommon) this,
                                                                                                                      CD_RestrictedResource );

    public RestrictedResource getRestrictedResource() {
        return processLazyLoadAccess( mRestrictedResource );
    }

    public void setRestrictedResource( RestrictedResource pRestrictedResource ) {
        processLazyLoadMutation( mRestrictedResource, pRestrictedResource );
    }

    private static class AttributeAccessor_RestrictedResource
            extends AttributeAccessorSCDtoOneRegular<ReportRestrictedResourceCommon, RestrictedResource> {
        public AttributeAccessor_RestrictedResource() {
            super( "RestrictedResource", "RestrictedResource_id", RestrictedResource.class, "ID", "Reports", false, true, Mutability.RW );
        }

        @Override
        public org.litesoft.orsup.lazyload.LazyLoadToOneRegular<ReportRestrictedResourceCommon, RestrictedResource> getValueHolder(
                ReportRestrictedResourceCommon pPO ) {
            return pPO.mRestrictedResource;
        }

        @Override
        public Object getValueOnPO( ReportRestrictedResourceCommon pPO ) {
            return pPO.getRestrictedResource();
        }

        @Override
        public void setValueOnPO( ReportRestrictedResourceCommon pPO, Object pValue ) {
            pPO.setRestrictedResource( to_PO( pPO, RestrictedResource.class, pValue ) );
        }

        @Override
        public Object db_getValueOnPO( ReportRestrictedResourceCommon pPO ) {
            return pPO.mRestrictedResource.db_getValue();
        }

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

    static class MyMetaData
            extends ReportMetaData<ReportRestrictedResourceCommon> {
        public static final String OBJECT_NAME = "ReportRestrictedResourceCommon";
        public static final String TABLE_NAME = "ReportRestrictedResourceCommon";

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

                   CD_RecordVersion, /* ....... */

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

                   // Paired
                   CD_SpecificReport, /* ...... Required */

                   // ToOne
                   CD_RestrictedResource /* ... Required */ );
            setIndexes( new Index( "ReportRestrictedResourceCommon21AIDX2", null, false, CD_RestrictedResource ), //
                        new Index( "ReportRestrictedResourceCommon21AIDX1", null, false, CD_SpecificReport ) );
        }

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

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

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

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

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