import com.google.common.base.Optional;
import com.google.common.collect.Maps;
-import org.opendaylight.controller.netconf.confignetconfconnector.util.Util;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import javax.management.openmbean.SimpleType;
+import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
+import java.math.BigDecimal;
import java.math.BigInteger;
+import java.text.ParseException;
import java.util.Date;
import java.util.Map;
+import javax.management.openmbean.SimpleType;
+import org.opendaylight.controller.netconf.api.NetconfDocumentedException;
+import org.opendaylight.controller.netconf.confignetconfconnector.util.Util;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
final class SimpleAttributeResolvingStrategy extends AbstractAttributeResolvingStrategy<Object, SimpleType<?>> {
- private static final Logger logger = LoggerFactory.getLogger(SimpleAttributeResolvingStrategy.class);
+ private static final Logger LOG = LoggerFactory.getLogger(SimpleAttributeResolvingStrategy.class);
SimpleAttributeResolvingStrategy(SimpleType<?> simpleType) {
super(simpleType);
}
@Override
- public Optional<Object> parseAttribute(String attrName, Object value) {
+ public Optional<Object> parseAttribute(String attrName, Object value) throws NetconfDocumentedException {
if (value == null) {
return Optional.absent();
}
prefferedPlugin = prefferedPlugin == null ? resolverPlugins.get(DEFAULT_RESOLVERS) : prefferedPlugin;
Object parsedValue = prefferedPlugin.resolveObject(cls, attrName, (String) value);
- logger.debug("Attribute {} : {} parsed to type {} with value {}", attrName, value, getOpenType(), parsedValue);
+ LOG.debug("Attribute {} : {} parsed to type {} with value {}", attrName, value, getOpenType(), parsedValue);
return Optional.of(parsedValue);
}
resolverPlugins.put(Date.class.getCanonicalName(), new DateResolver());
resolverPlugins.put(Character.class.getCanonicalName(), new CharResolver());
resolverPlugins.put(BigInteger.class.getCanonicalName(), new BigIntegerResolver());
+ resolverPlugins.put(BigDecimal.class.getCanonicalName(), new BigDecimalResolver());
}
static interface Resolver {
- Object resolveObject(Class<?> type, String attrName, String value);
+ Object resolveObject(Class<?> type, String attrName, String value) throws NetconfDocumentedException;
}
static class DefaultResolver implements Resolver {
@Override
- public Object resolveObject(Class<?> type, String attrName, String value) {
+ public Object resolveObject(Class<?> type, String attrName, String value) throws NetconfDocumentedException {
try {
- Object parsedValue = parseObject(type, value);
- return parsedValue;
+ return parseObject(type, value);
} catch (Exception e) {
- throw new RuntimeException("Unable to resolve attribute " + attrName + " from " + value, e);
+ throw new NetconfDocumentedException("Unable to resolve attribute " + attrName + " from " + value,
+ NetconfDocumentedException.ErrorType.application,
+ NetconfDocumentedException.ErrorTag.operation_failed,
+ NetconfDocumentedException.ErrorSeverity.error);
}
}
- protected Object parseObject(Class<?> type, String value) throws Exception {
- Method method = type.getMethod("valueOf", String.class);
- Object parsedValue = method.invoke(null, value);
- return parsedValue;
+ protected Object parseObject(Class<?> type, String value) throws NetconfDocumentedException {
+ Method method = null;
+ try {
+ method = type.getMethod("valueOf", String.class);
+ return method.invoke(null, value);
+ } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
+ LOG.trace("Error parsing object ",e);
+ throw new NetconfDocumentedException("Error parsing object.",
+ NetconfDocumentedException.ErrorType.application,
+ NetconfDocumentedException.ErrorTag.operation_failed,
+ NetconfDocumentedException.ErrorSeverity.error);
+ }
}
}
static class StringResolver extends DefaultResolver {
@Override
- protected Object parseObject(Class<?> type, String value) throws Exception {
+ protected Object parseObject(Class<?> type, String value) {
return value;
}
}
static class BigIntegerResolver extends DefaultResolver {
@Override
- protected Object parseObject(Class<?> type, String value) throws Exception {
+ protected Object parseObject(Class<?> type, String value) {
return new BigInteger(value);
}
}
+ static class BigDecimalResolver extends DefaultResolver {
+
+ @Override
+ protected Object parseObject(Class<?> type, String value) {
+ return new BigDecimal(value);
+ }
+ }
+
static class CharResolver extends DefaultResolver {
@Override
- protected Object parseObject(Class<?> type, String value) throws Exception {
- return new Character(value.charAt(0));
+ protected Object parseObject(Class<?> type, String value) {
+ return value.charAt(0);
}
}
static class DateResolver extends DefaultResolver {
-
@Override
- protected Object parseObject(Class<?> type, String value) throws Exception {
- return Util.readDate(value);
+ protected Object parseObject(Class<?> type, String value) throws NetconfDocumentedException {
+ try {
+ return Util.readDate(value);
+ } catch (ParseException e) {
+ LOG.trace("Unable parse value {} due to ",value, e);
+ throw new NetconfDocumentedException("Unable to parse value "+value+" as date.",
+ NetconfDocumentedException.ErrorType.application,
+ NetconfDocumentedException.ErrorTag.operation_failed,
+ NetconfDocumentedException.ErrorSeverity.error);
+ }
}
}