001: /* ===========================================================
002: * JFreeChart : a free chart library for the Java(tm) platform
003: * ===========================================================
004: *
005: * (C) Copyright 2000-2006, by Object Refinery Limited and Contributors.
006: *
007: * Project Info: http://www.jfree.org/jfreechart/index.html
008: *
009: * This library is free software; you can redistribute it and/or modify it
010: * under the terms of the GNU Lesser General Public License as published by
011: * the Free Software Foundation; either version 2.1 of the License, or
012: * (at your option) any later version.
013: *
014: * This library is distributed in the hope that it will be useful, but
015: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
016: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
017: * License for more details.
018: *
019: * You should have received a copy of the GNU Lesser General Public
020: * License along with this library; if not, write to the Free Software
021: * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
022: * USA.
023: *
024: * [Java is a trademark or registered trademark of Sun Microsystems, Inc.
025: * in the United States and other countries.]
026: *
027: * --------------
028: * StrokeMap.java
029: * --------------
030: * (C) Copyright 2006, by Object Refinery Limited.
031: *
032: * Original Author: David Gilbert (for Object Refinery Limited);
033: * Contributor(s): -;
034: *
035: * $Id: StrokeMap.java,v 1.1.2.1 2006/09/27 17:06:59 mungady Exp $
036: *
037: * Changes:
038: * --------
039: * 27-Sep-2006 : Version 1 (DG);
040: *
041: */
042:
043: package org.jfree.chart;
044:
045: import java.awt.Stroke;
046: import java.io.IOException;
047: import java.io.ObjectInputStream;
048: import java.io.ObjectOutputStream;
049: import java.io.Serializable;
050: import java.util.Iterator;
051: import java.util.Map;
052: import java.util.Set;
053: import java.util.TreeMap;
054:
055: import org.jfree.io.SerialUtilities;
056: import org.jfree.util.ObjectUtilities;
057:
058: /**
059: * A storage structure that maps <code>Comparable</code> instances with
060: * <code>Stroke</code> instances.
061: * <br><br>
062: * To support cloning and serialization, you should only use keys that are
063: * cloneable and serializable. Special handling for the <code>Stroke</code>
064: * instances is included in this class.
065: *
066: * @since 1.0.3
067: */
068: public class StrokeMap implements Cloneable, Serializable {
069:
070: /** Storage for the keys and values. */
071: private transient Map store;
072:
073: /**
074: * Creates a new (empty) map.
075: */
076: public StrokeMap() {
077: this .store = new TreeMap();
078: }
079:
080: /**
081: * Returns the stroke associated with the specified key, or
082: * <code>null</code>.
083: *
084: * @param key the key (<code>null</code> not permitted).
085: *
086: * @return The stroke, or <code>null</code>.
087: *
088: * @throws IllegalArgumentException if <code>key</code> is
089: * <code>null</code>.
090: */
091: public Stroke getStroke(Comparable key) {
092: if (key == null) {
093: throw new IllegalArgumentException("Null 'key' argument.");
094: }
095: return (Stroke) this .store.get(key);
096: }
097:
098: /**
099: * Returns <code>true</code> if the map contains the specified key, and
100: * <code>false</code> otherwise.
101: *
102: * @param key the key.
103: *
104: * @return <code>true</code> if the map contains the specified key, and
105: * <code>false</code> otherwise.
106: */
107: public boolean containsKey(Comparable key) {
108: return this .store.containsKey(key);
109: }
110:
111: /**
112: * Adds a mapping between the specified <code>key</code> and
113: * <code>stroke</code> values.
114: *
115: * @param key the key (<code>null</code> not permitted).
116: * @param stroke the stroke.
117: */
118: public void put(Comparable key, Stroke stroke) {
119: if (key == null) {
120: throw new IllegalArgumentException("Null 'key' argument.");
121: }
122: this .store.put(key, stroke);
123: }
124:
125: /**
126: * Resets the map to empty.
127: */
128: public void clear() {
129: this .store.clear();
130: }
131:
132: /**
133: * Tests this map for equality with an arbitrary object.
134: *
135: * @param obj the object (<code>null</code> permitted).
136: *
137: * @return A boolean.
138: */
139: public boolean equals(Object obj) {
140: if (obj == this ) {
141: return true;
142: }
143: if (!(obj instanceof StrokeMap)) {
144: return false;
145: }
146: StrokeMap that = (StrokeMap) obj;
147: if (this .store.size() != that.store.size()) {
148: return false;
149: }
150: Set keys = this .store.keySet();
151: Iterator iterator = keys.iterator();
152: while (iterator.hasNext()) {
153: Comparable key = (Comparable) iterator.next();
154: Stroke s1 = getStroke(key);
155: Stroke s2 = that.getStroke(key);
156: if (!ObjectUtilities.equal(s1, s2)) {
157: return false;
158: }
159: }
160: return true;
161: }
162:
163: /**
164: * Returns a clone of this <code>StrokeMap</code>.
165: *
166: * @return A clone of this instance.
167: *
168: * @throws CloneNotSupportedException if any key is not cloneable.
169: */
170: public Object clone() throws CloneNotSupportedException {
171: // TODO: I think we need to make sure the keys are actually cloned,
172: // whereas the stroke instances are always immutable so they're OK
173: return super .clone();
174: }
175:
176: /**
177: * Provides serialization support.
178: *
179: * @param stream the output stream.
180: *
181: * @throws IOException if there is an I/O error.
182: */
183: private void writeObject(ObjectOutputStream stream)
184: throws IOException {
185: stream.defaultWriteObject();
186: stream.writeInt(this .store.size());
187: Set keys = this .store.keySet();
188: Iterator iterator = keys.iterator();
189: while (iterator.hasNext()) {
190: Comparable key = (Comparable) iterator.next();
191: stream.writeObject(key);
192: Stroke stroke = getStroke(key);
193: SerialUtilities.writeStroke(stroke, stream);
194: }
195: }
196:
197: /**
198: * Provides serialization support.
199: *
200: * @param stream the input stream.
201: *
202: * @throws IOException if there is an I/O error.
203: * @throws ClassNotFoundException if there is a classpath problem.
204: */
205: private void readObject(ObjectInputStream stream)
206: throws IOException, ClassNotFoundException {
207: stream.defaultReadObject();
208: this .store = new TreeMap();
209: int keyCount = stream.readInt();
210: for (int i = 0; i < keyCount; i++) {
211: Comparable key = (Comparable) stream.readObject();
212: Stroke stroke = SerialUtilities.readStroke(stream);
213: this.store.put(key, stroke);
214: }
215: }
216:
217: }
|