X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-data-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fdata%2Fimpl%2Fcodec%2FTypeDefinitionAwareCodec.java;h=76f64377c37e80a641737d9573fb98c1aa76b2aa;hb=da0092ebeb0d025bc06f214bcc9b7dc2161aacce;hp=ce8c5bbd2b3c15e07bf2210c0c382d3b3649ef0c;hpb=ae810496a415aae66a72e16fdb333d4cb937be0a;p=yangtools.git diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/codec/TypeDefinitionAwareCodec.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/codec/TypeDefinitionAwareCodec.java index ce8c5bbd2b..76f64377c3 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/codec/TypeDefinitionAwareCodec.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/codec/TypeDefinitionAwareCodec.java @@ -7,37 +7,10 @@ */ package org.opendaylight.yangtools.yang.data.impl.codec; -import static org.opendaylight.yangtools.yang.model.util.BaseTypes.INT16_QNAME; -import static org.opendaylight.yangtools.yang.model.util.BaseTypes.INT32_QNAME; -import static org.opendaylight.yangtools.yang.model.util.BaseTypes.INT64_QNAME; -import static org.opendaylight.yangtools.yang.model.util.BaseTypes.INT8_QNAME; -import static org.opendaylight.yangtools.yang.model.util.BaseTypes.UINT16_QNAME; -import static org.opendaylight.yangtools.yang.model.util.BaseTypes.UINT32_QNAME; -import static org.opendaylight.yangtools.yang.model.util.BaseTypes.UINT64_QNAME; -import static org.opendaylight.yangtools.yang.model.util.BaseTypes.UINT8_QNAME; - -import java.math.BigDecimal; -import java.math.BigInteger; -import java.util.Set; -import java.util.regex.Matcher; -import java.util.regex.Pattern; - -import org.opendaylight.yangtools.yang.data.api.codec.BinaryCodec; -import org.opendaylight.yangtools.yang.data.api.codec.BitsCodec; -import org.opendaylight.yangtools.yang.data.api.codec.BooleanCodec; -import org.opendaylight.yangtools.yang.data.api.codec.DecimalCodec; -import org.opendaylight.yangtools.yang.data.api.codec.EmptyCodec; -import org.opendaylight.yangtools.yang.data.api.codec.EnumCodec; -import org.opendaylight.yangtools.yang.data.api.codec.Int16Codec; -import org.opendaylight.yangtools.yang.data.api.codec.Int32Codec; -import org.opendaylight.yangtools.yang.data.api.codec.Int64Codec; -import org.opendaylight.yangtools.yang.data.api.codec.Int8Codec; -import org.opendaylight.yangtools.yang.data.api.codec.StringCodec; -import org.opendaylight.yangtools.yang.data.api.codec.Uint16Codec; -import org.opendaylight.yangtools.yang.data.api.codec.Uint32Codec; -import org.opendaylight.yangtools.yang.data.api.codec.Uint64Codec; -import org.opendaylight.yangtools.yang.data.api.codec.Uint8Codec; -import org.opendaylight.yangtools.yang.data.api.codec.UnionCodec; +import com.google.common.base.Joiner; +import com.google.common.base.Optional; +import com.google.common.base.Preconditions; +import com.google.common.base.Splitter; import org.opendaylight.yangtools.yang.model.api.TypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition; @@ -45,124 +18,24 @@ import org.opendaylight.yangtools.yang.model.api.type.BooleanTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.EmptyTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition; -import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair; import org.opendaylight.yangtools.yang.model.api.type.IntegerTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition; import org.opendaylight.yangtools.yang.model.api.type.UnsignedIntegerTypeDefinition; - -import com.google.common.base.Joiner; -import com.google.common.base.Optional; -import com.google.common.base.Preconditions; -import com.google.common.base.Splitter; -import com.google.common.base.Strings; -import com.google.common.collect.ImmutableSet; -import com.google.common.collect.Sets; -import com.google.common.io.BaseEncoding; +import org.opendaylight.yangtools.yang.model.util.DerivedType; public abstract class TypeDefinitionAwareCodec> implements DataStringCodec { - private static final Pattern intPattern = Pattern.compile("[+-]?[1-9][0-9]*$"); - private static final Pattern hexPattern = Pattern.compile("[+-]?0[xX][0-9a-fA-F]+"); - private static final Pattern octalPattern = Pattern.compile("[+-]?0[1-7][0-7]*$"); - + private static final TypeDefinitionAwareCodec EMPTY_DEFAULT_CODEC = new EmptyStringCodec(Optional.absent()); private final Optional typeDefinition; private final Class inputClass; - private static final int provideBase(final String integer) { - if (integer == null) { - throw new IllegalArgumentException("String representing integer number cannot be NULL"); - } - - if ((integer.length() == 1) && (integer.charAt(0) == '0')) { - return 10; - } - - final Matcher intMatcher = intPattern.matcher(integer); - if (intMatcher.matches()) { - return 10; - } else { - final Matcher hexMatcher = hexPattern.matcher(integer); - if (hexMatcher.matches()) { - return 16; - } else { - final Matcher octMatcher = octalPattern.matcher(integer); - if (octMatcher.matches()) { - return 8; - } else { - String formatedMessage = String.format("Incorrect lexical representation of integer value: %s." - + "\nAn integer value can be defined as: " - + "\n - a decimal number," - + "\n - a hexadecimal number (prefix 0x)," - + "\n - an octal number (prefix 0)." - + "\nSigned values are allowed. Spaces between digits are NOT allowed.", integer); - throw new NumberFormatException(formatedMessage); - } - } - } - } - - private static String normalizeHexadecimal(final String hexInt) { - if (hexInt == null) { - throw new IllegalArgumentException( - "String representing integer number in Hexadecimal format cannot be NULL!"); - } - final String normalizedString; - if (hexInt.contains("x")) { - normalizedString = hexInt.replace("x", ""); - } else if (hexInt.contains("X")) { - normalizedString = hexInt.replace("X", ""); - } else { - normalizedString = hexInt; - } - return normalizedString; - } - - private static final BinaryCodecStringImpl BINARY_DEFAULT_CODEC = new BinaryCodecStringImpl( - Optional. absent()); - - private static final BooleanCodecStringImpl BOOLEAN_DEFAULT_CODEC = new BooleanCodecStringImpl( - Optional. absent()); - - private static final DecimalCodecStringImpl DECIMAL64_DEFAULT_CODEC = new DecimalCodecStringImpl( - Optional. absent()); - - private static final EmptyCodecStringImpl EMPTY_DEFAULT_CODEC = new EmptyCodecStringImpl( - Optional. absent()); - - private static final Int8CodecStringImpl INT8_DEFAULT_CODEC = new Int8CodecStringImpl( - Optional. absent()); - - private static final Int16CodecStringImpl INT16_DEFAULT_CODEC = new Int16CodecStringImpl( - Optional. absent()); - - private static final Int32CodecStringImpl INT32_DEFAULT_CODEC = new Int32CodecStringImpl( - Optional. absent()); - - private static final Int64CodecStringImpl INT64_DEFAULT_CODEC = new Int64CodecStringImpl( - Optional. absent()); - - private static final StringCodecStringImpl STRING_DEFAULT_CODEC = new StringCodecStringImpl( - Optional. absent()); - - private static final Uint8CodecStringImpl UINT8_DEFAULT_CODEC = new Uint8CodecStringImpl( - Optional. absent()); - - private static final Uint16CodecStringImpl UINT16_DEFAULT_CODEC = new Uint16CodecStringImpl( - Optional. absent()); - - private static final Uint32CodecStringImpl UINT32_DEFAULT_CODEC = new Uint32CodecStringImpl( - Optional. absent()); - - private static final Uint64CodecStringImpl UINT64_DEFAULT_CODEC = new Uint64CodecStringImpl( - Optional. absent()); - @Override public Class getInputClass() { return inputClass; } - protected TypeDefinitionAwareCodec(Optional typeDefinition, Class outputClass) { + protected TypeDefinitionAwareCodec(final Optional typeDefinition, final Class outputClass) { Preconditions.checkArgument(outputClass != null, "Output class must be specified."); this.typeDefinition = typeDefinition; this.inputClass = outputClass; @@ -173,450 +46,161 @@ public abstract class TypeDefinitionAwareCodec> i } @SuppressWarnings({ "rawtypes", "unchecked" }) - public static final TypeDefinitionAwareCodec> from(TypeDefinition typeDefinition) { + public static final TypeDefinitionAwareCodec> from(final TypeDefinition typeDefinition) { return fromType(typeDefinition); } @SuppressWarnings("unchecked") - public static final > TypeDefinitionAwareCodec fromType(T typeDefinition) { - T superType = typeDefinition; - while (superType.getBaseType() != null) { - superType = superType.getBaseType(); - } - + public static final > TypeDefinitionAwareCodec fromType(final T typeDefinition) { + final T normalizedType = (T) DerivedType.from(typeDefinition); @SuppressWarnings("rawtypes") TypeDefinitionAwareCodec codec = null; - if (superType instanceof BinaryTypeDefinition) { - codec = BINARY_DEFAULT_CODEC; - } else if (superType instanceof BitsTypeDefinition) { - codec = new BitsCodecStringImpl( Optional.of( (BitsTypeDefinition)superType ) ); - } else if (superType instanceof BooleanTypeDefinition) { - codec = BOOLEAN_DEFAULT_CODEC; - } else if (superType instanceof DecimalTypeDefinition) { - codec = DECIMAL64_DEFAULT_CODEC; - } else if (superType instanceof EmptyTypeDefinition) { + if (normalizedType instanceof BinaryTypeDefinition) { + codec = BinaryStringCodec.from((BinaryTypeDefinition)normalizedType); + } else if (normalizedType instanceof BitsTypeDefinition) { + codec = BitsStringCodec.from((BitsTypeDefinition)normalizedType); + } else if (normalizedType instanceof BooleanTypeDefinition) { + codec = BooleanStringCodec.from((BooleanTypeDefinition)normalizedType); + } else if (normalizedType instanceof DecimalTypeDefinition) { + codec = DecimalStringCodec.from((DecimalTypeDefinition)normalizedType); + } else if (normalizedType instanceof EmptyTypeDefinition) { codec = EMPTY_DEFAULT_CODEC; - } else if (superType instanceof EnumTypeDefinition) { - codec = new EnumCodecStringImpl( Optional.of( (EnumTypeDefinition)superType ) ); - } else if (superType instanceof IntegerTypeDefinition) { - if (INT8_QNAME.equals(superType.getQName())) { - codec = INT8_DEFAULT_CODEC; - } else if (INT16_QNAME.equals(superType.getQName())) { - codec = INT16_DEFAULT_CODEC; - } else if (INT32_QNAME.equals(superType.getQName())) { - codec = INT32_DEFAULT_CODEC; - } else if (INT64_QNAME.equals(superType.getQName())) { - codec = INT64_DEFAULT_CODEC; - } - } else if (superType instanceof StringTypeDefinition) { - codec = STRING_DEFAULT_CODEC; - } else if (superType instanceof UnionTypeDefinition) { - codec = new UnionCodecStringImpl( Optional.of( (UnionTypeDefinition)superType ) ); - } else if (superType instanceof UnsignedIntegerTypeDefinition) { - if (UINT8_QNAME.equals(superType.getQName())) { - codec = UINT8_DEFAULT_CODEC; - } - if (UINT16_QNAME.equals(superType.getQName())) { - codec = UINT16_DEFAULT_CODEC; - } - if (UINT32_QNAME.equals(superType.getQName())) { - codec = UINT32_DEFAULT_CODEC; - } - if (UINT64_QNAME.equals(superType.getQName())) { - codec = UINT64_DEFAULT_CODEC; - } + } else if (normalizedType instanceof EnumTypeDefinition) { + codec = EnumStringCodec.from((EnumTypeDefinition)normalizedType); + } else if (normalizedType instanceof IntegerTypeDefinition) { + codec = AbstractIntegerStringCodec.from((IntegerTypeDefinition) normalizedType); + } else if (normalizedType instanceof StringTypeDefinition) { + codec = StringStringCodec.from((StringTypeDefinition)normalizedType); + } else if (normalizedType instanceof UnionTypeDefinition) { + codec = UnionStringCodec.from((UnionTypeDefinition)normalizedType); + } else if (normalizedType instanceof UnsignedIntegerTypeDefinition) { + codec = AbstractIntegerStringCodec.from((UnsignedIntegerTypeDefinition) normalizedType); } - return codec; } - public static class BooleanCodecStringImpl extends TypeDefinitionAwareCodec - implements BooleanCodec { - - protected BooleanCodecStringImpl(Optional typeDef) { - super(typeDef, Boolean.class); - } - - @Override - public String serialize(Boolean data) { - return data == null ? "" : data.toString(); - } - - @Override - public Boolean deserialize(String stringRepresentation) { - return Boolean.valueOf(stringRepresentation); - } - }; - - public static class Uint8CodecStringImpl extends TypeDefinitionAwareCodec - implements Uint8Codec { - - protected Uint8CodecStringImpl(Optional typeDef) { - super(typeDef, Short.class); - } - - @Override - public String serialize(Short data) { - return data == null ? "" : data.toString(); - } - - @Override - public Short deserialize(String stringRepresentation) { - int base = provideBase(stringRepresentation); - if (base == 16) { - return Short.valueOf(normalizeHexadecimal(stringRepresentation), base); - } - return Short.valueOf(stringRepresentation, base); - } - }; - - public static class Uint16CodecStringImpl extends TypeDefinitionAwareCodec - implements Uint16Codec { - protected Uint16CodecStringImpl(Optional typeDef) { - super(typeDef, Integer.class); - } - - @Override - public Integer deserialize(String stringRepresentation) { - int base = provideBase(stringRepresentation); - if (base == 16) { - return Integer.valueOf(normalizeHexadecimal(stringRepresentation), base); - } - return Integer.valueOf(stringRepresentation, base); - } - - @Override - public String serialize(Integer data) { - return data == null ? "" : data.toString(); - } - }; - - public static class Uint32CodecStringImpl extends TypeDefinitionAwareCodec - implements Uint32Codec { - - protected Uint32CodecStringImpl(Optional typeDef) { - super(typeDef, Long.class); - } - - @Override - public Long deserialize(String stringRepresentation) { - int base = provideBase(stringRepresentation); - if (base == 16) { - return Long.valueOf(normalizeHexadecimal(stringRepresentation), base); - } - return Long.valueOf(stringRepresentation, base); - } - - @Override - public String serialize(Long data) { - return data == null ? "" : data.toString(); + @Deprecated + public static class BooleanCodecStringImpl extends BooleanStringCodec{ + protected BooleanCodecStringImpl(final Optional typeDef) { + super(typeDef); } - }; - - public static class Uint64CodecStringImpl extends - TypeDefinitionAwareCodec implements Uint64Codec { - - protected Uint64CodecStringImpl(Optional typeDef) { - super(typeDef, BigInteger.class); - } - - @Override - public BigInteger deserialize(String stringRepresentation) { - int base = provideBase(stringRepresentation); - if (base == 16) { - return new BigInteger(normalizeHexadecimal(stringRepresentation), base); - } - return new BigInteger(stringRepresentation, base); - } - - @Override - public String serialize(BigInteger data) { - return data == null ? "" : data.toString(); - } - }; - - public static class StringCodecStringImpl extends TypeDefinitionAwareCodec implements - StringCodec { - - protected StringCodecStringImpl(Optional typeDef) { - super(typeDef, String.class); - } - - @Override - public String deserialize(String stringRepresentation) { - return stringRepresentation == null ? "" :stringRepresentation; - } - - @Override - public String serialize(String data) { - return data == null ? "" : data.toString(); - } - }; - - public static class Int16CodecStringImpl extends TypeDefinitionAwareCodec implements - Int16Codec { - - protected Int16CodecStringImpl(Optional typeDef) { - super(typeDef, Short.class); - } - - @Override - public Short deserialize(String stringRepresentation) { - int base = provideBase(stringRepresentation); - if (base == 16) { - return Short.valueOf(normalizeHexadecimal(stringRepresentation), base); - } - return Short.valueOf(stringRepresentation, base); - } - - @Override - public String serialize(Short data) { - return data == null ? "" : data.toString(); - } - }; + } - public static class Int32CodecStringImpl extends TypeDefinitionAwareCodec implements - Int32Codec { + @Deprecated + public static class Uint8CodecStringImpl extends Uint8StringCodec { - protected Int32CodecStringImpl(Optional typeDef) { - super(typeDef, Integer.class); + protected Uint8CodecStringImpl(final Optional typeDef) { + super(typeDef); } + } - @Override - public Integer deserialize(String stringRepresentation) { - int base = provideBase(stringRepresentation); - if (base == 16) { - return Integer.valueOf(normalizeHexadecimal(stringRepresentation), base); - } - return Integer.valueOf(stringRepresentation, base); + @Deprecated + public static class Uint16CodecStringImpl extends Uint16StringCodec { + protected Uint16CodecStringImpl(final Optional typeDef) { + super(typeDef); } + } - @Override - public String serialize(Integer data) { - return data == null ? "" : data.toString(); + @Deprecated + public static class Uint32CodecStringImpl extends Uint32StringCodec { + protected Uint32CodecStringImpl(final Optional typeDef) { + super(typeDef); } - }; - - public static class Int64CodecStringImpl extends TypeDefinitionAwareCodec implements - Int64Codec { + } - protected Int64CodecStringImpl(Optional typeDef) { - super(typeDef, Long.class); + @Deprecated + public static class Uint64CodecStringImpl extends Uint64StringCodec { + protected Uint64CodecStringImpl(final Optional typeDef) { + super(typeDef); } + } - @Override - public Long deserialize(String stringRepresentation) { - int base = provideBase(stringRepresentation); - if (base == 16) { - return Long.valueOf(normalizeHexadecimal(stringRepresentation), base); - } - return Long.valueOf(stringRepresentation, base); + @Deprecated + public static class StringCodecStringImpl extends StringStringCodec { + protected StringCodecStringImpl(final Optional typeDef) { + super(typeDef); } + } - @Override - public String serialize(Long data) { - return data == null ? "" : data.toString(); + @Deprecated + public static class Int16CodecStringImpl extends Int16StringCodec { + protected Int16CodecStringImpl(final Optional typeDef) { + super(typeDef); } - }; - - public static class Int8CodecStringImpl extends TypeDefinitionAwareCodec implements - Int8Codec { + } - protected Int8CodecStringImpl(Optional typeDef) { - super(typeDef, Byte.class); + @Deprecated + public static class Int32CodecStringImpl extends Int32StringCodec { + protected Int32CodecStringImpl(final Optional typeDef) { + super(typeDef); } - @Override - public Byte deserialize(String stringRepresentation) { - int base = provideBase(stringRepresentation); - if (base == 16) { - return Byte.valueOf(normalizeHexadecimal(stringRepresentation), base); - } - return Byte.valueOf(stringRepresentation, base); - } + } - @Override - public String serialize(Byte data) { - return data == null ? "" : data.toString(); + @Deprecated + public static class Int64CodecStringImpl extends Int64StringCodec { + protected Int64CodecStringImpl(final Optional typeDef) { + super(typeDef); } - }; - - public static class EmptyCodecStringImpl extends TypeDefinitionAwareCodec implements - EmptyCodec { - protected EmptyCodecStringImpl(Optional typeDef) { - super(typeDef, Void.class); - } + } - @Override - public String serialize(Void data) { - return ""; - } + @Deprecated + public static class Int8CodecStringImpl extends Int8StringCodec { - @Override - public Void deserialize(String stringRepresentation) { - Preconditions.checkArgument( Strings.isNullOrEmpty( stringRepresentation ), - "The value must be empty" ); - return null; + protected Int8CodecStringImpl(final Optional typeDef) { + super(typeDef); } - }; - public static final class BinaryCodecStringImpl extends TypeDefinitionAwareCodec - implements BinaryCodec { + } - protected BinaryCodecStringImpl(Optional typeDef) { - super(typeDef, byte[].class); + @Deprecated + public static class EmptyCodecStringImpl extends EmptyStringCodec { + protected EmptyCodecStringImpl(final Optional typeDef) { + super(typeDef); } + } - @Override - public String serialize(byte[] data) { - return data == null ? "" : BaseEncoding.base64().encode(data); + @Deprecated + public static final class BinaryCodecStringImpl extends BinaryStringCodec { + protected BinaryCodecStringImpl(final Optional typeDef) { + super(typeDef); } - @Override - public byte[] deserialize(String stringRepresentation) { - return stringRepresentation == null ? null : - BaseEncoding.base64().decode(stringRepresentation); - } - }; + } - public static final class BitsCodecStringImpl extends TypeDefinitionAwareCodec, BitsTypeDefinition> - implements BitsCodec { + @Deprecated + public static final class BitsCodecStringImpl extends BitsStringCodec { public static final Joiner JOINER = Joiner.on(" ").skipNulls(); public static final Splitter SPLITTER = Splitter.on(' ').omitEmptyStrings().trimResults(); - @SuppressWarnings("unchecked") - protected BitsCodecStringImpl(Optional typeDef) { - super(typeDef, (Class>) ((Class) Set.class)); - } - - @Override - public String serialize(Set data) { - return data == null ? "" : JOINER.join(data); - } - - @Override - public Set deserialize(String stringRepresentation) { - if (stringRepresentation == null) { - return ImmutableSet.of(); - } - - Iterable strings = SPLITTER.split(stringRepresentation); - - if( getTypeDefinition().isPresent() ) { - Set allowedNames = Sets.newHashSet(); - for( BitsTypeDefinition.Bit bit: getTypeDefinition().get().getBits() ) { - allowedNames.add( bit.getName() ); - } - - for( String bit: strings ) { - if( !allowedNames.contains( bit ) ) { - throw new IllegalArgumentException( - "Invalid value \"" + bit + "\" for bits type. Allowed values are: " + - allowedNames ); - } - } - } - - return ImmutableSet.copyOf(strings); - } - }; - - public static class EnumCodecStringImpl extends TypeDefinitionAwareCodec implements - EnumCodec { - - protected EnumCodecStringImpl(Optional typeDef) { - super(typeDef, String.class); - } - - @Override - public String deserialize(String stringRepresentation) { - if( getTypeDefinition().isPresent() ) { - Set allowedNames = Sets.newHashSet(); - for( EnumPair pair: getTypeDefinition().get().getValues() ) { - allowedNames.add( pair.getName() ); - } - - if( !allowedNames.contains( stringRepresentation ) ) { - throw new IllegalArgumentException( - "Invalid value \"" + stringRepresentation + "\" for enum type. Allowed values are: " + - allowedNames ); - } - } - - return stringRepresentation; - } - - @Override - public String serialize(String data) { - return data == null ? "" : data; - } - }; - - public static class DecimalCodecStringImpl extends TypeDefinitionAwareCodec - implements DecimalCodec { - - protected DecimalCodecStringImpl(Optional typeDef) { - super(typeDef, BigDecimal.class); + protected BitsCodecStringImpl(final Optional typeDef) { + super(typeDef); } + } - @Override - public String serialize(BigDecimal data) { - return data == null ? "" : data.toString(); - } + @Deprecated + public static class EnumCodecStringImpl extends EnumStringCodec { - @Override - public BigDecimal deserialize(String stringRepresentation) { - Preconditions.checkArgument( stringRepresentation != null , "Input cannot be null" ); - return new BigDecimal(stringRepresentation); + protected EnumCodecStringImpl(final Optional typeDef) { + super(typeDef); } - }; - public static class UnionCodecStringImpl extends TypeDefinitionAwareCodec implements - UnionCodec { - - protected UnionCodecStringImpl(Optional typeDef) { - super(typeDef, Object.class); - } + } - @Override - public String serialize(Object data) { - return data == null ? "" : data.toString(); + @Deprecated + public static class DecimalCodecStringImpl extends DecimalStringCodec { + protected DecimalCodecStringImpl(final Optional typeDef) { + super(typeDef); } + } - @Override - public Object deserialize(String stringRepresentation) { - Object returnValue = stringRepresentation; - if( getTypeDefinition().isPresent() ) { - boolean valid = false; - for( TypeDefinition type: getTypeDefinition().get().getTypes() ) { - TypeDefinitionAwareCodec> typeAwareCodec = from( type ); - if( typeAwareCodec == null ) { - // This is a type for which we have no codec (eg identity ref) so we'll say it's valid - // but we'll continue in case there's another type for which we do have a codec. - valid = true; - continue; - } - - try { - returnValue = typeAwareCodec.deserialize( stringRepresentation ); - valid = true; - break; - } - catch( Exception e ) { - // invalid - try the next union type. - } - } - - if( !valid ) { - throw new IllegalArgumentException( - "Invalid value \"" + stringRepresentation + "\" for union type." ); - } - } - - return returnValue; + @Deprecated + public static class UnionCodecStringImpl extends UnionStringCodec { + protected UnionCodecStringImpl(final Optional typeDef) { + super(typeDef); } - }; + } }