1 package org.opendaylight.controller.sal.binding.dom.serializer.impl
3 import org.opendaylight.controller.sal.binding.dom.serializer.impl.TransformerGenerator
4 import javassist.ClassPool
5 import org.opendaylight.yangtools.yang.model.api.SchemaContext
6 import org.opendaylight.controller.sal.core.api.model.SchemaServiceListener
7 import org.opendaylight.yangtools.sal.binding.generator.impl.BindingGeneratorImpl
9 import org.opendaylight.yangtools.sal.binding.model.api.Type
10 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTypeBuilder
11 import org.opendaylight.yangtools.yang.model.api.SchemaNode
12 import java.util.concurrent.ConcurrentHashMap
13 import org.opendaylight.yangtools.yang.data.api.CompositeNode
14 import org.opendaylight.yangtools.yang.binding.DataObject
15 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier
16 import java.util.Map.Entry
17 import java.util.AbstractMap.SimpleEntry
18 import org.opendaylight.yangtools.yang.model.api.SchemaPath
19 import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil
20 import java.util.ArrayList
21 import org.opendaylight.yangtools.yang.common.QName
22 import org.opendaylight.yangtools.yang.binding.DataContainer
23 import static com.google.common.base.Preconditions.*;
25 import org.opendaylight.yangtools.yang.data.api.Node
26 import org.opendaylight.yangtools.yang.data.impl.CompositeNodeTOImpl
27 import org.opendaylight.yangtools.yang.data.impl.SimpleNodeTOImpl
28 import org.opendaylight.yangtools.concepts.Delegator
29 import java.util.concurrent.ConcurrentMap
30 import org.opendaylight.yangtools.sal.binding.model.api.GeneratedType
31 import org.opendaylight.yangtools.yang.binding.BindingCodec
32 import com.google.common.collect.HashMultimap
33 import com.google.common.util.concurrent.SettableFuture
34 import java.util.concurrent.Future
35 import org.opendaylight.yangtools.binding.generator.util.ReferencedTypeImpl
36 import org.opendaylight.controller.sal.binding.dom.serializer.impl.LazyGeneratedCodecRegistry
37 import org.opendaylight.controller.sal.binding.impl.connect.dom.BindingIndependentMappingService
38 import org.slf4j.LoggerFactory
39 import org.opendaylight.controller.sal.binding.dom.serializer.api.ValueWithQName
40 import org.opendaylight.controller.sal.binding.dom.serializer.api.DataContainerCodec
41 import org.opendaylight.yangtools.binding.generator.util.Types
43 class RuntimeGeneratedMappingServiceImpl implements BindingIndependentMappingService, SchemaServiceListener {
48 private static val LOG = LoggerFactory.getLogger(RuntimeGeneratedMappingServiceImpl);
51 extension TransformerGenerator binding;
54 extension LazyGeneratedCodecRegistry registry;
57 val ConcurrentMap<Type, Type> typeDefinitions = new ConcurrentHashMap();
60 val ConcurrentMap<Type, GeneratedTypeBuilder> typeToDefinition = new ConcurrentHashMap();
63 val ConcurrentMap<Type, SchemaNode> typeToSchemaNode = new ConcurrentHashMap();
65 val promisedTypeDefinitions = HashMultimap.<Type, SettableFuture<GeneratedTypeBuilder>>create;
67 val promisedSchemas = HashMultimap.<Type, SettableFuture<SchemaNode>>create;
69 override onGlobalContextUpdated(SchemaContext arg0) {
70 recreateBindingContext(arg0);
71 registry.onGlobalContextUpdated(arg0);
74 def recreateBindingContext(SchemaContext schemaContext) {
75 val newBinding = new BindingGeneratorImpl();
76 newBinding.generateTypes(schemaContext);
78 for (entry : newBinding.moduleContexts.entrySet) {
80 registry.onModuleContextAdded(schemaContext, entry.key, entry.value);
82 //val module = entry.key;
83 val context = entry.value;
84 updateBindingFor(context.childNodes, schemaContext);
85 updateBindingFor(context.cases, schemaContext);
88 val typedefs = context.typedefs;
89 for (typedef : typedefs.values) {
90 binding.typeDefinitions.put(typedef, typedef as GeneratedType);
92 val augmentations = context.augmentations;
93 for (augmentation : augmentations) {
94 binding.typeToDefinition.put(augmentation, augmentation);
97 binding.typeToAugmentation.putAll(context.typeToAugmentation);
101 override CompositeNode toDataDom(DataObject data) {
102 toCompositeNodeImpl(data);
105 override Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> toDataDom(
106 Entry<InstanceIdentifier<? extends DataObject>, DataObject> entry) {
107 val key = toDataDom(entry.key)
108 val data = toCompositeNodeImpl(entry.value);
109 return new SimpleEntry(key, data);
112 private def CompositeNode toCompositeNodeImpl(DataObject object) {
113 val cls = object.implementedInterface;
115 val codec = registry.getCodecForDataObject(cls) as DataContainerCodec<DataObject>;
116 val ret = codec.serialize(new ValueWithQName(null, object));
117 return ret as CompositeNode;
120 private def waitForSchema(Class<? extends DataContainer> class1) {
121 val ref = Types.typeForClass(class1);
122 getSchemaWithRetry(ref);
125 override org.opendaylight.yangtools.yang.data.api.InstanceIdentifier toDataDom(
126 InstanceIdentifier<? extends DataObject> path) {
127 for (arg : path.path) {
128 waitForSchema(arg.type);
130 return registry.instanceIdentifierCodec.serialize(path);
133 override dataObjectFromDataDom(InstanceIdentifier<? extends DataObject> path, CompositeNode node) {
137 val targetType = path.targetType
138 val transformer = registry.getCodecForDataObject(targetType);
139 val ret = transformer.deserialize(node)?.value as DataObject;
143 private def void updateBindingFor(Map<SchemaPath, GeneratedTypeBuilder> map, SchemaContext module) {
144 for (entry : map.entrySet) {
145 val schemaNode = SchemaContextUtil.findDataSchemaNode(module, entry.key);
146 //LOG.info("{} : {}",entry.key,entry.value.fullyQualifiedName)
147 if (schemaNode != null) {
148 typeToSchemaNode.put(entry.value, schemaNode);
149 typeToDefinition.put(entry.value, entry.value);
150 updatePromisedSchemas(entry.value, schemaNode);
155 public def void start() {
156 binding = new TransformerGenerator(pool);
157 registry = new LazyGeneratedCodecRegistry()
158 registry.generator = binding
160 //binding.staticFieldsInitializer = registry
161 binding.listener = registry
162 binding.typeToDefinition = typeToDefinition
163 binding.typeToSchemaNode = typeToSchemaNode
164 binding.typeDefinitions = typeDefinitions
168 private def getTypeDefinition(Type type) {
169 val typeDef = typeToDefinition.get(type);
170 if (typeDef !== null) {
173 return type.getTypeDefInFuture.get();
176 private def Future<GeneratedTypeBuilder> getTypeDefInFuture(Type type) {
177 val future = SettableFuture.<GeneratedTypeBuilder>create()
178 promisedTypeDefinitions.put(type, future);
182 private def void updatePromisedTypeDefinitions(GeneratedTypeBuilder builder) {
183 val futures = promisedTypeDefinitions.get(builder);
184 if (futures === null || futures.empty) {
187 for (future : futures) {
190 promisedTypeDefinitions.removeAll(builder);
193 private def getSchemaWithRetry(Type type) {
194 val typeDef = typeToSchemaNode.get(type);
195 if (typeDef !== null) {
198 return type.getSchemaInFuture.get();
201 private def Future<SchemaNode> getSchemaInFuture(Type type) {
202 val future = SettableFuture.<SchemaNode>create()
203 promisedSchemas.put(type, future);
207 private def void updatePromisedSchemas(Type builder, SchemaNode schema) {
208 val ref = new ReferencedTypeImpl(builder.packageName, builder.name);
209 val futures = promisedSchemas.get(ref);
210 if (futures === null || futures.empty) {
213 for (future : futures) {
216 promisedSchemas.removeAll(builder);