MemorySensitiveClassPathRepository.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.util;

  18. import java.lang.ref.SoftReference;
  19. import java.util.HashMap;
  20. import java.util.Map;

  21. import org.apache.bcel.classfile.JavaClass;

  22. /**
  23.  * This repository is used in situations where a Class is created outside the realm of a ClassLoader. Classes are loaded
  24.  * from the file systems using the paths specified in the given class path. By default, this is the value returned by
  25.  * ClassPath.getClassPath(). This repository holds onto classes with SoftReferences, and will reload as needed, in cases
  26.  * where memory sizes are important.
  27.  *
  28.  * @see org.apache.bcel.Repository
  29.  */
  30. public class MemorySensitiveClassPathRepository extends AbstractClassPathRepository {

  31.     private final Map<String, SoftReference<JavaClass>> loadedClasses = new HashMap<>(); // CLASSNAME X JAVACLASS

  32.     public MemorySensitiveClassPathRepository(final ClassPath path) {
  33.         super(path);
  34.     }

  35.     /**
  36.      * Clear all entries from cache.
  37.      */
  38.     @Override
  39.     public void clear() {
  40.         loadedClasses.clear();
  41.     }

  42.     /**
  43.      * Find an already defined (cached) JavaClass object by name.
  44.      */
  45.     @Override
  46.     public JavaClass findClass(final String className) {
  47.         final SoftReference<JavaClass> ref = loadedClasses.get(className);
  48.         return ref == null ? null : ref.get();
  49.     }

  50.     /**
  51.      * Remove class from repository
  52.      */
  53.     @Override
  54.     public void removeClass(final JavaClass clazz) {
  55.         loadedClasses.remove(clazz.getClassName());
  56.     }

  57.     /**
  58.      * Store a new JavaClass instance into this Repository.
  59.      */
  60.     @Override
  61.     public void storeClass(final JavaClass clazz) {
  62.         // Not calling super.storeClass because this subclass maintains the mapping.
  63.         loadedClasses.put(clazz.getClassName(), new SoftReference<>(clazz));
  64.         clazz.setRepository(this);
  65.     }
  66. }