2 * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
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
8 package org.opendaylight.yangtools.yang.data.impl.codec;
10 import static com.google.common.base.Preconditions.checkArgument;
11 import static org.opendaylight.yangtools.yang.model.util.BaseTypes.INT16_QNAME;
12 import static org.opendaylight.yangtools.yang.model.util.BaseTypes.INT32_QNAME;
13 import static org.opendaylight.yangtools.yang.model.util.BaseTypes.INT64_QNAME;
14 import static org.opendaylight.yangtools.yang.model.util.BaseTypes.INT8_QNAME;
15 import static org.opendaylight.yangtools.yang.model.util.BaseTypes.UINT16_QNAME;
16 import static org.opendaylight.yangtools.yang.model.util.BaseTypes.UINT32_QNAME;
17 import static org.opendaylight.yangtools.yang.model.util.BaseTypes.UINT64_QNAME;
18 import static org.opendaylight.yangtools.yang.model.util.BaseTypes.UINT8_QNAME;
20 import com.google.common.annotations.Beta;
21 import com.google.common.base.CharMatcher;
22 import com.google.common.collect.RangeSet;
23 import java.util.Optional;
24 import java.util.regex.Pattern;
25 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
26 import org.opendaylight.yangtools.yang.model.api.type.IntegerTypeDefinition;
27 import org.opendaylight.yangtools.yang.model.api.type.RangeConstraint;
28 import org.opendaylight.yangtools.yang.model.api.type.UnsignedIntegerTypeDefinition;
31 * Do not use this class outside of yangtools, its presence does not fall into the API stability contract.
34 public abstract class AbstractIntegerStringCodec<N extends Number & Comparable<N>, T extends TypeDefinition<T>>
35 extends TypeDefinitionAwareCodec<N, T> {
37 private static final Pattern INT_PATTERN = Pattern.compile("[+-]?[1-9][0-9]*$");
38 private static final Pattern HEX_PATTERN = Pattern.compile("[+-]?0[xX][0-9a-fA-F]+");
39 private static final Pattern OCT_PATTERN = Pattern.compile("[+-]?0[1-7][0-7]*$");
41 // For up to two characters, this is very fast
42 private static final CharMatcher X_MATCHER = CharMatcher.anyOf("xX");
44 private static final String INCORRECT_LEXICAL_REPRESENTATION =
45 "Incorrect lexical representation of integer value: %s."
46 + "\nAn integer value can be defined as: "
47 + "\n - a decimal number,"
48 + "\n - a hexadecimal number (prefix 0x)," + "%n - an octal number (prefix 0)."
49 + "\nSigned values are allowed. Spaces between digits are NOT allowed.";
51 private final RangeSet<N> rangeConstraints;
53 AbstractIntegerStringCodec(final Optional<T> typeDefinition, final Optional<RangeConstraint<?>> constraint,
54 final Class<N> outputClass) {
55 super(typeDefinition, outputClass);
56 rangeConstraints = (RangeSet<N>) constraint.map(RangeConstraint::getAllowedRanges).orElse(null);
59 public static AbstractIntegerStringCodec<?, IntegerTypeDefinition> from(final IntegerTypeDefinition type) {
60 // FIXME: this is not necessary with yang.model.util.type
61 IntegerTypeDefinition baseType = type;
62 while (baseType.getBaseType() != null) {
63 baseType = baseType.getBaseType();
66 final Optional<IntegerTypeDefinition> typeOptional = Optional.of(type);
68 // FIXME: use DerivedTypes#isInt8() and friends
69 if (INT8_QNAME.equals(baseType.getQName())) {
70 return new Int8StringCodec(typeOptional);
71 } else if (INT16_QNAME.equals(baseType.getQName())) {
72 return new Int16StringCodec(typeOptional);
73 } else if (INT32_QNAME.equals(baseType.getQName())) {
74 return new Int32StringCodec(typeOptional);
75 } else if (INT64_QNAME.equals(baseType.getQName())) {
76 return new Int64StringCodec(typeOptional);
78 throw new IllegalArgumentException("Unsupported base type: " + baseType.getQName());
82 public static AbstractIntegerStringCodec<?, UnsignedIntegerTypeDefinition> from(
83 final UnsignedIntegerTypeDefinition type) {
84 // FIXME: this is not necessary with yang.model.util.type
85 UnsignedIntegerTypeDefinition baseType = type;
86 while (baseType.getBaseType() != null) {
87 baseType = baseType.getBaseType();
90 final Optional<UnsignedIntegerTypeDefinition> typeOptional = Optional.of(type);
92 // FIXME: use DerivedTypes#isUint8() and friends
93 if (UINT8_QNAME.equals(baseType.getQName())) {
94 return new Uint8StringCodec(typeOptional);
95 } else if (UINT16_QNAME.equals(baseType.getQName())) {
96 return new Uint16StringCodec(typeOptional);
97 } else if (UINT32_QNAME.equals(baseType.getQName())) {
98 return new Uint32StringCodec(typeOptional);
99 } else if (UINT64_QNAME.equals(baseType.getQName())) {
100 return new Uint64StringCodec(typeOptional);
102 throw new IllegalArgumentException("Unsupported base type: " + baseType.getQName());
107 public final N deserialize(final String stringRepresentation) {
108 final int base = provideBase(stringRepresentation);
109 final N deserialized;
111 deserialized = deserialize(normalizeHexadecimal(stringRepresentation),base);
113 deserialized = deserialize(stringRepresentation,base);
115 validate(deserialized);
120 * Deserializes value from supplied string representation is supplied radix. See
121 * {@link Integer#parseInt(String, int)} for in-depth description about string and radix relationship.
123 * @param stringRepresentation String representation
124 * @param radix numeric base.
125 * @return Deserialized value.
127 abstract N deserialize(String stringRepresentation, int radix);
129 private void validate(final N value) {
130 if (rangeConstraints != null) {
131 checkArgument(rangeConstraints.contains(value), "Value '%s' is not in required ranges %s",
132 value, rangeConstraints);
136 protected static Optional<RangeConstraint<?>> extractRange(final IntegerTypeDefinition type) {
137 return type == null ? Optional.empty() : type.getRangeConstraint();
140 protected static Optional<RangeConstraint<?>> extractRange(final UnsignedIntegerTypeDefinition type) {
141 return type == null ? Optional.empty() : type.getRangeConstraint();
144 private static int provideBase(final String integer) {
145 checkArgument(integer != null, "String representing integer number cannot be NULL");
147 if (integer.length() == 1 && integer.charAt(0) == '0') {
149 } else if (INT_PATTERN.matcher(integer).matches()) {
151 } else if (HEX_PATTERN.matcher(integer).matches()) {
153 } else if (OCT_PATTERN.matcher(integer).matches()) {
156 throw new NumberFormatException(String.format(INCORRECT_LEXICAL_REPRESENTATION, integer));
160 private static String normalizeHexadecimal(final String hexInt) {
161 checkArgument(hexInt != null, "String representing integer number in Hexadecimal format cannot be NULL!");
162 return X_MATCHER.removeFrom(hexInt);