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) throws IOException { 184 stream.defaultWriteObject(); 185 stream.writeInt(this.store.size()); 186 Set keys = this.store.keySet(); 187 Iterator iterator = keys.iterator(); 188 while (iterator.hasNext()) { 189 Comparable key = (Comparable) iterator.next(); 190 stream.writeObject(key); 191 Stroke stroke = getStroke(key); 192 SerialUtilities.writeStroke(stroke, stream); 193 } 194 } 195 196 /** 197 * Provides serialization support. 198 * 199 * @param stream the input stream. 200 * 201 * @throws IOException if there is an I/O error. 202 * @throws ClassNotFoundException if there is a classpath problem. 203 */ 204 private void readObject(ObjectInputStream stream) 205 throws IOException, ClassNotFoundException { 206 stream.defaultReadObject(); 207 this.store = new TreeMap(); 208 int keyCount = stream.readInt(); 209 for (int i = 0; i < keyCount; i++) { 210 Comparable key = (Comparable) stream.readObject(); 211 Stroke stroke = SerialUtilities.readStroke(stream); 212 this.store.put(key, stroke); 213 } 214 } 215 216 }