Remove yang-test
[controller.git] / opendaylight / config / yang-jmx-generator / src / main / java / org / opendaylight / controller / config / yangjmxgenerator / attribute / JavaAttribute.java
1 /*
2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
3  *
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
7  */
8 package org.opendaylight.controller.config.yangjmxgenerator.attribute;
9
10 import com.google.common.base.Preconditions;
11 import java.util.Arrays;
12 import java.util.List;
13 import java.util.Optional;
14 import javax.management.openmbean.ArrayType;
15 import javax.management.openmbean.CompositeType;
16 import javax.management.openmbean.OpenDataException;
17 import javax.management.openmbean.OpenType;
18 import javax.management.openmbean.SimpleType;
19 import org.opendaylight.controller.config.api.IdentityAttributeRef;
20 import org.opendaylight.controller.config.yangjmxgenerator.TypeProviderWrapper;
21 import org.opendaylight.mdsal.binding.model.api.Type;
22 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
23 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
24 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
25 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
26 import org.opendaylight.yangtools.yang.model.api.type.IdentityrefTypeDefinition;
27 import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
28 import org.opendaylight.yangtools.yang.model.util.type.CompatUtils;
29
30 public class JavaAttribute extends AbstractAttribute implements TypedAttribute {
31
32     public static final String DESCRIPTION_OF_VALUE_ATTRIBUTE_FOR_UNION = "valueOfArtificialUnionProperty";
33
34     private final Type type;
35     private final String nullableDescription, nullableDefault, nullableDefaultWrappedForCode;
36     private final TypeProviderWrapper typeProviderWrapper;
37     private final TypeDefinition<?> typeDefinition;
38
39     public JavaAttribute(final LeafSchemaNode leaf,
40             final TypeProviderWrapper typeProviderWrapper) {
41         super(leaf);
42         this.type = typeProviderWrapper.getType(leaf);
43
44         this.typeDefinition = CompatUtils.compatLeafType(leaf);
45         this.typeProviderWrapper = typeProviderWrapper;
46
47         final Optional<? extends Object> typeDefault = leaf.getType().getDefaultValue();
48         if (typeDefault.isPresent()) {
49             nullableDefault = (String) typeDefault.get();
50             nullableDefaultWrappedForCode = typeProviderWrapper.getDefault(leaf);
51         } else {
52             nullableDefault = null;
53             nullableDefaultWrappedForCode = null;
54         }
55
56         this.nullableDescription = leaf.getDescription().orElse(null);
57     }
58
59     public JavaAttribute(final LeafListSchemaNode leaf,
60             final TypeProviderWrapper typeProviderWrapper) {
61         super(leaf);
62         this.type = typeProviderWrapper.getType(leaf);
63         this.typeDefinition = leaf.getType();
64         this.typeProviderWrapper = typeProviderWrapper;
65         this.nullableDefault = this.nullableDefaultWrappedForCode = null;
66         this.nullableDescription = leaf.getDescription().orElse(null);
67     }
68
69     public boolean isUnion() {
70         final TypeDefinition<?> base = getBaseType(this.typeProviderWrapper, this.typeDefinition);
71         return base instanceof UnionTypeDefinition;
72     }
73
74     public boolean isEnum() {
75         final TypeDefinition<?> base = getBaseType(this.typeProviderWrapper, this.typeDefinition);
76         return base instanceof EnumTypeDefinition;
77     }
78
79     public TypeDefinition<?> getTypeDefinition() {
80         return this.typeDefinition;
81     }
82
83     /**
84      * Returns the most base type
85      */
86     private TypeDefinition<?> getBaseType(final TypeProviderWrapper typeProviderWrapper, TypeDefinition<?> baseType) {
87         while(baseType.getBaseType()!=null) {
88             baseType = baseType.getBaseType();
89         }
90         return baseType;
91     }
92
93     public String getNullableDefaultWrappedForCode() {
94         return this.nullableDefaultWrappedForCode;
95     }
96
97     @Override
98     public Type getType() {
99         return this.type;
100     }
101
102     @Override
103     public String getNullableDescription() {
104         return this.nullableDescription;
105     }
106
107     @Override
108     public String getNullableDefault() {
109         return this.nullableDefault;
110     }
111
112     @Override
113     public boolean equals(final Object o) {
114         if (this == o) {
115             return true;
116         }
117         if (o == null || getClass() != o.getClass()) {
118             return false;
119         }
120         if (!super.equals(o)) {
121             return false;
122         }
123
124         final JavaAttribute that = (JavaAttribute) o;
125
126         if (this.nullableDefault != null ? !this.nullableDefault
127                 .equals(that.nullableDefault) : that.nullableDefault != null) {
128             return false;
129         }
130         if (this.nullableDescription != null ? !this.nullableDescription
131                 .equals(that.nullableDescription)
132                 : that.nullableDescription != null) {
133             return false;
134         }
135         if (this.type != null ? !this.type.equals(that.type) : that.type != null) {
136             return false;
137         }
138
139         return true;
140     }
141
142     @Override
143     public int hashCode() {
144         int result = super.hashCode();
145         result = 31 * result + (this.type != null ? this.type.hashCode() : 0);
146         result = 31
147                 * result
148                 + (this.nullableDescription != null ? this.nullableDescription.hashCode()
149                         : 0);
150         result = 31 * result
151                 + (this.nullableDefault != null ? this.nullableDefault.hashCode() : 0);
152         return result;
153     }
154
155     @Override
156     public String toString() {
157         return "JavaAttribute{" + getAttributeYangName() + "," + "type=" + this.type
158                 + '}';
159     }
160
161     @Override
162     public OpenType<?> getOpenType() {
163         final TypeDefinition<?> baseTypeDefinition = getBaseType(this.typeProviderWrapper, this.typeDefinition);
164         final Type baseType = this.typeProviderWrapper.getType(baseTypeDefinition, baseTypeDefinition);
165
166         if (isArray()) {
167             return getArrayType();
168         } else if (isEnum()) {
169             return getEnumType(baseTypeDefinition);
170         } else if (isUnion()) {
171             return getCompositeTypeForUnion(baseTypeDefinition);
172         } else if (isDerivedType(baseType, getType())) {
173             return getCompositeType(baseType, baseTypeDefinition);
174         } else if (isIdentityRef()) {
175             return getCompositeTypeForIdentity();
176         }
177
178         return getSimpleType(getType());
179     }
180
181     private OpenType<?> getEnumType(final TypeDefinition<?> baseType) {
182         final String fullyQualifiedName = this.typeProviderWrapper.getType(this.node, getTypeDefinition()).getFullyQualifiedName();
183         final String[] items = {"instance"};
184         final String description = getNullableDescription() == null ? getAttributeYangName() : getNullableDescription();
185
186         try {
187             return new CompositeType(fullyQualifiedName, description, items, items, new OpenType[]{SimpleType.STRING});
188         } catch (final OpenDataException e) {
189             throw new RuntimeException("Unable to create enum type" + fullyQualifiedName + " as open type", e);
190         }
191     }
192
193     public boolean isIdentityRef() {
194         return this.typeDefinition instanceof IdentityrefTypeDefinition;
195     }
196
197     private OpenType<?> getCompositeTypeForUnion(final TypeDefinition<?> baseTypeDefinition) {
198         Preconditions.checkArgument(baseTypeDefinition instanceof UnionTypeDefinition,
199                 "Expected %s instance but was %s", UnionTypeDefinition.class, baseTypeDefinition);
200
201         final List<TypeDefinition<?>> types = ((UnionTypeDefinition) baseTypeDefinition).getTypes();
202
203         final String[] itemNames = new String[types.size()+1];
204         final OpenType<?>[] itemTypes = new OpenType[itemNames.length];
205
206         addArtificialPropertyToUnionCompositeType(baseTypeDefinition, itemNames, itemTypes);
207
208         final String description = getNullableDescription() == null ? getAttributeYangName() : getNullableDescription();
209
210         int i = 1;
211         for (final TypeDefinition<?> innerTypeDefinition : types) {
212
213             final Type innerType = this.typeProviderWrapper.getType(innerTypeDefinition, innerTypeDefinition);
214
215             final TypeDefinition<?> baseInnerTypeDefinition = getBaseType(this.typeProviderWrapper, innerTypeDefinition);
216             final Type innerTypeBaseType = this.typeProviderWrapper.getType(baseInnerTypeDefinition, baseInnerTypeDefinition);
217
218             OpenType<?> innerCompositeType;
219
220             if(isDerivedType(innerTypeBaseType, innerType)) {
221                 innerCompositeType = baseInnerTypeDefinition instanceof UnionTypeDefinition ?
222                         getCompositeTypeForUnion(baseInnerTypeDefinition) :
223                         getCompositeType(innerTypeBaseType, baseInnerTypeDefinition);
224             } else {
225                 innerCompositeType = SimpleTypeResolver.getSimpleType(innerType);
226             }
227
228             itemNames[i] = this.typeProviderWrapper.getJMXParamForUnionInnerType(innerTypeDefinition);
229             itemTypes[i++] = innerCompositeType;
230         }
231
232         final String[] descriptions = itemNames.clone();
233         descriptions[0] = DESCRIPTION_OF_VALUE_ATTRIBUTE_FOR_UNION;
234
235         try {
236             return new CompositeType(getUpperCaseCammelCase(), description, itemNames, descriptions, itemTypes);
237         } catch (final OpenDataException e) {
238             throw new RuntimeException("Unable to create " + CompositeType.class + " with inner elements "
239                     + Arrays.toString(itemTypes), e);
240         }
241     }
242
243     public static final Class<Character> TYPE_OF_ARTIFICIAL_UNION_PROPERTY = char.class;
244
245     private void addArtificialPropertyToUnionCompositeType(final TypeDefinition<?> baseTypeDefinition, final String[] itemNames, final OpenType<?>[] itemTypes) {
246         final String artificialPropertyName = this.typeProviderWrapper.getJMXParamForBaseType(baseTypeDefinition);
247         itemNames[0] = artificialPropertyName;
248
249         final OpenType<?> artificialPropertyType = getArrayOpenTypeForSimpleType(TYPE_OF_ARTIFICIAL_UNION_PROPERTY.getName(),
250                 SimpleTypeResolver.getSimpleType(TYPE_OF_ARTIFICIAL_UNION_PROPERTY.getName()));
251         itemTypes[0] = artificialPropertyType;
252     }
253
254     private OpenType<?> getSimpleType(final Type type) {
255         final SimpleType<?> simpleType = SimpleTypeResolver.getSimpleType(type);
256         return simpleType;
257     }
258
259     private OpenType<?> getCompositeType(final Type baseType, final TypeDefinition<?> baseTypeDefinition) {
260
261         final SimpleType<?> innerItemType = SimpleTypeResolver.getSimpleType(baseType);
262         final String innerItemName = this.typeProviderWrapper.getJMXParamForBaseType(baseTypeDefinition);
263
264         final String[] itemNames = new String[]{innerItemName};
265         final String description = getNullableDescription() == null ? getAttributeYangName() : getNullableDescription();
266
267         final OpenType<?>[] itemTypes = new OpenType[]{innerItemType};
268         try {
269             return new CompositeType(getUpperCaseCammelCase(), description, itemNames, itemNames, itemTypes);
270         } catch (final OpenDataException e) {
271             throw new RuntimeException("Unable to create " + CompositeType.class + " with inner element of type "
272                     + itemTypes, e);
273         }
274     }
275
276     public OpenType<?> getCompositeTypeForIdentity() {
277         final String[] itemNames = new String[]{IdentityAttributeRef.QNAME_ATTR_NAME};
278         final String description = getNullableDescription() == null ? getAttributeYangName() : getNullableDescription();
279         final OpenType<?>[] itemTypes = new OpenType[]{SimpleType.STRING};
280
281         try {
282             return new CompositeType(getUpperCaseCammelCase(), description, itemNames, itemNames, itemTypes);
283         } catch (final OpenDataException e) {
284             throw new RuntimeException("Unable to create " + CompositeType.class + " with inner element of type "
285                     + itemTypes, e);
286         }
287     }
288
289     private OpenType<?> getArrayType() {
290         final String innerTypeFullyQName = getInnerType(getType());
291         final SimpleType<?> innerSimpleType = SimpleTypeResolver.getSimpleType(innerTypeFullyQName);
292         return getArrayOpenTypeForSimpleType(innerTypeFullyQName, innerSimpleType);
293     }
294
295     private OpenType<?> getArrayOpenTypeForSimpleType(final String innerTypeFullyQName, final SimpleType<?> innerSimpleType) {
296         try {
297             final ArrayType<Object> arrayType = isPrimitive(innerTypeFullyQName) ? new ArrayType<>(innerSimpleType, true)
298                     : new ArrayType<>(1, innerSimpleType);
299             return arrayType;
300         } catch (final OpenDataException e) {
301             throw new RuntimeException("Unable to create " + ArrayType.class + " with inner element of type "
302                     + innerSimpleType, e);
303         }
304     }
305
306     // TODO verify
307     private boolean isPrimitive(final String innerTypeFullyQName) {
308         if (innerTypeFullyQName.contains(".")) {
309             return false;
310         }
311
312         return true;
313     }
314
315     private boolean isArray() {
316         return this.type.getName().endsWith("[]");
317     }
318
319     private boolean isDerivedType(final Type baseType, final Type currentType) {
320         return baseType.equals(currentType) == false;
321     }
322
323     private static String getInnerType(final Type type) {
324         final String fullyQualifiedName = type.getFullyQualifiedName();
325         return fullyQualifiedName.substring(0, fullyQualifiedName.length() - 2);
326     }
327
328 }

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.