    001/*
    002 *  Licensed to the Apache Software Foundation (ASF) under one or more
    003 *  contributor license agreements.  See the NOTICE file distributed with
    004 *  this work for additional information regarding copyright ownership.
    005 *  The ASF licenses this file to You under the Apache License, Version 2.0
    006 *  (the "License"); you may not use this file except in compliance with
    007 *  the License.  You may obtain a copy of the License at
    008 *
    009 *     http://www.apache.org/licenses/LICENSE-2.0
    010 *
    011 *  Unless required by applicable law or agreed to in writing, software
    012 *  distributed under the License is distributed on an "AS IS" BASIS,
    013 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014 *  See the License for the specific language governing permissions and
    015 *  limitations under the License.
    016 */
    017package org.apache.commons.compress.harmony.unpack200;
    018
    019import java.util.ArrayList;
    020import java.util.Collections;
    021import java.util.HashMap;
    022import java.util.IdentityHashMap;
    023import java.util.List;
    024
    025/**
    026 * The SegmentConstantPool spends a lot of time searching through large arrays of Strings looking for matches. This can
    027 * be sped up by caching the arrays in HashMaps so the String keys are looked up and resolve to positions in the array
    028 * rather than iterating through the arrays each time.
    029 *
    030 * Because the arrays only grow (never shrink or change) we can use the last known size as a way to determine if the
    031 * array has changed.
    032 *
    033 * Note that this cache must be synchronized externally if it is shared.
    034 */
    035public class SegmentConstantPoolArrayCache {
    036
    037    /**
    038     * CachedArray keeps track of the last known size of an array as well as a HashMap that knows the mapping from
    039     * element values to the indices of the array which contain that value.
    040     */
    041    protected class CachedArray {
    042        String[] primaryArray;
    043        int lastKnownSize;
    044        HashMap<String, List<Integer>> primaryTable;
    045
    046        public CachedArray(final String[] array) {
    047            this.primaryArray = array;
    048            this.lastKnownSize = array.length;
    049            this.primaryTable = new HashMap<>(lastKnownSize);
    050            cacheIndexes();
    051        }
    052
    053        /**
    054         * Given a primaryArray, cache its values in a HashMap to provide a backwards mapping from element values to
    055         * element indexes. For instance, a primaryArray of: {"Zero", "Foo", "Two", "Foo"} would yield a HashMap of:
    056         * "Zero" -&gt; 0 "Foo" -&gt; 1, 3 "Two" -&gt; 2 which is then cached.
    057         */
    058        protected void cacheIndexes() {
    059            for (int index = 0; index < primaryArray.length; index++) {
    060                final String key = primaryArray[index];
    061                primaryTable.computeIfAbsent(key, k -> new ArrayList<>()).add(Integer.valueOf(index));
    062            }
    063        }
    064
    065        /**
    066         * Given a particular key, answer a List of index locations in the array which contain that key.
    067         *
    068         * If no elements are found, answer an empty list.
    069         *
    070         * @param key String element of the array
    071         * @return List of indexes containing that key in the array.
    072         */
    073        public List<Integer> indexesForKey(final String key) {
    074            final List<Integer> list = primaryTable.get(key);
    075            return list != null ? list : Collections.emptyList();
    076        }
    077
    078        /**
    079         * Answer the last known size of the array cached. If the last known size is not the same as the current size,
    080         * the array must have changed.
    081         *
    082         * @return int last known size of the cached array
    083         */
    084        public int lastKnownSize() {
    085            return lastKnownSize;
    086        }
    087    }
    088
    089    protected IdentityHashMap<String[], CachedArray> knownArrays = new IdentityHashMap<>(1000);
    090    protected List<Integer> lastIndexes;
    091    protected String[] lastArray;
    092
    093    protected String lastKey;
    094
    095    /**
    096     * Given a String array, answer true if the array is correctly cached. Answer false if the array is not cached, or
    097     * if the array cache is outdated.
    098     *
    099     * @param array of String
    100     * @return boolean true if up-to-date cache, otherwise false.
    101     */
    102    protected boolean arrayIsCached(final String[] array) {
    103        final CachedArray cachedArray = knownArrays.get(array);
    104        return !(cachedArray == null || cachedArray.lastKnownSize() != array.length);
    105    }
    106
    107    /**
    108     * Cache the array passed in as the argument
    109     *
    110     * @param array String[] to cache
    111     */
    112    protected void cacheArray(final String[] array) {
    113        if (arrayIsCached(array)) {
    114            throw new IllegalArgumentException("Trying to cache an array that already exists");
    115        }
    116        knownArrays.put(array, new CachedArray(array));
    117        // Invalidate the cache-within-a-cache
    118        lastArray = null;
    119    }
    120
    121    /**
    122     * Answer the indices for the given key in the given array. If no such key exists in the cached array, answer -1.
    123     *
    124     * @param array String[] array to search for the value
    125     * @param key String value for which to search
    126     * @return List collection of index positions in the array
    127     */
    128    public List<Integer> indexesForArrayKey(final String[] array, final String key) {
    129        if (!arrayIsCached(array)) {
    130            cacheArray(array);
    131        }
    132
    133        // If the search is one we've just done, don't even
    134        // bother looking and return the last indices. This
    135        // is a second cache within the cache. This is
    136        // efficient because we are usually looking for
    137        // several secondary elements with the same primary
    138        // key.
    139        if ((lastArray == array) && (lastKey == key)) {
    140            return lastIndexes;
    141        }
    142
    143        // Remember the last thing we found.
    144        lastArray = array;
    145        lastKey = key;
    146        lastIndexes = knownArrays.get(array).indexesForKey(key);
    147
    148        return lastIndexes;
    149    }
    150}