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.bcel.classfile;
018
019import java.io.DataInput;
020import java.io.DataOutputStream;
021import java.io.IOException;
022import java.util.HashMap;
023import java.util.LinkedHashMap;
024import java.util.Map;
025import java.util.Objects;
026
027import org.apache.bcel.Const;
028
029/**
030 * Extends the abstract {@link Constant} to represent a reference to a UTF-8 encoded string.
031 * <p>
032 * The following system properties govern caching this class performs.
033 * </p>
034 * <ul>
035 * <li>{@link #SYS_PROP_CACHE_MAX_ENTRIES} (since 6.4): The size of the cache, by default 0, meaning caching is
036 * disabled.</li>
037 * <li>{@link #SYS_PROP_CACHE_MAX_ENTRY_SIZE} (since 6.0): The maximum size of the values to cache, by default 200, 0
038 * disables caching. Values larger than this are <em>not</em> cached.</li>
039 * <li>{@link #SYS_PROP_STATISTICS} (since 6.0): Prints statistics on the console when the JVM exits.</li>
040 * </ul>
041 * <p>
042 * Here is a sample Maven invocation with caching disabled:
043 * </p>
044 *
045 * <pre>
046 * mvn test -Dbcel.statistics=true -Dbcel.maxcached.size=0 -Dbcel.maxcached=0
047 * </pre>
048 * <p>
049 * Here is a sample Maven invocation with caching enabled:
050 * </p>
051 *
052 * <pre>
053 * mvn test -Dbcel.statistics=true -Dbcel.maxcached.size=100000 -Dbcel.maxcached=5000000
054 * </pre>
055 *
056 * @see Constant
057 */
058public final class ConstantUtf8 extends Constant {
059
060    private static final class Cache {
061
062        private static final boolean BCEL_STATISTICS = Boolean.getBoolean(SYS_PROP_STATISTICS);
063        private static final int MAX_ENTRIES = Integer.getInteger(SYS_PROP_CACHE_MAX_ENTRIES, 0).intValue();
064        private static final int INITIAL_CAPACITY = (int) (MAX_ENTRIES / 0.75);
065
066        private static final HashMap<String, ConstantUtf8> CACHE = new LinkedHashMap<String, ConstantUtf8>(INITIAL_CAPACITY, 0.75f, true) {
067
068            private static final long serialVersionUID = -8506975356158971766L;
069
070            @Override
071            protected boolean removeEldestEntry(final Map.Entry<String, ConstantUtf8> eldest) {
072                return size() > MAX_ENTRIES;
073            }
074        };
075
076        // Set the size to 0 or below to skip caching entirely
077        private static final int MAX_ENTRY_SIZE = Integer.getInteger(SYS_PROP_CACHE_MAX_ENTRY_SIZE, 200).intValue();
078
079        static boolean isEnabled() {
080            return Cache.MAX_ENTRIES > 0 && MAX_ENTRY_SIZE > 0;
081        }
082
083    }
084
085    // TODO these should perhaps be AtomicInt?
086    private static volatile int considered;
087    private static volatile int created;
088    private static volatile int hits;
089    private static volatile int skipped;
090
091    private static final String SYS_PROP_CACHE_MAX_ENTRIES = "bcel.maxcached";
092    private static final String SYS_PROP_CACHE_MAX_ENTRY_SIZE = "bcel.maxcached.size";
093    private static final String SYS_PROP_STATISTICS = "bcel.statistics";
094
095    static {
096        if (Cache.BCEL_STATISTICS) {
097            Runtime.getRuntime().addShutdownHook(new Thread(ConstantUtf8::printStats));
098        }
099    }
100
101    /**
102     * Clears the cache.
103     *
104     * @since 6.4.0
105     */
106    public static synchronized void clearCache() {
107        Cache.CACHE.clear();
108    }
109
110    // for access by test code
111    static synchronized void clearStats() {
112        hits = considered = skipped = created = 0;
113    }
114
115    // Avoid Spotbugs complaint about Write to static field
116    private static void countCreated() {
117        created++;
118    }
119
120    /**
121     * Gets a new or cached instance of the given value.
122     * <p>
123     * See {@link ConstantUtf8} class Javadoc for details.
124     * </p>
125     *
126     * @param value the value.
127     * @return a new or cached instance of the given value.
128     * @since 6.0
129     */
130    public static ConstantUtf8 getCachedInstance(final String value) {
131        if (value.length() > Cache.MAX_ENTRY_SIZE) {
132            skipped++;
133            return new ConstantUtf8(value);
134        }
135        considered++;
136        synchronized (ConstantUtf8.class) { // might be better with a specific lock object
137            ConstantUtf8 result = Cache.CACHE.get(value);
138            if (result != null) {
139                hits++;
140                return result;
141            }
142            result = new ConstantUtf8(value);
143            Cache.CACHE.put(value, result);
144            return result;
145        }
146    }
147
148    /**
149     * Gets a new or cached instance of the given value.
150     * <p>
151     * See {@link ConstantUtf8} class Javadoc for details.
152     * </p>
153     *
154     * @param dataInput the value.
155     * @return a new or cached instance of the given value.
156     * @throws IOException if an I/O error occurs.
157     * @since 6.0
158     */
159    public static ConstantUtf8 getInstance(final DataInput dataInput) throws IOException {
160        return getInstance(dataInput.readUTF());
161    }
162
163    /**
164     * Gets a new or cached instance of the given value.
165     * <p>
166     * See {@link ConstantUtf8} class Javadoc for details.
167     * </p>
168     *
169     * @param value the value.
170     * @return a new or cached instance of the given value.
171     * @since 6.0
172     */
173    public static ConstantUtf8 getInstance(final String value) {
174        return Cache.isEnabled() ? getCachedInstance(value) : new ConstantUtf8(value);
175    }
176
177    // for access by test code
178    static void printStats() {
179        final String prefix = "[Apache Commons BCEL]";
180        System.err.printf("%s Cache hit %,d/%,d, %d skipped.%n", prefix, hits, considered, skipped);
181        System.err.printf("%s Total of %,d ConstantUtf8 objects created.%n", prefix, created);
182        System.err.printf("%s Configuration: %s=%,d, %s=%,d.%n", prefix, SYS_PROP_CACHE_MAX_ENTRIES, Cache.MAX_ENTRIES, SYS_PROP_CACHE_MAX_ENTRY_SIZE,
183            Cache.MAX_ENTRY_SIZE);
184    }
185
186    private final String value;
187
188    /**
189     * Initializes from another object.
190     *
191     * @param constantUtf8 the value.
192     */
193    public ConstantUtf8(final ConstantUtf8 constantUtf8) {
194        this(constantUtf8.getBytes());
195    }
196
197    /**
198     * Initializes instance from file data.
199     *
200     * @param dataInput Input stream
201     * @throws IOException if an I/O error occurs.
202     */
203    ConstantUtf8(final DataInput dataInput) throws IOException {
204        super(Const.CONSTANT_Utf8);
205        value = dataInput.readUTF();
206        countCreated();
207    }
208
209    /**
210     * @param value Data
211     */
212    public ConstantUtf8(final String value) {
213        super(Const.CONSTANT_Utf8);
214        this.value = Objects.requireNonNull(value, "value");
215        countCreated();
216    }
217
218    /**
219     * Called by objects that are traversing the nodes of the tree implicitly defined by the contents of a Java class.
220     * I.e., the hierarchy of methods, fields, attributes, etc. spawns a tree of objects.
221     *
222     * @param v Visitor object
223     */
224    @Override
225    public void accept(final Visitor v) {
226        v.visitConstantUtf8(this);
227    }
228
229    /**
230     * Dumps String in Utf8 format to file stream.
231     *
232     * @param file Output file stream
233     * @throws IOException if an I/O error occurs.
234     */
235    @Override
236    public void dump(final DataOutputStream file) throws IOException {
237        file.writeByte(super.getTag());
238        file.writeUTF(value);
239    }
240
241    /**
242     * @return Data converted to string.
243     */
244    public String getBytes() {
245        return value;
246    }
247
248    /**
249     * @param bytes the raw bytes of this UTF-8
250     * @deprecated (since 6.0)
251     */
252    @java.lang.Deprecated
253    public void setBytes(final String bytes) {
254        throw new UnsupportedOperationException();
255    }
256
257    /**
258     * @return String representation
259     */
260    @Override
261    public String toString() {
262        return super.toString() + "(\"" + Utility.replace(value, "\n", "\\n") + "\")";
263    }
264}