Please help me in my program

[Phuong Thuy]

Hi all.
I am builing a dictionary program use J2ME.
I developer it from OSS of 7bit
http://www.7bit.biz/wap/pocketdict.jar
The database is texts file.
I have successed for "search word" ...
For now,I would like to add "word" in My Program,but the text file only can read not write so
I know that I must be to use RMS for this but i just study J2ME for 1 weeks
so if must study RMS very hard then it will be lost my time.
but i am very very needing it.i am make plan to submit a report for my teacher ,
please help me or maybe tutorial detail for me,
I will eternally grateful.
Here is code.Please correct me to add RMS for appropriate without modify the code...
Here is LineTextLoader class!

 
package Dictionary.util;
 
import java.io.*;
 
public class LineTextLoader {
    InputStream is;
    
    /* contructor */
    public LineTextLoader(String filename) {
       is = this.getClass().getResourceAsStream(filename);          
    }
    
    /* read line */
    public String readLine()
    {
        try {
            int ch = is.read();
            
            if (ch==-1) {
                is.close();
                return null;
            }
            else
            { 
                String ret = "";
                while (ch != -1 && ch != 13) {
                    if (ch!=10) ret += (char)ch;                   
                    ch = is.read();
                }
                
                return ret;
            }
        } 
        catch (Exception e) {
            System.out.println("Error when reading file " +e.getMessage());
        }
        
        return null;
    }    
}   

Here is LineTextLoader Class

 package Dictionary;
 
import java.util.*;
import Dictionary.util.LineTextLoader;
 
public class Translator {
    
    private String[] files;//array ch?a t�n c�c file d? li?u
    private Hashtable[] hash;//array ch?a c�c Hashtable t??ng ?ng
    private String[] indexs;//b?ng index, ch?a d? li?u ??c t? index file  
    
    // variables used for garbage collection
    private int maxNumberOfHash;//s? l??ng t?i ?a Hashtable ch?a d? li?u
    private int currentIndex = 0;// index c?a Hashtable hi?n t?i
    
    /** Creates a new instance of Translator */
    public Translator(String[] dataFiles, String indexFile, int maxNumberOfHash) {        
        files = dataFiles;                        
        int size = dataFiles.length;        
        
        // init array of index
        indexs = new String[size];
        initIndex(indexFile);
 
        // create new array of hashtable which contain dictionary definition
        hash = new Hashtable[size];
        for (int i=0; i<size; i++)
            hash[i] = null;
                
        // maximum number of hash table which have data (not equals null)
        // if the number of hash table which have data inside exceeds this number,
        // garbage collection will be done to reduce the amount of memory that is in used.
        this.maxNumberOfHash = (maxNumberOfHash>=size)?(size-1):maxNumberOfHash;        
    }
    
    /** Creates a new instance of Translator */
    public Translator(String[] dataFiles, String indexFile) {        
        this(dataFiles, indexFile, dataFiles.length-1);
    }
    
    /** translate a keyword */
    public String translate(String keyword) {
        Hashtable currentHash = getHashTable(keyword);
        return (String)currentHash.get(keyword);        
    }
    
    /** 
     * Get list of keywords which are started with specific letter 
     * For example: getList("lo") may result in 'love','long','lock',...
     */
    public String[] getList(String keyword) {        
        Hashtable currentHash = getHashTable(keyword);
        Enumeration enumeration = currentHash.keys();                
        
        String firstLetter = String.valueOf(keyword.charAt(0));
        String currentWord;        
        Vector v = new Vector();
 
        while (enumeration.hasMoreElements()) {
            currentWord = (String)enumeration.nextElement();
            if (currentWord.startsWith(firstLetter))
                v.addElement(currentWord);
        }
   
        String[] retString = new String[v.size()];
        v.copyInto(retString);
        quicksort(retString, 0, retString.length - 1);
 
        return retString;
    }
    
    /** 
     * ?? kh?i t?o b?ng index, ta ??c n?i dung c?a file index r?i l?u t?ng d�ng v�o m?ng indexs nh? sau:
     *  Load index file (reading line by line) and then store data into an array
     *  Example of the contain index file is as the following:
     *  ABC
     *  DEFG
     *  HIGKLM
     *  ...
     */
    private void initIndex(String filename)
    {
        LineTextLoader loader = new LineTextLoader(filename);
        String strLine = loader.readLine();
        int i = 0;
 
        while (strLine != null && ! strLine.equals("")) {
            indexs[i++] = strLine;
            strLine = loader.readLine();
        }
        
        loader = null;        
    }
 
    /** 
     * get HashTable which may contain a finding keyword.
     */
    private Hashtable getHashTable(String keyword) {
        // get index of hash table which may contain keyword
        int index = getIndex(keyword.charAt(0));        
 
        if (hash[index]==null || hash[index].size()<=0) {
            gc(); // call garbage collection
            initHash(index); // load data from file into this hash table
        }        
        
        currentIndex = index;
        return hash[index];
    }
 
    /** get index of hash table from hash table array  */
    private int getIndex(char c) {
        // search from index table to get out the appropriate index of hash table
        for (int i=0; i<indexs.length; i++)
            if (indexs[i].indexOf(c)>=0)
                return i;
 
        // not found
        return indexs.length-1;
    }
    
    /* garbage collection*/
    private void gc()
    {
        int count = 0; // number of not null hashbtable
        for (int i=0; i<hash.length; i++)
            if (hash[i] != null && hash[i].size()>0) count++;
        
        if (count >= maxNumberOfHash)  {
            hash[currentIndex] = null; // set last-accessed hash table to null
            System.gc(); // call system garbage collection
        }               
    }
    
    /** 
     * load data from file and store in hash table
     * data in text file forms as follow
     * word1|meaning1
     * word2|meaning2
     * ...
     * wordn|meaningn
     */
    private void initHash(int index)
    {
        Hashtable hashtable = new Hashtable();
        LineTextLoader loader = new LineTextLoader(files[index]);
 
        int pos;
        String strLeft, strRight;
        String strLine = loader.readLine();
 
        while (strLine != null) 
        {
            if ((pos = strLine.indexOf("|"))>0) {
                strLeft = strLine.substring(0,pos);
                strRight = strLine.substring(pos+1,strLine.length());
 
                if (!strLeft.equals("") && !strRight.equals("")) 
                    hashtable.put(strLeft.toLowerCase(),strRight);
            }
 
            strLine = loader.readLine();
        }
        
        hash[index] = hashtable;
        loader = null;        
    }    
    
   /** quick sort */
   private static void quicksort(String a[], int lo0, int hi0)
   {
        int lo = lo0;
        int hi = hi0;
        if(lo >= hi)
            return;
        String mid = a[(lo + hi) / 2];
        while(lo < hi) 
        {
            while(lo < hi && a[lo].compareTo(mid) < 0) 
                lo++;
            for(; lo < hi && a[hi].compareTo(mid) > 0; hi--);
            if(lo < hi)
            {
                String T = a[lo];
                a[lo] = a[hi];
                a[hi] = T;
                lo++;
                hi--;
            }
        }
        if(hi < lo)
        {
            int T = hi;
            hi = lo;
            lo = T;
        }
        quicksort(a, lo0, lo);
        quicksort(a, lo != lo0 ? lo : lo + 1, hi0);
    }
}   

Finally here is PocketDictionary Class

  package Dictionary;
 
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
import Dictionary.*;
 
public class PocketDictionary extends MIDlet implements CommandListener {
    private Display display;
    
    private Form searchScreen;   // search screen
    private Form resultScreen;   // screen which displays search result
    private List listScreen;     // screen which displays list of person names
    
    private TextField searchField; // text field for insert keyword
    private String mainTitle = "English-VietNammse";
    private int prev = 0;  // = 0: previous screen is search screen, = 1: is list screen
    
    private static final Command OK_COMMAND = new Command("OK", Command.OK, 0);
    private static final Command EXIT_COMMAND = new Command("Exit", Command.EXIT, 0);
    private static final Command BACK_COMMAND = new Command("Back", Command.BACK, 1);
    
    private String url = "/Dictionary/resources/";
    private String[] dataFiles = {url+"en-vn1.txt",url+"en-vn2.txt",url+"en-vn3.txt",url+"en-vn4.txt"};
    private String indexFile = url+"en-vnindex.txt";
    
    private Translator translator = null;
    
    /* startApp */
    public void startApp() {
        if (display==null) {
            display = Display.getDisplay(this);
            translator = new Translator(dataFiles, indexFile, 2);
        }
        
        display.setCurrent(createSearchScreen());
    }
       
    /* pauseApp */
    public void pauseApp() {
    }
    
    /* destroyApp */
    public void destroyApp(boolean unconditional) {
        notifyDestroyed();
    }
   
    /* return a search screen */
    public Screen createSearchScreen() {
        searchField = new TextField("English word:", "", 20, TextField.ANY);
        searchScreen = new Form(mainTitle);
        
        searchScreen.append(searchField);
        searchScreen.addCommand(OK_COMMAND);
        searchScreen.addCommand(EXIT_COMMAND);
        searchScreen.setCommandListener(this);
        
        return searchScreen;
    }
 
    /* return result screen after translation */
    public Screen createResultScreen(String inputWord) {
        inputWord = inputWord.toLowerCase();
        String result = translator.translate(inputWord);
 
        if (result == null) {
            return createListScreen(inputWord);
        }
        else {
            resultScreen = new Form(inputWord.toLowerCase());
            resultScreen.append(result);
            resultScreen.addCommand(BACK_COMMAND);            
            resultScreen.setCommandListener(this);
            
            return resultScreen;
        }
    }
    
    /* return screen displays list of person names */ 
    public Screen createListScreen(String inputWord)
    {         
        String[] result = translator.getList(inputWord);
        
        listScreen = new List("Not found",List.IMPLICIT);                
        listScreen.addCommand(BACK_COMMAND);
        
        if (result!=null) {
            listScreen.addCommand(OK_COMMAND);
            for (int i=0;i<result.length;i++)
                listScreen.append(result[i].toLowerCase(),null);
        }
                
        listScreen.setCommandListener(this);
         
        return listScreen;
    }
    
    public void commandAction(Command c, Displayable d) {
        if (d.equals(searchScreen)) {
            if(c == OK_COMMAND) {
                if(! searchField.getString().equals("")) {
                    prev = 0;
                    searchScreen.setTitle("loading..");
                    display.setCurrent(createResultScreen(searchField.getString()));
                }
            } 
            else if(c == EXIT_COMMAND)
                destroyApp(true);
        }
        else if (d.equals(resultScreen)) {
            if (c == BACK_COMMAND) {
                if (prev==0) {
                    searchScreen.setTitle(mainTitle);
                    searchField.setString("");
                    display.setCurrent(searchScreen);
                }
                else
                    display.setCurrent(listScreen);
            }
        }
        else if (d.equals(listScreen)) {
            if (c == BACK_COMMAND) {
                searchScreen.setTitle(mainTitle);
                searchField.setString("");
                display.setCurrent(searchScreen);
            }
            else if (c == OK_COMMAND) {
                prev = 1;
                display.setCurrent(createResultScreen(listScreen.getString(listScreen.getSelectedIndex())));
            }
        }
    }
}  

Best Regards and sorry for my bad English.

[ December 08, 2006: Message edited by: Phuong Thuy ]

[ December 08, 2006: Message edited by: Phuong Thuy ]

[ December 08, 2006: Message edited by: Phuong Thuy ]
[ December 11, 2006: Message edited by: Bear Bibeault ]

[Phuong Thuy]

Anyone???Someone???PLEASE!!!

[Mark Spritzler]

I am a little bit confused. Just know this, we frown upon doing other people's homework and that is most likely why you haven't gotten a response.

But here is my actual confusion, I look at your code and it looks very clean, clean enough to make me think that figuring out how to use a RecordSource should be very quick and easy for you to figure out. The API is very straight forward. Just recreate a class that is a RecordSource Reader and Writer, and use that API in your code.

Mark