import java.util.concurrent.Callable
import org.opendaylight.yangtools.yang.binding.Augmentation
import org.opendaylight.controller.sal.binding.impl.util.YangSchemaUtils
+import org.opendaylight.controller.sal.binding.dom.serializer.api.AugmentationCodec
+import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates
+import java.util.ArrayList
+import org.opendaylight.yangtools.yang.data.api.Node
+import org.opendaylight.yangtools.yang.data.impl.SimpleNodeTOImpl
+import org.opendaylight.yangtools.yang.data.impl.CompositeNodeTOImpl
class RuntimeGeneratedMappingServiceImpl implements BindingIndependentMappingService, SchemaServiceListener, AutoCloseable {
override Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> toDataDom(
Entry<InstanceIdentifier<? extends DataObject>, DataObject> entry) {
+
+ try {
val key = toDataDom(entry.key)
- val data = toCompositeNodeImpl(entry.value);
+ var CompositeNode data;
+ if(Augmentation.isAssignableFrom(entry.key.targetType)) {
+ data = toCompositeNodeImpl(key,entry.value);
+ } else {
+ data = toCompositeNodeImpl(entry.value);
+ }
return new SimpleEntry(key, data);
+
+ } catch (Exception e) {
+ LOG.error("Error during serialization for {}.", entry.key,e);
+ throw e;
+ }
}
private def CompositeNode toCompositeNodeImpl(DataObject object) {
val ret = codec.serialize(new ValueWithQName(null, object));
return ret as CompositeNode;
}
+
+
+ private def CompositeNode toCompositeNodeImpl(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier identifier,DataObject object) {
+
+ //val cls = object.implementedInterface;
+ //waitForSchema(cls);
+ val last = identifier.path.last;
+ val codec = registry.getCodecForAugmentation(object.implementedInterface as Class) as AugmentationCodec;
+ val ret = codec.serialize(new ValueWithQName(last.nodeType, object));
+ if(last instanceof NodeIdentifierWithPredicates) {
+ val predicates = last as NodeIdentifierWithPredicates;
+ val newNodes = new ArrayList<Node<?>>(predicates.keyValues.size);
+ for(predicate : predicates.keyValues.entrySet) {
+ newNodes.add(new SimpleNodeTOImpl(predicate.key,null,predicate.value));
+ }
+ newNodes.addAll(ret.children);
+ return new CompositeNodeTOImpl(last.nodeType,null,newNodes);
+ }
+ return ret as CompositeNode;
+ }
private def void waitForSchema(Class<? extends DataContainer> class1) {
if(Augmentation.isAssignableFrom(class1)) {
*/
return;
}
-
+ if(registry.isCodecAvailable(class1)) {
+ return;
+ }
val ref = Types.typeForClass(class1);
getSchemaWithRetry(ref);
}
}
}
- private def getTypeDefinition(Type type) {
- val typeDef = typeToDefinition.get(type);
- if (typeDef !== null) {
- return typeDef;
- }
- return type.getTypeDefInFuture.get();
- }
-
- private def Future<GeneratedTypeBuilder> getTypeDefInFuture(Type type) {
- val future = SettableFuture.<GeneratedTypeBuilder>create()
- promisedTypeDefinitions.put(type, future);
- return future;
- }
-
- private def void updatePromisedTypeDefinitions(GeneratedTypeBuilder builder) {
- val futures = promisedTypeDefinitions.get(builder);
- if (futures === null || futures.empty) {
- return;
- }
- for (future : futures) {
- future.set(builder);
- }
- promisedTypeDefinitions.removeAll(builder);
- }
-
private def getSchemaWithRetry(Type type) {
val typeDef = typeToSchemaNode.get(type);
if (typeDef !== null) {