}
@Override
- public final Class<T> getDataClass() {
+ public final Class<T> getDataType() {
return codec.getInputClass();
}
@Override
- public final T deserializeString(final String input) {
- return codec.deserialize(input);
+ public final T parseValue(final Object ctx, final String str) {
+ return codec.deserialize(str);
}
final String serialize(final T input) {
super(codec);
}
- /**
- * Serialize specified value with specified JsonWriter.
- *
- * @param writer JsonWriter
- * @param value
- */
@Override
- public void serializeToWriter(final JsonWriter writer, final Boolean value) throws IOException {
- writer.value(value);
+ public void writeValue(final JsonWriter ctx, final Boolean value) throws IOException {
+ ctx.value(value);
}
}
}
@Override
- public Void deserializeString(final String input) {
- return null;
+ public Class<Void> getDataType() {
+ return Void.class;
}
@Override
- public void serializeToWriter(final JsonWriter writer, final Void value) throws IOException {
- writer.beginArray();
- writer.value((String) null);
- writer.endArray();
+ public Void parseValue(final Object ctx, final String input) {
+ return null;
}
@Override
- public Class<Void> getDataClass() {
- return Void.class;
+ public void writeValue(final JsonWriter ctx, final Void value) throws IOException {
+ ctx.beginArray();
+ ctx.value((String) null);
+ ctx.endArray();
}
}
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
+import org.opendaylight.yangtools.yang.data.util.codec.TypeAwareCodec;
-interface JSONCodec<T> {
+interface JSONCodec<T> extends TypeAwareCodec<T, Object, JsonWriter> {
/**
- * Deserialize (parse) a String representation into its native format.
+ * {@inheritDoc}
*
- * @param value String representation
- * @return Value in native format
- * @throws IllegalArgumentException if the value does not parse or pass type validation
- */
- T deserializeString(String value);
-
- /**
- * Serialize specified value with specified JsonWriter.
- *
- * @param writer JsonWriter
- * @param value Value in native format
* @throws IOException if the write fails
*/
- void serializeToWriter(JsonWriter writer, T value) throws IOException;
-
- /**
- * Return the internal representation class.
- *
- * @return Data representation class.
- */
- Class<T> getDataClass();
+ @Override
+ void writeValue(JsonWriter ctx, T value) throws IOException;
}
import static org.w3c.dom.Node.TEXT_NODE;
import com.google.common.base.Preconditions;
+import com.google.common.base.Throwables;
import com.google.gson.stream.JsonWriter;
import java.io.IOException;
import java.net.URI;
}
}
+ @SuppressWarnings("unchecked")
private void writeValue(final Object value, final JSONCodec<?> codec)
throws IOException {
- ((JSONCodec<Object>) codec).serializeToWriter(writer, value);
+ try {
+ ((JSONCodec<Object>) codec).writeValue(writer, value);
+ } catch (IOException e) {
+ throw e;
+ } catch (Exception e) {
+ Throwables.propagateIfPossible(e);
+ throw new RuntimeException(e);
+ }
}
private void writeAnyXmlValue(final DOMSource anyXmlValue) throws IOException {
}
@Override
- public Class<QName> getDataClass() {
+ public Class<QName> getDataType() {
return QName.class;
}
@Override
- public QName deserializeString(final String value) {
- return deserialize(value);
+ public QName parseValue(final Object ctx, final String str) {
+ return deserialize(str);
}
- /**
- * Serialize QName with specified JsonWriter.
- *
- * @param writer JsonWriter
- * @param value QName
- */
@Override
- public void serializeToWriter(final JsonWriter writer, final QName value) throws IOException {
- writer.value(serialize(value));
+ public void writeValue(final JsonWriter ctx, final QName value) throws IOException {
+ ctx.value(serialize(value));
}
}
Preconditions.checkNotNull(schemaNode, "schemaNode cannot be null");
Preconditions.checkArgument(schemaNode instanceof LeafSchemaNode, "schemaNode must be of type LeafSchemaNode");
final JSONCodec<?> objectJSONCodec = codecFactory.codecFor((LeafSchemaNode) schemaNode);
- return objectJSONCodec.deserializeString(value);
+ return objectJSONCodec.parseValue(null, value);
}
@Override
- public Class<YangInstanceIdentifier> getDataClass() {
+ public Class<YangInstanceIdentifier> getDataType() {
return YangInstanceIdentifier.class;
}
@Override
- public YangInstanceIdentifier deserializeString(final String value) {
- return deserialize(value);
+ public YangInstanceIdentifier parseValue(final Object ctx, final String str) {
+ return deserialize(str);
}
- /**
- * Serialize YangInstanceIdentifier with specified JsonWriter.
- *
- * @param writer JsonWriter
- * @param value YangInstanceIdentifier
- */
@Override
- public void serializeToWriter(final JsonWriter writer, final YangInstanceIdentifier value) throws IOException {
- writer.value(serialize(value));
+ public void writeValue(final JsonWriter ctx, final YangInstanceIdentifier value) throws IOException {
+ ctx.value(serialize(value));
}
}
private Object translateValueByType(final String value, final DataSchemaNode node) {
Preconditions.checkArgument(node instanceof TypedSchemaNode);
- return codecs.codecFor((TypedSchemaNode) node).deserializeString(value);
+ return codecs.codecFor((TypedSchemaNode) node).parseValue(null, value);
}
private void removeNamespace() {
}
@Override
- public Class<Object> getDataClass() {
+ public Class<Object> getDataType() {
return Object.class;
}
@Override
- public Object deserializeString(final String value) {
+ public Object parseValue(final Object ctx, final String str) {
LOG.warn("Call of the deserializeString method on null codec. No operation performed.");
return null;
}
@Override
- public void serializeToWriter(final JsonWriter writer, final Object value) throws IOException {
- // NOOP since codec is unkwown.
+ public void writeValue(final JsonWriter ctx, final Object value) throws IOException {
+ // NOOP since codec is unknown.
LOG.warn("Call of the serializeToWriter method on null codec. No operation performed.");
}
}
super(codec);
}
- /**
- * Serialize specified value with specified JsonWriter.
- *
- * @param writer JsonWriter
- * @param value
- */
@Override
- public void serializeToWriter(final JsonWriter writer, final T value) throws IOException {
- writer.value(value);
+ public void writeValue(final JsonWriter ctx, final T value) throws IOException {
+ ctx.value(value);
}
}
\ No newline at end of file
super(codec);
}
- /**
- * Serialize specified value with specified JsonWriter.
- *
- * @param writer JsonWriter
- * @param value
- */
@Override
- public void serializeToWriter(final JsonWriter writer, final T value) throws IOException {
- writer.value(serialize(value));
+ public void writeValue(final JsonWriter ctx, final T value) throws IOException {
+ ctx.value(serialize(value));
}
}
\ No newline at end of file
}
@Override
- public Class<Object> getDataClass() {
+ public Class<Object> getDataType() {
return Object.class;
}
}
}
@Override
- public Class<T> getDataClass() {
+ public Class<T> getDataType() {
return dataClass;
}
}
final Iterator<JSONCodec<?>> it = codecs.iterator();
Verify.verify(it.hasNext(), "Union %s has no subtypes", type);
- Class<?> dataClass = it.next().getDataClass();
+ Class<?> dataClass = it.next().getDataType();
while (it.hasNext()) {
- final Class<?> next = it.next().getDataClass();
+ final Class<?> next = it.next().getDataType();
if (!dataClass.equals(next)) {
LOG.debug("Type {} has diverse data classes: {} and {}", type, dataClass, next);
return new Diverse(codecs);
}
@Override
- public final T deserializeString(final String input) {
+ public final T parseValue(final Object ctx, final String str) {
for (JSONCodec<?> codec : codecs) {
final Object ret;
try {
- ret = codec.deserializeString(input);
+ ret = codec.parseValue(ctx, str);
} catch (RuntimeException e) {
- LOG.debug("Codec {} did not accept input '{}'", codec, input, e);
+ LOG.debug("Codec {} did not accept input '{}'", codec, str, e);
continue;
}
- return getDataClass().cast(ret);
+ return getDataType().cast(ret);
}
- throw new IllegalArgumentException("Invalid value \"" + input + "\" for union type.");
+ throw new IllegalArgumentException("Invalid value \"" + str + "\" for union type.");
}
@Override
- public final void serializeToWriter(final JsonWriter writer, final T value) throws IOException {
+ public final void writeValue(final JsonWriter ctx, final T value) throws IOException {
for (JSONCodec<?> codec : codecs) {
- if (!codec.getDataClass().isInstance(value)) {
+ if (!codec.getDataType().isInstance(value)) {
LOG.debug("Codec {} cannot accept input {}, skipping it", codec, value);
continue;
}
@SuppressWarnings("unchecked")
final JSONCodec<Object> objCodec = (JSONCodec<Object>) codec;
try {
- objCodec.serializeToWriter(writer, value);
+ objCodec.writeValue(ctx, value);
return;
} catch (RuntimeException e) {
LOG.debug("Codec {} failed to serialize {}", codec, value, e);
}
@Override
- public final Class<T> getDataClass() {
+ public final Class<T> getDataType() {
return codec.getInputClass();
}
@Override
- public final T deserializeFromString(final NamespaceContext namespaceContext, final String value) {
- return codec.deserialize(value);
+ public final T parseValue(final NamespaceContext namespaceContext, final String str) {
+ return codec.deserialize(str);
}
final String serialize(final T input) {
}
@Override
- public void serializeToWriter(final XMLStreamWriter writer, final Boolean value) throws XMLStreamException {
- writer.writeCharacters(String.valueOf(value));
+ public void writeValue(final XMLStreamWriter ctx, final Boolean value) throws XMLStreamException {
+ ctx.writeCharacters(String.valueOf(value));
}
}
}
@Override
- public Class<Void> getDataClass() {
+ public Class<Void> getDataType() {
return Void.class;
}
@Override
- public Void deserializeFromString(final NamespaceContext namespaceContext, final String value) {
+ public Void parseValue(final NamespaceContext ctx, final String str) {
return null;
}
@Override
- public void serializeToWriter(final XMLStreamWriter writer, final Void value) throws XMLStreamException {
- writer.writeCharacters("");
+ public void writeValue(final XMLStreamWriter ctx, final Void value) throws XMLStreamException {
+ ctx.writeCharacters("");
}
}
}
@Override
- public Class<QName> getDataClass() {
+ public Class<QName> getDataType() {
return QName.class;
}
- /**
- * Serialize QName with specified XMLStreamWriter.
- *
- * @param writer XMLStreamWriter
- * @param value QName
- */
@Override
- public void serializeToWriter(final XMLStreamWriter writer, final QName value) throws XMLStreamException {
- // FIXME: this does not work correctly, as we need to populate entries into the namespace context
- writer.writeCharacters(serialize(value));
- }
-
- @Override
- public QName deserializeFromString(final NamespaceContext namespaceContext, final String value) {
- pushNamespaceContext(namespaceContext);
+ public QName parseValue(final NamespaceContext ctx, final String str) {
+ pushNamespaceContext(ctx);
try {
- return deserialize(value);
+ return deserialize(str);
} finally {
popNamespaceContext();
}
}
+ @Override
+ public void writeValue(final XMLStreamWriter ctx, final QName value) throws XMLStreamException {
+ // FIXME: this does not work correctly, as we need to populate entries into the namespace context
+ ctx.writeCharacters(serialize(value));
+ }
+
private static NamespaceContext getNamespaceContext() {
return TL_NSCONTEXT.get().getFirst();
}
}
@Override
- public Class<Object> getDataClass() {
+ public Class<Object> getDataType() {
return Object.class;
}
@Override
- public void serializeToWriter(final XMLStreamWriter writer, final Object value) throws XMLStreamException {
- // NOOP since codec is unkwown.
- LOG.warn("Call of the serializeToWriter method on null codec. No operation performed.");
- }
-
- @Override
- public Object deserializeFromString(final NamespaceContext namespaceContext, final String value) {
+ public Object parseValue(final NamespaceContext ctx, final String str) {
LOG.warn("Call of the deserializeString method on null codec. No operation performed.");
return null;
}
+ @Override
+ public void writeValue(final XMLStreamWriter ctx, final Object value) throws XMLStreamException {
+ // NOOP since codec is unkwown.
+ LOG.warn("Call of the serializeToWriter method on null codec. No operation performed.");
+ }
}
}
@Override
- public void serializeToWriter(final XMLStreamWriter writer, final T value) throws XMLStreamException {
- writer.writeCharacters(String.valueOf(value));
+ public void writeValue(final XMLStreamWriter ctx, final T value) throws XMLStreamException {
+ ctx.writeCharacters(String.valueOf(value));
}
}
super(codec);
}
- /**
- * Serialize specified value with specified XMLStreamWriter.
- *
- * @param writer XMLStreamWriter
- * @param value value which will be serialized to the writer
- */
@Override
- public void serializeToWriter(final XMLStreamWriter writer, final T value) throws XMLStreamException {
- writer.writeCharacters(serialize(value));
+ public void writeValue(final XMLStreamWriter ctx, final T value) throws XMLStreamException {
+ ctx.writeCharacters(serialize(value));
}
}
}
@Override
- public Class<Object> getDataClass() {
+ public Class<Object> getDataType() {
return Object.class;
}
}
}
@Override
- public Class<T> getDataClass() {
+ public Class<T> getDataType() {
return dataClass;
}
}
final Iterator<XmlCodec<?>> it = codecs.iterator();
Verify.verify(it.hasNext(), "Union %s has no subtypes", type);
- Class<?> dataClass = it.next().getDataClass();
+ Class<?> dataClass = it.next().getDataType();
while (it.hasNext()) {
- final Class<?> next = it.next().getDataClass();
+ final Class<?> next = it.next().getDataType();
if (!dataClass.equals(next)) {
LOG.debug("Type {} has diverse data classes: {} and {}", type, dataClass, next);
return new Diverse(codecs);
}
@Override
- public final T deserializeFromString(final NamespaceContext namespaceContext, final String input) {
+ public final T parseValue(final NamespaceContext ctx, final String str) {
for (XmlCodec<?> codec : codecs) {
final Object ret;
try {
- ret = codec.deserializeFromString(namespaceContext, input);
+ ret = codec.parseValue(ctx, str);
} catch (RuntimeException e) {
- LOG.debug("Codec {} did not accept input '{}'", codec, input, e);
+ LOG.debug("Codec {} did not accept input '{}'", codec, str, e);
continue;
}
- return getDataClass().cast(ret);
+ return getDataType().cast(ret);
}
- throw new IllegalArgumentException("Invalid value \"" + input + "\" for union type.");
+ throw new IllegalArgumentException("Invalid value \"" + str + "\" for union type.");
}
@Override
- public void serializeToWriter(final XMLStreamWriter writer, final Object value) throws XMLStreamException {
+ public void writeValue(final XMLStreamWriter ctx, final Object value) throws XMLStreamException {
for (XmlCodec<?> codec : codecs) {
- if (!codec.getDataClass().isInstance(value)) {
+ if (!codec.getDataType().isInstance(value)) {
LOG.debug("Codec {} cannot accept input {}, skipping it", codec, value);
continue;
}
@SuppressWarnings("unchecked")
final XmlCodec<Object> objCodec = (XmlCodec<Object>) codec;
try {
- objCodec.serializeToWriter(writer, value);
+ objCodec.writeValue(ctx, value);
return;
} catch (RuntimeException e) {
LOG.debug("Codec {} failed to serialize {}", codec, value, e);
import javax.xml.namespace.NamespaceContext;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
+import org.opendaylight.yangtools.yang.data.util.codec.TypeAwareCodec;
-interface XmlCodec<T> {
- Class<T> getDataClass();
-
- T deserializeFromString(NamespaceContext namespaceContext, String value);
-
+interface XmlCodec<T> extends TypeAwareCodec<T, NamespaceContext, XMLStreamWriter> {
/**
- * Serialize specified value with specified XMLStreamWriter.
+ * {@inheritDoc}
*
- * @param writer XMLStreamWriter
- * @param value value which will be serialized to the writer
* @throws XMLStreamException from {@link XMLStreamWriter}
*/
- void serializeToWriter(XMLStreamWriter writer, T value) throws XMLStreamException;
+ @Override
+ void writeValue(XMLStreamWriter ctx, T value) throws XMLStreamException;
}
}
Preconditions.checkArgument(node instanceof TypedSchemaNode);
- return codecs.codecFor((TypedSchemaNode) node).deserializeFromString(namespaceCtx, value);
+ return codecs.codecFor((TypedSchemaNode) node).parseValue(namespaceCtx, value);
}
private static AbstractNodeDataWithSchema newEntryNode(final AbstractNodeDataWithSchema parent) {
Preconditions.checkNotNull(schemaNode, "schemaNode cannot be null");
Preconditions.checkArgument(schemaNode instanceof LeafSchemaNode, "schemaNode must be of type LeafSchemaNode");
final XmlCodec<?> objectXmlCodec = codecFactory.codecFor((LeafSchemaNode) schemaNode);
- return objectXmlCodec.deserializeFromString(getNamespaceContext(), value);
+ return objectXmlCodec.parseValue(getNamespaceContext(), value);
}
@Override
- public Class<YangInstanceIdentifier> getDataClass() {
+ public Class<YangInstanceIdentifier> getDataType() {
return YangInstanceIdentifier.class;
}
@Override
- public YangInstanceIdentifier deserializeFromString(final NamespaceContext namespaceContext, final String value) {
- pushNamespaceContext(namespaceContext);
+ public YangInstanceIdentifier parseValue(final NamespaceContext ctx, final String str) {
+ pushNamespaceContext(ctx);
try {
- return deserialize(value);
+ return deserialize(str);
} finally {
popNamespaceContext();
}
}
@Override
- public void serializeToWriter(final XMLStreamWriter writer, final YangInstanceIdentifier value)
+ public void writeValue(final XMLStreamWriter ctx, final YangInstanceIdentifier value)
throws XMLStreamException {
- writer.writeCharacters(serialize(value));
+ ctx.writeCharacters(serialize(value));
}
private static NamespaceContext getNamespaceContext() {
* @param <T> Codec type
*/
@ThreadSafe
-public abstract class AbstractCodecFactory<T> {
+public abstract class AbstractCodecFactory<T extends TypeAwareCodec<?, ?, ?>> {
private static final Logger LOG = LoggerFactory.getLogger(AbstractCodecFactory.class);
private final CodecCache<T> cache;
--- /dev/null
+/*
+ * Copyright (c) 2017 Pantheon Technologies, s.r.o. 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.util.codec;
+
+import com.google.common.annotations.Beta;
+
+/**
+ * A codec, which knows what the native representation for a particular data type is. It knows how to convert a native
+ * value to and from string representation based on some additional input or output context.
+ *
+ * @author Robert Varga
+ *
+ * @param <T> Data value type
+ * @param <I> Input context type
+ * @param <O> Output context type
+ */
+@Beta
+public interface TypeAwareCodec<T, I, O> {
+ /**
+ * Return the data type class.
+ *
+ * @return Data type class
+ */
+ Class<T> getDataType();
+
+ /**
+ * Parse a String representation into its native format.
+ *
+ * @param ctx Parse context
+ * @param str String representation
+ * @return Value in native format
+ * @throws IllegalArgumentException if the value does not parse or pass type validation
+ */
+ T parseValue(I ctx, String str);
+
+ /**
+ * Serialize specified value with specified JsonWriter.
+ *
+ * @param ctx Write context
+ * @param value Value in native format
+ * @throws Exception if the write fails
+ */
+ void writeValue(O ctx, T value) throws Exception;
+}
Code Review / yangtools.git / commitdiff