package org.litesoft.initfrom.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 DeviceGO
        extends org.litesoft.orsup.nonpublic.PersistentObjectImpl<Device>
        implements HasAttributes {
    private static final ConstructionControl CONSTRUCTION_CONTROL = new ConstructionControl();

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

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

    protected DeviceGO( ConstructionControl pConstructionControl ) {
        super( DeviceMetaData.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<Device> {
        public AttributeAccessor_RecordVersion() {
            super( "RecordVersion", "RecordVersion" );
        }

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

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

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

    public static final AttributeAccessorSCD CD_Hostname = new AttributeAccessor_Hostname();

    private String mHostname;

    public String getHostname() {
        return mHostname;
    }

    public void setHostname( String pHostname ) {
        verifyMutability( CD_Hostname, mHostname, pHostname );
        mHostname = pHostname;
    }

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

        @Override
        public Object getValueOnPO( Device pPO ) {
            return pPO.getHostname();
        }

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

    public static final AttributeAccessorSCD CD_Location = new AttributeAccessor_Location();

    private String mLocation;

    public String getLocation() {
        return mLocation;
    }

    public void setLocation( String pLocation ) {
        verifyMutability( CD_Location, mLocation, pLocation );
        mLocation = pLocation;
    }

    private static class AttributeAccessor_Location
            extends AttributeAccessorSCDsimplePersistedRegular<Device> {
        public AttributeAccessor_Location() {
            super( "Location", "Location", false, _String.with( MaxLength.of( 40 ), //
                                                                DisplayLength.of( 20 ) ) );
        }

        @Override
        public Object getValueOnPO( Device pPO ) {
            return pPO.getLocation();
        }

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

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

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

                   CD_RecordVersion, /* .. */

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

                   // Regular
                   CD_Hostname, /* ....... Required */
                   CD_Location /* ........ */ );
            setIndexes( new Index( "DeviceMUGIDX1", null, true, CD_Hostname ) );
        }

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

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

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

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

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