ConstantUtf8.java

  1. /*
  2.  * Licensed to the Apache Software Foundation (ASF) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * The ASF licenses this file to You under the Apache License, Version 2.0
  6.  * (the "License"); you may not use this file except in compliance with
  7.  * the License.  You may obtain a copy of the License at
  8.  *
  9.  *      http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  *  Unless required by applicable law or agreed to in writing, software
  12.  *  distributed under the License is distributed on an "AS IS" BASIS,
  13.  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  *  See the License for the specific language governing permissions and
  15.  *  limitations under the License.
  16.  */
  17. package org.apache.bcel.classfile;

  19. import java.io.DataInput;
  20. import java.io.DataOutputStream;
  21. import java.io.IOException;
  22. import java.util.HashMap;
  23. import java.util.LinkedHashMap;
  24. import java.util.Map;
  25. import java.util.Objects;

  27. import org.apache.bcel.Const;

  29. /**
  30.  * Extends the abstract {@link Constant} to represent a reference to a UTF-8 encoded string.
  31.  * <p>
  32.  * The following system properties govern caching this class performs.
  33.  * </p>
  34.  * <ul>
  35.  * <li>{@link #SYS_PROP_CACHE_MAX_ENTRIES} (since 6.4): The size of the cache, by default 0, meaning caching is
  36.  * disabled.</li>
  37.  * <li>{@link #SYS_PROP_CACHE_MAX_ENTRY_SIZE} (since 6.0): The maximum size of the values to cache, by default 200, 0
  38.  * disables caching. Values larger than this are <em>not</em> cached.</li>
  39.  * <li>{@link #SYS_PROP_STATISTICS} (since 6.0): Prints statistics on the console when the JVM exits.</li>
  40.  * </ul>
  41.  * <p>
  42.  * Here is a sample Maven invocation with caching disabled:
  43.  * </p>
  44.  *
  45.  * <pre>
  46.  * mvn test -Dbcel.statistics=true -Dbcel.maxcached.size=0 -Dbcel.maxcached=0
  47.  * </pre>
  48.  * <p>
  49.  * Here is a sample Maven invocation with caching enabled:
  50.  * </p>
  51.  *
  52.  * <pre>
  53.  * mvn test -Dbcel.statistics=true -Dbcel.maxcached.size=100000 -Dbcel.maxcached=5000000
  54.  * </pre>
  55.  *
  56.  * @see Constant
  57.  */
  58. public final class ConstantUtf8 extends Constant {

  60.     private static final class Cache {

  62.         private static final boolean BCEL_STATISTICS = Boolean.getBoolean(SYS_PROP_STATISTICS);
  63.         private static final int MAX_ENTRIES = Integer.getInteger(SYS_PROP_CACHE_MAX_ENTRIES, 0).intValue();
  64.         private static final int INITIAL_CAPACITY = (int) (MAX_ENTRIES / 0.75);

  66.         private static final HashMap<String, ConstantUtf8> CACHE = new LinkedHashMap<String, ConstantUtf8>(INITIAL_CAPACITY, 0.75f, true) {

  68.             private static final long serialVersionUID = -8506975356158971766L;

  70.             @Override
  71.             protected boolean removeEldestEntry(final Map.Entry<String, ConstantUtf8> eldest) {
  72.                 return size() > MAX_ENTRIES;
  73.             }
  74.         };

  76.         // Set the size to 0 or below to skip caching entirely
  77.         private static final int MAX_ENTRY_SIZE = Integer.getInteger(SYS_PROP_CACHE_MAX_ENTRY_SIZE, 200).intValue();

  79.         static boolean isEnabled() {
  80.             return MAX_ENTRIES > 0 && MAX_ENTRY_SIZE > 0;
  81.         }

  83.     }

  85.     // TODO these should perhaps be AtomicInt?
  86.     private static volatile int considered;
  87.     private static volatile int created;
  88.     private static volatile int hits;
  89.     private static volatile int skipped;

  91.     private static final String SYS_PROP_CACHE_MAX_ENTRIES = "bcel.maxcached";
  92.     private static final String SYS_PROP_CACHE_MAX_ENTRY_SIZE = "bcel.maxcached.size";
  93.     private static final String SYS_PROP_STATISTICS = "bcel.statistics";

  95.     static {
  96.         if (Cache.BCEL_STATISTICS) {
  97.             Runtime.getRuntime().addShutdownHook(new Thread(ConstantUtf8::printStats));
  98.         }
  99.     }

  101.     /**
  102.      * Clears the cache.
  103.      *
  104.      * @since 6.4.0
  105.      */
  106.     public static synchronized void clearCache() {
  107.         Cache.CACHE.clear();
  108.     }

  110.     // for access by test code
  111.     static synchronized void clearStats() {
  112.         hits = considered = skipped = created = 0;
  113.     }

  115.     // Avoid Spotbugs complaint about Write to static field
  116.     private static void countCreated() {
  117.         created++;
  118.     }

  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.     }

  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.     }

  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.     }

  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.     }

  186.     private final String value;

  188.     /**
  189.      * Initializes from another object.
  190.      *
  191.      * @param constantUtf8 the value.
  192.      */
  193.     public ConstantUtf8(final ConstantUtf8 constantUtf8) {
  194.         this(constantUtf8.getBytes());
  195.     }

  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.     }

  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.     }

  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.     }

  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.     }

  241.     /**
  242.      * @return Data converted to string.
  243.      */
  244.     public String getBytes() {
  245.         return value;
  246.     }

  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.     }

  257.     /**
  258.      * @return String representation
  259.      */
  260.     @Override
  261.     public String toString() {
  262.         return super.toString() + "(\"" + Utility.replace(value, "\n", "\\n") + "\")";
  263.     }
  264. }
Created with JaCoCo 0.8.12.202403310830