Back to index...

	/*
	* Copyright (c) 2001, 2008, 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 javax.swing.text;

	import java.util.ArrayList;
	import java.util.List;

	/**
	* SegmentCache caches <code>Segment</code>s to avoid continually creating
	* and destroying of <code>Segment</code>s. A common use of this class would
	* be:
	* <pre>
	* Segment segment = segmentCache.getSegment();
	* // do something with segment
	* ...
	* segmentCache.releaseSegment(segment);
	* </pre>
	*
	*/
	class SegmentCache {
	/**
	* A global cache.
	*/
	private static SegmentCache sharedCache = new SegmentCache();

	/**
	* A list of the currently unused Segments.
	*/
	private List<Segment> segments;


	/**
	* Returns the shared SegmentCache.
	*/
	public static SegmentCache getSharedInstance() {
	return sharedCache;
	}

	/**
	* A convenience method to get a Segment from the shared
	* <code>SegmentCache</code>.
	*/
	public static Segment getSharedSegment() {
	return getSharedInstance().getSegment();
	}

	/**
	* A convenience method to release a Segment to the shared
	* <code>SegmentCache</code>.
	*/
	public static void releaseSharedSegment(Segment segment) {
	getSharedInstance().releaseSegment(segment);
	}



	/**
	* Creates and returns a SegmentCache.
	*/
	public SegmentCache() {
	segments = new ArrayList<Segment>(11);
	}

	/**
	* Returns a <code>Segment</code>. When done, the <code>Segment</code>
	* should be recycled by invoking <code>releaseSegment</code>.
	*/
	public Segment getSegment() {
	synchronized(this) {
	int size = segments.size();

	if (size > 0) {
	return segments.remove(size - 1);
	}
	}
	return new CachedSegment();
	}

	/**
	* Releases a Segment. You should not use a Segment after you release it,
	* and you should NEVER release the same Segment more than once, eg:
	* <pre>
	* segmentCache.releaseSegment(segment);
	* segmentCache.releaseSegment(segment);
	* </pre>
	* Will likely result in very bad things happening!
	*/
	public void releaseSegment(Segment segment) {
	if (segment instanceof CachedSegment) {
	synchronized(this) {
	segment.array = null;
	segment.count = 0;
	segments.add(segment);
	}
	}
	}


	/**
	* CachedSegment is used as a tagging interface to determine if
	* a Segment can successfully be shared.
	*/
	private static class CachedSegment extends Segment {
	}
	}

Back to index...