return getterMethod;
}
- abstract public Map<InstanceIdentifier, DataContainer> readUsingPathArgument(DataContainer parent,
+ public abstract Map<InstanceIdentifier, DataContainer> readUsingPathArgument(DataContainer parent,
PathArgument childArgument, InstanceIdentifier targetBuilder);
- abstract public DataContainer read(DataContainer parent, Class<?> childType);
+ public abstract DataContainer read(DataContainer parent, Class<?> childType);
}
abstract class RpcMethodInvoker {
- private static Lookup LOOKUP = MethodHandles.publicLookup();
+ private static final Lookup LOOKUP = MethodHandles.publicLookup();
protected abstract Future<RpcResult<?>> invokeOn(RpcService impl, DataObject input);
}
}
-
-}
\ No newline at end of file
+}
private static final Field PATHARGUMENTS_FIELD;
private static final long serialVersionUID = 3L;
- private
transient final Iterable<PathArgument> pathArguments;
+ private
final transient Iterable<PathArgument> pathArguments;
private final int hash;
private volatile ImmutableList<PathArgument> legacyPath = null;
*
* @return new builder for InstanceIdentifier with empty path arguments.
*/
- static public InstanceIdentifierBuilder builder() {
+ public static InstanceIdentifierBuilder builder() {
return new BuilderImpl();
}
* @param origin Instace Identifier from which path arguments are copied.
* @return new builder for InstanceIdentifier with path arguments copied from original instance identifier.
*/
- static public InstanceIdentifierBuilder builder(final YangInstanceIdentifier origin) {
+ public static InstanceIdentifierBuilder builder(final YangInstanceIdentifier origin) {
return new BuilderImpl(origin.getPathArguments(), origin.hashCode());
}
* @param version data node version
* @return new AbstractTreeNode instance, covering the data tree provided
*/
- public static final TreeNode createTreeNodeRecursively(final NormalizedNode<?, ?> data, final Version version) {
+ public static TreeNode createTreeNodeRecursively(final NormalizedNode<?, ?> data, final Version version) {
if (data instanceof NormalizedNodeContainer<?, ?, ?>) {
@SuppressWarnings("unchecked")
NormalizedNodeContainer<?, ?, NormalizedNode<?, ?>> container = (NormalizedNodeContainer<?, ?, NormalizedNode<?, ?>>) data;
* @param version data node version
* @return new AbstractTreeNode instance, covering the data tree provided
*/
- public static final TreeNode createTreeNode(final NormalizedNode<?, ?> data, final Version version) {
+ public static TreeNode createTreeNode(final NormalizedNode<?, ?> data, final Version version) {
if (data instanceof NormalizedNodeContainer<?, ?, ?>) {
@SuppressWarnings("unchecked")
NormalizedNodeContainer<?, ?, NormalizedNode<?, ?>> container = (NormalizedNodeContainer<?, ?, NormalizedNode<?, ?>>) data;
private final SchemaContext schemaContext;
private final JSONCodec<?> iidCodec;
- private final JSONCodec<?> idrefCodec;
private JSONCodecFactory(final SchemaContext context) {
this.schemaContext = Preconditions.checkNotNull(context);
iidCodec = new JSONStringInstanceIdentifierCodec(context);
- idrefCodec = new JSONStringIdentityrefCodec(context);
}
/**
return superType;
}
+ @SuppressWarnings("unchecked")
private JSONCodec<Object> createCodec(DataSchemaNode key, TypeDefinition<?> type) {
TypeDefinition<?> baseType = resolveBaseTypeFrom(type);
if (baseType instanceof LeafrefTypeDefinition) {
return createReferencedTypeCodec(key, (LeafrefTypeDefinition) baseType);
+ } else if (baseType instanceof IdentityrefType) {
+ final JSONCodec<?> jsonStringIdentityrefCodec = new JSONStringIdentityrefCodec(schemaContext,
+ key.getQName().getModule());
+ return (JSONCodec<Object>) jsonStringIdentityrefCodec;
}
return createFromSimpleType(type);
}
// FIXME: Verify if this does indeed support leafref of leafref
TypeDefinition<?> referencedType =
SchemaContextUtil.getBaseTypeForLeafRef(type, getSchemaContext(), schema);
- return createFromSimpleType(referencedType);
+ return createCodec(schema, referencedType);
}
@SuppressWarnings("unchecked")
if (baseType instanceof InstanceIdentifierType) {
return (JSONCodec<Object>) iidCodec;
}
- if (baseType instanceof IdentityrefType) {
- return (JSONCodec<Object>) idrefCodec;
- }
final TypeDefinitionAwareCodec<Object, ?> codec = TypeDefinitionAwareCodec.from(type);
if (codec == null) {
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.net.URI;
+
import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.data.util.AbstractModuleStringIdentityrefCodec;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
final class JSONStringIdentityrefCodec extends AbstractModuleStringIdentityrefCodec implements JSONCodec<QName> {
private final SchemaContext context;
+ private final QNameModule parentModuleQname;
- JSONStringIdentityrefCodec(final SchemaContext context) {
+ JSONStringIdentityrefCodec(final SchemaContext context, final QNameModule parentModule) {
this.context = Preconditions.checkNotNull(context);
+ this.parentModuleQname = Preconditions.checkNotNull(parentModule);
}
@Override
protected Module moduleForPrefix(final String prefix) {
- return context.findModuleByName(prefix, null);
+ if (prefix.isEmpty()) {
+ return context.findModuleByNamespaceAndRevision(parentModuleQname.getNamespace(),
+ parentModuleQname.getRevision());
+ } else {
+ return context.findModuleByName(prefix, null);
+ }
}
@Override
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collections;
-import java.util.Date;
import java.util.Deque;
import java.util.HashSet;
import java.util.List;
}
- private final void validate(final N value) {
+ private void validate(final N value) {
if (rangeConstraints.isEmpty()) {
return;
}
return type.getRangeConstraints();
}
- private static final int provideBase(final String integer) {
+ private static int provideBase(final String integer) {
if (integer == null) {
throw new IllegalArgumentException("String representing integer number cannot be NULL");
}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.impl.codec;
+
+import com.google.common.base.Optional;
+import com.google.common.io.BaseEncoding;
+import javax.xml.bind.DatatypeConverter;
+import org.opendaylight.yangtools.yang.data.api.codec.BinaryCodec;
+import org.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
+
+class BinaryStringCodec extends TypeDefinitionAwareCodec<byte[], BinaryTypeDefinition> implements BinaryCodec<String> {
+
+ protected BinaryStringCodec(final Optional<BinaryTypeDefinition> typeDef) {
+ super(typeDef, byte[].class);
+ }
+
+ static TypeDefinitionAwareCodec<?,BinaryTypeDefinition> from(final BinaryTypeDefinition type) {
+ return new BinaryStringCodec(Optional.fromNullable(type));
+ }
+
+ @Override
+ public String serialize(final byte[] data) {
+ return data == null ? "" : BaseEncoding.base64().encode(data);
+ }
+
+ @Override
+ public byte[] deserialize(final String stringRepresentation) {
+ return stringRepresentation == null ? null : DatatypeConverter.parseBase64Binary(stringRepresentation);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.impl.codec;
+
+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.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import java.util.List;
+import java.util.Set;
+import org.opendaylight.yangtools.yang.data.api.codec.BitsCodec;
+import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition.Bit;
+
+class BitsStringCodec extends TypeDefinitionAwareCodec<Set<String>, BitsTypeDefinition>
+ implements BitsCodec<String> {
+
+ private static final Joiner JOINER = Joiner.on(" ").skipNulls();
+ private static final Splitter SPLITTER = Splitter.on(' ').omitEmptyStrings().trimResults();
+
+ private final Set<String> bits;
+
+ @SuppressWarnings("unchecked")
+ protected BitsStringCodec(final Optional<BitsTypeDefinition> typeDef) {
+ super(typeDef, (Class<Set<String>>) ((Class<?>) Set.class));
+ if (typeDef.isPresent()) {
+ final List<Bit> yangBits = typeDef.get().getBits();
+ final Set<String> bitsBuilder = Sets.newHashSet();
+ for (final Bit bit : yangBits) {
+ bitsBuilder.add(bit.getName());
+ }
+ bits = ImmutableSet.copyOf(bitsBuilder);
+ } else {
+ bits = null;
+ }
+ }
+
+ static TypeDefinitionAwareCodec<?, BitsTypeDefinition> from(final BitsTypeDefinition normalizedType) {
+ return new BitsStringCodec(Optional.fromNullable(normalizedType));
+ }
+
+ @Override
+ public final String serialize(final Set<String> data) {
+ return data == null ? "" : JOINER.join(data);
+ }
+
+ @Override
+ public final Set<String> deserialize(final String stringRepresentation) {
+ if (stringRepresentation == null) {
+ return ImmutableSet.of();
+ }
+
+ final Iterable<String> strings = SPLITTER.split(stringRepresentation);
+ validate(strings);
+ return ImmutableSet.copyOf(strings);
+ }
+
+ private void validate(final Iterable<String> strings) {
+ if (bits != null) {
+ for (final String bit : strings) {
+ Preconditions.checkArgument(bits.contains(bit),
+ "Invalid value '%s' for bits type. Allowed values are: %s", bit, bits);
+ }
+ }
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.impl.codec;
+
+import com.google.common.base.Optional;
+import org.opendaylight.yangtools.yang.data.api.codec.BooleanCodec;
+import org.opendaylight.yangtools.yang.model.api.type.BooleanTypeDefinition;
+
+class BooleanStringCodec extends TypeDefinitionAwareCodec<Boolean, BooleanTypeDefinition>
+ implements BooleanCodec<String> {
+
+ protected BooleanStringCodec(final Optional<BooleanTypeDefinition> typeDef) {
+ super(typeDef, Boolean.class);
+ }
+
+ @Override
+ public final String serialize(final Boolean data) {
+ return data == null ? "" : data.toString();
+ }
+
+ @Override
+ public final Boolean deserialize(final String stringRepresentation) {
+ return Boolean.valueOf(stringRepresentation);
+ }
+
+ static TypeDefinitionAwareCodec<?,BooleanTypeDefinition> from(final BooleanTypeDefinition normalizedType) {
+ return new BooleanStringCodec(Optional.fromNullable(normalizedType));
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.impl.codec;
+
+import com.google.common.base.Preconditions;
+import com.google.common.base.Strings;
+import java.util.regex.Pattern;
+import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
+
+class CompiledPatternContext {
+
+ private final Pattern pattern;
+ private final String errorMessage;
+
+ CompiledPatternContext(final PatternConstraint yangConstraint) {
+ pattern = Pattern.compile("^" + yangConstraint.getRegularExpression() + "$");
+ final String yangMessage = yangConstraint.getErrorMessage();
+ if (Strings.isNullOrEmpty(yangMessage)) {
+ errorMessage = "Value %s does not match regular expression <" + pattern.pattern() + ">";
+ } else {
+ errorMessage = yangMessage;
+ }
+ }
+
+ public void validate(final String s) {
+ Preconditions.checkArgument(pattern.matcher(s).matches(), errorMessage, s);
+ }
+
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.impl.codec;
+
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import java.math.BigDecimal;
+import org.opendaylight.yangtools.yang.data.api.codec.DecimalCodec;
+import org.opendaylight.yangtools.yang.model.api.type.DecimalTypeDefinition;
+
+class DecimalStringCodec extends TypeDefinitionAwareCodec<BigDecimal, DecimalTypeDefinition>
+ implements DecimalCodec<String> {
+
+ protected DecimalStringCodec(final Optional<DecimalTypeDefinition> typeDef) {
+ super(typeDef, BigDecimal.class);
+ }
+
+ static TypeDefinitionAwareCodec<?,DecimalTypeDefinition> from(final DecimalTypeDefinition normalizedType) {
+ return new DecimalStringCodec(Optional.fromNullable(normalizedType));
+ }
+
+ @Override
+ public final String serialize(final BigDecimal data) {
+ return data == null ? "" : data.toString();
+ }
+
+ @Override
+ public final BigDecimal deserialize(final String stringRepresentation) {
+ Preconditions.checkArgument( stringRepresentation != null , "Input cannot be null" );
+ return new BigDecimal(stringRepresentation);
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.impl.codec;
+
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Strings;
+import org.opendaylight.yangtools.yang.data.api.codec.EmptyCodec;
+import org.opendaylight.yangtools.yang.model.api.type.EmptyTypeDefinition;
+
+class EmptyStringCodec extends TypeDefinitionAwareCodec<Void, EmptyTypeDefinition> implements
+ EmptyCodec<String> {
+
+ protected EmptyStringCodec(final Optional<EmptyTypeDefinition> typeDef) {
+ super(typeDef, Void.class);
+ }
+
+ @Override
+ public final String serialize(final Void data) {
+ return "";
+ }
+
+ @Override
+ public final Void deserialize(final String stringRepresentation) {
+ Preconditions.checkArgument( Strings.isNullOrEmpty( stringRepresentation ),
+ "The value must be empty" );
+ return null;
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.impl.codec;
+
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import java.util.List;
+import java.util.Set;
+import org.opendaylight.yangtools.yang.data.api.codec.EnumCodec;
+import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition.EnumPair;
+
+ class EnumStringCodec extends TypeDefinitionAwareCodec<String, EnumTypeDefinition> implements
+ EnumCodec<String> {
+
+ private final Set<String> values;
+
+ protected EnumStringCodec(final Optional<EnumTypeDefinition> typeDef) {
+ super(typeDef, String.class);
+ if(typeDef.isPresent()) {
+ final List<EnumPair> enumValues = typeDef.get().getValues();
+ final Set<String> valuesBuilder = Sets.newHashSetWithExpectedSize(enumValues.size());
+ for( final EnumPair pair: enumValues ) {
+ valuesBuilder.add( pair.getName() );
+ }
+ values = ImmutableSet.copyOf(valuesBuilder);
+ } else {
+ values = null;
+ }
+
+ }
+
+ static TypeDefinitionAwareCodec<?,EnumTypeDefinition> from(final EnumTypeDefinition normalizedType) {
+ return new EnumStringCodec(Optional.fromNullable(normalizedType));
+ }
+
+ @Override
+ public final String deserialize(final String s) {
+ if (values != null) {
+ Preconditions.checkArgument(values.contains(s), "Invalid value '%s' for enum type. Allowed values are: %s",
+ s, values);
+ }
+ return s;
+ }
+
+ @Override
+ public final String serialize(final String data) {
+ return data == null ? "" : data;
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.impl.codec;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.regex.PatternSyntaxException;
+import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
+import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+class StringPatternCheckingCodec extends StringStringCodec {
+
+ private static final Logger LOG = LoggerFactory.getLogger(StringPatternCheckingCodec.class);
+ private final Collection<CompiledPatternContext> patterns;
+
+ protected StringPatternCheckingCodec(final StringTypeDefinition typeDef) {
+ super(typeDef);
+ patterns = new ArrayList<>(typeDef.getPatternConstraints().size());
+ for (final PatternConstraint yangPattern : typeDef.getPatternConstraints()) {
+ try {
+ patterns.add(new CompiledPatternContext(yangPattern));
+ } catch (final PatternSyntaxException e) {
+ LOG.debug("Unable to compile {} pattern, excluding it from validation.", yangPattern, e);
+ }
+ }
+ }
+
+ @Override
+ protected void validate(final String s) {
+ super.validate(s);
+ for (final CompiledPatternContext pattern : patterns) {
+ pattern.validate(s);
+ }
+ }
+
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.impl.codec;
+
+import com.google.common.base.Optional;
+import org.opendaylight.yangtools.yang.data.api.codec.StringCodec;
+import org.opendaylight.yangtools.yang.model.api.type.StringTypeDefinition;
+
+class StringStringCodec extends TypeDefinitionAwareCodec<String, StringTypeDefinition> implements
+ StringCodec<String> {
+
+ protected StringStringCodec(final StringTypeDefinition typeDef) {
+ super(Optional.of(typeDef), String.class);
+ typeDef.getLengthConstraints();
+ }
+
+ static TypeDefinitionAwareCodec<?, StringTypeDefinition> from(final StringTypeDefinition normalizedType) {
+ if (normalizedType.getPatternConstraints().isEmpty()) {
+ return new StringStringCodec(normalizedType);
+ }
+
+ return new StringPatternCheckingCodec(normalizedType);
+ }
+
+ @Override
+ public final String deserialize(final String stringRepresentation) {
+ if (stringRepresentation == null) {
+ // FIXME: These seems buggy, but someone may be using this behaviour
+ return "";
+ }
+ validate(stringRepresentation);
+ return stringRepresentation;
+ }
+
+ @Override
+ public final String serialize(final String data) {
+ return data == null ? "" : data;
+ }
+
+ protected void validate(final String s) {
+
+ }
+}
\ No newline at end of file
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 java.math.BigDecimal;
-import java.util.Set;
-import javax.xml.bind.DatatypeConverter;
-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.StringCodec;
-import org.opendaylight.yangtools.yang.data.api.codec.UnionCodec;
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;
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;
public abstract class TypeDefinitionAwareCodec<J, T extends TypeDefinition<T>> implements DataStringCodec<J> {
-
-
+ private static final TypeDefinitionAwareCodec<?,?> EMPTY_DEFAULT_CODEC = new EmptyStringCodec(Optional.<EmptyTypeDefinition>absent());
private final Optional<T> typeDefinition;
private final Class<J> inputClass;
-
-
- private static final BinaryCodecStringImpl BINARY_DEFAULT_CODEC = new BinaryCodecStringImpl(
- Optional.<BinaryTypeDefinition> absent());
-
- private static final BooleanCodecStringImpl BOOLEAN_DEFAULT_CODEC = new BooleanCodecStringImpl(
- Optional.<BooleanTypeDefinition> absent());
-
- private static final DecimalCodecStringImpl DECIMAL64_DEFAULT_CODEC = new DecimalCodecStringImpl(
- Optional.<DecimalTypeDefinition> absent());
-
- private static final EmptyCodecStringImpl EMPTY_DEFAULT_CODEC = new EmptyCodecStringImpl(
- Optional.<EmptyTypeDefinition> absent());
-
- private static final StringCodecStringImpl STRING_DEFAULT_CODEC = new StringCodecStringImpl(
- Optional.<StringTypeDefinition> absent());
-
@Override
public Class<J> getInputClass() {
return inputClass;
TypeDefinitionAwareCodec codec = null;
if (normalizedType instanceof BinaryTypeDefinition) {
- codec = BINARY_DEFAULT_CODEC;
+ codec = BinaryStringCodec.from((BinaryTypeDefinition)normalizedType);
} else if (normalizedType instanceof BitsTypeDefinition) {
- codec = new BitsCodecStringImpl( Optional.of( (BitsTypeDefinition)normalizedType ) );
+ codec = BitsStringCodec.from((BitsTypeDefinition)normalizedType);
} else if (normalizedType instanceof BooleanTypeDefinition) {
- codec = BOOLEAN_DEFAULT_CODEC;
+ codec = BooleanStringCodec.from((BooleanTypeDefinition)normalizedType);
} else if (normalizedType instanceof DecimalTypeDefinition) {
- codec = DECIMAL64_DEFAULT_CODEC;
+ codec = DecimalStringCodec.from((DecimalTypeDefinition)normalizedType);
} else if (normalizedType instanceof EmptyTypeDefinition) {
codec = EMPTY_DEFAULT_CODEC;
} else if (normalizedType instanceof EnumTypeDefinition) {
- codec = new EnumCodecStringImpl( Optional.of( (EnumTypeDefinition)normalizedType ) );
+ codec = EnumStringCodec.from((EnumTypeDefinition)normalizedType);
} else if (normalizedType instanceof IntegerTypeDefinition) {
codec = AbstractIntegerStringCodec.from((IntegerTypeDefinition) normalizedType);
} else if (normalizedType instanceof StringTypeDefinition) {
- codec = STRING_DEFAULT_CODEC;
+ codec = StringStringCodec.from((StringTypeDefinition)normalizedType);
} else if (normalizedType instanceof UnionTypeDefinition) {
- codec = new UnionCodecStringImpl( Optional.of( (UnionTypeDefinition)normalizedType ) );
+ codec = UnionStringCodec.from((UnionTypeDefinition)normalizedType);
} else if (normalizedType instanceof UnsignedIntegerTypeDefinition) {
codec = AbstractIntegerStringCodec.from((UnsignedIntegerTypeDefinition) normalizedType);
}
return codec;
}
- public static class BooleanCodecStringImpl extends TypeDefinitionAwareCodec<Boolean, BooleanTypeDefinition>
- implements BooleanCodec<String> {
-
+ @Deprecated
+ public static class BooleanCodecStringImpl extends BooleanStringCodec{
protected BooleanCodecStringImpl(final Optional<BooleanTypeDefinition> typeDef) {
- super(typeDef, Boolean.class);
- }
-
- @Override
- public String serialize(final Boolean data) {
- return data == null ? "" : data.toString();
- }
-
- @Override
- public Boolean deserialize(final String stringRepresentation) {
- return Boolean.valueOf(stringRepresentation);
+ super(typeDef);
}
}
@Deprecated
public static class Uint32CodecStringImpl extends Uint32StringCodec {
-
protected Uint32CodecStringImpl(final Optional<UnsignedIntegerTypeDefinition> typeDef) {
super(typeDef);
}
-
}
@Deprecated
public static class Uint64CodecStringImpl extends Uint64StringCodec {
-
protected Uint64CodecStringImpl(final Optional<UnsignedIntegerTypeDefinition> typeDef) {
super(typeDef);
}
-
}
- public static class StringCodecStringImpl extends TypeDefinitionAwareCodec<String, StringTypeDefinition> implements
- StringCodec<String> {
-
+ @Deprecated
+ public static class StringCodecStringImpl extends StringStringCodec {
protected StringCodecStringImpl(final Optional<StringTypeDefinition> typeDef) {
- super(typeDef, String.class);
- }
-
- @Override
- public String deserialize(final String stringRepresentation) {
- return stringRepresentation == null ? "" : stringRepresentation;
- }
-
- @Override
- public String serialize(final String data) {
- return data == null ? "" : data;
+ super(typeDef.get());
}
}
@Deprecated
public static class Int16CodecStringImpl extends Int16StringCodec {
-
protected Int16CodecStringImpl(final Optional<IntegerTypeDefinition> typeDef) {
super(typeDef);
}
-
}
@Deprecated
public static class Int32CodecStringImpl extends Int32StringCodec {
-
protected Int32CodecStringImpl(final Optional<IntegerTypeDefinition> typeDef) {
super(typeDef);
}
@Deprecated
public static class Int64CodecStringImpl extends Int64StringCodec {
-
protected Int64CodecStringImpl(final Optional<IntegerTypeDefinition> typeDef) {
super(typeDef);
}
}
- public static class EmptyCodecStringImpl extends TypeDefinitionAwareCodec<Void, EmptyTypeDefinition> implements
- EmptyCodec<String> {
-
+ @Deprecated
+ public static class EmptyCodecStringImpl extends EmptyStringCodec {
protected EmptyCodecStringImpl(final Optional<EmptyTypeDefinition> typeDef) {
- super(typeDef, Void.class);
- }
-
- @Override
- public String serialize(final Void data) {
- return "";
- }
-
- @Override
- public Void deserialize(final String stringRepresentation) {
- Preconditions.checkArgument( Strings.isNullOrEmpty( stringRepresentation ),
- "The value must be empty" );
- return null;
+ super(typeDef);
}
}
- public static final class BinaryCodecStringImpl extends TypeDefinitionAwareCodec<byte[], BinaryTypeDefinition>
- implements BinaryCodec<String> {
-
+ @Deprecated
+ public static final class BinaryCodecStringImpl extends BinaryStringCodec {
protected BinaryCodecStringImpl(final Optional<BinaryTypeDefinition> typeDef) {
- super(typeDef, byte[].class);
- }
-
- @Override
- public String serialize(final byte[] data) {
- return data == null ? "" : BaseEncoding.base64().encode(data);
+ super(typeDef);
}
- @Override
- public byte[] deserialize(final String stringRepresentation) {
- return stringRepresentation == null ? null : DatatypeConverter.parseBase64Binary(stringRepresentation);
- }
}
- public static final class BitsCodecStringImpl extends TypeDefinitionAwareCodec<Set<String>, BitsTypeDefinition>
- implements BitsCodec<String> {
+ @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(final Optional<BitsTypeDefinition> typeDef) {
- super(typeDef, (Class<Set<String>>) ((Class<?>) Set.class));
- }
-
- @Override
- public String serialize(final Set<String> data) {
- return data == null ? "" : JOINER.join(data);
- }
-
- @Override
- public Set<String> deserialize(final String stringRepresentation) {
- if (stringRepresentation == null) {
- return ImmutableSet.of();
- }
-
- final Iterable<String> strings = SPLITTER.split(stringRepresentation);
-
- if( getTypeDefinition().isPresent() ) {
- final Set<String> allowedNames = Sets.newHashSet();
- for( final BitsTypeDefinition.Bit bit: getTypeDefinition().get().getBits() ) {
- allowedNames.add( bit.getName() );
- }
-
- for( final String bit: strings ) {
- if( !allowedNames.contains( bit ) ) {
- throw new IllegalArgumentException(
- "Invalid value \"" + bit + "\" for bits type. Allowed values are: " +
- allowedNames );
- }
- }
- }
-
- return ImmutableSet.copyOf(strings);
+ super(typeDef);
}
}
- public static class EnumCodecStringImpl extends TypeDefinitionAwareCodec<String, EnumTypeDefinition> implements
- EnumCodec<String> {
+ @Deprecated
+ public static class EnumCodecStringImpl extends EnumStringCodec {
protected EnumCodecStringImpl(final Optional<EnumTypeDefinition> typeDef) {
- super(typeDef, String.class);
- }
-
- @Override
- public String deserialize(final String stringRepresentation) {
- if( getTypeDefinition().isPresent() ) {
- final Set<String> allowedNames = Sets.newHashSet();
- for( final 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;
+ super(typeDef);
}
- @Override
- public String serialize(final String data) {
- return data == null ? "" : data;
- }
}
- public static class DecimalCodecStringImpl extends TypeDefinitionAwareCodec<BigDecimal, DecimalTypeDefinition>
- implements DecimalCodec<String> {
-
+ @Deprecated
+ public static class DecimalCodecStringImpl extends DecimalStringCodec {
protected DecimalCodecStringImpl(final Optional<DecimalTypeDefinition> typeDef) {
- super(typeDef, BigDecimal.class);
- }
-
- @Override
- public String serialize(final BigDecimal data) {
- return data == null ? "" : data.toString();
- }
-
- @Override
- public BigDecimal deserialize(final String stringRepresentation) {
- Preconditions.checkArgument( stringRepresentation != null , "Input cannot be null" );
- return new BigDecimal(stringRepresentation);
+ super(typeDef);
}
}
- public static class UnionCodecStringImpl extends TypeDefinitionAwareCodec<Object, UnionTypeDefinition> implements
- UnionCodec<String> {
-
+ @Deprecated
+ public static class UnionCodecStringImpl extends UnionStringCodec {
protected UnionCodecStringImpl(final Optional<UnionTypeDefinition> typeDef) {
- super(typeDef, Object.class);
- }
-
- @Override
- public String serialize(final Object data) {
- return data == null ? "" : data.toString();
- }
-
- @Override
- public Object deserialize(final String stringRepresentation) {
- if( getTypeDefinition().isPresent() ) {
- boolean valid = false;
- for( final TypeDefinition<?> type: getTypeDefinition().get().getTypes() ) {
- final TypeDefinitionAwareCodec<Object, ? extends TypeDefinition<?>> 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 {
- typeAwareCodec.deserialize( stringRepresentation );
- valid = true;
- break;
- }
- catch( final Exception e ) {
- // invalid - try the next union type.
- }
- }
-
- if( !valid ) {
- throw new IllegalArgumentException(
- "Invalid value \"" + stringRepresentation + "\" for union type." );
- }
- }
-
- return stringRepresentation;
+ super(typeDef);
}
}
}
--- /dev/null
+/*
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the terms of the Eclipse
+ * Public License v1.0 which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.data.impl.codec;
+
+import com.google.common.base.Optional;
+import org.opendaylight.yangtools.yang.data.api.codec.UnionCodec;
+import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+class UnionStringCodec extends TypeDefinitionAwareCodec<Object, UnionTypeDefinition> implements UnionCodec<String> {
+
+ private final static Logger LOG = LoggerFactory.getLogger(UnionStringCodec.class);
+
+ protected UnionStringCodec(final Optional<UnionTypeDefinition> typeDef) {
+ super(typeDef, Object.class);
+ }
+
+ static TypeDefinitionAwareCodec<?, UnionTypeDefinition> from(final UnionTypeDefinition normalizedType) {
+ return new UnionStringCodec(Optional.fromNullable(normalizedType));
+ }
+
+ @Override
+ public final String serialize(final Object data) {
+ return data == null ? "" : data.toString();
+ }
+
+ @Override
+ public final Object deserialize(final String stringRepresentation) {
+
+ if (!getTypeDefinition().isPresent()) {
+ return stringRepresentation;
+ }
+
+ for (final TypeDefinition<?> type : getTypeDefinition().get().getTypes()) {
+ final TypeDefinitionAwareCodec<Object, ? extends TypeDefinition<?>> 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
+ */
+ return stringRepresentation;
+ }
+
+ try {
+ typeAwareCodec.deserialize(stringRepresentation);
+ return stringRepresentation;
+ } catch (final Exception e) {
+ LOG.debug("Value {} did not matched representation for {}",stringRepresentation,type,e);
+ // invalid - try the next union type.
+ }
+ }
+
+ throw new IllegalArgumentException("Invalid value \"" + stringRepresentation + "\" for union type.");
+ }
+}
import org.w3c.dom.Element;
public final class XmlDocumentUtils {
+ public static final QName OPERATION_ATTRIBUTE_QNAME = QName.create(SchemaContext.NAME, "operation");
+ private static final Logger LOG = LoggerFactory.getLogger(XmlDocumentUtils.class);
private XmlDocumentUtils() {
throw new UnsupportedOperationException("Utility class should not be instantiated");
}
- public static final QName OPERATION_ATTRIBUTE_QNAME = QName.create(SchemaContext.NAME, "operation");
- private static final Logger LOG = LoggerFactory.getLogger(XmlDocumentUtils.class);
-
public static Document getDocument() {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
Document doc = null;
return doc;
}
- private static final Element createElementFor(final Document doc, final QName qname, final Object obj) {
+ private static Element createElementFor(final Document doc, final QName qname, final Object obj) {
final Element ret;
if (qname.getNamespace() != null) {
ret = doc.createElementNS(qname.getNamespace().toString(), qname.getLocalName());
return QName.create(namespace != null ? URI.create(namespace) : null, null, localName);
}
-
-
public static Optional<ModifyAction> getModifyOperationFromAttributes(final Element xmlElement) {
Attr attributeNodeNS = xmlElement.getAttributeNodeNS(OPERATION_ATTRIBUTE_QNAME.getNamespace().toString(), OPERATION_ATTRIBUTE_QNAME.getLocalName());
if(attributeNodeNS == null) {
return Optional.of(action);
}
-
- public static final Optional<DataSchemaNode> findFirstSchema(final QName qname, final Iterable<DataSchemaNode> dataSchemaNode) {
+ public static Optional<DataSchemaNode> findFirstSchema(final QName qname, final Iterable<DataSchemaNode> dataSchemaNode) {
if (dataSchemaNode != null && qname != null) {
for (DataSchemaNode dsn : dataSchemaNode) {
if (qname.isEqualWithoutRevision(dsn.getQName())) {
return Optional.absent();
}
- public static final XmlCodecProvider defaultValueCodecProvider() {
+ public static XmlCodecProvider defaultValueCodecProvider() {
return XmlUtils.DEFAULT_XML_CODEC_PROVIDER;
}
}
if (baseType instanceof LeafrefTypeDefinition) {
final LeafrefTypeDefinition leafrefTypeDefinition = (LeafrefTypeDefinition) baseType;
baseType = SchemaContextUtil.getBaseTypeForLeafRef(leafrefTypeDefinition, schemaCtx, schema);
- value = parseXmlValue(xml, codecProvider, baseType);
+ value = parseXmlValue(xml, codecProvider, schema, baseType, schemaCtx);
} else if (baseType instanceof InstanceIdentifierType) {
value = InstanceIdentifierForXmlCodec.deserialize(xml, schemaCtx);
} else if (baseType instanceof IdentityrefTypeDefinition) {
* @param namespace Namespace to map
* @return Allocated unique prefix, or null if the prefix cannot be mapped.
*/
- protected abstract @Nullable String prefixForNamespace(final @Nonnull URI namespace);
+ @Nullable protected abstract String prefixForNamespace(@Nonnull final URI namespace);
/**
* Create a QName for a prefix and local name.
* @return QName
* @throws IllegalArgumentException if the prefix cannot be resolved
*/
- protected abstract @Nullable QName createQName(final @Nonnull String prefix, final @Nonnull String localName);
+ @Nullable protected abstract QName createQName(@Nonnull final String prefix, @Nonnull final String localName);
private static String getIdAndPrefixAsStr(final String pathPart) {
int predicateStartIndex = pathPart.indexOf('[');
YangVersion(YangVersionStatement.class, "yang-version", "value"),
YinElement(YinElementStatement.class, "yin-element", "value");
- private final @Nonnull Class<? extends DeclaredStatement<?>> type;
- private final @Nonnull QName name;
- private final @Nullable QName argument;
+ private final Class<? extends DeclaredStatement<?>> type;
+ private final QName name;
+ private final QName argument;
private final boolean yinElement;
this.yinElement = yinElement;
}
- private static QName yinQName(String nameStr) {
+ @Nonnull private static QName yinQName(String nameStr) {
return QName.cachedReference(QName.create(YangConstants.RFC6020_YIN_MODULE, nameStr));
}
}
@Override
- public QName getArgumentName() {
+ @Nullable public QName getArgumentName() {
return argument;
}
@Override
- public Class<? extends DeclaredStatement<?>> getDeclaredRepresentationClass() {
+ @Nonnull public Class<? extends DeclaredStatement<?>> getDeclaredRepresentationClass() {
return type;
}
* @see BitsTypeDefinition
*/
public final class BitsType implements BitsTypeDefinition {
- private final static QName NAME = BaseTypes.BITS_QNAME;
-
- private final SchemaPath path;
+ private static final QName NAME = BaseTypes.BITS_QNAME;
private static final String DESCRIPTION = "The bits built-in type represents a bit set. "
+ "That is, a bits value is a set of flags identified by small integer position "
+ "numbers starting at 0. Each bit number has an assigned name.";
private static final String REFERENCE = "https://tools.ietf.org/html/rfc6020#section-9.7";
- private final List<Bit> bits;
private static final String UNITS = "";
+ private final SchemaPath path;
+ private final List<Bit> bits;
/**
* Default constructor. <br>
* @param input Optional of schema source, representing one returned from delegate.
* @return Optional of schema source, representing result returned from this cache.
*/
- abstract protected Optional<O> cacheSchemaSource(SourceIdentifier identifier, Optional<I> input);
+ protected abstract Optional<O> cacheSchemaSource(SourceIdentifier identifier, Optional<I> input);
/**
* Returns cached schema source of {@link Optional#absent()} if source is not present in cache.
* @param identifier Source Identifier for which schema should be retrieved.
* @return Cached schema source.
*/
- abstract protected Optional<O> getCachedSchemaSource(SourceIdentifier identifier);
+ protected abstract Optional<O> getCachedSchemaSource(SourceIdentifier identifier);
@Override
public AdvancedSchemaSourceProvider<I> getDelegate() {
*
*/
@Beta
- private class SchemaSourceProviderInstance implements //
- AdvancedSchemaSourceProvider<O>,
- Delegator<AdvancedSchemaSourceProvider<I>> {
+ private class SchemaSourceProviderInstance implements AdvancedSchemaSourceProvider<O>, Delegator<AdvancedSchemaSourceProvider<I>> {
private final AdvancedSchemaSourceProvider<I> delegate;
import com.google.common.collect.Iterables;
import com.google.common.io.ByteSource;
import com.google.common.io.ByteStreams;
-import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
this.namespaceDefinitions = namespaces;
}
- public static final Builder builder() {
+ public static Builder builder() {
return new Builder(EMPTY);
}
- public static final Builder derivedFrom(StatementSupportBundle parent) {
+ public static Builder derivedFrom(StatementSupportBundle parent) {
return new Builder(parent);
}
public final class StmtContextUtils {
private static final Function<StmtContext<?, ?,?>, DeclaredStatement<?>> BUILD_DECLARED = new Function<StmtContext<?,?,?>, DeclaredStatement<?>>() {
-
@Override
public DeclaredStatement<?> apply(StmtContext<?,?,?> input) {
return input.buildDeclared();
}
-
};
private static final Function<StmtContext<?, ?,?>, EffectiveStatement<?,?>> BUILD_EFFECTIVE = new Function<StmtContext<?,?,?>, EffectiveStatement<?,?>>() {
-
@Override
public EffectiveStatement<?,?> apply(StmtContext<?,?,?> input) {
return input.buildEffective();
}
-
};
private StmtContextUtils() {
throw new UnsupportedOperationException("Utility class");
}
-
@SuppressWarnings("unchecked")
- public static final <D extends DeclaredStatement<?>> Function<StmtContext<?, ? extends D, ?>, D> buildDeclared() {
+ public static <D extends DeclaredStatement<?>> Function<StmtContext<?, ? extends D, ?>, D> buildDeclared() {
return Function.class.cast(BUILD_DECLARED);
}
@SuppressWarnings("unchecked")
- public static final <E extends EffectiveStatement<?,?>> Function<StmtContext<?, ?,? extends E>, E> buildEffective() {
+ public static <E extends EffectiveStatement<?,?>> Function<StmtContext<?, ?,? extends E>, E> buildEffective() {
return Function.class.cast(BUILD_EFFECTIVE);
}
@SuppressWarnings("unchecked")
- public static
final <AT,DT extends DeclaredStatement<AT>> AT firstAttributeOf(Iterable<? extends StmtContext<?,?,?>> contexts, Class<DT> declaredType) {
+ public static <AT,DT extends DeclaredStatement<AT>> AT firstAttributeOf(Iterable<? extends StmtContext<?,?,?>> contexts, Class<DT> declaredType) {
for(StmtContext<?, ?, ?> ctx : contexts) {
if(producesDeclared(ctx,declaredType)) {
return (AT) ctx.getStatementArgument();
return null;
}
- public static final boolean producesDeclared(StmtContext<?, ?, ?> ctx, Class<? extends DeclaredStatement<?>> type) {
+ public static boolean producesDeclared(StmtContext<?, ?, ?> ctx, Class<? extends DeclaredStatement<?>> type) {
return type.isAssignableFrom(ctx.getPublicDefinition().getDeclaredRepresentationClass());
}
-
-
-
}
super(provider, YangTextSchemaSource.class, consumer, ASTSchemaSource.class, TRANSFORMATION);
}
- public static final TextToASTTransformer create(final SchemaRepository provider, final SchemaSourceRegistry consumer) {
+ public static TextToASTTransformer create(final SchemaRepository provider, final SchemaSourceRegistry consumer) {
return new TextToASTTransformer(provider, consumer);
}
}
Code Review / yangtools.git / commitdiff