We only require method references during DataObjectCodecContext,
after which all we need is their name -- hence we index the map
by Method, as we can get the name from there and we can derive
the former string from the underlying schema, just as we did
before.
Change-Id: Icfb6bc3b89ce313ae054e773bd566c03c16d8a31
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
- public ImmutableMap<String, ValueNodeCodecContext> getLeafNodes(final Class<?> parentClass,
+ public ImmutableMap<Method, ValueNodeCodecContext> getLeafNodes(final Class<?> parentClass,
final DataNodeContainer childSchema) {
final Map<String, DataSchemaNode> getterToLeafSchema = new HashMap<>();
for (final DataSchemaNode leaf : childSchema.getChildNodes()) {
final DataNodeContainer childSchema) {
final Map<String, DataSchemaNode> getterToLeafSchema = new HashMap<>();
for (final DataSchemaNode leaf : childSchema.getChildNodes()) {
return getLeafNodesUsingReflection(parentClass, getterToLeafSchema);
}
return getLeafNodesUsingReflection(parentClass, getterToLeafSchema);
}
- private ImmutableMap<String, ValueNodeCodecContext> getLeafNodesUsingReflection(final Class<?> parentClass,
- final Map<String, DataSchemaNode> getterToLeafSchema) {
- final Map<String, ValueNodeCodecContext> leaves = new HashMap<>();
+ private ImmutableMap<Method, ValueNodeCodecContext> getLeafNodesUsingReflection(
+ final Class<?> parentClass, final Map<String, DataSchemaNode> getterToLeafSchema) {
+ final Map<Method, ValueNodeCodecContext> leaves = new HashMap<>();
for (final Method method : parentClass.getMethods()) {
if (method.getParameterCount() == 0) {
final DataSchemaNode schema = getterToLeafSchema.get(method.getName());
for (final Method method : parentClass.getMethods()) {
if (method.getParameterCount() == 0) {
final DataSchemaNode schema = getterToLeafSchema.get(method.getName());
final Class<?> valueType = method.getReturnType();
final Codec<Object, Object> codec = getCodec(valueType, leafSchema.getType());
final Class<?> valueType = method.getReturnType();
final Codec<Object, Object> codec = getCodec(valueType, leafSchema.getType());
- valueNode = LeafNodeCodecContext.of(leafSchema, codec, method, valueType,
+ valueNode = LeafNodeCodecContext.of(leafSchema, codec, method.getName(), valueType,
context.getSchemaContext());
} else if (schema instanceof LeafListSchemaNode) {
final Optional<Type> optType = ClassLoaderUtils.getFirstGenericParameter(
context.getSchemaContext());
} else if (schema instanceof LeafListSchemaNode) {
final Optional<Type> optType = ClassLoaderUtils.getFirstGenericParameter(
final LeafListSchemaNode leafListSchema = (LeafListSchemaNode) schema;
final Codec<Object, Object> codec = getCodec(valueType, leafListSchema.getType());
final LeafListSchemaNode leafListSchema = (LeafListSchemaNode) schema;
final Codec<Object, Object> codec = getCodec(valueType, leafListSchema.getType());
- valueNode = new LeafSetNodeCodecContext(leafListSchema, codec, method);
+ valueNode = new LeafSetNodeCodecContext(leafListSchema, codec, method.getName());
} else if (schema instanceof AnyXmlSchemaNode) {
final Class<?> valueType = method.getReturnType();
verify(OpaqueObject.class.isAssignableFrom(valueType), "Illegal value type %s", valueType);
} else if (schema instanceof AnyXmlSchemaNode) {
final Class<?> valueType = method.getReturnType();
verify(OpaqueObject.class.isAssignableFrom(valueType), "Illegal value type %s", valueType);
- valueNode = new OpaqueNodeCodecContext.AnyXml<>((AnyXmlSchemaNode) schema, method,
+ valueNode = new OpaqueNodeCodecContext.AnyXml<>((AnyXmlSchemaNode) schema, method.getName(),
valueType.asSubclass(OpaqueObject.class), loader);
} else {
verify(schema == null, "Unhandled schema %s for method %s", schema, method);
valueType.asSubclass(OpaqueObject.class), loader);
} else {
verify(schema == null, "Unhandled schema %s for method %s", schema, method);
- leaves.put(schema.getQName().getLocalName(), valueNode);
+ leaves.put(method, valueNode);
}
}
return ImmutableMap.copyOf(leaves);
}
}
return ImmutableMap.copyOf(leaves);
super(prototype);
final Class<D> bindingClass = getBindingClass();
super(prototype);
final Class<D> bindingClass = getBindingClass();
- this.leafChild = factory().getLeafNodes(bindingClass, getSchema());
+ final Map<Method, ValueNodeCodecContext> tmpLeaves = factory().getLeafNodes(bindingClass, getSchema());
final Map<Class<?>, Method> clsToMethod = BindingReflections.getChildrenClassToMethod(bindingClass);
final Map<YangInstanceIdentifier.PathArgument, NodeContextSupplier> byYangBuilder = new HashMap<>();
final Map<Class<?>, Method> clsToMethod = BindingReflections.getChildrenClassToMethod(bindingClass);
final Map<YangInstanceIdentifier.PathArgument, NodeContextSupplier> byYangBuilder = new HashMap<>();
final Map<Class<?>, DataContainerCodecPrototype<?>> byBindingArgClassBuilder = new HashMap<>();
// Adds leaves to mapping
final Map<Class<?>, DataContainerCodecPrototype<?>> byBindingArgClassBuilder = new HashMap<>();
// Adds leaves to mapping
- for (final ValueNodeCodecContext leaf : leafChild.values()) {
- tmpMethodToSupplier.put(leaf.getGetter(), leaf);
+ final Builder<String, ValueNodeCodecContext> leafChildBuilder =
+ ImmutableMap.builderWithExpectedSize(tmpLeaves.size());
+ for (final Entry<Method, ValueNodeCodecContext> entry : tmpLeaves.entrySet()) {
+ final ValueNodeCodecContext leaf = entry.getValue();
+ tmpMethodToSupplier.put(entry.getKey(), leaf);
+ leafChildBuilder.put(leaf.getSchema().getQName().getLocalName(), leaf);
byYangBuilder.put(leaf.getDomPathArgument(), leaf);
}
byYangBuilder.put(leaf.getDomPathArgument(), leaf);
}
+ this.leafChild = leafChildBuilder.build();
for (final Entry<Class<?>, Method> childDataObj : clsToMethod.entrySet()) {
final Method method = childDataObj.getValue();
for (final Entry<Class<?>, Method> childDataObj : clsToMethod.entrySet()) {
final Method method = childDataObj.getValue();
import static java.util.Objects.requireNonNull;
import static java.util.Objects.requireNonNull;
-import java.lang.reflect.Method;
import java.util.Optional;
import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
import java.util.Optional;
import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
implements BindingTypeObjectCodecTreeNode<T> {
private final @NonNull Class<T> bindingClass;
implements BindingTypeObjectCodecTreeNode<T> {
private final @NonNull Class<T> bindingClass;
- OfTypeObject(final LeafSchemaNode schema, final Codec<Object, Object> codec, final Method getter,
+ OfTypeObject(final LeafSchemaNode schema, final Codec<Object, Object> codec, final String getterName,
final SchemaContext schemaContext, final Class<T> bindingClass) {
final SchemaContext schemaContext, final Class<T> bindingClass) {
- super(schema, codec, getter, schemaContext);
+ super(schema, codec, getterName, schemaContext);
this.bindingClass = requireNonNull(bindingClass);
}
this.bindingClass = requireNonNull(bindingClass);
}
}
LeafNodeCodecContext(final LeafSchemaNode schema, final Codec<Object, Object> codec,
}
LeafNodeCodecContext(final LeafSchemaNode schema, final Codec<Object, Object> codec,
- final Method getter, final SchemaContext schemaContext) {
- super(schema, codec, getter, createDefaultObject(schema, codec, schemaContext));
+ final String getterName, final SchemaContext schemaContext) {
+ super(schema, codec, getterName, createDefaultObject(schema, codec, schemaContext));
}
static LeafNodeCodecContext of(final LeafSchemaNode schema, final Codec<Object, Object> codec,
}
static LeafNodeCodecContext of(final LeafSchemaNode schema, final Codec<Object, Object> codec,
- final Method getter, final Class<?> valueType, final SchemaContext schemaContext) {
+ final String getterName, final Class<?> valueType, final SchemaContext schemaContext) {
return TypeObject.class.isAssignableFrom(valueType)
return TypeObject.class.isAssignableFrom(valueType)
- ? new OfTypeObject<>(schema, codec, getter, schemaContext, valueType.asSubclass(TypeObject.class))
- : new LeafNodeCodecContext(schema, codec, getter, schemaContext);
+ ? new OfTypeObject<>(schema, codec, getterName, schemaContext, valueType.asSubclass(TypeObject.class))
+ : new LeafNodeCodecContext(schema, codec, getterName, schemaContext);
*/
package org.opendaylight.mdsal.binding.dom.codec.impl;
*/
package org.opendaylight.mdsal.binding.dom.codec.impl;
-import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
final class LeafSetNodeCodecContext extends ValueNodeCodecContext.WithCodec {
LeafSetNodeCodecContext(final LeafListSchemaNode schema, final Codec<Object, Object> codec,
final class LeafSetNodeCodecContext extends ValueNodeCodecContext.WithCodec {
LeafSetNodeCodecContext(final LeafListSchemaNode schema, final Codec<Object, Object> codec,
+ final String getterName) {
// FIXME: add support for defaults
// FIXME: add support for defaults
- super(schema, codec, getter, null);
+ super(schema, codec, getterName, null);
package org.opendaylight.mdsal.binding.dom.codec.impl;
import com.google.common.collect.ImmutableMap;
package org.opendaylight.mdsal.binding.dom.codec.impl;
import com.google.common.collect.ImmutableMap;
+import java.lang.reflect.Method;
import java.util.List;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import java.util.List;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
* @param schema Instantiated schema of binding type.
* @return Map of local name to leaf node context.
*/
* @param schema Instantiated schema of binding type.
* @return Map of local name to leaf node context.
*/
- ImmutableMap<String, ValueNodeCodecContext> getLeafNodes(Class<?> type, DataNodeContainer schema);
+ ImmutableMap<Method, ValueNodeCodecContext> getLeafNodes(Class<?> type, DataNodeContainer schema);
/**
* Returns Path argument codec for list item.
/**
* Returns Path argument codec for list item.
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.reflect.Constructor;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.reflect.Constructor;
-import java.lang.reflect.Method;
import javax.xml.transform.dom.DOMSource;
import net.bytebuddy.ByteBuddy;
import net.bytebuddy.dynamic.DynamicType.Builder;
import javax.xml.transform.dom.DOMSource;
import net.bytebuddy.ByteBuddy;
import net.bytebuddy.dynamic.DynamicType.Builder;
abstract class OpaqueNodeCodecContext<T extends OpaqueObject<T>> extends ValueNodeCodecContext
implements BindingOpaqueObjectCodecTreeNode<T> {
static final class AnyXml<T extends OpaqueObject<T>> extends OpaqueNodeCodecContext<T> {
abstract class OpaqueNodeCodecContext<T extends OpaqueObject<T>> extends ValueNodeCodecContext
implements BindingOpaqueObjectCodecTreeNode<T> {
static final class AnyXml<T extends OpaqueObject<T>> extends OpaqueNodeCodecContext<T> {
- AnyXml(final AnyXmlSchemaNode schema, final Method getter, final Class<T> bindingClass,
+ AnyXml(final AnyXmlSchemaNode schema, final String getterName, final Class<T> bindingClass,
final CodecClassLoader loader) {
final CodecClassLoader loader) {
- super(schema, getter, bindingClass, loader);
+ super(schema, getterName, bindingClass, loader);
private final MethodHandle proxyConstructor;
private final @NonNull Class<T> bindingClass;
private final MethodHandle proxyConstructor;
private final @NonNull Class<T> bindingClass;
- OpaqueNodeCodecContext(final DataSchemaNode schema, final Method getter, final Class<T> bindingClass,
+ OpaqueNodeCodecContext(final DataSchemaNode schema, final String getterName, final Class<T> bindingClass,
final CodecClassLoader loader) {
final CodecClassLoader loader) {
- super(schema, getter, null);
+ super(schema, getterName, null);
this.bindingClass = requireNonNull(bindingClass);
proxyConstructor = createImpl(loader, bindingClass);
}
this.bindingClass = requireNonNull(bindingClass);
proxyConstructor = createImpl(loader, bindingClass);
}
private final String getterName;
ValueContext(final Class<?> identifier, final ValueNodeCodecContext leaf) {
private final String getterName;
ValueContext(final Class<?> identifier, final ValueNodeCodecContext leaf) {
- getterName = leaf.getGetter().getName();
+ getterName = leaf.getGetterName();
try {
getter = MethodHandles.publicLookup().unreflect(identifier.getMethod(getterName)).asType(OBJECT_METHOD);
} catch (IllegalAccessException | NoSuchMethodException | SecurityException e) {
try {
getter = MethodHandles.publicLookup().unreflect(identifier.getMethod(getterName)).asType(OBJECT_METHOD);
} catch (IllegalAccessException | NoSuchMethodException | SecurityException e) {
import static java.util.Objects.requireNonNull;
import static java.util.Objects.requireNonNull;
-import java.lang.reflect.Method;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.Codec;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.concepts.Codec;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
abstract static class WithCodec extends ValueNodeCodecContext {
private final @NonNull Codec<Object, Object> valueCodec;
abstract static class WithCodec extends ValueNodeCodecContext {
private final @NonNull Codec<Object, Object> valueCodec;
- WithCodec(final DataSchemaNode schema, final Codec<Object, Object> codec, final Method getter,
+ WithCodec(final DataSchemaNode schema, final Codec<Object, Object> codec, final String getterName,
final Object defaultObject) {
final Object defaultObject) {
- super(schema, getter, defaultObject);
+ super(schema, getterName, defaultObject);
this.valueCodec = requireNonNull(codec);
}
this.valueCodec = requireNonNull(codec);
}
}
private final @NonNull NodeIdentifier yangIdentifier;
}
private final @NonNull NodeIdentifier yangIdentifier;
- private final @NonNull Method getter;
+ private final @NonNull String getterName;
private final @NonNull DataSchemaNode schema;
private final Object defaultObject;
private final @NonNull DataSchemaNode schema;
private final Object defaultObject;
- ValueNodeCodecContext(final DataSchemaNode schema, final Method getter, final Object defaultObject) {
+ ValueNodeCodecContext(final DataSchemaNode schema, final String getterName, final Object defaultObject) {
this.yangIdentifier = NodeIdentifier.create(schema.getQName());
this.yangIdentifier = NodeIdentifier.create(schema.getQName());
- this.getter = requireNonNull(getter);
+ this.getterName = requireNonNull(getterName);
this.schema = requireNonNull(schema);
this.defaultObject = defaultObject;
}
this.schema = requireNonNull(schema);
this.defaultObject = defaultObject;
}
- final Method getGetter() {
- return getter;
+ final String getGetterName() {
+ return getterName;
}
abstract Codec<Object, Object> getValueCodec();
}
abstract Codec<Object, Object> getValueCodec();