X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fcommons%2Fconcepts%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fconcepts%2Ftransform%2FCompositeClassBasedTransformer.java;h=2548c340d5d5f80807a99c8bd3ccf9c45674f843;hb=refs%2Fchanges%2F69%2F27369%2F1;hp=dae949912b96cfe564e018e2b99146597d26d626;hpb=eb9e1983a0fce7e4a381eff33e40cae957cddf53;p=controller.git

diff --git a/opendaylight/commons/concepts/src/main/java/org/opendaylight/controller/concepts/transform/CompositeClassBasedTransformer.java b/opendaylight/commons/concepts/src/main/java/org/opendaylight/controller/concepts/transform/CompositeClassBasedTransformer.java
index dae949912b..2548c340d5 100644
--- a/opendaylight/commons/concepts/src/main/java/org/opendaylight/controller/concepts/transform/CompositeClassBasedTransformer.java
+++ b/opendaylight/commons/concepts/src/main/java/org/opendaylight/controller/concepts/transform/CompositeClassBasedTransformer.java
@@ -1,121 +1,121 @@
-/*
- * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-package org.opendaylight.controller.concepts.transform;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-
-
-/**
- * Transformer which aggregates multiple implementations of
- * {@link InputClassBasedTransformer}.
- *
- * The transformation process is driven by {@link Class} of input. The selection
- * of used {@link InputClassBasedTransformer} is done by using the {@link Class}
- * of input as a key to select the transformer.
- *
- * This approach provides quick resolution of transformer, but does not support
- * registering a super type of input to provide transformation support for all
- * subclasses, one must register a new instance of transformer for each valid
- * input class.
- *
- * If you need more flexible selection of transformation consider using
- * {@link CompositeConditionalTransformer} which is slower but most flexible or
- * {@link RuleBasedTransformer} which provides declarative approach for
- * transformation.
- *
- * See {@link #transform(Object)} for more information about tranformation
- * process.
- *
- * @author Tony Tkacik <ttkacik@cisco.com>
- *
- * @param <I>
- *            Input super-type
- * @param <P>
- *            Product
- */
-public abstract class CompositeClassBasedTransformer<I, P> implements
-        InputClassBasedTransformer<I, I, P>,
-        AggregateTransformer<I, P> {
-
-    private Map<Class<? extends I>, InputClassBasedTransformer<I, ? extends I, P>> transformers = new ConcurrentHashMap<Class<? extends I>, InputClassBasedTransformer<I, ? extends I, P>>();
-
-    /**
-     * Transforms an input into instance of Product class.
-     *
-     * The final registered transformer is the one which match following
-     * condition:
-     *
-     * <code>input.getClass() == transformer.getInputClass()</code>
-     *
-     * This means that transformers are not resolved by class hierarchy, only
-     * selected based on final class of the input. If you need more flexible
-     * selection of transformation consider using
-     * {@link CompositeConditionalTransformer} which is slower but more
-     * flexible.
-     *
-     */
-    @Override
-    public P transform(I input) {
-        @SuppressWarnings("unchecked")
-        InputClassBasedTransformer<I, I, P> transformer = (InputClassBasedTransformer<I, I, P>) transformers
-                .get(input.getClass());
-        if (transformer == null)
-            throw new IllegalArgumentException("Transformation of: " + input
-                    + " is not supported");
-        return transformer.transform(input);
-    }
-
-    /**
-     * Registers a new transformer.
-     *
-     * The transformer is registered for class returned by
-     * {@link InputClassBasedTransformer#getInputClass()}. Only one transformer
-     * can be registered for particular input class.
-     *
-     */
-    public void addTransformer(
-            InputClassBasedTransformer<I, ? extends I, P> transformer)
-            throws IllegalStateException {
-        if (transformer == null)
-            throw new IllegalArgumentException("Transformer should not be null");
-        if (transformer.getInputClass() == null)
-            throw new IllegalArgumentException(
-                    "Transformer should specify input class.");
-        transformers.put(transformer.getInputClass(), transformer);
-    }
-
-    /**
-     * Removes an registered transformer.
-     *
-     * Note: Removal is currently unsupported.
-     *
-     * @param transformer
-     *            Tranformer to be removed.
-     * @throws IllegalArgumentException
-     *             If the provided transformer is null or is not registered.
-     */
-    public void removeTransformer(
-            InputClassBasedTransformer<I, ? extends I, P> transformer)
-            throws IllegalArgumentException {
-        throw new UnsupportedOperationException("Not implemented yet");
-    }
-
-    @Override
-    public Collection<P> transformAll(Collection<? extends I> inputs) {
-        Collection<P> ret = new ArrayList<P>();
-        for (I i : inputs) {
-            ret.add(transform(i));
-        }
-        return ret;
-    }
-
-}
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.controller.concepts.transform;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+
+/**
+ * Transformer which aggregates multiple implementations of
+ * {@link InputClassBasedTransformer}.
+ *
+ * The transformation process is driven by {@link Class} of input. The selection
+ * of used {@link InputClassBasedTransformer} is done by using the {@link Class}
+ * of input as a key to select the transformer.
+ *
+ * This approach provides quick resolution of transformer, but does not support
+ * registering a super type of input to provide transformation support for all
+ * subclasses, one must register a new instance of transformer for each valid
+ * input class.
+ *
+ * If you need more flexible selection of transformation consider using
+ * {@link CompositeConditionalTransformer} which is slower but most flexible or
+ * {@link RuleBasedTransformer} which provides declarative approach for
+ * transformation.
+ *
+ * See {@link #transform(Object)} for more information about tranformation
+ * process.
+ *
+ * @author Tony Tkacik <ttkacik@cisco.com>
+ *
+ * @param <I>
+ *            Input super-type
+ * @param <P>
+ *            Product
+ */
+public abstract class CompositeClassBasedTransformer<I, P> implements
+        InputClassBasedTransformer<I, I, P>,
+        AggregateTransformer<I, P> {
+
+    private Map<Class<? extends I>, InputClassBasedTransformer<I, ? extends I, P>> transformers = new ConcurrentHashMap<Class<? extends I>, InputClassBasedTransformer<I, ? extends I, P>>();
+
+    /**
+     * Transforms an input into instance of Product class.
+     *
+     * The final registered transformer is the one which match following
+     * condition:
+     *
+     * <code>input.getClass() == transformer.getInputClass()</code>
+     *
+     * This means that transformers are not resolved by class hierarchy, only
+     * selected based on final class of the input. If you need more flexible
+     * selection of transformation consider using
+     * {@link CompositeConditionalTransformer} which is slower but more
+     * flexible.
+     *
+     */
+    @Override
+    public P transform(I input) {
+        @SuppressWarnings("unchecked")
+        InputClassBasedTransformer<I, I, P> transformer = (InputClassBasedTransformer<I, I, P>) transformers
+                .get(input.getClass());
+        if (transformer == null)
+            throw new IllegalArgumentException("Transformation of: " + input
+                    + " is not supported");
+        return transformer.transform(input);
+    }
+
+    /**
+     * Registers a new transformer.
+     *
+     * The transformer is registered for class returned by
+     * {@link InputClassBasedTransformer#getInputClass()}. Only one transformer
+     * can be registered for particular input class.
+     *
+     */
+    public void addTransformer(
+            InputClassBasedTransformer<I, ? extends I, P> transformer)
+            throws IllegalStateException {
+        if (transformer == null)
+            throw new IllegalArgumentException("Transformer should not be null");
+        if (transformer.getInputClass() == null)
+            throw new IllegalArgumentException(
+                    "Transformer should specify input class.");
+        transformers.put(transformer.getInputClass(), transformer);
+    }
+
+    /**
+     * Removes an registered transformer.
+     *
+     * Note: Removal is currently unsupported.
+     *
+     * @param transformer
+     *            Tranformer to be removed.
+     * @throws IllegalArgumentException
+     *             If the provided transformer is null or is not registered.
+     */
+    public void removeTransformer(
+            InputClassBasedTransformer<I, ? extends I, P> transformer)
+            throws IllegalArgumentException {
+        throw new UnsupportedOperationException("Not implemented yet");
+    }
+
+    @Override
+    public Collection<P> transformAll(Collection<? extends I> inputs) {
+        Collection<P> ret = new ArrayList<P>();
+        for (I i : inputs) {
+            ret.add(transform(i));
+        }
+        return ret;
+    }
+
+}