2 * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.yangtools.binding.data.codec.impl;
10 import com.google.common.base.Preconditions;
11 import com.google.common.collect.ImmutableMap;
12 import java.lang.reflect.Constructor;
13 import java.lang.reflect.InvocationTargetException;
14 import java.lang.reflect.Method;
15 import java.lang.reflect.ParameterizedType;
16 import java.lang.reflect.Type;
17 import java.util.AbstractMap.SimpleEntry;
18 import java.util.ArrayList;
19 import java.util.Collection;
20 import java.util.HashMap;
21 import java.util.LinkedHashMap;
22 import java.util.LinkedList;
23 import java.util.List;
25 import java.util.Map.Entry;
26 import java.util.concurrent.Callable;
27 import javax.annotation.Nonnull;
28 import javax.annotation.Nullable;
29 import org.opendaylight.yangtools.binding.data.codec.impl.NodeCodecContext.CodecContextFactory;
30 import org.opendaylight.yangtools.concepts.Codec;
31 import org.opendaylight.yangtools.concepts.Immutable;
32 import org.opendaylight.yangtools.sal.binding.generator.util.BindingRuntimeContext;
33 import org.opendaylight.yangtools.sal.binding.model.api.GeneratedType;
34 import org.opendaylight.yangtools.util.ClassLoaderUtils;
35 import org.opendaylight.yangtools.yang.binding.BaseIdentity;
36 import org.opendaylight.yangtools.yang.binding.BindingMapping;
37 import org.opendaylight.yangtools.yang.binding.BindingStreamEventWriter;
38 import org.opendaylight.yangtools.yang.binding.Identifiable;
39 import org.opendaylight.yangtools.yang.binding.Identifier;
40 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
41 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.IdentifiableItem;
42 import org.opendaylight.yangtools.yang.binding.util.BindingReflections;
43 import org.opendaylight.yangtools.yang.common.QName;
44 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
45 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
46 import org.opendaylight.yangtools.yang.data.api.schema.stream.NormalizedNodeStreamWriter;
47 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
48 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
49 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
50 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
51 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
52 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
53 import org.opendaylight.yangtools.yang.model.api.type.BooleanTypeDefinition;
54 import org.opendaylight.yangtools.yang.model.api.type.EmptyTypeDefinition;
55 import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
56 import org.opendaylight.yangtools.yang.model.api.type.InstanceIdentifierTypeDefinition;
57 import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
58 import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
59 import org.slf4j.Logger;
60 import org.slf4j.LoggerFactory;
62 final class BindingCodecContext implements CodecContextFactory, Immutable {
63 private static final Logger LOG = LoggerFactory.getLogger(BindingCodecContext.class);
64 private static final String GETTER_PREFIX = "get";
66 private final Codec<YangInstanceIdentifier, InstanceIdentifier<?>> instanceIdentifierCodec =
67 new InstanceIdentifierCodec();
68 private final Codec<QName, Class<?>> identityCodec;
69 private final BindingRuntimeContext context;
70 private final SchemaRootCodecContext root;
72 public BindingCodecContext(final BindingRuntimeContext context) {
73 this.context = Preconditions.checkNotNull(context, "Binding Runtime Context is required.");
74 this.root = SchemaRootCodecContext.create(this);
75 this.identityCodec = new IdentityCodec(context);
79 public BindingRuntimeContext getRuntimeContext() {
83 Codec<YangInstanceIdentifier, InstanceIdentifier<?>> getInstanceIdentifierCodec() {
84 return instanceIdentifierCodec;
87 public Codec<QName, Class<?>> getIdentityCodec() {
91 public Entry<YangInstanceIdentifier, BindingStreamEventWriter> newWriter(final InstanceIdentifier<?> path,
92 final NormalizedNodeStreamWriter domWriter) {
93 LinkedList<YangInstanceIdentifier.PathArgument> yangArgs = new LinkedList<>();
94 DataContainerCodecContext<?> codecContext = getCodecContextNode(path, yangArgs);
95 BindingStreamEventWriter writer = new BindingToNormalizedStreamWriter(codecContext, domWriter);
96 return new SimpleEntry<>(YangInstanceIdentifier.create(yangArgs), writer);
99 public BindingStreamEventWriter newWriterWithoutIdentifier(final InstanceIdentifier<?> path,
100 final NormalizedNodeStreamWriter domWriter) {
101 return new BindingToNormalizedStreamWriter(getCodecContextNode(path, null), domWriter);
104 public DataContainerCodecContext<?> getCodecContextNode(final InstanceIdentifier<?> binding,
105 final List<YangInstanceIdentifier.PathArgument> builder) {
106 DataContainerCodecContext<?> currentNode = root;
107 for (InstanceIdentifier.PathArgument bindingArg : binding.getPathArguments()) {
108 currentNode = currentNode.getIdentifierChild(bindingArg, builder);
114 * Multi-purpose utility function. Traverse the codec tree, looking for
115 * the appropriate codec for the specified {@link YangInstanceIdentifier}.
116 * As a side-effect, gather all traversed binding {@link InstanceIdentifier.PathArgument}s
117 * into the supplied collection.
119 * @param dom {@link YangInstanceIdentifier} which is to be translated
120 * @param bindingArguments Collection for traversed path arguments
121 * @return Codec for target node, or @null if the node does not have a
122 * binding representation (choice, case, leaf).
124 @Nullable NodeCodecContext getCodecContextNode(final @Nonnull YangInstanceIdentifier dom,
125 final @Nonnull Collection<InstanceIdentifier.PathArgument> bindingArguments) {
126 NodeCodecContext currentNode = root;
127 ListNodeCodecContext currentList = null;
129 for (YangInstanceIdentifier.PathArgument domArg : dom.getPathArguments()) {
130 Preconditions.checkArgument(currentNode instanceof DataContainerCodecContext<?>, "Unexpected child of non-container node %s", currentNode);
131 final DataContainerCodecContext<?> previous = (DataContainerCodecContext<?>) currentNode;
132 final NodeCodecContext nextNode = previous.getYangIdentifierChild(domArg);
135 * List representation in YANG Instance Identifier consists of two
136 * arguments: first is list as a whole, second is list as an item so
137 * if it is /list it means list as whole, if it is /list/list - it
138 * is wildcarded and if it is /list/list[key] it is concrete item,
139 * all this variations are expressed in Binding Aware Instance
140 * Identifier as Item or IdentifiableItem
142 if (currentList != null) {
143 Preconditions.checkArgument(currentList == nextNode, "List should be referenced two times in YANG Instance Identifier %s", dom);
145 // We entered list, so now we have all information to emit
146 // list path using second list argument.
147 bindingArguments.add(currentList.getBindingPathArgument(domArg));
149 currentNode = nextNode;
150 } else if (nextNode instanceof ListNodeCodecContext) {
151 // We enter list, we do not update current Node yet,
152 // since we need to verify
153 currentList = (ListNodeCodecContext) nextNode;
154 } else if (nextNode instanceof ChoiceNodeCodecContext) {
155 // We do not add path argument for choice, since
156 // it is not supported by binding instance identifier.
157 currentNode = nextNode;
158 } else if (nextNode instanceof DataContainerCodecContext<?>) {
159 bindingArguments.add(((DataContainerCodecContext<?>) nextNode).getBindingPathArgument(domArg));
160 currentNode = nextNode;
161 } else if (nextNode instanceof LeafNodeCodecContext) {
162 LOG.debug("Instance identifier referencing a leaf is not representable (%s)", dom);
167 // Algorithm ended in list as whole representation
168 // we sill need to emit identifier for list
169 if (currentNode instanceof ChoiceNodeCodecContext) {
170 LOG.debug("Instance identifier targeting a choice is not representable (%s)", dom);
173 if (currentNode instanceof CaseNodeCodecContext) {
174 LOG.debug("Instance identifier targeting a case is not representable (%s)", dom);
178 if (currentList != null) {
179 bindingArguments.add(currentList.getBindingPathArgument(null));
186 public ImmutableMap<String, LeafNodeCodecContext> getLeafNodes(final Class<?> parentClass,
187 final DataNodeContainer childSchema) {
188 HashMap<String, DataSchemaNode> getterToLeafSchema = new HashMap<>();
189 for (DataSchemaNode leaf : childSchema.getChildNodes()) {
190 final TypeDefinition<?> typeDef;
191 if (leaf instanceof LeafSchemaNode) {
192 typeDef = ((LeafSchemaNode) leaf).getType();
193 } else if (leaf instanceof LeafListSchemaNode) {
194 typeDef = ((LeafListSchemaNode) leaf).getType();
199 String getterName = getGetterName(leaf.getQName(), typeDef);
200 getterToLeafSchema.put(getterName, leaf);
202 return getLeafNodesUsingReflection(parentClass, getterToLeafSchema);
205 private String getGetterName(final QName qName, TypeDefinition<?> typeDef) {
206 String suffix = BindingMapping.getClassName(qName);
208 while (typeDef.getBaseType() != null) {
209 typeDef = typeDef.getBaseType();
211 if (typeDef instanceof BooleanTypeDefinition || typeDef instanceof EmptyTypeDefinition) {
212 return "is" + suffix;
214 return GETTER_PREFIX + suffix;
217 private ImmutableMap<String, LeafNodeCodecContext> getLeafNodesUsingReflection(final Class<?> parentClass,
218 final Map<String, DataSchemaNode> getterToLeafSchema) {
219 Map<String, LeafNodeCodecContext> leaves = new HashMap<>();
220 for (Method method : parentClass.getMethods()) {
221 if (method.getParameterTypes().length == 0) {
222 DataSchemaNode schema = getterToLeafSchema.get(method.getName());
223 final Class<?> valueType;
224 if (schema instanceof LeafSchemaNode) {
225 valueType = method.getReturnType();
226 } else if (schema instanceof LeafListSchemaNode) {
227 Type genericType = ClassLoaderUtils.getFirstGenericParameter(method.getGenericReturnType());
229 if (genericType instanceof Class<?>) {
230 valueType = (Class<?>) genericType;
231 } else if (genericType instanceof ParameterizedType) {
232 valueType = (Class<?>) ((ParameterizedType) genericType).getRawType();
234 throw new IllegalStateException("Unexpected return type " + genericType);
237 continue; // We do not have schema for leaf, so we will ignore it (eg. getClass, getImplementedInterface).
239 Codec<Object, Object> codec = getCodec(valueType, schema);
240 final LeafNodeCodecContext leafNode = new LeafNodeCodecContext(schema, codec, method);
241 leaves.put(schema.getQName().getLocalName(), leafNode);
244 return ImmutableMap.copyOf(leaves);
249 private Codec<Object, Object> getCodec(final Class<?> valueType, final DataSchemaNode schema) {
250 final TypeDefinition<?> instantiatedType;
251 if (schema instanceof LeafSchemaNode) {
252 instantiatedType = ((LeafSchemaNode) schema).getType();
253 } else if (schema instanceof LeafListSchemaNode) {
254 instantiatedType = ((LeafListSchemaNode) schema).getType();
256 throw new IllegalArgumentException("Unsupported leaf node type " + schema.getClass());
258 if (Class.class.equals(valueType)) {
259 @SuppressWarnings({ "unchecked", "rawtypes" })
260 final Codec<Object, Object> casted = (Codec) identityCodec;
262 } else if (InstanceIdentifier.class.equals(valueType)) {
263 @SuppressWarnings({ "unchecked", "rawtypes" })
264 final Codec<Object, Object> casted = (Codec) instanceIdentifierCodec;
266 } else if (Boolean.class.equals(valueType)) {
267 if(instantiatedType instanceof EmptyTypeDefinition) {
268 return ValueTypeCodec.EMPTY_CODEC;
270 } else if (BindingReflections.isBindingClass(valueType)) {
271 return getCodec(valueType, instantiatedType);
273 return ValueTypeCodec.NOOP_CODEC;
276 private Codec<Object, Object> getCodec(final Class<?> valueType, final TypeDefinition<?> instantiatedType) {
277 @SuppressWarnings("rawtypes")
278 TypeDefinition rootType = instantiatedType;
279 while (rootType.getBaseType() != null) {
280 rootType = rootType.getBaseType();
282 if (rootType instanceof IdentityrefTypeDefinition) {
283 return ValueTypeCodec.encapsulatedValueCodecFor(valueType, identityCodec);
284 } else if (rootType instanceof InstanceIdentifierTypeDefinition) {
285 return ValueTypeCodec.encapsulatedValueCodecFor(valueType, instanceIdentifierCodec);
286 } else if (rootType instanceof UnionTypeDefinition) {
287 Callable<UnionTypeCodec> loader = UnionTypeCodec.loader(valueType, (UnionTypeDefinition) rootType);
289 return loader.call();
290 } catch (Exception e) {
291 throw new IllegalStateException("Unable to load codec for " + valueType, e);
293 } else if(rootType instanceof LeafrefTypeDefinition) {
294 Entry<GeneratedType, Object> typeWithSchema = context.getTypeWithSchema(valueType);
295 Object schema = typeWithSchema.getValue();
296 Preconditions.checkState(schema instanceof TypeDefinition<?>);
297 return getCodec(valueType, (TypeDefinition<?>) schema);
299 return ValueTypeCodec.getCodecFor(valueType, instantiatedType);
302 private class InstanceIdentifierCodec implements Codec<YangInstanceIdentifier, InstanceIdentifier<?>> {
305 public YangInstanceIdentifier serialize(final InstanceIdentifier<?> input) {
306 List<YangInstanceIdentifier.PathArgument> domArgs = new ArrayList<>();
307 getCodecContextNode(input, domArgs);
308 return YangInstanceIdentifier.create(domArgs);
312 public InstanceIdentifier<?> deserialize(final YangInstanceIdentifier input) {
313 final List<InstanceIdentifier.PathArgument> builder = new ArrayList<>();
314 final NodeCodecContext codec = getCodecContextNode(input, builder);
315 return codec == null ? null : InstanceIdentifier.create(builder);
319 private static class IdentityCodec implements Codec<QName, Class<?>> {
320 private final BindingRuntimeContext context;
322 IdentityCodec(final BindingRuntimeContext context) {
323 this.context = Preconditions.checkNotNull(context);
327 public Class<?> deserialize(final QName input) {
328 Preconditions.checkArgument(input != null, "Input must not be null.");
329 return context.getIdentityClass(input);
333 public QName serialize(final Class<?> input) {
334 Preconditions.checkArgument(BaseIdentity.class.isAssignableFrom(input));
335 return BindingReflections.findQName(input);
339 private static class ValueContext {
342 Codec<Object, Object> codec;
344 public ValueContext(final Class<?> identifier, final LeafNodeCodecContext leaf) {
345 final String getterName = GETTER_PREFIX
346 + BindingMapping.getClassName(leaf.getDomPathArgument().getNodeType());
348 getter = identifier.getMethod(getterName);
349 } catch (NoSuchMethodException | SecurityException e) {
350 throw new IllegalStateException(e);
352 codec = leaf.getValueCodec();
355 public Object getAndSerialize(final Object obj) {
357 Object value = getter.invoke(obj);
358 Preconditions.checkArgument(value != null,
359 "All keys must be specified for %s. Missing key is %s. Supplied key is %s",
360 getter.getDeclaringClass(), getter.getName(), obj);
361 return codec.serialize(value);
362 } catch (IllegalAccessException | InvocationTargetException e) {
363 throw new IllegalArgumentException(e);
367 public Object deserialize(final Object obj) {
368 return codec.deserialize(obj);
373 private static class IdentifiableItemCodec implements Codec<NodeIdentifierWithPredicates, IdentifiableItem<?, ?>> {
375 private final Map<QName, ValueContext> keyValueContexts;
376 private final ListSchemaNode schema;
377 private final Constructor<? extends Identifier<?>> constructor;
378 private final Class<?> identifiable;
380 public IdentifiableItemCodec(final ListSchemaNode schema, final Class<? extends Identifier<?>> keyClass,
381 final Class<?> identifiable, final Map<QName, ValueContext> keyValueContexts) {
382 this.schema = schema;
383 this.identifiable = identifiable;
384 this.constructor = getConstructor(keyClass);
387 * We need to re-index to make sure we instantiate nodes in the order in which
390 final Map<QName, ValueContext> keys = new LinkedHashMap<>();
391 for (QName qname : schema.getKeyDefinition()) {
392 keys.put(qname, keyValueContexts.get(qname));
394 this.keyValueContexts = ImmutableMap.copyOf(keys);
398 public IdentifiableItem<?, ?> deserialize(final NodeIdentifierWithPredicates input) {
399 final Collection<QName> keys = schema.getKeyDefinition();
400 final ArrayList<Object> bindingValues = new ArrayList<>(keys.size());
401 for (QName key : keys) {
402 Object yangValue = input.getKeyValues().get(key);
403 bindingValues.add(keyValueContexts.get(key).deserialize(yangValue));
406 final Identifier<?> identifier;
408 identifier = constructor.newInstance(bindingValues.toArray());
409 } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
410 throw new IllegalStateException(String.format("Failed to instantiate key class %s", constructor.getDeclaringClass()), e);
413 @SuppressWarnings({ "rawtypes", "unchecked" })
414 final IdentifiableItem identifiableItem = new IdentifiableItem(identifiable, identifier);
415 return identifiableItem;
419 public NodeIdentifierWithPredicates serialize(final IdentifiableItem<?, ?> input) {
420 Object value = input.getKey();
422 Map<QName, Object> values = new LinkedHashMap<>();
423 for (Entry<QName, ValueContext> valueCtx : keyValueContexts.entrySet()) {
424 values.put(valueCtx.getKey(), valueCtx.getValue().getAndSerialize(value));
426 return new NodeIdentifierWithPredicates(schema.getQName(), values);
430 @SuppressWarnings("unchecked")
431 private static Constructor<? extends Identifier<?>> getConstructor(final Class<? extends Identifier<?>> clazz) {
432 for (@SuppressWarnings("rawtypes") Constructor constr : clazz.getConstructors()) {
433 Class<?>[] parameters = constr.getParameterTypes();
434 if (!clazz.equals(parameters[0])) {
435 // It is not copy constructor;
439 throw new IllegalArgumentException("Supplied class " + clazz + "does not have required constructor.");
443 public Codec<NodeIdentifierWithPredicates, IdentifiableItem<?, ?>> getPathArgumentCodec(final Class<?> listClz,
444 final ListSchemaNode schema) {
445 Class<? extends Identifier<?>> identifier = ClassLoaderUtils.findFirstGenericArgument(listClz,
447 Map<QName, ValueContext> valueCtx = new HashMap<>();
448 for (LeafNodeCodecContext leaf : getLeafNodes(identifier, schema).values()) {
449 QName name = leaf.getDomPathArgument().getNodeType();
450 valueCtx.put(name, new ValueContext(identifier, leaf));
452 return new IdentifiableItemCodec(schema, identifier, listClz, valueCtx);