}
@Override
- 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()) {
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());
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(
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);
- 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);
continue;
}
- leaves.put(schema.getQName().getLocalName(), valueNode);
+ leaves.put(method, valueNode);
}
}
return ImmutableMap.copyOf(leaves);
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<?>, 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);
}
+ this.leafChild = leafChildBuilder.build();
for (final Entry<Class<?>, Method> childDataObj : clsToMethod.entrySet()) {
final Method method = childDataObj.getValue();
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;
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) {
- super(schema, codec, getter, schemaContext);
+ super(schema, codec, getterName, schemaContext);
this.bindingClass = requireNonNull(bindingClass);
}
}
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,
- final Method getter, final Class<?> valueType, final SchemaContext schemaContext) {
+ final String getterName, final Class<?> valueType, final SchemaContext schemaContext) {
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);
}
@Override
*/
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;
final class LeafSetNodeCodecContext extends ValueNodeCodecContext.WithCodec {
LeafSetNodeCodecContext(final LeafListSchemaNode schema, final Codec<Object, Object> codec,
- final Method getter) {
+ final String getterName) {
// FIXME: add support for defaults
- super(schema, codec, getter, null);
+ super(schema, codec, getterName, null);
}
@Override
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;
* @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.
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;
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) {
- super(schema, getter, bindingClass, loader);
+ super(schema, getterName, bindingClass, loader);
}
@Override
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) {
- super(schema, getter, null);
+ super(schema, getterName, null);
this.bindingClass = requireNonNull(bindingClass);
proxyConstructor = createImpl(loader, bindingClass);
}
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) {
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;
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) {
- super(schema, getter, defaultObject);
+ super(schema, getterName, defaultObject);
this.valueCodec = requireNonNull(codec);
}
}
private final @NonNull NodeIdentifier yangIdentifier;
- private final @NonNull Method getter;
+ private final @NonNull String getterName;
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.getter = requireNonNull(getter);
+ this.getterName = requireNonNull(getterName);
this.schema = requireNonNull(schema);
this.defaultObject = defaultObject;
}
return this;
}
- final Method getGetter() {
- return getter;
+ final String getGetterName() {
+ return getterName;
}
abstract Codec<Object, Object> getValueCodec();