Updated PoC APIs of Model-driven SAL

[controller.git] / opendaylight / sal / yang-prototype / concepts-lang / src / main / java / org / opendaylight / controller / concepts / lang / CompositeClassBasedTransformer.java

diff --git a/opendaylight/sal/yang-prototype/concepts-lang/src/main/java/org/opendaylight/controller/concepts/lang/CompositeClassBasedTransformer.java b/opendaylight/sal/yang-prototype/concepts-lang/src/main/java/org/opendaylight/controller/concepts/lang/CompositeClassBasedTransformer.java
new file mode 100644 (file)
index 0000000..253ac85
--- /dev/null
+++ b/opendaylight/sal/yang-prototype/concepts-lang/src/main/java/org/opendaylight/controller/concepts/lang/CompositeClassBasedTransformer.java
@@ -0,0 +1,120 @@
+/*
+ * 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.lang;
+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;
+    }
+
+}