001: /*
002: * Copyright 2006 Le Duc Bao, Ralf Joachim
003: *
004: * Licensed under the Apache License, Version 2.0 (the "License"); you may not
005: * use this file except in compliance with the License. You may obtain a copy of
006: * the License at
007: *
008: * http://www.apache.org/licenses/LICENSE-2.0
009: *
010: * Unless required by applicable law or agreed to in writing, software
011: * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
012: * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
013: * License for the specific language governing permissions and limitations under
014: * the License.
015: */
016: package org.castor.ddlgen;
017:
018: import java.util.Collection;
019: import java.util.Collections;
020: import java.util.Hashtable;
021: import java.util.Map;
022: import java.util.StringTokenizer;
023:
024: import org.apache.commons.logging.Log;
025: import org.apache.commons.logging.LogFactory;
026: import org.castor.ddlgen.schemaobject.KeyGenerator;
027: import org.exolab.castor.mapping.xml.KeyGeneratorDef;
028:
029: /**
030: * Registry for key generator factory implementations obtained from the configuration.
031: * In addition this is also a registry for key generators that holds default key
032: * generators as well as key generators defined through mapping.
033: *
034: * @author <a href="mailto:leducbao AT gmail DOT com">Le Duc Bao</a>
035: * @author <a href="mailto:ralf DOT joachim AT syscon DOT eu">Ralf Joachim</a>
036: * @version $Revision: 5951 $ $Date: 2006-04-25 16:09:10 -0600 (Tue, 25 Apr 2006) $
037: * @since 1.1
038: */
039: public final class KeyGeneratorRegistry {
040: //--------------------------------------------------------------------------
041:
042: /** The <a href="http://jakarta.apache.org/commons/logging/">Jakarta Commons
043: * Logging </a> instance used for all logging. */
044: private static final Log LOG = LogFactory
045: .getLog(KeyGeneratorRegistry.class);
046:
047: //--------------------------------------------------------------------------
048:
049: /** Configuration to be used for all key generators. */
050: private final DDLGenConfiguration _config;
051:
052: /** Association between algorithm name and key generator factory implementation. */
053: private final Map _factories = new Hashtable();
054:
055: /** Association between key generator name and key generator implementation. */
056: private final Map _generators = new Hashtable();
057:
058: //--------------------------------------------------------------------------
059:
060: /**
061: * Construct an instance of each key generator factory specified in given
062: * configuration. If key generator does not require mandatory parameters a default
063: * instance of the key generator will also be created.
064: *
065: * @param config The configuration to obtain the key generator factory classes from.
066: * Also used for all key generator instances to obtain configuration
067: * properties from.
068: */
069: public KeyGeneratorRegistry(final DDLGenConfiguration config) {
070: _config = config;
071:
072: String prop = config.getStringValue(
073: DDLGenConfiguration.KEYGEN_FACTORIES_KEY, "");
074: StringTokenizer tokenizer = new StringTokenizer(prop, ",");
075: ClassLoader loader = KeyGeneratorRegistry.class
076: .getClassLoader();
077: while (tokenizer.hasMoreTokens()) {
078: String classname = tokenizer.nextToken().trim();
079: try {
080: Class cls = loader.loadClass(classname);
081: KeyGeneratorFactory factory = (KeyGeneratorFactory) cls
082: .newInstance();
083: _factories.put(factory.getAlgorithmName(), factory);
084:
085: if (!factory.hasMandatoryParameters()) {
086: KeyGenerator generator = factory
087: .createKeyGenerator();
088: _generators.put(generator.getAlias(), generator);
089: }
090: } catch (Exception ex) {
091: String msg = "Problem instantiating key generator factory: ";
092: LOG.error(msg + classname, ex);
093: }
094: }
095: }
096:
097: //--------------------------------------------------------------------------
098:
099: /**
100: * Create an instance of the key generator specifed by given definiton. The name
101: * of the definition is used as algorithm to lookup the key generator factory. The
102: * is used to create a key generator initialized with the given definition and the
103: * configuration that has been passed to the constructor of this registry. At least
104: * the key generator is added to the registry assoziated by its alias.
105: *
106: * @param definition The definition to initialize the key generator.
107: * @return A key generator instance initialized with given definition.
108: * @throws GeneratorException If failed to create a key generator instance.
109: */
110: public KeyGenerator createKeyGenerator(
111: final KeyGeneratorDef definition) throws GeneratorException {
112: String algorithm = definition.getName();
113: KeyGeneratorFactory factory = getKeyGeneratorFactory(algorithm);
114: if (factory == null) {
115: LOG.warn("Unknown KeyGeneratorFactory: " + algorithm);
116: throw new GeneratorException(
117: "Unknown KeyGeneratorFactory: " + algorithm);
118: }
119:
120: KeyGenerator generator = factory.createKeyGenerator(definition);
121: generator.setConfiguration(_config);
122: _generators.put(generator.getAlias(), generator);
123: return generator;
124: }
125:
126: //--------------------------------------------------------------------------
127:
128: /**
129: * Returns key generator factory with given algorithm.
130: *
131: * @param algorithm Algorithm of the key generator factory.
132: * @return Key generator factory with algorithm.
133: * @throws GeneratorException If no key generator factory with given algorithm can
134: * be found.
135: */
136: public KeyGeneratorFactory getKeyGeneratorFactory(
137: final String algorithm) throws GeneratorException {
138: if (algorithm == null) {
139: throw new GeneratorException("No algorithm specified");
140: }
141: KeyGeneratorFactory factory = (KeyGeneratorFactory) _factories
142: .get(algorithm);
143: if (factory == null) {
144: LOG.warn("Unknown KeyGeneratorFactory: " + algorithm);
145: throw new GeneratorException(
146: "Unknown KeyGeneratorFactory: " + algorithm);
147: }
148: return factory;
149: }
150:
151: /**
152: * Returns a collection of the current configured key generator factories.
153: *
154: * @return Collection of the current configured key generator factories.
155: */
156: public Collection getKeyGeneratorFactories() {
157: return Collections.unmodifiableCollection(_factories.values());
158: }
159:
160: /**
161: * Returns a collection of the algorithms of current configured key generator
162: * factories.
163: *
164: * @return Algorithms of current configured key generator factories.
165: */
166: public Collection getKeyGeneratorFactoryAlgorithms() {
167: return Collections.unmodifiableCollection(_factories.keySet());
168: }
169:
170: //--------------------------------------------------------------------------
171:
172: /**
173: * Returns key generator with given alias.
174: *
175: * @param alias Alias of the key generator.
176: * @return Generator with given alias.
177: * @throws GeneratorException If no generator for alias can be found.
178: */
179: public KeyGenerator getKeyGenerator(final String alias)
180: throws GeneratorException {
181: if (alias == null) {
182: throw new GeneratorException(
183: "No keygenerator alias specified");
184: }
185: KeyGenerator generator = (KeyGenerator) _generators.get(alias);
186: if (generator == null) {
187: LOG.warn("Unknown KeyGenerator: " + alias);
188: throw new GeneratorException("Unknown KeyGenerator: "
189: + alias);
190: }
191: return generator;
192: }
193:
194: /**
195: * Returns a collection of the current registered key generators.
196: *
197: * @return Collection of the current registered key generators.
198: */
199: public Collection getKeyGenerators() {
200: return Collections.unmodifiableCollection(_generators.values());
201: }
202:
203: /**
204: * Returns a collection of the aliasses of current registered key generators.
205: *
206: * @return Aliasses of current registered key generators.
207: */
208: public Collection getKeyGeneratorAliases() {
209: return Collections.unmodifiableCollection(_generators.keySet());
210: }
211:
212: //--------------------------------------------------------------------------
213: }
|