bugdb.java

我参与的一个J2ME项目的部分代码

package com.sepco.apps.trouble.database;

import java.util.*;
import java.io.*;
import javax.microedition.lcdui.*;
import javax.microedition.midlet.*;
import javax.microedition.rms.*;
import com.sepco.apps.trouble.businessobject.*;

/**
 * Fields inside recordstore are | delimited.
 * 10 Fields for bugTicket
 *      
 */

public class BugDB {

    RecordStore recordStore = null;
    RecordEnumeration enum = null;
    String recordStoreName = null;

    public BugDB(String storeName) {
        //构造器：打开或者创建一个RMS数据库
        try {
            recordStoreName = storeName;
            recordStore = RecordStore.openRecordStore(storeName,true);
        } catch(RecordStoreException rse) {
            rse.printStackTrace();
        }
    }

    public void close() throws RecordStoreNotOpenException, RecordStoreException {
        //关闭或者删除数据存储
        if (recordStore.getNumRecords() == 0) {
            recordStore.closeRecordStore();
            RecordStore.deleteRecordStore(recordStoreName);
        } else {
            recordStore.closeRecordStore();
        }
        if (enum != null) {
            enum.destroy();
        }
    }

    public synchronized void setFault(FaultRecord theRecord) {
        try {
            int recId = getRecordIdOfFault(theRecord.getPDA());
            ByteArrayOutputStream bout = new ByteArrayOutputStream();
            DataOutputStream dout = new DataOutputStream(bout);
            dout.writeUTF(theRecord.toDelimitedString());
            byte[] b = bout.toByteArray();
            if (recId != -1) { //do an Update
               recordStore.setRecord(recId, b, 0, b.length);
             } else if (recId == -1){ //do an Insert
               recordStore.addRecord(b, 0, b.length);
             }
        } catch (Exception e) {
        }
    }

    public synchronized boolean deleteFault(FaultRecord theRecord) {
        try {
            int recId = getRecordIdOfFault(theRecord.getPDA());
            if (recId != -1) {
                recordStore.deleteRecord(recId);
                return (true);
            } else {
                return (false);
            }
        } catch (Exception e) {
            return (false);
        }
    }

    public void vectorOfBizObjIntoRMS(Vector in) {
        if (in != null) {
            Enumeration enum = in.elements();
            while (enum.hasMoreElements()) {
                FaultRecord rlRec = (FaultRecord)enum.nextElement();
                int recId = getRecordIdOfFault(rlRec.getPDA());
                if (recId == -1) { // Not found
                    setFault(rlRec);
                }
            }
        }
    }

    public void refreshRMSWithVector(Vector in) {

        try {
            recordStore.closeRecordStore();
            RecordStore.deleteRecordStore(recordStoreName);
            recordStore = RecordStore.openRecordStore(recordStoreName, true);
            Enumeration enum = in.elements();
            while (enum.hasMoreElements()) {
            	FaultRecord rlRec = (FaultRecord)enum.nextElement();
                ByteArrayOutputStream bout = new ByteArrayOutputStream();
                DataOutputStream dout = new DataOutputStream(bout);
                dout.writeUTF(rlRec.toDelimitedString());
                byte[] b = bout.toByteArray();
                int recId = getRecordIdOfFault(rlRec.getPDA());
                recordStore.addRecord(b, 0, b.length);
             }
        } catch (RecordStoreException ex1) {
        } catch (IOException ex2) {
        }
    }
    
    public Vector rmsToVectorOfBizObj() {

        String record;
        Vector returnVector = new Vector();

        MyComparator comparator = new MyComparator();
        comparator.setSortColumn(2);
        try {
            enum = recordStore.enumerateRecords(null, comparator, false);
            while (enum.hasNextElement()) {
                ByteArrayInputStream bin = new ByteArrayInputStream(enum.nextRecord());
                DataInputStream      din = new DataInputStream(bin);
                record = din.readUTF();
                if (record.length() != 0) {
                    returnVector.addElement((parseRecIntoBizObj(record)));
                }

            }
            if (returnVector.isEmpty()) {
                return (null);
            } else {
                return (returnVector);
            }
        } catch (Exception e) {
            return (null);
        }
    }

    public int getRecordIdOfFault(String PDA) {
        MyFilter filter = new MyFilter();
        filter.setFilterCondition(PDA, 2, MyFilter.FILTER_EXACT);
        
        try {
            enum = recordStore.enumerateRecords(filter, null, false);

            if (enum.hasNextElement()) {
                return (enum.nextRecordId());
            } else {
                return (-1);
            }
        } catch (Exception e) {
            return (-1);
        }
    }

    private FaultRecord parseRecIntoBizObj(String record) {
        int column = 0;
        int index = 0;
        int prevIndex = 0;
        String field;
        FaultRecord rlRec = new FaultRecord();

        while (prevIndex < record.length()) {
            index = record.indexOf('|', prevIndex);
            if (index < 0) {
                field = record.substring(prevIndex, record.length()-1);
                prevIndex = record.length()+1;
            } else {
                field = record.substring(prevIndex, index);
                prevIndex = index+1;
            }
            switch (column) {
                case 0:
                    rlRec.setToBeSync(field);
                    break;
                case 1:
                    rlRec.setPDA(field);
                    break;
                case 2:
                    rlRec.setvoltageClass(field);
                    break;
                case 3:
                    rlRec.setLineName(field);
                    break;
                case 4:
                    rlRec.setPoleID(field);
                    break;
                case 5:
                    rlRec.setFaultDescription(field);
                    break;
                case 6:
                    rlRec.setSuggestion(field);
                    break;
                case 7:
                    rlRec.setDiscoverDate(field);
                    break;
                case 8:
                    rlRec.setDiscoverMan(field);
                    break;
                case 9:
                    rlRec.setSyncStatus(field);
                    break;
                default:
                    break;
            }
            column++;
        }

        return (rlRec);
    }

    private class MyFilter implements RecordFilter {

        // Define the filtering modes
        private static final int FILTER_NONE = 0;
        private static final int FILTER_STARTSWITH = 1;
        private static final int FILTER_CONTAINS = 2;
        private static final int FILTER_EXACT = 3;

        private String filterText;
        private int filterColumn;
        private int filterBy;

        public MyFilter() {
            super();
            filterColumn = 0;
            filterBy = FILTER_NONE;
        }

        public void setFilterCondition(String searchText, int recColumn, int by) {
            filterText = searchText;
            filterColumn = recColumn;
            filterBy = by;
        }

        public boolean matches(byte[] rec) {

            int i;
            int index = 0;
            int prevIndex = 0;
            String record;
            String field = new String();

            try {
                ByteArrayInputStream bin = new ByteArrayInputStream(rec);
                DataInputStream      din = new DataInputStream(bin);
                record = din.readUTF();
                for (i=0; i<filterColumn && prevIndex < record.length(); i++) {
                    index = record.indexOf('|', prevIndex);
                    if (index < 0) {
                        field = record.substring(prevIndex, record.length()-1);
                        prevIndex = record.length()+1;
                    } else {
                        field = record.substring(prevIndex, index);
                        prevIndex = index+1;
                    }
                }

                if( filterBy == FILTER_STARTSWITH ){
                    return (field.startsWith(filterText));
                } else if( filterBy == FILTER_CONTAINS ){
                    return (field.indexOf(filterText) >= 0);
                } else if( filterBy == FILTER_EXACT ){
                    return (field.equals(filterText));
                }
            } catch (Exception e) {
                return false;
            }
            return false;
        }
    }

    private class MyComparator implements RecordComparator {

        private int sortColumn;

        public void setSortColumn(int column) {
            sortColumn = column;
        }

        public int compare(byte[] rec1, byte[] rec2){

            int i;
            int index = 0;
            int prevIndex = 0;
            String record1;
            String record2;
            String field1 = new String();
            String field2 = new String();

            try {
                ByteArrayInputStream bin1 = new ByteArrayInputStream(rec1);
                DataInputStream      din1 = new DataInputStream(bin1);
                ByteArrayInputStream bin2 = new ByteArrayInputStream(rec2);
                DataInputStream      din2 = new DataInputStream(bin2);
                record1 = din1.readUTF();
                record2 = din2.readUTF();

                for (i=0; i<sortColumn && prevIndex < record1.length(); i++) {
                    index = record1.indexOf('|', prevIndex);
                    if (index < 0) {
                        field1 = record1.substring(prevIndex, record1.length()-1);
                        prevIndex = record1.length()+1;
                    } else {
                        field1 = record1.substring(prevIndex, index);
                        prevIndex = index+1;
                    }
                }
                
                for (i=0, index = 0, prevIndex = 0; i<sortColumn && prevIndex < record2.length(); i++) {
                    index = record2.indexOf('|', prevIndex);
                    if (index < 0) {
                        field2 = record2.substring(prevIndex, record2.length()-1);
                        prevIndex = record2.length()+1;
                    } else {
                        field2 = record2.substring(prevIndex, index);
                        prevIndex = index+1;
                    }
                }

                i = field1.compareTo(field2);
                if (i == 0) {
                    return EQUIVALENT;
                } else if (i<0) {
                    return PRECEDES;
                } else {
                    return FOLLOWS;
                }
            } catch(Exception e) {
                return EQUIVALENT;
            }
        }
    }

}