38f58ea9a1a78b92809aafd0530f5a4e0ac0fe06
[controller.git] / opendaylight / config / config-manager-facade-xml / src / main / java / org / opendaylight / controller / config / facade / xml / mapping / attributes / resolving / SimpleAttributeResolvingStrategy.java
1 /*
2  * Copyright (c) 2015 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.config.facade.xml.mapping.attributes.resolving;
10
11 import com.google.common.base.Optional;
12 import com.google.common.collect.Maps;
13 import java.lang.reflect.InvocationTargetException;
14 import java.lang.reflect.Method;
15 import java.math.BigDecimal;
16 import java.math.BigInteger;
17 import java.text.ParseException;
18 import java.util.Date;
19 import java.util.Map;
20 import javax.management.openmbean.SimpleType;
21 import org.opendaylight.controller.config.facade.xml.util.Util;
22 import org.opendaylight.controller.config.util.xml.DocumentedException;
23 import org.slf4j.Logger;
24 import org.slf4j.LoggerFactory;
25
26 final class SimpleAttributeResolvingStrategy extends AbstractAttributeResolvingStrategy<Object, SimpleType<?>> {
27
28     private static final Logger LOG = LoggerFactory.getLogger(SimpleAttributeResolvingStrategy.class);
29
30     SimpleAttributeResolvingStrategy(SimpleType<?> simpleType) {
31         super(simpleType);
32     }
33
34     @Override
35     public String toString() {
36         return "ResolvedSimpleAttribute [" + getOpenType().getClassName() + "]";
37     }
38
39     @Override
40     public Optional<Object> parseAttribute(String attrName, Object value) throws DocumentedException {
41         if (value == null) {
42             return Optional.absent();
43         }
44
45         Class<?> cls;
46         try {
47             cls = Class.forName(getOpenType().getClassName());
48         } catch (ClassNotFoundException e) {
49             throw new RuntimeException("Unable to locate class for " + getOpenType().getClassName(), e);
50         }
51
52         Util.checkType(value, String.class);
53
54         Resolver prefferedPlugin = resolverPlugins.get(cls.getCanonicalName());
55         prefferedPlugin = prefferedPlugin == null ? resolverPlugins.get(DEFAULT_RESOLVERS) : prefferedPlugin;
56
57         Object parsedValue = prefferedPlugin.resolveObject(cls, attrName, (String) value);
58         LOG.debug("Attribute {} : {} parsed to type {} with value {}", attrName, value, getOpenType(), parsedValue);
59         return Optional.of(parsedValue);
60     }
61
62     private static final String DEFAULT_RESOLVERS = "default";
63     private static final Map<String, Resolver> resolverPlugins = Maps.newHashMap();
64
65     static {
66         resolverPlugins.put(DEFAULT_RESOLVERS, new DefaultResolver());
67         resolverPlugins.put(String.class.getCanonicalName(), new StringResolver());
68         resolverPlugins.put(Date.class.getCanonicalName(), new DateResolver());
69         resolverPlugins.put(Character.class.getCanonicalName(), new CharResolver());
70         resolverPlugins.put(BigInteger.class.getCanonicalName(), new BigIntegerResolver());
71         resolverPlugins.put(BigDecimal.class.getCanonicalName(), new BigDecimalResolver());
72     }
73
74     static interface Resolver {
75         Object resolveObject(Class<?> type, String attrName, String value) throws DocumentedException;
76     }
77
78     static class DefaultResolver implements Resolver {
79
80         @Override
81         public Object resolveObject(Class<?> type, String attrName, String value) throws DocumentedException {
82             try {
83                 return parseObject(type, value);
84             } catch (Exception e) {
85                 throw new DocumentedException("Unable to resolve attribute " + attrName + " from " + value,
86                         DocumentedException.ErrorType.application,
87                         DocumentedException.ErrorTag.operation_failed,
88                         DocumentedException.ErrorSeverity.error);
89             }
90         }
91
92         protected Object parseObject(Class<?> type, String value) throws DocumentedException {
93             Method method = null;
94             try {
95                 method = type.getMethod("valueOf", String.class);
96                 return method.invoke(null, value);
97             } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
98                 LOG.trace("Error parsing object ",e);
99                 throw new DocumentedException("Error parsing object.",
100                         DocumentedException.ErrorType.application,
101                         DocumentedException.ErrorTag.operation_failed,
102                         DocumentedException.ErrorSeverity.error);
103             }
104         }
105     }
106
107     static class StringResolver extends DefaultResolver {
108
109         @Override
110         protected Object parseObject(Class<?> type, String value) {
111             return value;
112         }
113     }
114
115     static class BigIntegerResolver extends DefaultResolver {
116
117         @Override
118         protected Object parseObject(Class<?> type, String value) {
119             return new BigInteger(value);
120         }
121     }
122
123     static class BigDecimalResolver extends DefaultResolver {
124
125         @Override
126         protected Object parseObject(Class<?> type, String value) {
127             return new BigDecimal(value);
128         }
129     }
130
131     static class CharResolver extends DefaultResolver {
132
133         @Override
134         protected Object parseObject(Class<?> type, String value)  {
135             return value.charAt(0);
136         }
137     }
138
139     static class DateResolver extends DefaultResolver {
140         @Override
141         protected Object parseObject(Class<?> type, String value) throws DocumentedException {
142             try {
143                 return Util.readDate(value);
144             } catch (ParseException e) {
145                 LOG.trace("Unable parse value {} due to ",value, e);
146                 throw new DocumentedException("Unable to parse value "+value+" as date.",
147                         DocumentedException.ErrorType.application,
148                         DocumentedException.ErrorTag.operation_failed,
149                         DocumentedException.ErrorSeverity.error);
150             }
151         }
152     }
153
154 }

©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.