001: /* ========================================================================
002: * JCommon : a free general purpose class library for the Java(tm) platform
003: * ========================================================================
004: *
005: * (C) Copyright 2000-2005, by Object Refinery Limited and Contributors.
006: *
007: * Project Info: http://www.jfree.org/jcommon/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: * SimpleObjectFactory.java
029: * ------------------------
030: * (C)opyright 2003-2005, by Thomas Morgner and Contributors.
031: *
032: * Original Author: Thomas Morgner;
033: * Contributor(s): David Gilbert (for Object Refinery Limited);
034: *
035: * $Id: SimpleObjectFactory.java,v 1.3 2005/10/18 13:33:53 mungady Exp $
036: *
037: * Changes
038: * -------
039: * 02-Dec-2003 : Initial version
040: *
041: */
042:
043: package org.jfree.xml.util;
044:
045: import java.util.HashMap;
046:
047: /**
048: * A simple object factory.
049: */
050: public class SimpleObjectFactory implements ObjectFactory {
051:
052: /** The object mappings. */
053: private HashMap objectMappings;
054:
055: /** The manual object mappings. */
056: private HashMap manualMappings;
057:
058: /** The multiplex mappings. */
059: private HashMap multiplexMappings;
060:
061: /**
062: * Creates a new instance.
063: */
064: public SimpleObjectFactory() {
065: this .objectMappings = new HashMap();
066: this .manualMappings = new HashMap();
067: this .multiplexMappings = new HashMap();
068: }
069:
070: /**
071: * Adds a manual mapping.
072: *
073: * @param mapping the mapping.
074: */
075: public void addManualMapping(final ManualMappingDefinition mapping) {
076: this .manualMappings.put(mapping.getBaseClass(), mapping);
077: }
078:
079: /**
080: * Adds a generic handler.
081: *
082: * @param handler the handler.
083: */
084: public void addGenericHandler(final GenericObjectFactory handler) {
085: this .objectMappings.put(handler.getBaseClass(), handler);
086: }
087:
088: /**
089: * Adds a multiplex mapping.
090: *
091: * @param mplex the multiplex mapping.
092: */
093: public void addMultiplexMapping(
094: final MultiplexMappingDefinition mplex) {
095: this .multiplexMappings.put(mplex.getBaseClass(), mplex);
096: }
097:
098: /**
099: * Clears the mappings.
100: */
101: public void clear() {
102: this .objectMappings.clear();
103: this .manualMappings.clear();
104: this .multiplexMappings.clear();
105: }
106:
107: /**
108: * Returns a factory instance for the given class. The factory is independent
109: * from all previously generated instances.
110: *
111: * @param c the class
112: * @return the object factory.
113: */
114: public GenericObjectFactory getFactoryForClass(final Class c) {
115: final GenericObjectFactory factory = (GenericObjectFactory) this .objectMappings
116: .get(c);
117: if (factory == null) {
118: return null;
119: }
120: return factory.getInstance();
121: }
122:
123: /**
124: * Returns the manual mapping definition for the given class, or null, if
125: * not manual definition exists.
126: *
127: * @param c the class for which to check the existence of the definition
128: * @return the manual mapping definition or null.
129: */
130: public ManualMappingDefinition getManualMappingDefinition(
131: final Class c) {
132: return (ManualMappingDefinition) this .manualMappings.get(c);
133: }
134:
135: /**
136: * Returns the multiplex definition for the given class, or null, if no
137: * such definition exists.
138: *
139: * @param c the class for which to check the existence of the multiplexer
140: * @return the multiplexer for the class, or null if no multiplexer exists.
141: */
142: public MultiplexMappingDefinition getMultiplexDefinition(
143: final Class c) {
144: final MultiplexMappingDefinition definition = (MultiplexMappingDefinition) this .multiplexMappings
145: .get(c);
146: return definition;
147: }
148:
149: /**
150: * Checks, whether a generic handler exists for the given class. This does
151: * not check, whether an mapping exists.
152: *
153: * @param c the class for which to check
154: * @return true, if an generic handler is defined, false otherwise.
155: */
156: public boolean isGenericHandler(final Class c) {
157: return this.objectMappings.containsKey(c);
158: }
159: }
|