cachemanager.java

自行开发的高缓存table

// Decompiled by DJ v2.9.9.60 Copyright 2000 Atanas Neshkov  Date: 2004-2-20 9:17:10
// Home Page : http://members.fortunecity.com/neshkov/dj.html  - Check often for new version!
// Decompiler options: packimports(3) 
// Source File Name:   CacheManager.java

package utility.HWCacheTable;

import java.util.Vector;

// Referenced classes of package utility.HWCacheTable:
//            Cache, ServerModel, CacheTableStatusViewer, CacheTableModel

class CacheManager
{

    CacheManager(ServerModel servermodel, CacheTableModel cachetablemodel)
    {
        _serverModel = null;
        _cacheTableModel = null;
        _state = 1;
        _count = 0;
        _sizeHasGet = false;
        _cache = null;
        _thrownCache = null;
        _statusViewer = null;
        _prevStatus = 65535;
        _serverModel = servermodel;
        _cacheTableModel = cachetablemodel;
        checkState();
    }

    public void setServerModel(ServerModel servermodel)
    {
        _serverModel = servermodel;
        checkState();
    }

    private void checkState()
    {
        if(_serverModel != null)
            _state = 2;
        else
            _state = 1;
    }

    void clearSizeRelativeValue()
    {
        _sizeHasGet = false;
    }

    public int getRowCount()
    {
        if(_state == 1)
            return 0;
        if(_sizeHasGet)
        {
            return _count;
        } else
        {
            _count = _serverModel.getSize();
            _sizeHasGet = true;
            return _count;
        }
    }

    void restoreCache()
    {
        _state = 2;
        _count = 0;
        _sizeHasGet = false;
        if(_cache != null && !_cache.gettingDataFinished())
            _cache.stopGettingData();
        disposeCache();
    }

    void throwCacheData()
    {
        _cache = null;
    }

    ServerModel getServerModel()
    {
        return _serverModel;
    }

    CacheTableModel getCacheTableModel()
    {
        return _cacheTableModel;
    }

    public Object getValueAt(int i, int j)
    {
        if(_cache == null)
        {
            _cache = new Cache(this, i);
            _cache.start();
        } else
        if(!isDataInTheCache(i))
        {
            _thrownCache = _cache;
            _thrownCache.setThrowFlag(true);
            _cache = new Cache(this, i);
            if(_thrownCache.gettingDataFinished())
            {
                _cache.start();
                releaseThrownCache();
            } else
            {
                _thrownCache.stopGettingDataAndStart();
            }
        }
        return _cache.getValueAt(i, j);
    }

    void thrownCacheFinishWorking()
    {
        releaseThrownCache();
        _cache.start();
    }

    public int getFrom()
    {
        if(_cache == null || _cache.size() == 0)
            return -1;
        else
            return _cache.getFrom();
    }

    public int getTo()
    {
        if(_cache == null || _cache.size() == 0)
            return -1;
        else
            return _cache.getTo();
    }

    private void releaseThrownCache()
    {
        if(_thrownCache != null)
        {
            _thrownCache.release();
            _thrownCache.clear();
        }
        _thrownCache = null;
    }

    public boolean isDataInTheCache(int i)
    {
        if(_cache == null)
            return false;
        else
            return _cache.isIndexInCache(i);
    }

    public void setStatusViewer(CacheTableStatusViewer cachetablestatusviewer)
    {
        _statusViewer = cachetablestatusviewer;
    }

    void showStatus()
    {
        int i = _cache.getCacheStatus();
        if(i != _prevStatus)
        {
            if(_statusViewer != null)
                _statusViewer.showLoadingStatus(i);
            _prevStatus = i;
        }
    }

    boolean isRowDataInCache(int i)
    {
        return isDataInTheCache(i);
    }

    boolean gettingDataFinished()
    {
        if(_cache != null)
            return _cache.gettingDataFinished();
        else
            return false;
    }

    public void repaintLoadingStatus()
    {
        showStatus();
    }

    void release()
    {
        _serverModel = null;
        _cacheTableModel = null;
        if(_cache != null)
        {
            _cache.release();
            _cache.clear();
        }
        _cache = null;
        if(_thrownCache != null)
        {
            _thrownCache.release();
            _thrownCache.clear();
        }
        _thrownCache = null;
        _statusViewer = null;
    }

    public void disposeCache()
    {
        if(_cache != null)
        {
            _cache.release();
            _cache.clear();
        }
        _cache = null;
        if(_thrownCache != null)
        {
            _thrownCache.release();
            _thrownCache.clear();
        }
        _thrownCache = null;
    }

    private ServerModel _serverModel;
    private CacheTableModel _cacheTableModel;
    private final int INIT_STATE = 1;
    private final int READY_STATE = 2;
    private int _state;
    private int _count;
    private boolean _sizeHasGet;
    private Cache _cache;
    private Cache _thrownCache;
    private CacheTableStatusViewer _statusViewer;
    private int _prevStatus;
}