Merge "BUG-592: Fix InstanceIdentifier instantiation"
[controller.git] / opendaylight / sal / yang-prototype / concepts-lang / src / main / java / org / opendaylight / controller / concepts / lang / CompositeClassBasedTransformer.java
1 /*
2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
3  *
4  * This program and the accompanying materials are made available under the
5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6  * and is available at http://www.eclipse.org/legal/epl-v10.html
7  */
8
9 package org.opendaylight.controller.concepts.lang;
10 import java.util.ArrayList;
11 import java.util.Collection;
12 import java.util.Map;
13 import java.util.concurrent.ConcurrentHashMap;
14
15
16 /**
17  * Transformer which aggregates multiple implementations of
18  * {@link InputClassBasedTransformer}.
19  *
20  * The transformation process is driven by {@link Class} of input. The selection
21  * of used {@link InputClassBasedTransformer} is done by using the {@link Class}
22  * of input as a key to select the transformer.
23  *
24  * This approach provides quick resolution of transformer, but does not support
25  * registering a super type of input to provide transformation support for all
26  * subclasses, one must register a new instance of transformer for each valid
27  * input class.
28  *
29  * If you need more flexible selection of transformation consider using
30  * {@link CompositeConditionalTransformer} which is slower but most flexible or
31  * {@link RuleBasedTransformer} which provides declarative approach for
32  * transformation.
33  *
34  * See {@link #transform(Object)} for more information about tranformation
35  * process.
36  *
37  * @author Tony Tkacik <ttkacik@cisco.com>
38  *
39  * @param <I>
40  *            Input super-type
41  * @param <P>
42  *            Product
43  */
44 public abstract class CompositeClassBasedTransformer<I, P> implements
45         InputClassBasedTransformer<I, I, P>,
46         AggregateTransformer<I, P> {
47
48     private Map<Class<? extends I>, InputClassBasedTransformer<I, ? extends I, P>> transformers = new ConcurrentHashMap<Class<? extends I>, InputClassBasedTransformer<I, ? extends I, P>>();
49
50     /**
51      * Transforms an input into instance of Product class.
52      *
53      * The final registered transformer is the one which match following
54      * condition:
55      *
56      * <code>input.getClass() == transformer.getInputClass()</code>
57      *
58      * This means that transformers are not resolved by class hierarchy, only
59      * selected based on final class of the input. If you need more flexible
60      * selection of transformation consider using
61      * {@link CompositeConditionalTransformer} which is slower but more
62      * flexible.
63      *
64      */
65     @Override
66     public P transform(I input) {
67         @SuppressWarnings("unchecked")
68         InputClassBasedTransformer<I, I, P> transformer = (InputClassBasedTransformer<I, I, P>) transformers
69                 .get(input.getClass());
70         if (transformer == null)
71             throw new IllegalArgumentException("Transformation of: " + input
72                     + " is not supported");
73         return transformer.transform(input);
74     }
75
76     /**
77      * Registers a new transformer.
78      *
79      * The transformer is registered for class returned by
80      * {@link InputClassBasedTransformer#getInputClass()}. Only one transformer
81      * can be registered for particular input class.
82      *
83      */
84     public void addTransformer(
85             InputClassBasedTransformer<I, ? extends I, P> transformer)
86             throws IllegalStateException {
87         if (transformer == null)
88             throw new IllegalArgumentException("Transformer should not be null");
89         if (transformer.getInputClass() == null)
90             throw new IllegalArgumentException(
91                     "Transformer should specify input class.");
92         transformers.put(transformer.getInputClass(), transformer);
93     }
94
95     /**
96      * Removes an registered transformer.
97      *
98      * Note: Removal is currently unsupported.
99      *
100      * @param transformer
101      *            Tranformer to be removed.
102      * @throws IllegalArgumentException
103      *             If the provided transformer is null or is not registered.
104      */
105     public void removeTransformer(
106             InputClassBasedTransformer<I, ? extends I, P> transformer)
107             throws IllegalArgumentException {
108         throw new UnsupportedOperationException("Not implemented yet");
109     }
110
111     @Override
112     public Collection<P> transformAll(Collection<? extends I> inputs) {
113         Collection<P> ret = new ArrayList<P>();
114         for (I i : inputs) {
115             ret.add(transform(i));
116         }
117         return ret;
118     }
119
120 }

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.