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

©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.