import org.opendaylight.yangtools.yang.model.api.NotificationDefinition
import org.opendaylight.yangtools.yang.binding.BindingMapping
import org.opendaylight.yangtools.yang.model.api.type.EmptyTypeDefinition
+import java.util.Collection
class TransformerGenerator {
var Map<Type, AugmentationSchema> typeToAugmentation = new ConcurrentHashMap();
@Property
- var GeneratorListener listener;
+ var LazyGeneratedCodecRegistry listener;
@Property
var extension GeneratedClassLoadingStrategy classLoadingStrategy
}
val ref = Types.typeForClass(inputType)
val node = typeToSchemaNode.get(ref)
+ createMapping(inputType, node, null)
val typeSpecBuilder = typeToDefinition.get(ref)
checkState(typeSpecBuilder !== null, "Could not find typedefinition for %s", inputType.name);
val typeSpec = typeSpecBuilder.toInstance();
def Class<? extends BindingCodec<Map<QName, Object>, Object>> transformerFor(Class<?> inputType, DataSchemaNode node) {
return withClassLoaderAndLock(inputType.classLoader, lock) [ |
+ createMapping(inputType, node, null)
val ret = getGeneratedClass(inputType)
if (ret !== null) {
listener.onClassProcessed(inputType);
def Class<? extends BindingCodec<Map<QName, Object>, Object>> augmentationTransformerFor(Class<?> inputType) {
return withClassLoaderAndLock(inputType.classLoader, lock) [ |
+
val ret = getGeneratedClass(inputType)
if (ret !== null) {
return ret as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
val node = typeToAugmentation.get(ref)
val typeSpecBuilder = typeToDefinition.get(ref)
val typeSpec = typeSpecBuilder.toInstance();
+ //mappingForNodes(node.childNodes, typeSpec.allProperties, bindingId)
val newret = generateAugmentationTransformerFor(inputType, typeSpec, node);
listener.onClassProcessed(inputType);
return newret as Class<? extends BindingCodec<Map<QName,Object>, Object>>;
def Class<? extends BindingCodec<Object, Object>> caseCodecFor(Class<?> inputType, ChoiceCaseNode node) {
return withClassLoaderAndLock(inputType.classLoader, lock) [ |
+ createMapping(inputType, node, null)
val ret = getGeneratedClass(inputType)
if (ret !== null) {
return ret as Class<? extends BindingCodec<Object, Object>>;
]
}
+ private def void createMapping(Class<?> inputType, SchemaNode node, InstanceIdentifier<?> parentId) {
+ var ClassLoader cl = inputType.classLoader
+ if (cl === null) {
+ cl = Thread.currentThread.contextClassLoader
+ }
+ withClassLoader(cl,
+ [ |
+ if (!(node instanceof DataNodeContainer)) {
+ return null
+ }
+ var InstanceIdentifier<?> bindingId = listener.getBindingIdentifierByPath(node.path)
+ if (bindingId != null) {
+ return null
+ }
+ val ref = Types.typeForClass(inputType)
+ var typeSpecBuilder = typeToDefinition.get(ref)
+ if (typeSpecBuilder == null) {
+ typeSpecBuilder = pathToType.get(node.path);
+ }
+ checkState(typeSpecBuilder !== null, "Could not find typedefinition for %s, $s", inputType.name, node);
+ val typeSpec = typeSpecBuilder.toInstance();
+ var InstanceIdentifier<?> parent
+ if (parentId == null) {
+ bindingId = InstanceIdentifier.create(inputType as Class)
+ parent = bindingId
+ listener.putPathToBindingIdentifier(node.path, bindingId)
+ } else {
+ parent = listener.putPathToBindingIdentifier(node.path, parentId, inputType)
+ }
+ val Map<String, Type> properties = typeSpec.allProperties
+ if (node instanceof DataNodeContainer) {
+ mappingForNodes((node as DataNodeContainer).childNodes, properties, parent)
+ } else if (node instanceof ChoiceNode) {
+ mappingForNodes((node as ChoiceNode).cases, properties, parent)
+ }
+ return null;
+ ])
+ }
+
+ private def void mappingForNodes(Collection<? extends DataSchemaNode> childNodes, Map<String, Type> properties,
+ InstanceIdentifier<?> parent) {
+ for (DataSchemaNode child : childNodes) {
+ val signature = properties.getFor(child)
+ if (signature != null) {
+ val Type childType = signature.value
+ var Class<?> childTypeClass = null;
+ if (child instanceof ListSchemaNode && childType instanceof ParameterizedType) {
+ childTypeClass = loadClass((childType as ParameterizedType).actualTypeArguments.get(0))
+ } else {
+ childTypeClass = loadClass(childType)
+ }
+ createMapping(childTypeClass, child, parent)
+ }
+ }
+ }
+
def getIdentifierDefinition(GeneratedTypeBuilder builder) {
val inst = builder.toInstance
val keyMethod = inst.methodDefinitions.findFirst[name == "getKey"]
staticField(it, IDENTITYREF_CODEC, BindingCodec)
staticQNameField(node.QName);
implementsType(BINDING_CODEC)
- method(Object, "toDomStatic", QName, Object) [
+ method(Object, "toDomStatic", #[QName, Object]) [
modifiers = PUBLIC + FINAL + STATIC
bodyChecked = '''
{
}
'''
]
- method(Object, "fromDomStatic", QName, Object) [
+ method(Object, "fromDomStatic", #[QName, Object]) [
modifiers = PUBLIC + FINAL + STATIC
bodyChecked = '''
{
private def Class<? extends BindingCodec<Object, Object>> generateCaseCodec(Class<?> inputType, GeneratedType type,
ChoiceCaseNode node) {
try {
-
//log.info("Generating DOM Codec for {} with {}, TCCL is: {}", inputType, inputType.classLoader,Thread.currentThread.contextClassLoader)
val ctCls = createClass(type.codecClassName) [
//staticField(Map,"AUGMENTATION_SERIALIZERS");
staticField(it, INSTANCE_IDENTIFIER_CODEC, BindingCodec)
staticField(it, AUGMENTATION_CODEC, BindingCodec)
staticField(it, IDENTITYREF_CODEC, BindingCodec)
- method(Object, "toDomStatic", QName, Object) [
+ method(Object, "toDomStatic", #[QName, Object]) [
modifiers = PUBLIC + FINAL + STATIC
bodyChecked = '''
{
}
'''
]
- method(Object, "fromDomStatic", QName, Object) [
+ method(Object, "fromDomStatic", #[QName, Object, InstanceIdentifier]) [
modifiers = PUBLIC + FINAL + STATIC
- bodyChecked = deserializeBody(type, node)
+ bodyChecked = deserializeBody(type, node, listener.getBindingIdentifierByPath(node.path))
]
- method(Object, "deserialize", Object) [
+ method(Object, "deserialize", #[Object, InstanceIdentifier]) [
bodyChecked = '''
{
//System.out.println("«type.name»#deserialize: " +$1);
java.util.Map.Entry _input = (java.util.Map.Entry) $1;
- return fromDomStatic((«QName.name»)_input.getKey(),_input.getValue());
+ return fromDomStatic((«QName.name»)_input.getKey(),_input.getValue(),$2);
}
'''
]
staticField(it, IDENTITYREF_CODEC, BindingCodec)
staticField(it, AUGMENTATION_CODEC, BindingCodec)
implementsType(BINDING_CODEC)
- method(Object, "toDomStatic", QName, Object) [
+
+ method(Object, "toDomStatic", #[QName, Object]) [
modifiers = PUBLIC + FINAL + STATIC
bodyChecked = serializeBodyFacade(typeSpec, node)
]
}
'''
]
- method(Object, "fromDomStatic", QName, Object) [
+
+ method(Object, "fromDomStatic", #[QName, Object, InstanceIdentifier]) [
modifiers = PUBLIC + FINAL + STATIC
- bodyChecked = deserializeBody(typeSpec, node)
+ bodyChecked = deserializeBody(typeSpec, node, listener.getBindingIdentifierByPath(node.path))
]
- method(Object, "deserialize", Object) [
+
+ method(Object, "deserialize", #[Object, InstanceIdentifier]) [
bodyChecked = '''
{
«QName.name» _qname = QNAME;
if($1 instanceof java.util.Map.Entry) {
_qname = («QName.name») ((java.util.Map.Entry) $1).getKey();
}
- return fromDomStatic(_qname,$1);
+ return fromDomStatic(_qname,$1,$2);
}
'''
]
staticField(it, AUGMENTATION_CODEC, BindingCodec)
staticField(it, IDENTITYREF_CODEC, BindingCodec)
implementsType(BINDING_CODEC)
- method(Object, "toDomStatic", QName, Object) [
+
+ method(Object, "toDomStatic", #[QName, Object]) [
modifiers = PUBLIC + FINAL + STATIC
bodyChecked = '''
{
}
'''
]
- method(Object, "fromDomStatic", QName, Object) [
+
+ method(Object, "fromDomStatic", #[QName, Object, InstanceIdentifier]) [
modifiers = PUBLIC + FINAL + STATIC
bodyChecked = '''
{
«QName.name» _localQName = QNAME;
-
+
if($2 == null) {
return null;
}
«type.builderName» _builder = new «type.builderName»();
boolean _is_empty = true;
«FOR child : node.childNodes»
- «val signature = properties.getFor(child)»
- «deserializeProperty(child, signature.value, signature.key)»
- _builder.«signature.key.toSetter»(«signature.key»);
+ «val signature = properties.getFor(child)»
+ «deserializeProperty(child, signature.value, signature.key)»
+ _builder.«signature.key.toSetter»(«signature.key»);
«ENDFOR»
if(_is_empty) {
return null;
}
'''
]
- method(Object, "deserialize", Object) [
+
+ method(Object, "deserialize", #[Object, InstanceIdentifier]) [
bodyChecked = '''
- return fromDomStatic(QNAME,$1);
+ return fromDomStatic(QNAME,$1,$2);
'''
]
]
staticField(it, COMPOSITE_TO_CASE, Map)
//staticField(it,QNAME_TO_CASE_MAP,BindingCodec)
implementsType(BINDING_CODEC)
- method(List, "toDomStatic", QName, Object) [
+ method(List, "toDomStatic", #[QName, Object]) [
modifiers = PUBLIC + FINAL + STATIC
bodyChecked = '''
{
throw new «UnsupportedOperationException.name»("Direct invocation not supported.");
'''
]
- method(Object, "fromDomStatic", QName, Map) [
+ method(Object, "fromDomStatic", #[QName, Map, InstanceIdentifier]) [
modifiers = PUBLIC + FINAL + STATIC
bodyChecked = '''
{
«BINDING_CODEC.name» _codec = («BINDING_CODEC.name») «COMPOSITE_TO_CASE».get($2);
if(_codec != null) {
- return _codec.deserialize(new «SimpleEntry.name»($1,$2));
+ return _codec.deserialize(new «SimpleEntry.name»($1,$2),$3);
}
return null;
}
'''
]
- method(Object, "deserialize", Object) [
+ method(Object, "deserialize", #[Object, InstanceIdentifier]) [
bodyChecked = '''
throw new «UnsupportedOperationException.name»("Direct invocation not supported.");
'''
return ret;
}
- private def String deserializeBody(GeneratedType type, SchemaNode node) {
- val ret = deserializeBodyImpl(type, node);
+ private def String deserializeBody(GeneratedType type, SchemaNode node, InstanceIdentifier<?> bindingId) {
+ val ret = deserializeBodyImpl(type, node, bindingId);
return ret;
}
}
}
- private def String deserializeBodyWithAugmentations(GeneratedType type, DataNodeContainer node) '''
+ private def String deserializeBodyWithAugmentations(GeneratedType type, DataNodeContainer node, InstanceIdentifier<?> bindingId) '''
{
«QName.name» _localQName = «QName.name».create($1,QNAME.getLocalName());
if($2 == null) {
java.util.Map _compositeNode = (java.util.Map) $2;
//System.out.println(_localQName + " " + _compositeNode);
«type.builderName» _builder = new «type.builderName»();
- «deserializeDataNodeContainerBody(type, node)»
- «deserializeAugmentations»
+ «deserializeDataNodeContainerBody(type, node, bindingId)»
+ «type.deserializeAugmentations»
return _builder.build();
}
'''
- private def dispatch String deserializeBodyImpl(GeneratedType type, SchemaNode node) '''
+ private def dispatch String deserializeBodyImpl(GeneratedType type, SchemaNode node, InstanceIdentifier<?> bindingId) '''
{
«QName.name» _localQName = «QName.name».create($1,QNAME.getLocalName());
-
+
if($2 == null) {
return null;
}
}
'''
- private def dispatch String deserializeBodyImpl(GeneratedType type, ListSchemaNode node) '''
+ private def dispatch String deserializeBodyImpl(GeneratedType type, ListSchemaNode node, InstanceIdentifier<?> bindingId) '''
{
«QName.name» _localQName = «QName.name».create($1,QNAME.getLocalName());
if($2 == null) {
//System.out.println(_localQName + " " + _compositeNode);
«type.builderName» _builder = new «type.builderName»();
«deserializeKey(type, node)»
- «deserializeDataNodeContainerBody(type, node)»
- «deserializeAugmentations»
+ «deserializeDataNodeContainerBody(type, node, bindingId)»
+ «type.deserializeAugmentations»
return _builder.build();
}
'''
- private def dispatch String deserializeBodyImpl(GeneratedType type, ContainerSchemaNode node) {
- return deserializeBodyWithAugmentations(type, node);
+ private def dispatch String deserializeBodyImpl(GeneratedType type, ContainerSchemaNode node, InstanceIdentifier<?> bindingId) {
+ return deserializeBodyWithAugmentations(type, node, bindingId);
}
- private def dispatch String deserializeBodyImpl(GeneratedType type, NotificationDefinition node) {
- return deserializeBodyWithAugmentations(type, node);
+ private def dispatch String deserializeBodyImpl(GeneratedType type, NotificationDefinition node, InstanceIdentifier<?> bindingId) {
+ return deserializeBodyWithAugmentations(type, node, bindingId);
}
- private def dispatch String deserializeBodyImpl(GeneratedType type, ChoiceCaseNode node) {
- return deserializeBodyWithAugmentations(type, node);
+ private def dispatch String deserializeBodyImpl(GeneratedType type, ChoiceCaseNode node, InstanceIdentifier<?> bindingId) {
+ return deserializeBodyWithAugmentations(type, node, bindingId);
}
- private def deserializeDataNodeContainerBody(GeneratedType type, DataNodeContainer node) {
- deserializeNodeContainerBodyImpl(type, type.allProperties, node);
+ private def deserializeDataNodeContainerBody(GeneratedType type, DataNodeContainer node, InstanceIdentifier<?> bindingId) {
+ deserializeNodeContainerBodyImpl(type, type.allProperties, node, bindingId);
}
private def deserializeNodeContainerBodyImpl(GeneratedType type, HashMap<String, Type> properties,
- DataNodeContainer node) {
+ DataNodeContainer node, InstanceIdentifier<?> bindingId) {
val ret = '''
boolean _is_empty = true;
«FOR child : node.childNodes»
return ret;
}
- def deserializeAugmentations() '''
- java.util.Map _augmentation = (java.util.Map) «AUGMENTATION_CODEC».deserialize(_compositeNode);
+ def deserializeAugmentations(GeneratedType type) '''
+ «InstanceIdentifier.resolvedName» iid = $3.builder().child(«type.resolvedName».class).build();
+ java.util.Map _augmentation = (java.util.Map) «AUGMENTATION_CODEC».deserialize(_compositeNode,$3);
if(_augmentation != null) {
«Iterator.name» _entries = _augmentation.entrySet().iterator();
while(_entries.hasNext()) {
Object _listItem = _iterator.next();
_is_empty = false;
////System.out.println(" item" + _listItem);
- Object _value = «type.actualTypeArguments.get(0).serializer(schema).resolvedName».fromDomStatic(_localQName,_listItem);
+ «val param = type.actualTypeArguments.get(0)»
+ «InstanceIdentifier.resolvedName» iid = $3.builder().child(«param.resolvedName».class).build();
+ Object _value = «type.actualTypeArguments.get(0).serializer(schema).resolvedName».fromDomStatic(_localQName,_listItem,iid);
////System.out.println(" value" + _value);
«propertyName».add(_value);
_hasNext = _iterator.hasNext();
}
}
-
+
////System.out.println(" list" + «propertyName»);
'''
if(_dom_«propertyName»_list != null && _dom_«propertyName»_list.size() > 0) {
_is_empty = false;
java.util.Map _dom_«propertyName» = (java.util.Map) _dom_«propertyName»_list.get(0);
- «propertyName» = «type.serializer(schema).resolvedName».fromDomStatic(_localQName,_dom_«propertyName»);
+ «InstanceIdentifier.resolvedName» iid = $3.builder().child(«type.resolvedName».class).build();
+ «propertyName» = «type.serializer(schema).resolvedName».fromDomStatic(_localQName,_dom_«propertyName»,iid);
}
'''
private def dispatch CharSequence deserializeProperty(ChoiceNode schema, Type type, String propertyName) '''
- «type.resolvedName» «propertyName» = «type.serializer(schema).resolvedName».fromDomStatic(_localQName,_compositeNode);
+ «type.resolvedName» «propertyName» = «type.serializer(schema).resolvedName».fromDomStatic(_localQName,_compositeNode,$3);
if(«propertyName» != null) {
_is_empty = false;
}
bodyChecked = '''
{
////System.out.println("«inputType.simpleName»#toDomValue: "+$1);
-
+
if($1 == null) {
return null;
}
bodyChecked = '''
{
////System.out.println("«inputType.simpleName»#fromDomValue: "+$1);
-
+
if($1 == null) {
return null;
}
bodyChecked = '''
{
////System.out.println("«inputType.simpleName»#toDomValue: "+$1);
-
+
if($1 == null) {
return null;
}
}
«ENDIF»
«ENDFOR»
-
+
return null;
}
'''
bodyChecked = '''
{
////System.out.println("«inputType.simpleName»#fromDomValue: "+$1);
-
+
if($1 == null) {
return null;
}
bodyChecked = '''
{
////System.out.println("«inputType.simpleName»#toDomValue: "+$1);
-
+
if($1 == null) {
return null;
}
«typeSpec.resolvedName» _encapsulatedValue = («typeSpec.resolvedName») $1;
«HashSet.resolvedName» _value = new «HashSet.resolvedName»();
//System.out.println("«inputType.simpleName»#toDomValue:Enc: "+_encapsulatedValue);
-
+
«FOR bit : typeDef.bits»
«val getter = bit.getterName()»
if(Boolean.TRUE.equals(_encapsulatedValue.«getter»())) {
«ENDFOR»
«Set.resolvedName» _domValue = «Collections.resolvedName».unmodifiableSet(_value);
//System.out.println("«inputType.simpleName»#toDomValue:DeEnc: "+_domValue);
-
+
return _domValue;
}
'''
bodyChecked = '''
{
//System.out.println("«inputType.simpleName»#fromDomValue: "+$1);
-
+
if($1 == null) {
return null;
}
«FOR bit : sortedBits»
Boolean «bit.propertyName» = Boolean.valueOf(_domValue.contains("«bit.name»"));
«ENDFOR»
-
+
return new «inputType.resolvedName»(«FOR bit : sortedBits SEPARATOR ","»«bit.propertyName»«ENDFOR»);
}
'''
return '''(«InstanceIdentifier.name») «INSTANCE_IDENTIFIER_CODEC».deserialize(«domParameter»)'''
} else if (CLASS_TYPE.equals(type)) {
return '''(«Class.name») «IDENTITYREF_CODEC».deserialize(«domParameter»)'''
+ } else if (typeDef!=null && typeDef instanceof EmptyTypeDefinition) {
+ if(domParameter == null) {
+ return ''' Boolean.FALSE '''
+ } else {
+ return ''' Boolean.TRUE '''
+ }
}
return '''(«type.resolvedName») «domParameter»'''
private def dispatch CharSequence serializeProperty(LeafSchemaNode schema, Type type, String propertyName) '''
«type.resolvedName» «propertyName» = value.«propertyName»();
-
+
if(«propertyName» != null) {
«QName.name» _qname = «QName.name».create(_resultName,"«schema.QName.localName»");
Object _propValue = «serializeValue(type, propertyName, schema.type)»;
private def dispatch serializeValue(Enumeration type, String parameter, TypeDefinition<?> typeDefinition) {
'''«type.valueSerializer(typeDefinition).resolvedName».toDomValue(«parameter»)'''
}
-
+
private def dispatch serializeValue(Type type, String parameter, EmptyTypeDefinition typeDefinition) {
'''(«parameter».booleanValue() ? "" : null)'''
}
-
+
private def dispatch serializeValue(Type signature, String property, TypeDefinition<?> typeDefinition) {
serializeValue(signature,property)
}
-
+
private def dispatch serializeValue(Type signature, String property, Void typeDefinition) {
serializeValue(signature,property)
}
-
+
private def dispatch serializeValue(Type signature, String property) {
if (INSTANCE_IDENTIFIER == signature) {
return '''«INSTANCE_IDENTIFIER_CODEC».serialize(«property»)'''
Code Review / yangtools.git / blobdiff