vpffeaturecache.java

openmap java写的开源数字地图程序. 用applet实现,可以像google map 那样放大缩小地图.

// **********************************************************************
// 
// <copyright>
// 
//  BBN Technologies
//  10 Moulton Street
//  Cambridge, MA 02138
//  [phone]
// 
//  Copyright (C) BBNT Solutions LLC. All rights reserved.
// 
// </copyright>
// **********************************************************************
// 
// $Source: /cvs/distapps/openmap/src/openmap/com/bbn/openmap/layer/vpf/VPFFeatureCache.java,v $
// $RCSfile: VPFFeatureCache.java,v $
// $Revision: 1.2.2.2 $
// $Date: 2004/10/14 18:27:22 $
// $Author: dietrick $
// 
// **********************************************************************

package com.bbn.openmap.layer.vpf;

import com.bbn.openmap.layer.util.cacheHandler.CacheHandler;
import com.bbn.openmap.layer.util.cacheHandler.CacheObject;
import com.bbn.openmap.omGraphics.OMGraphic;
import com.bbn.openmap.omGraphics.OMGraphicList;
import com.bbn.openmap.util.Debug;

/**
 * The VPFFeatureCache is an extended CacheHandler that caches
 * OMGraphicLists representing a specific feature contained in a
 * CoverageTile. It's used by the VPFCachedFeatureGraphicWarehouse,
 * which in turn is used by the LibraryBean as a central warehouse.
 */
public class VPFFeatureCache extends CacheHandler {

    /**
     * Create a VPFFeatureCache of the default maximum size.
     */
    public VPFFeatureCache() {
        super();
    }

    /**
     * Create a VPFFeatureCache of the specified maximum size.
     */
    public VPFFeatureCache(int maxSize) {
        super(maxSize);
    }

    /**
     * Adds an OMGraphic to a list, signified by the feature type and
     * the table. The PrimitiveTable provides an identifying tile
     * path.
     * 
     * @param omg OMGraphic to add
     * @param featureType the feature code of the OMGraphic
     * @param pt the PrimitiveTable containing the path to the
     *        CoverageTile.
     */
    protected synchronized void addToCachedList(OMGraphic omg,
                                                String featureType,
                                                PrimitiveTable pt, String type) {
        String key = createTableCacheKey(featureType, pt.getTileDirectory()
                .getPath());
        FeatureCacheGraphicList omgl = (FeatureCacheGraphicList) get(key);
        omgl.add(omg);
    }

    /**
     * Create an identifying key from the feature type and tile path.
     */
    public static String createTableCacheKey(String featureType, String tilePath) {
        return featureType + "-" + tilePath;
    }

    /**
     * Returns true if the features from a tile (as described by the
     * key) existed and was added to the warehouse graphics list.
     * Returns false if the list needs to be created and the contents
     * read in from data files. In both cases the OMGraphicList for
     * the tile/feature is loaded into the cache, the return value is
     * a signal to the caller that the list must be populated or not.
     * 
     * @param featureType the feature type code.
     * @param tilePath the relative path to the tile file.
     * @param requestor the OMGraphicList used to contain cached
     *        lists. The cached list will for the featureType/path
     *        code will be added to this list, regardless of whether
     *        it's been populated or not. The requestor list will be
     *        returned when the warehouse is asked for the graphics
     *        list.
     * @return true if the list has already been loaded and the caller
     *         doesn't need to read the data files to create list
     *         contents.
     */
    public synchronized boolean loadCachedGraphicList(String featureType,
                                                      String tilePath,
                                                      OMGraphicList requestor) {

        String key = createTableCacheKey(featureType, tilePath);
        boolean exists = (searchCache(key) != null);

        // Will retrieve the old list if it exists, create a new one
        // if it doesn't.

        FeatureCacheGraphicList fcgl = (FeatureCacheGraphicList) get(key,
                VPFUtil.getTypeForFeatureCode(featureType));
        if (fcgl.getFeatureName() == null) {
            fcgl.setFeatureName(featureType);
        }
        requestor.add(fcgl);

        // Might want to set the current attributes for the existing
        // contents of the list in case they were changed by the user.
        return exists;
    }

    /**
     * Query that the CoverageTable makes to decide whether to read
     * the file contents or to used the cached version.
     * 
     * @param currentFeature the feature type
     * @param currentTile the tile directory
     * @param requestor the OMGraphicList to add the cached list to.
     *        If the CoverageTable reads the data files, the
     *        OMGraphics created from the files will be added to the
     *        list added to the requestor.
     * @return true if the CoverageTable needs to read the data files.
     */
    public synchronized boolean needToFetchTileContents(
                                                        String currentFeature,
                                                        TileDirectory currentTile,
                                                        OMGraphicList requestor) {
        if (loadCachedGraphicList(currentFeature,
                currentTile.getPath(),
                requestor)) {
            if (Debug.debugging("vpf.cache")) {
                Debug.output("VPFFeatureCache: Loaded Cached List: "
                        + createTableCacheKey(currentFeature,
                                currentTile.getPath()));
            }
            return false;
        }
        return true;
    }

    /**
     * Additional get method that will call a load() method that takes
     * into account the featureType. The regular get() method will not
     * be used, unless something else calls it, which is not advised.
     * 
     * @param key the created key for cached list, see
     *        createTableCacheKey
     * @param featureType the kind of feature, VPFUtil.Area,
     *        VPFUtil.Edge, VPFUtil.Point or VPFUtil.Text.
     */
    public Object get(String key, String featureType) {
        CacheObject ret = searchCache(key);
        if (ret != null)
            return ret.obj;

        ret = load(key, featureType);
        if (ret == null)
            return null;

        replaceLeastUsed(ret);
        return ret.obj;
    }

    /**
     * CacheHandler method to load the new OMGraphicLists
     * (FeatureCacheGraphicLists). Shouldn't be used because the
     * FeatureCacheGraphicList type will be unknown. This method is
     * only defined to implement the CacheHandler abstract method.
     */
    public CacheObject load(String key) {
        return load(key, null);
    }

    /**
     * CacheHandler method to load the new OMGraphicLists
     * (FeatureCacheGraphicLists).
     */
    public CacheObject load(String key, String featureType) {
        if (key != null) {
            return new VPFListCacheObject(key, FeatureCacheGraphicList.createForType(featureType));
        }
        return null;
    }

    /**
     * CacheObject used by VPFFeatureCache.
     */
    public static class VPFListCacheObject extends CacheObject {
        /**
         * Construct a VPFListCacheObject, just calls superclass
         * constructor
         * 
         * @param id passed to superclass
         * @param obj passed to superclass
         */
        public VPFListCacheObject(String id, OMGraphicList obj) {
            super(id, obj);
        }

        /**
         */
        public void finalize() {
            ((OMGraphicList) obj).clear();
        }
    }

}