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