1 /*
   2  * Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 /*
  27  * (C) Copyright Taligent, Inc. 1996, 1997 - All Rights Reserved
  28  * (C) Copyright IBM Corp. 1996 - 1998 - All Rights Reserved
  29  *
  30  * The original version of this source code and documentation
  31  * is copyrighted and owned by Taligent, Inc., a wholly-owned
  32  * subsidiary of IBM. These materials are provided under terms
  33  * of a License Agreement between Taligent and Sun. This technology
  34  * is protected by multiple US and International patents.
  35  *
  36  * This notice and attribution to Taligent may not be removed.
  37  * Taligent is a registered trademark of Taligent, Inc.
  38  *
  39  */
  40 
  41 package sun.util.resources;
  42 
  43 import java.util.Enumeration;
  44 import java.util.HashMap;
  45 import java.util.HashSet;
  46 import java.util.Map;
  47 import java.util.ResourceBundle;
  48 import java.util.Set;
  49 import sun.util.ResourceBundleEnumeration;
  50 
  51 /**
  52  * Subclass of <code>ResourceBundle</code> which mimics
  53  * <code>ListResourceBundle</code>, but provides more hooks
  54  * for specialized subclass behavior. For general description,
  55  * see {@link java.util.ListResourceBundle}.
  56  * <p>
  57  * This class leaves handleGetObject non-final, and
  58  * adds a method createMap which allows subclasses to
  59  * use specialized Map implementations.
  60  */
  61 public abstract class OpenListResourceBundle extends ResourceBundle {
  62     /**
  63      * Sole constructor.  (For invocation by subclass constructors, typically
  64      * implicit.)
  65      */
  66     protected OpenListResourceBundle() {
  67     }
  68 
  69     // Implements java.util.ResourceBundle.handleGetObject; inherits javadoc specification.
  70     @Override
  71     protected Object handleGetObject(String key) {
  72         if (key == null) {
  73             throw new NullPointerException();
  74         }
  75 
  76         loadLookupTablesIfNecessary();
  77         return lookup.get(key); // this class ignores locales
  78     }
  79 
  80     /**
  81      * Implementation of ResourceBundle.getKeys.
  82      */
  83     @Override
  84     public Enumeration<String> getKeys() {
  85         ResourceBundle parentBundle = this.parent;
  86         return new ResourceBundleEnumeration(handleKeySet(),
  87                 (parentBundle != null) ? parentBundle.getKeys() : null);
  88      }
  89 
  90     /**
  91      * Returns a set of keys provided in this resource bundle,
  92      * including no parents.
  93      */
  94     @Override
  95     protected Set<String> handleKeySet() {
  96         loadLookupTablesIfNecessary();
  97         return lookup.keySet();
  98     }
  99 
 100     @Override
 101     public Set<String> keySet() {
 102         if (keyset != null) {
 103             return keyset;
 104         }
 105         Set<String> ks = createSet();
 106         ks.addAll(handleKeySet());
 107         if (parent != null) {
 108             ks.addAll(parent.keySet());
 109         }
 110         synchronized (this) {
 111             if (keyset == null) {
 112                 keyset = ks;
 113             }
 114         }
 115         return keyset;
 116     }
 117 
 118     /**
 119      * See ListResourceBundle class description.
 120      */
 121     abstract protected Object[][] getContents();
 122 
 123     /**
 124      * Load lookup tables if they haven't been loaded already.
 125      */
 126     void loadLookupTablesIfNecessary() {
 127         if (lookup == null) {
 128             loadLookup();
 129         }
 130     }
 131 
 132     /**
 133      * We lazily load the lookup hashtable.  This function does the
 134      * loading.
 135      */
 136     private void loadLookup() {
 137         Object[][] contents = getContents();
 138         Map<String, Object> temp = createMap(contents.length);
 139         for (int i = 0; i < contents.length; ++i) {
 140             // key must be non-null String, value must be non-null
 141             String key = (String) contents[i][0];
 142             Object value = contents[i][1];
 143             if (key == null || value == null) {
 144                 throw new NullPointerException();
 145             }
 146             temp.put(key, value);
 147         }
 148         synchronized (this) {
 149             if (lookup == null) {
 150                 lookup = temp;
 151             }
 152         }
 153     }
 154 
 155     /**
 156      * Lets subclasses provide specialized Map implementations.
 157      * Default uses HashMap.
 158      */
 159     protected <K, V> Map<K, V> createMap(int size) {
 160         return new HashMap<>(size);
 161     }
 162 
 163     protected <E> Set<E> createSet() {
 164         return new HashSet<>();
 165     }
 166 
 167     private volatile Map<String, Object> lookup = null;
 168     private volatile Set<String> keyset;
 169 }