recordstorecache.java

来自「Sony Ericsson手机上的Facebook客户端全套代码」· Java 代码 · 共 351 行

// Decompiled by Jad v1.5.7g. Copyright 2000 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/SiliconValley/Bridge/8617/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   RecordStoreCache.java

package se.southend.drops.cache;

import java.io.*;
import java.util.Enumeration;
import java.util.Hashtable;
import javax.microedition.rms.RecordStore;

// Referenced classes of package se.southend.drops.cache:
//            MemoryCache, CacheInfo, Cache

public class RecordStoreCache
    implements Cache
{
    private class Entry
    {

        CacheInfo info;
        int page;
        int pointer;
        int length;

        Entry(CacheInfo info, int page, int pointer, int length)
        {
            this.info = info;
            this.page = page;
            this.pointer = pointer;
            this.length = length;
        }
    }


    public RecordStoreCache()
    {
        setIndexTableName("CacheTOC");
        setPageName("Cache");
        setPageSize(0x10000);
        setNbrPages(15);
        indexTable = new Hashtable();
        memoryCache = new MemoryCache();
    }

    public void open()
    {
        read();
    }

    public static RecordStoreCache getInstance()
    {
        if(instance == null)
            instance = new RecordStoreCache();
        return instance;
    }

    public void setCacheInfo(CacheInfo cacheInfo)
    {
        infoClass = cacheInfo != null ? cacheInfo.getClass() : null;
    }

    public void setIndexTableName(String name)
    {
        indexTableName = name;
    }

    public void setPageName(String name)
    {
        pageName = name;
    }

    public void setPageSize(int pageSize)
    {
        this.pageSize = pageSize;
    }

    public void setNbrPages(int nbrPages)
    {
        this.nbrPages = nbrPages;
    }

    public byte[] get(String key)
    {
        byte data[] = memoryCache.get(key);
        if(data == null)
        {
            Entry entry = (Entry)indexTable.get(key);
            if(entry != null)
            {
                RecordStore page = null;
                try
                {
                    page = RecordStore.openRecordStore(pageName + entry.page, true);
                    data = new byte[entry.length];
                    System.arraycopy(page.getRecord(1), entry.pointer, data, 0, entry.length);
                    page.closeRecordStore();
                }
                catch(Exception e)
                {
                    System.out.println("Page nbr: " + entry.page);
                    System.out.println("Entry pointer: " + entry.pointer + "   Entry length: " + entry.length);
                    try
                    {
                        System.out.println("Page: " + page + "   records: " + page.getNumRecords() + "   size: " + page.getSize());
                    }
                    catch(Exception ee)
                    {
                        ee.printStackTrace();
                    }
                    e.printStackTrace();
                }
            }
        }
        return data;
    }

    public CacheInfo getInfo(String key)
    {
        CacheInfo info = memoryCache.getInfo(key);
        if(info == null)
        {
            Entry entry = (Entry)indexTable.get(key);
            if(entry != null)
                info = entry.info;
        }
        return info;
    }

    public void put(String key, byte data[])
    {
        put(key, null, data);
    }

    public void put(String key, CacheInfo info, byte data[])
    {
        if(data.length > pageSize)
        {
            System.out.println("Cache put error: data sizes greater than the page size not supported.");
            return;
        }
        if(memoryCache.size() + data.length > pageSize)
        {
            write();
            pageNbr++;
            if(pageNbr == nbrPages)
                pageNbr = 0;
        }
        memoryCache.put(key, info, data);
    }

    public void remove(String key)
    {
        if(memoryCache.contains(key))
            memoryCache.remove(key);
        else
            indexTable.remove(key);
    }

    public void empty()
    {
        memoryCache.empty();
        indexTable.clear();
    }

    public boolean contains(String key)
    {
        return memoryCache.contains(key) || indexTable.containsKey(key);
    }

    public String[] contents()
    {
        String memoryContents[] = memoryCache.contents();
        String contents[] = new String[memoryContents.length + indexTable.size()];
        for(int i = 0; i < memoryContents.length; i++)
            contents[i] = memoryContents[i];

        Enumeration en = indexTable.keys();
        for(int i = memoryContents.length; i < contents.length; i++)
            contents[i] = (String)en.nextElement();

        return contents;
    }

    public int size()
    {
        return memoryCache.size();
    }

    public void close()
    {
        write();
        memoryCache.close();
        indexTable.clear();
    }

    private void read()
    {
        RecordStore index = null;
        try
        {
            index = RecordStore.openRecordStore(indexTableName, true);
            if(index.getNumRecords() != 0)
            {
                ByteArrayInputStream indexInput = new ByteArrayInputStream(index.getRecord(1));
                DataInputStream indexData = new DataInputStream(indexInput);
                pageNbr = indexData.readInt();
                indexTable.clear();
                do
                {
                    if(indexData.available() <= 0)
                        break;
                    String key = indexData.readUTF();
                    int page = indexData.readInt();
                    int pointer = indexData.readInt();
                    int length = indexData.readInt();
                    CacheInfo info = null;
                    if(infoClass != null)
                    {
                        info = (CacheInfo)infoClass.newInstance();
                        info.read(indexData);
                    }
                    Entry entry = new Entry(info, page, pointer, length);
                    indexTable.put(key, entry);
                    if(page == pageNbr)
                    {
                        memoryCache.put(key, info, get(key));
                        indexTable.remove(key);
                    }
                } while(true);
            }
            index.closeRecordStore();
        }
        catch(Exception e)
        {
            e.printStackTrace();
            try
            {
                index.closeRecordStore();
                RecordStore.deleteRecordStore(indexTableName);
                index = RecordStore.openRecordStore(indexTableName, true);
            }
            catch(Exception ee)
            {
                e.printStackTrace();
            }
        }
    }

    private void write()
    {
        try
        {
            try
            {
                RecordStore.deleteRecordStore(pageName + pageNbr);
                Enumeration en = indexTable.keys();
                do
                {
                    if(!en.hasMoreElements())
                        break;
                    String key = (String)en.nextElement();
                    Entry entry = (Entry)indexTable.get(key);
                    if(entry.page == pageNbr)
                        indexTable.remove(key);
                } while(true);
            }
            catch(Exception e) { }
            byte bytes[] = serializeMemoryCache();
            memoryCache.empty();
            RecordStore page = RecordStore.openRecordStore(pageName + pageNbr, true);
            page.addRecord(bytes, 0, bytes.length);
            page.closeRecordStore();
            bytes = serializeIndexTable();
            page = RecordStore.openRecordStore(indexTableName, true);
            if(page.getNumRecords() == 0)
                page.addRecord(bytes, 0, bytes.length);
            else
                page.setRecord(1, bytes, 0, bytes.length);
            page.closeRecordStore();
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }

    private byte[] serializeMemoryCache()
    {
        String contents[] = memoryCache.contents();
        byte result[] = new byte[memoryCache.size()];
        int pointer = 0;
        for(int i = 0; i < contents.length; i++)
        {
            String key = contents[i];
            CacheInfo info = memoryCache.getInfo(key);
            byte data[] = memoryCache.get(key);
            int length = data.length;
            indexTable.put(key, new Entry(info, pageNbr, pointer, length));
            System.arraycopy(data, 0, result, pointer, length);
            pointer += length;
        }

        return result;
    }

    private byte[] serializeIndexTable()
    {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        DataOutputStream dataOut = new DataOutputStream(out);
        try
        {
            dataOut.writeInt(pageNbr);
            Enumeration en = indexTable.keys();
            do
            {
                if(!en.hasMoreElements())
                    break;
                String key = (String)en.nextElement();
                Entry entry = (Entry)indexTable.get(key);
                dataOut.writeUTF(key);
                dataOut.writeInt(entry.page);
                dataOut.writeInt(entry.pointer);
                dataOut.writeInt(entry.length);
                if(entry.info != null)
                    entry.info.write(dataOut);
            } while(true);
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        return out.toByteArray();
    }

    private static final String DEFAULT_INDEX_TABLE_NAME = "CacheTOC";
    private static final String DEFAULT_PAGE_NAME = "Cache";
    private static final int DEFAULT_PAGE_SIZE = 0x10000;
    private static final int DEFAULT_NBR_PAGES = 15;
    private static RecordStoreCache instance;
    private Hashtable indexTable;
    private MemoryCache memoryCache;
    private String indexTableName;
    private String pageName;
    private int pageSize;
    private int nbrPages;
    private int pageNbr;
    private Class infoClass;
}