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 PhoneGO
        extends org.litesoft.orsup.nonpublic.PersistentObjectImpl<Phone>
        implements HasAttributes {
    public static final String[] sValidOptionsType = //
            { //
              PhoneNames.poType_Home, //
              PhoneNames.poType_Work, //
              PhoneNames.poType_Cell, //
              PhoneNames.poType_Fax, //
              PhoneNames.poType_Skype, //
            };

    private static final ConstructionControl CONSTRUCTION_CONTROL = new ConstructionControl();

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

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

    protected PhoneGO( ConstructionControl pConstructionControl ) {
        super( PhoneMetaData.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<Phone> {
        public AttributeAccessor_RecordVersion() {
            super( "RecordVersion", "RecordVersion" );
        }

        @Override
        protected RecordVersionHelper getRecordVersionHelper( Phone 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<Phone>
            implements NonImportableFeature {
        public AttributeAccessor_ID() {
            super( "ID", "ID", false, _Long.AddOnly() );
        }

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

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

    public static final AttributeAccessorSCDtoOneVariable<Phone> CD_Owner = new AttributeAccessor_Owner();

    protected org.litesoft.orsup.lazyload.LazyLoadToOneVariable<Phone> mOwner = //
            new org.litesoft.orsup.lazyload.LazyLoadToOneVariable<Phone>( (Phone) this, CD_Owner );

    public org.litesoft.orsup.nonpublic.PersistentObjectImpl getOwner() {
        return processLazyLoadAccess( mOwner );
    }

    private static class AttributeAccessor_Owner
            extends AttributeAccessorSCDtoOneVariable<Phone> {
        public AttributeAccessor_Owner() {
            super( "Owner", "Owner", true, Mutability.RW );
        }

        @Override
        public org.litesoft.orsup.lazyload.LazyLoadToOneVariable<Phone> getValueHolder( Phone pPO ) {
            return pPO.mOwner;
        }

        @Override
        public Object getValueOnPO( Phone pPO ) {
            return pPO.getOwner();
        }
    }

    public static final AttributeAccessorSCD CD_PhoneNumber = new AttributeAccessor_PhoneNumber();

    private String mPhoneNumber;

    public String getPhoneNumber() {
        return mPhoneNumber;
    }

    public void setPhoneNumber( String pPhoneNumber ) {
        verifyMutability( CD_PhoneNumber, mPhoneNumber, pPhoneNumber );
        mPhoneNumber = pPhoneNumber;
    }

    private static class AttributeAccessor_PhoneNumber
            extends AttributeAccessorSCDsimplePersistedRegular<Phone> {
        public AttributeAccessor_PhoneNumber() {
            super( "PhoneNumber", "PhoneNumber", true, _String.with( MaxLength.of( 40 ), //
                                                                     DisplayLength.of( 20 ) ) );
        }

        @Override
        public Object getValueOnPO( Phone pPO ) {
            return pPO.getPhoneNumber();
        }

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

    public static final AttributeAccessorSCD CD_Type = new AttributeAccessor_Type();

    private String mType;

    public String getType() {
        return mType;
    }

    public void setType( String pType ) {
        verifyMutability( CD_Type, mType, pType );
        mType = pType;
    }

    private static class AttributeAccessor_Type
            extends AttributeAccessorSCDsimplePersistedRegular<Phone> {
        public AttributeAccessor_Type() {
            super( "Type", "Type", true, _OpenValidOptions.with( Options.of( sValidOptionsType ) ) );
        }

        @Override
        public Object getValueOnPO( Phone pPO ) {
            return pPO.getType();
        }

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

    public static final AttributeAccessorSCD CD_ViewOrder = new AttributeAccessor_ViewOrder();

    private Float mViewOrder;

    public Float getViewOrder() {
        return mViewOrder;
    }

    public void setViewOrder( Float pViewOrder ) {
        verifyMutability( CD_ViewOrder, mViewOrder, pViewOrder );
        mViewOrder = pViewOrder;
    }

    private static class AttributeAccessor_ViewOrder
            extends AttributeAccessorSCDsimplePersistedRegular<Phone> {
        public AttributeAccessor_ViewOrder() {
            super( "ViewOrder", "ViewOrder", false, _Float.with( DisplayLength.of( 9 ) ) );
        }

        @Override
        public Object getValueOnPO( Phone pPO ) {
            return pPO.getViewOrder();
        }

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

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

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

                   CD_RecordVersion, /* .. */

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

                   // Regular
                   CD_PhoneNumber, /* .... Required */
                   CD_Type, /* ........... Required */
                   CD_ViewOrder, /* ...... */

                   // ToOne
                   CD_Owner /* ........... Required */ );
            setIndexes( new Index( "Phone21AIDX1", null, false, CD_Owner ) );
        }

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

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

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

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

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