1 package org.opendaylight.controller.sal.binding.dom.serializer.impl
3 import javassist.ClassPool
4 import org.opendaylight.yangtools.sal.binding.model.api.GeneratedType
5 import org.opendaylight.yangtools.yang.model.api.SchemaNode
6 import org.opendaylight.controller.sal.binding.codegen.util.JavassistUtils
7 import javassist.CtClass
9 import org.opendaylight.yangtools.yang.common.QName
10 import javassist.CtField
11 import static javassist.Modifier.*
12 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode
13 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode
14 import org.opendaylight.yangtools.sal.binding.model.api.MethodSignature
15 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer
16 import org.opendaylight.yangtools.sal.binding.model.api.Type
17 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTypeBuilder
18 import org.opendaylight.yangtools.binding.generator.util.Types
19 import org.opendaylight.yangtools.sal.binding.model.api.ParameterizedType
20 import java.util.HashMap
21 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode
22 import org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil
23 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode
24 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode
25 import java.util.WeakHashMap
27 import java.util.TreeSet
28 import com.google.common.base.Joiner
29 import org.opendaylight.yangtools.sal.binding.model.api.GeneratedTransferObject
30 import org.opendaylight.yangtools.sal.binding.model.api.Enumeration
31 import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode
32 import static org.opendaylight.controller.sal.binding.impl.util.ClassLoaderUtils.*;
33 import org.opendaylight.yangtools.yang.binding.BindingDeserializer
34 import org.opendaylight.yangtools.yang.binding.BindingSerializer
35 import org.opendaylight.yangtools.yang.binding.BindingCodec
36 import org.slf4j.LoggerFactory
37 import org.opendaylight.controller.sal.binding.codegen.CodeGenerationException
38 import org.opendaylight.yangtools.yang.model.api.ChoiceNode
39 import java.security.ProtectionDomain
42 class TransformerGenerator {
44 private static val log = LoggerFactory.getLogger(TransformerGenerator)
46 public static val STRING = Types.typeForClass(String);
47 public static val BOOLEAN = Types.typeForClass(Boolean);
48 public static val INTEGER = Types.typeForClass(Integer);
50 //public static val DECIMAL = Types.typeForClass(Decimal);
51 public static val LONG = Types.typeForClass(Long);
53 val ClassPool classPool
54 val extension JavassistUtils utils;
56 CtClass ctTransformator
61 var File classFileCapturePath;
65 var Map<Type, Type> typeDefinitions;
68 var Map<Type, GeneratedTypeBuilder> typeToDefinition
71 var Map<Type, SchemaNode> typeToSchemaNode
73 val Map<Class<?>, Class<?>> generatedClasses = new WeakHashMap();
75 public new(ClassPool pool) {
77 utils = new JavassistUtils(pool)
79 ctTransformator = BindingCodec.asCtClass;
80 ctQName = QName.asCtClass
83 def Class<? extends BindingCodec<Map<QName, Object>, Object>> transformerFor(Class<?> inputType) {
84 return withClassLoader(inputType.classLoader) [ |
85 val ret = generatedClasses.get(inputType);
87 return ret as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
89 val ref = Types.typeForClass(inputType)
90 val node = typeToSchemaNode.get(ref)
91 val typeSpecBuilder = typeToDefinition.get(ref)
92 val typeSpec = typeSpecBuilder.toInstance();
93 val newret = generateTransformerFor(inputType, typeSpec, node)
94 generatedClasses.put(inputType, newret);
95 return newret as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
99 private def Class<?> keyTransformerFor(Class<?> inputType, GeneratedType type, ListSchemaNode schema) {
100 return withClassLoader(inputType.classLoader) [ |
101 val transformer = generatedClasses.get(inputType);
102 if (transformer != null) {
105 val newret = generateKeyTransformerFor(inputType, type, schema);
106 generatedClasses.put(inputType, newret);
107 return newret as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
111 def Class<?> keyTransformer(GeneratedType type, ListSchemaNode node) {
112 val cls = loadClassWithTCCL(type.resolvedName + "Key");
113 keyTransformerFor(cls, type, node);
116 private def serializer(Type type) {
117 val cls = loadClassWithTCCL(type.resolvedName);
122 private def Class<?> getValueSerializer(GeneratedTransferObject type) {
123 val cls = loadClassWithTCCL(type.resolvedName);
124 val transformer = generatedClasses.get(cls);
125 if (transformer !== null) {
128 val valueTransformer = generateValueTransformer(cls, type);
129 generatedClasses.put(cls, valueTransformer);
130 return valueTransformer;
133 private def generateKeyTransformerFor(Class<? extends Object> inputType, GeneratedType typeSpec, ListSchemaNode node) {
135 log.info("Generating DOM Codec for {} with {}",inputType,inputType.classLoader)
136 val properties = typeSpec.allProperties;
137 val ctCls = createClass(inputType.transformatorFqn) [
138 //staticField(Map,"AUGMENTATION_SERIALIZERS");
139 staticQNameField(node.QName);
140 implementsType(ctTransformator)
141 method(Object, "toDomStatic", QName, Object) [
142 modifiers = PUBLIC + FINAL + STATIC
150 method(Object, "fromDomStatic", QName, Object) [
151 modifiers = PUBLIC + FINAL + STATIC
157 «QName.name» _localQName = $1;
158 java.util.Map _compositeNode = (java.util.Map) $2;
159 «FOR key : node.keyDefinition»
160 «val propertyName = key.getterName»
161 «val keyDef = node.getDataChildByName(key)»
162 «val property = properties.get(propertyName)»
163 «deserializeProperty(keyDef, property.returnType, property)»;
165 «inputType.name» _value = new «inputType.name»(«node.keyDefinition.keyConstructorList»);
170 method(Object, "serialize", Object) [
172 return toDomStatic(QNAME,$1);
175 method(Object, "deserialize", Object) [
177 return fromDomStatic(QNAME,$1);
181 val ret = ctCls.toClassImpl(inputType.classLoader, inputType.protectionDomain)
182 log.info("DOM Codec for {} was generated {}",inputType,ret)
183 return ret as Class<? extends BindingCodec<Map<QName,Object>, ?>>;
184 } catch (Exception e) {
185 processException(inputType,e);
190 private def dispatch Class<? extends BindingCodec<Map<QName, Object>, Object>> generateTransformerFor(Class inputType,
191 GeneratedType typeSpec, SchemaNode node) {
193 log.info("Generating DOM Codec for {} with {}",inputType,inputType.classLoader)
194 val ctCls = createClass(typeSpec.transformatorFqn) [
195 //staticField(Map,"AUGMENTATION_SERIALIZERS");
196 staticQNameField(inputType);
197 implementsType(ctTransformator)
198 method(Object, "toDomStatic", QName, Object) [
199 modifiers = PUBLIC + FINAL + STATIC
200 body = serializeBodyFacade(typeSpec, node)
202 method(Object, "serialize", Object) [
204 return toDomStatic(QNAME,$1);
207 method(Object, "fromDomStatic", QName, Object) [
208 modifiers = PUBLIC + FINAL + STATIC
209 body = deserializeBody(typeSpec, node)
211 method(Object, "deserialize", Object) [
213 return fromDomStatic(QNAME,$1);
218 val ret = ctCls.toClassImpl(inputType.classLoader, inputType.protectionDomain)
219 return ret as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
220 } catch (Exception e) {
221 processException(inputType,e);
227 private def dispatch Class<? extends BindingCodec<Map<QName, Object>, Object>> generateTransformerFor(Class inputType,
228 GeneratedType typeSpec, ChoiceNode node) {
230 log.info("Generating DOM Codec for {} with {}",inputType,inputType.classLoader)
231 val ctCls = createClass(typeSpec.transformatorFqn) [
232 //staticField(Map,"AUGMENTATION_SERIALIZERS");
233 //staticQNameField(inputType);
234 implementsType(ctTransformator)
235 method(Object, "toDomStatic", QName, Object) [
236 modifiers = PUBLIC + FINAL + STATIC
241 method(Object, "serialize", Object) [
246 method(Object, "fromDomStatic", QName, Object) [
247 modifiers = PUBLIC + FINAL + STATIC
252 method(Object, "deserialize", Object) [
259 val ret = ctCls.toClassImpl(inputType.classLoader, inputType.protectionDomain)
260 return ret as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
261 } catch (Exception e) {
262 processException(inputType,e);
268 private def keyConstructorList(List<QName> qnames) {
269 val names = new TreeSet<String>()
270 for (name : qnames) {
271 val fieldName = name.getterName;
272 names.add(fieldName);
274 return Joiner.on(",").join(names);
277 private def serializeBodyFacade(GeneratedType type, SchemaNode node) {
278 val ret = serializeBody(type, node);
282 private def String deserializeBody(GeneratedType type, SchemaNode node) {
283 val ret = deserializeBodyImpl(type, node);
287 private def deserializeKey(GeneratedType type, ListSchemaNode node) {
288 if (node.keyDefinition != null && !node.keyDefinition.empty) {
290 «type.resolvedName»Key getKey = («type.resolvedName»Key) «keyTransformer(type, node).canonicalName».fromDomStatic(_localQName,_compositeNode);
291 _builder.setKey(getKey);
296 private def dispatch String deserializeBodyImpl(GeneratedType type, SchemaNode node) '''
298 «QName.name» _localQName = «QName.name».create($1,QNAME.getLocalName());
303 java.util.Map _compositeNode = (java.util.Map) $2;
304 «type.builderName» _builder = new «type.builderName»();
306 return _builder.build();
310 private def dispatch String deserializeBodyImpl(GeneratedType type, ListSchemaNode node) '''
312 «QName.name» _localQName = «QName.name».create($1,QNAME.getLocalName());
316 java.util.Map _compositeNode = (java.util.Map) $2;
317 «type.builderName» _builder = new «type.builderName»();
318 «deserializeKey(type, node)»
319 «deserializeDataNodeContainerBody(type, node)»
320 return _builder.build();
324 private def dispatch String deserializeBodyImpl(GeneratedType type, ContainerSchemaNode node) '''
326 «QName.name» _localQName = «QName.name».create($1,QNAME.getLocalName());
330 java.util.Map _compositeNode = (java.util.Map) $2;
331 «type.builderName» _builder = new «type.builderName»();
332 «deserializeDataNodeContainerBody(type, node)»
333 return _builder.build();
337 private def dispatch String deserializeBodyImpl(GeneratedType type, ChoiceCaseNode node) '''
339 «QName.name» _localQName = «QName.name».create($1,QNAME.getLocalName());
343 java.util.Map _compositeNode = (java.util.Map) $2;
344 «type.builderName» _builder = new «type.builderName»();
345 «deserializeDataNodeContainerBody(type, node)»
346 return _builder.build();
350 private def deserializeDataNodeContainerBody(GeneratedType type, DataNodeContainer node) {
351 deserializeNodeContainerBodyImpl(type, type.allProperties, node);
354 private def deserializeNodeContainerBodyImpl(GeneratedType type, HashMap<String, MethodSignature> properties,
355 DataNodeContainer node) {
357 «FOR child : node.childNodes.filter[!augmenting]»
358 «val signature = properties.getFor(child)»
359 «deserializeProperty(child, signature.returnType, signature)»
360 _builder.«signature.name.toSetter»(«signature.name»);
366 private def dispatch CharSequence deserializeProperty(ListSchemaNode schema, ParameterizedType type,
367 MethodSignature property) '''
368 java.util.List _dom_«property.name» = _compositeNode.get(«QName.name».create(_localQName,"«schema.QName.
370 //System.out.println("«property.name»#deCode"+_dom_«property.name»);
371 java.util.List «property.name» = new java.util.ArrayList();
372 if(_dom_«property.name» != null) {
373 java.util.List _serialized = new java.util.ArrayList();
374 java.util.Iterator _iterator = _dom_«property.name».iterator();
375 boolean _hasNext = _iterator.hasNext();
377 Object _listItem = _iterator.next();
378 //System.out.println(" item" + _listItem);
379 Object _value = «type.actualTypeArguments.get(0).serializer.name».fromDomStatic(_localQName,_listItem);
380 //System.out.println(" value" + _value);
381 «property.name».add(_value);
382 _hasNext = _iterator.hasNext();
386 //System.out.println(" list" + «property.name»);
389 private def dispatch CharSequence deserializeProperty(LeafListSchemaNode schema, ParameterizedType type,
390 MethodSignature property) '''
391 java.util.List _dom_«property.name» = _compositeNode.get(«QName.name».create(_localQName,"«schema.QName.
393 java.util.List «property.name» = new java.util.ArrayList();
394 if(_dom_«property.name» != null) {
395 java.util.List _serialized = new java.util.ArrayList();
396 java.util.Iterator _iterator = _dom_«property.name».iterator();
397 boolean _hasNext = _iterator.hasNext();
399 Object _listItem = _iterator.next();
400 if(_listItem instanceof java.util.Map.Entry) {
401 Object _innerValue = ((java.util.Map.Entry) _listItem).getValue();
402 Object _value = «deserializeValue(type.actualTypeArguments.get(0), "_innerValue")»;
403 «property.name».add(_value);
405 _hasNext = _iterator.hasNext();
410 private def dispatch CharSequence deserializeProperty(LeafSchemaNode schema, Type type, MethodSignature property) '''
411 java.util.List _dom_«property.name»_list =
412 _compositeNode.get(«QName.name».create(_localQName,"«schema.QName.localName»"));
413 «type.resolvedName» «property.name» = null;
414 if(_dom_«property.name»_list != null && _dom_«property.name»_list.size() > 0) {
415 java.util.Map.Entry _dom_«property.name» = (java.util.Map.Entry) _dom_«property.name»_list.get(0);
416 Object _inner_value = _dom_«property.name».getValue();
417 «property.name» = «deserializeValue(type, "_inner_value")»;
421 private def dispatch CharSequence deserializeProperty(ContainerSchemaNode schema, Type type,
422 MethodSignature property) '''
423 java.util.List _dom_«property.name»_list =
424 _compositeNode.get(«QName.name».create(_localQName,"«schema.QName.localName»"));
425 «type.resolvedName» «property.name» = null;
426 if(_dom_«property.name»_list != null && _dom_«property.name»_list.size() > 0) {
428 java.util.Map _dom_«property.name» = (java.util.Map) _dom_«property.name»_list.get(0);
429 «type.resolvedName» «property.name» = «type.serializer.name».fromDomStatic(_localQName,_dom_«property.name»);
433 private def dispatch String deserializeValue(GeneratedTransferObject type, String domParameter) '''
434 («type.resolvedName») «type.valueSerializer.name».fromDomValue(«domParameter»);
437 private def dispatch Class<? extends BindingCodec<Map<QName, Object>, Object>> generateValueTransformer(
438 Class<?> inputType, GeneratedTransferObject typeSpec) {
441 val returnType = typeSpec.valueReturnType;
442 if (returnType == null) {
444 val ctCls = createDummyImplementation(inputType, typeSpec);
445 val ret = ctCls.toClassImpl(inputType.classLoader, inputType.protectionDomain)
446 return ret as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
448 val ctCls = createClass(typeSpec.transformatorFqn) [
449 //staticField(Map,"AUGMENTATION_SERIALIZERS");
450 implementsType(ctTransformator)
451 implementsType(BindingDeserializer.asCtClass)
452 method(Object, "toDomValue", Object) [
453 modifiers = PUBLIC + FINAL + STATIC
456 ////System.out.println("«inputType.simpleName»#toDomValue: "+$1);
461 «typeSpec.resolvedName» _encapsulatedValue = («typeSpec.resolvedName») $1;
462 //System.out.println("«inputType.simpleName»#toDomValue:Enc: "+_encapsulatedValue);
463 «returnType.resolvedName» _value = _encapsulatedValue.getValue();
464 //System.out.println("«inputType.simpleName»#toDomValue:DeEnc: "+_value);
469 method(Object, "serialize", Object) [
472 return toDomValue($1);
476 method(Object, "fromDomValue", Object) [
477 modifiers = PUBLIC + FINAL + STATIC
480 //System.out.println("«inputType.simpleName»#fromDomValue: "+$1);
485 «returnType.resolvedName» _simpleValue = «deserializeValue(returnType, "$1")»;
486 «typeSpec.resolvedName» _value = new «typeSpec.resolvedName»(_simpleValue);
491 method(Object, "deserialize", Object) [
493 return fromDomValue($1);
499 val ret = ctCls.toClassImpl(inputType.classLoader, inputType.protectionDomain)
500 log.info("DOM Codec for {} was generated {}",inputType,ret)
501 return ret as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
502 } catch (Exception e) {
503 log.error("Cannot compile DOM Codec for {}",inputType,e);
504 val exception = new CodeGenerationException("Cannot compile Transformator for " + inputType);
505 exception.addSuppressed(e);
511 private def createDummyImplementation(Class<?> object, GeneratedTransferObject typeSpec) {
512 log.info("Generating Dummy DOM Codec for {} with {}",object,object.classLoader)
513 return createClass(typeSpec.transformatorFqn) [
514 //staticField(Map,"AUGMENTATION_SERIALIZERS");
515 implementsType(ctTransformator)
516 implementsType(BindingDeserializer.asCtClass)
517 method(Object, "toDomValue", Object) [
518 modifiers = PUBLIC + FINAL + STATIC
519 body = '''return null;'''
521 method(Object, "serialize", Object) [
524 return toDomValue($1);
528 method(Object, "fromDomValue", Object) [
529 modifiers = PUBLIC + FINAL + STATIC
530 body = '''return null;'''
532 method(Object, "deserialize", Object) [
534 return fromDomValue($1);
541 private def Type getValueReturnType(GeneratedTransferObject object) {
542 for (prop : object.properties) {
543 if (prop.name == "value") {
544 return prop.returnType;
547 if (object.superType != null) {
548 return getValueReturnType(object.superType);
553 private def dispatch Class<? extends BindingCodec<Map<QName, Object>, Object>> generateValueTransformer(
554 Class<?> inputType, Enumeration typeSpec) {
556 log.info("Generating DOM Codec for {} with {}",inputType,inputType.classLoader)
557 val ctCls = createClass(typeSpec.transformatorFqn) [
558 //staticField(Map,"AUGMENTATION_SERIALIZERS");
559 implementsType(ctTransformator)
560 method(Object, "toDomValue", Object) [
561 modifiers = PUBLIC + FINAL + STATIC
566 «typeSpec.resolvedName» _value = («typeSpec.resolvedName») $1;
567 return _value.getValue();
570 method(Object, "serialize", Object) [
572 return toDomValue($1);
575 method(Object, "fromDomValue", Object) [
576 modifiers = PUBLIC + FINAL + STATIC
582 «typeSpec.resolvedName» _value = new «typeSpec.resolvedName»(null);
586 method(Object, "deserialize", Object) [
588 return fromDomValue($1);
593 val ret = ctCls.toClassImpl(inputType.classLoader, inputType.protectionDomain)
594 log.info("DOM Codec for {} was generated {}",inputType,ret)
595 return ret as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
596 } catch (CodeGenerationException e) {
597 throw new CodeGenerationException("Cannot compile Transformator for " + inputType,e);
598 } catch (Exception e) {
599 log.error("Cannot compile DOM Codec for {}",inputType,e);
600 val exception = new CodeGenerationException("Cannot compile Transformator for " + inputType);
601 exception.addSuppressed(e);
607 def Class<?> toClassImpl(CtClass newClass, ClassLoader loader, ProtectionDomain domain) {
608 val cls = newClass.toClass(loader,domain);
609 if(classFileCapturePath !== null) {
610 newClass.writeFile(classFileCapturePath.absolutePath);
615 def debugWriteClass(CtClass class1) {
616 val path = class1.name.replace(".","/")+".class"
618 val captureFile = new File(classFileCapturePath,path);
619 captureFile.createNewFile
624 private def dispatch String deserializeValue(Type type, String domParameter) '''(«type.resolvedName») «domParameter»'''
630 private def dispatch CharSequence deserializeProperty(DataSchemaNode container, Type type, MethodSignature property) '''
631 «type.resolvedName» «property.name» = null;
634 private def dispatch CharSequence deserializeProperty(DataSchemaNode container, GeneratedTypeBuilder type,
635 MethodSignature property) {
636 _deserializeProperty(container, type.toInstance, property)
639 public static def toSetter(String it) {
641 if (startsWith("is")) {
642 return "set" + substring(2);
643 } else if (startsWith("get")) {
644 return "set" + substring(3);
650 private def dispatch CharSequence deserializeProperty(DataSchemaNode container,GeneratedType type, MethodSignature property) '''
651 «property.returnType.resolvedName» «property.name» = value.«property.name»();
652 if(«property.name» != null) {
653 Object domValue = «type.serializer».toDomStatic(QNAME,«property.name»);
654 childNodes.add(domValue);
658 private def getBuilderName(GeneratedType type) '''«type.resolvedName»Builder'''
660 private def staticQNameField(CtClass it, Class node) {
661 val field = new CtField(ctQName, "QNAME", it);
662 field.modifiers = PUBLIC + FINAL + STATIC;
663 addField(field, '''«node.name».QNAME''')
666 private def staticQNameField(CtClass it, QName node) {
667 val field = new CtField(ctQName, "QNAME", it);
668 field.modifiers = PUBLIC + FINAL + STATIC;
669 addField(field, '''«QName.asCtClass.name».create("«node.namespace»","«node.formattedRevision»","«node.localName»")''')
672 private def dispatch String serializeBody(GeneratedType type, ListSchemaNode node) '''
674 «QName.name» resultName = «QName.name».create($1,QNAME.getLocalName());
675 java.util.List childNodes = new java.util.ArrayList();
676 «type.resolvedName» value = («type.resolvedName») $2;
677 «transformDataContainerBody(type.allProperties, node)»
678 return ($r) java.util.Collections.singletonMap(resultName,childNodes);
682 private def dispatch String serializeBody(GeneratedType type, ContainerSchemaNode node) '''
684 «QName.name» resultName = «QName.name».create($1,QNAME.getLocalName());
685 java.util.List childNodes = new java.util.ArrayList();
686 «type.resolvedName» value = («type.resolvedName») $2;
687 «transformDataContainerBody(type.allProperties, node)»
688 return ($r) java.util.Collections.singletonMap(resultName,childNodes);
692 private def dispatch String serializeBody(GeneratedType type, ChoiceCaseNode node) '''
694 «QName.name» resultName = «QName.name».create($1,QNAME.getLocalName());
695 java.util.List childNodes = new java.util.ArrayList();
696 «type.resolvedName» value = («type.resolvedName») $2;
697 «transformDataContainerBody(type.allProperties, node)»
698 return ($r) java.util.Collections.singletonMap(resultName,childNodes);
702 private def dispatch String serializeBody(GeneratedType type, SchemaNode node) '''
704 «QName.name» resultName = «QName.name».create($1,QNAME.getLocalName());
705 java.util.List childNodes = new java.util.ArrayList();
706 «type.resolvedName» value = («type.resolvedName») $2;
707 return ($r) java.util.Collections.singletonMap(resultName,childNodes);
712 private def transformDataContainerBody(Map<String, MethodSignature> properties, DataNodeContainer node) {
714 «FOR child : node.childNodes.filter[!augmenting]»
715 «var signature = properties.getFor(child)»
716 «serializeProperty(child, signature.returnType, signature)»
722 def MethodSignature getFor(Map<String,MethodSignature> map, DataSchemaNode node) {
723 val sig = map.get(node.getterName);
725 return map.get(node.booleanGetterName);
730 private static def String getBooleanGetterName(DataSchemaNode node) {
731 return "is" + BindingGeneratorUtil.parseToClassName(node.QName.localName);
734 private static def String getGetterName(DataSchemaNode node) {
735 return "get" + BindingGeneratorUtil.parseToClassName(node.QName.localName);
738 private static def String getGetterName(QName node) {
739 return "get" + BindingGeneratorUtil.parseToClassName(node.localName);
742 private def dispatch CharSequence serializeProperty(ListSchemaNode schema, ParameterizedType type,
743 MethodSignature property) '''
744 «property.returnType.resolvedName» «property.name» = value.«property.name»();
745 if(«property.name» != null) {
746 java.util.Iterator _iterator = «property.name».iterator();
747 boolean _hasNext = _iterator.hasNext();
749 Object _listItem = _iterator.next();
750 Object _domValue = «type.actualTypeArguments.get(0).serializer.name».toDomStatic(QNAME,_listItem);
751 childNodes.add(_domValue);
752 _hasNext = _iterator.hasNext();
757 private def dispatch CharSequence serializeProperty(LeafSchemaNode schema, Type type, MethodSignature property) '''
758 «property.returnType.resolvedName» «property.name» = value.«property.name»();
760 if(«property.name» != null) {
761 «QName.name» _qname = «QName.name».create(resultName,"«schema.QName.localName»");
762 Object _propValue = «serializeValue(type, property.name)»;
763 if(_propValue != null) {
764 Object _domValue = java.util.Collections.singletonMap(_qname,_propValue);
765 childNodes.add(_domValue);
770 private def dispatch serializeValue(GeneratedTransferObject type, String parameter) '''«type.valueSerializer.name».toDomValue(«parameter»)'''
772 private def dispatch serializeValue(Type signature, String property) '''«property»'''
774 private def dispatch CharSequence serializeProperty(LeafListSchemaNode schema, Type type, MethodSignature property) '''
775 «property.returnType.resolvedName» «property.name» = value.«property.name»();
776 if(«property.name» != null) {
777 «QName.name» _qname = «QName.name».create(resultName,"«schema.QName.localName»");
778 java.util.Iterator _iterator = «property.name».iterator();
779 boolean _hasNext = _iterator.hasNext();
781 Object _listItem = _iterator.next();
782 Object _propValue = «property.name»;
783 Object _domValue = java.util.Collections.singletonMap(_qname,_propValue);
784 childNodes.add(_domValue);
785 _hasNext = _iterator.hasNext();
794 private def dispatch CharSequence serializeProperty(DataSchemaNode container, Type type, MethodSignature property) '''
795 «property.returnType.resolvedName» «property.name» = value.«property.name»();
796 if(«property.name» != null) {
797 Object domValue = «property.name»;
798 childNodes.add(domValue);
802 private def dispatch CharSequence serializeProperty(DataSchemaNode container, GeneratedTypeBuilder type,
803 MethodSignature property) {
804 serializeProperty(container, type.toInstance, property)
807 private def dispatch CharSequence serializeProperty(DataSchemaNode container, GeneratedType type,
808 MethodSignature property) '''
809 «property.returnType.resolvedName» «property.name» = value.«property.name»();
810 if(«property.name» != null) {
811 Object domValue = «type.serializer.name».toDomStatic(QNAME,«property.name»);
812 childNodes.add(domValue);
818 private def transformatorFqn(GeneratedType typeSpec) {
819 return '''«typeSpec.resolvedName»$Broker$Codec$DOM'''
822 private def transformatorFqn(Class typeSpec) {
823 return '''«typeSpec.name»$Broker$Codec$DOM'''
826 private def HashMap<String, MethodSignature> getAllProperties(GeneratedType type) {
827 val ret = new HashMap<String, MethodSignature>();
828 type.collectAllProperties(ret);
832 private def dispatch void collectAllProperties(GeneratedType type, Map<String, MethodSignature> set) {
833 for (definition : type.methodDefinitions) {
834 set.put(definition.name, definition);
837 for (parent : type.implements) {
838 parent.collectAllProperties(set);
842 private def dispatch void collectAllProperties(Type type, Map<String, MethodSignature> set) {
843 // NOOP for generic type.
846 def String getResolvedName(Type type) {
847 return type.asCtClass.name;
850 def CtClass asCtClass(Type type) {
851 val name = type.fullyQualifiedName
852 val cls = loadClassWithTCCL(type.fullyQualifiedName)
853 return cls.asCtClass;
858 private def dispatch processException(Class<?> inputType,CodeGenerationException e){
859 log.error("Cannot compile DOM Codec for {}. One of it's prerequisites was not generated.",inputType);
863 private def dispatch processException(Class<?> inputType,Exception e){
864 log.error("Cannot compile DOM Codec for {}",inputType,e);
865 val exception = new CodeGenerationException("Cannot compile Transformator for " + inputType,e);
879 MethodSignature signature;
881 SchemaNode schemaNode;