SortMixedRecordDataTypeExample.java Source code

Introduction

Here is the source code for SortMixedRecordDataTypeExample.java

Source

/*
J2ME: The Complete Reference
    
James Keogh
    
Publisher: McGraw-Hill
    
ISBN 0072227109
    
*/
//jad file (please verify the jar size)
/*
MIDlet-Name: SortMixedRecordDataTypeExample
MIDlet-Version: 1.0
MIDlet-Vendor: MyCompany
MIDlet-Jar-URL: SortMixedRecordDataTypeExample.jar
MIDlet-1: SortMixedRecordDataTypeExample, ,
       SortMixedRecordDataTypeExample
MicroEdition-Configuration: CLDC-1.0
MicroEdition-Profile: MIDP-1.0
MIDlet-JAR-SIZE: 100
    
*/

import javax.microedition.rms.*;
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import java.io.*;

public class SortMixedRecordDataTypeExample extends MIDlet implements CommandListener {
    private Display display;
    private Alert alert;
    private Form form;
    private Command exit;
    private Command start;
    private RecordStore recordstore = null;
    private RecordEnumeration recordEnumeration = null;
    private Comparator comparator = null;

    public SortMixedRecordDataTypeExample() {
        display = Display.getDisplay(this);
        exit = new Command("Exit", Command.SCREEN, 1);
        start = new Command("Start", Command.SCREEN, 1);
        form = new Form("Mixed RecordEnumeration");
        form.addCommand(exit);
        form.addCommand(start);
        form.setCommandListener(this);
    }

    public void startApp() {
        display.setCurrent(form);
    }

    public void pauseApp() {
    }

    public void destroyApp(boolean unconditional) {
    }

    public void commandAction(Command command, Displayable displayable) {
        if (command == exit) {
            destroyApp(true);
            notifyDestroyed();
        } else if (command == start) {
            try {
                recordstore = RecordStore.openRecordStore("myRecordStore", true);
            } catch (Exception error) {
                alert = new Alert("Error Creating", error.toString(), null, AlertType.WARNING);
                alert.setTimeout(Alert.FOREVER);
                display.setCurrent(alert);
            }
            try {
                byte[] outputRecord;
                String outputString[] = { "Mary", "Bob", "Adam" };
                int outputInteger[] = { 15, 10, 5 };
                ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
                DataOutputStream outputDataStream = new DataOutputStream(outputStream);
                for (int x = 0; x < 3; x++) {
                    outputDataStream.writeUTF(outputString[x]);
                    outputDataStream.writeInt(outputInteger[x]);
                    outputDataStream.flush();
                    outputRecord = outputStream.toByteArray();
                    recordstore.addRecord(outputRecord, 0, outputRecord.length);
                    outputStream.reset();
                }
                outputStream.close();
                outputDataStream.close();
            } catch (Exception error) {
                alert = new Alert("Error Writing", error.toString(), null, AlertType.WARNING);
                alert.setTimeout(Alert.FOREVER);
                display.setCurrent(alert);
            }
            try {
                String[] inputString = new String[3];
                int z = 0;
                byte[] byteInputData = new byte[300];
                ByteArrayInputStream inputStream = new ByteArrayInputStream(byteInputData);
                DataInputStream inputDataStream = new DataInputStream(inputStream);
                StringBuffer buffer = new StringBuffer();
                comparator = new Comparator();
                recordEnumeration = recordstore.enumerateRecords(null, comparator, false);
                while (recordEnumeration.hasNextElement()) {
                    recordstore.getRecord(recordEnumeration.nextRecordId(), byteInputData, 0);
                    buffer.append(inputDataStream.readUTF());
                    buffer.append(inputDataStream.readInt());
                    buffer.append("\n");
                    inputDataStream.reset();
                }
                alert = new Alert("Reading", buffer.toString(), null, AlertType.WARNING);
                alert.setTimeout(Alert.FOREVER);
                display.setCurrent(alert);
                inputDataStream.close();
                inputStream.close();
            } catch (Exception error) {
                alert = new Alert("Error Reading", error.toString(), null, AlertType.WARNING);
                alert.setTimeout(Alert.FOREVER);
                display.setCurrent(alert);
            }
            try {
                recordstore.closeRecordStore();
            } catch (Exception error) {
                alert = new Alert("Error Closing", error.toString(), null, AlertType.WARNING);
                alert.setTimeout(Alert.FOREVER);
                display.setCurrent(alert);
            }
            if (RecordStore.listRecordStores() != null) {
                try {
                    RecordStore.deleteRecordStore("myRecordStore");
                    comparator.compareClose();
                    recordEnumeration.destroy();
                } catch (Exception error) {
                    alert = new Alert("Error Removing", error.toString(), null, AlertType.WARNING);
                    alert.setTimeout(Alert.FOREVER);
                    display.setCurrent(alert);
                }
            }
        }
    }
}

class Comparator implements RecordComparator {
    private byte[] comparatorInputData = new byte[300];
    private ByteArrayInputStream comparatorInputStream = null;
    private DataInputStream comparatorInputDataType = null;

    public int compare(byte[] record1, byte[] record2) {
        int record1int, record2int;
        try {
            int maxlen = Math.max(record1.length, record2.length);
            if (maxlen > comparatorInputData.length) {
                comparatorInputData = new byte[maxlen];
            }
            comparatorInputStream = new ByteArrayInputStream(record1);
            comparatorInputDataType = new DataInputStream(comparatorInputStream);
            comparatorInputDataType.readUTF();
            record1int = comparatorInputDataType.readInt();
            comparatorInputStream = new ByteArrayInputStream(record2);
            comparatorInputDataType = new DataInputStream(comparatorInputStream);
            comparatorInputDataType.readUTF();
            record2int = comparatorInputDataType.readInt();
            if (record1int == record2int) {
                return RecordComparator.EQUIVALENT;
            } else if (record1int < record2int) {
                return RecordComparator.PRECEDES;
            } else {
                return RecordComparator.FOLLOWS;
            }
        } catch (Exception error) {
            return RecordComparator.EQUIVALENT;
        }
    }

    public void compareClose() {
        try {
            if (comparatorInputStream != null) {
                comparatorInputStream.close();
            }
            if (comparatorInputDataType != null) {
                comparatorInputDataType.close();
            }
        } catch (Exception error) {
        }
    }
}