Back to index...

	/*
	* Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package sun.util.resources;

	import java.util.AbstractSet;
	import java.util.Collections;
	import java.util.Enumeration;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.NoSuchElementException;
	import java.util.ResourceBundle;
	import java.util.Set;
	import java.util.concurrent.ConcurrentHashMap;
	import java.util.concurrent.ConcurrentMap;
	import java.util.concurrent.atomic.AtomicMarkableReference;

	/**
	* ParallelListResourceBundle is another variant of ListResourceBundle
	* supporting "parallel" contents provided by another resource bundle
	* (OpenListResourceBundle). Parallel contents, if any, are added into this
	* bundle on demand.
	*
	* @author Masayoshi Okutsu
	*/
	public abstract class ParallelListResourceBundle extends ResourceBundle {
	private volatile ConcurrentMap<String, Object> lookup;
	private volatile Set<String> keyset;
	private final AtomicMarkableReference<Object[][]> parallelContents
	= new AtomicMarkableReference<>(null, false);

	/**
	* Sole constructor. (For invocation by subclass constructors, typically
	* implicit.)
	*/
	protected ParallelListResourceBundle() {
	}

	/**
	* Returns an array in which each item is a pair of objects in an
	* Object array. The first element of each pair is the key, which
	* must be a String, and the second element is the value
	* associated with that key. See the class description for
	* details.
	*
	* @return an array of an Object array representing a key-value pair.
	*/
	protected abstract Object[][] getContents();

	/**
	* Returns the parent of this resource bundle or null if there's no parent.
	*
	* @return the parent or null if no parent
	*/
	ResourceBundle getParent() {
	return parent;
	}

	/**
	* Sets the parallel contents to the data given by rb. If rb is null, this
	* bundle will be marked as `complete'.
	*
	* @param rb an OpenResourceBundle for parallel contents, or null indicating
	* there are no parallel contents for this bundle
	*/
	public void setParallelContents(OpenListResourceBundle rb) {
	if (rb == null) {
	parallelContents.compareAndSet(null, null, false, true);
	} else {
	parallelContents.compareAndSet(null, rb.getContents(), false, false);
	}
	}

	/**
	* Returns true if any parallel contents have been set or if this bundle is
	* marked as complete.
	*
	* @return true if any parallel contents have been processed
	*/
	boolean areParallelContentsComplete() {
	// Quick check for `complete'
	if (parallelContents.isMarked()) {
	return true;
	}
	boolean[] done = new boolean[1];
	Object[][] data = parallelContents.get(done);
	return data != null \|\| done[0];
	}

	@Override
	protected Object handleGetObject(String key) {
	if (key == null) {
	throw new NullPointerException();
	}

	loadLookupTablesIfNecessary();
	return lookup.get(key);
	}

	@Override
	public Enumeration<String> getKeys() {
	return Collections.enumeration(keySet());
	}

	@Override
	public boolean containsKey(String key) {
	return keySet().contains(key);
	}

	@Override
	protected Set<String> handleKeySet() {
	loadLookupTablesIfNecessary();
	return lookup.keySet();
	}

	@Override
	@SuppressWarnings("UnusedAssignment")
	public Set<String> keySet() {
	Set<String> ks;
	while ((ks = keyset) == null) {
	ks = new KeySet(handleKeySet(), parent);
	synchronized (this) {
	if (keyset == null) {
	keyset = ks;
	}
	}
	}
	return ks;
	}

	/**
	* Discards any cached keyset value. This method is called from
	* LocaleData for re-creating a KeySet.
	*/
	synchronized void resetKeySet() {
	keyset = null;
	}

	/**
	* Loads the lookup table if they haven't been loaded already.
	*/
	void loadLookupTablesIfNecessary() {
	ConcurrentMap<String, Object> map = lookup;
	if (map == null) {
	map = new ConcurrentHashMap<>();
	for (Object[] item : getContents()) {
	map.put((String) item[0], item[1]);
	}
	}

	// If there's any parallel contents data, merge the data into map.
	Object[][] data = parallelContents.getReference();
	if (data != null) {
	for (Object[] item : data) {
	map.putIfAbsent((String) item[0], item[1]);
	}
	parallelContents.set(null, true);
	}
	if (lookup == null) {
	synchronized (this) {
	if (lookup == null) {
	lookup = map;
	}
	}
	}
	}

	/**
	* This class implements the Set interface for
	* ParallelListResourceBundle methods.
	*/
	private static class KeySet extends AbstractSet<String> {
	private final Set<String> set;
	private final ResourceBundle parent;

	private KeySet(Set<String> set, ResourceBundle parent) {
	this.set = set;
	this.parent = parent;
	}

	@Override
	public boolean contains(Object o) {
	if (set.contains(o)) {
	return true;
	}
	return (parent != null) ? parent.containsKey((String) o) : false;
	}

	@Override
	public Iterator<String> iterator() {
	if (parent == null) {
	return set.iterator();
	}
	return new Iterator<>() {
	private Iterator<String> itr = set.iterator();
	private boolean usingParent;

	@Override
	public boolean hasNext() {
	if (itr.hasNext()) {
	return true;
	}
	if (!usingParent) {
	Set<String> nextset = new HashSet<>(parent.keySet());
	nextset.removeAll(set);
	itr = nextset.iterator();
	usingParent = true;
	}
	return itr.hasNext();
	}

	@Override
	public String next() {
	if (hasNext()) {
	return itr.next();
	}
	throw new NoSuchElementException();
	}

	@Override
	public void remove() {
	throw new UnsupportedOperationException();
	}
	};
	}

	@Override
	public int size() {
	if (parent == null) {
	return set.size();
	}
	Set<String> allset = new HashSet<>(set);
	allset.addAll(parent.keySet());
	return allset.size();
	}
	}
	}

Back to index...