opendaylight/sal/yang-prototype/code-generator/binding-generator-impl/src/main/java/org/opendaylight/controller/sal/binding/yang/types/TypeProviderImpl.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.sal.binding.yang.types;
   9
  10 import static org.opendaylight.controller.yang.model.util.SchemaContextUtil.findDataSchemaNode;
  11 import static org.opendaylight.controller.yang.model.util.SchemaContextUtil.findDataSchemaNodeForRelativeXPath;
  12 import static org.opendaylight.controller.yang.model.util.SchemaContextUtil.resolveModuleFromSchemaPath;
  13
  14 import java.util.ArrayList;
  15 import java.util.HashMap;
  16 import java.util.List;
  17 import java.util.Map;
  18 import java.util.Set;
  19
  20 import org.opendaylight.controller.binding.generator.util.BindingGeneratorUtil;
  21 import org.opendaylight.controller.binding.generator.util.Types;
  22 import org.opendaylight.controller.binding.generator.util.generated.type.builder.EnumerationBuilderImpl;
  23 import org.opendaylight.controller.binding.generator.util.generated.type.builder.GeneratedTOBuilderImpl;
  24 import org.opendaylight.controller.sal.binding.generator.spi.TypeProvider;
  25 import org.opendaylight.controller.sal.binding.model.api.Enumeration;
  26 import org.opendaylight.controller.sal.binding.model.api.GeneratedTransferObject;
  27 import org.opendaylight.controller.sal.binding.model.api.Type;
  28 import org.opendaylight.controller.sal.binding.model.api.type.builder.EnumBuilder;
  29 import org.opendaylight.controller.sal.binding.model.api.type.builder.GeneratedPropertyBuilder;
  30 import org.opendaylight.controller.sal.binding.model.api.type.builder.GeneratedTOBuilder;
  31 import org.opendaylight.controller.sal.binding.model.api.type.builder.GeneratedTypeBuilder;
  32 import org.opendaylight.controller.yang.model.api.DataSchemaNode;
  33 import org.opendaylight.controller.yang.model.api.LeafListSchemaNode;
  34 import org.opendaylight.controller.yang.model.api.LeafSchemaNode;
  35 import org.opendaylight.controller.yang.model.api.Module;
  36 import org.opendaylight.controller.yang.model.api.RevisionAwareXPath;
  37 import org.opendaylight.controller.yang.model.api.SchemaContext;
  38 import org.opendaylight.controller.yang.model.api.TypeDefinition;
  39 import org.opendaylight.controller.yang.model.api.type.EnumTypeDefinition;
  40 import org.opendaylight.controller.yang.model.api.type.EnumTypeDefinition.EnumPair;
  41 import org.opendaylight.controller.yang.model.api.type.IdentityrefTypeDefinition;
  42 import org.opendaylight.controller.yang.model.api.type.LeafrefTypeDefinition;
  43 import org.opendaylight.controller.yang.model.api.type.UnionTypeDefinition;
  44 import org.opendaylight.controller.yang.model.util.ExtendedType;
  45
  46 public class TypeProviderImpl implements TypeProvider {
  47
  48     private final SchemaContext schemaContext;
  49     private Map<String, Map<String, GeneratedTransferObject>> genTypeDefsContextMap;
  50     private final List<GeneratedTransferObject> allTypeDefinitions;
  51
  52     public TypeProviderImpl(final SchemaContext schemaContext) {
  53         if (schemaContext == null) {
  54             throw new IllegalArgumentException("Schema Context cannot be null!");
  55         }
  56
  57         this.schemaContext = schemaContext;
  58         this.genTypeDefsContextMap = new HashMap<String, Map<String, GeneratedTransferObject>>();
  59         allTypeDefinitions = resolveTypeDefsFromContext();
  60     }
  61
  62     public List<GeneratedTransferObject> getGeneratedTypeDefs() {
  63         return allTypeDefinitions;
  64     }
  65
  66     /*
  67      * (non-Javadoc)
  68      *
  69      * @see org.opendaylight.controller.yang.model.type.provider.TypeProvider#
  70      * javaTypeForYangType(java.lang.String)
  71      */
  72     @Override
  73     public Type javaTypeForYangType(String type) {
  74         Type t = BaseYangTypes.BASE_YANG_TYPES_PROVIDER
  75                 .javaTypeForYangType(type);
  76         return t;
  77     }
  78
  79     @Override
  80     public Type javaTypeForSchemaDefinitionType(
  81             final TypeDefinition<?> typeDefinition) {
  82         Type returnType = null;
  83         if (typeDefinition != null) {
  84             final String typedefName = typeDefinition.getQName().getLocalName();
  85             if (typeDefinition instanceof ExtendedType) {
  86                 final TypeDefinition<?> baseTypeDef = baseTypeDefForExtendedType(typeDefinition);
  87
  88                 if (baseTypeDef instanceof LeafrefTypeDefinition) {
  89                     final LeafrefTypeDefinition leafref = (LeafrefTypeDefinition) baseTypeDef;
  90                     returnType = provideTypeForLeafref(leafref);
  91                 } else if (baseTypeDef instanceof IdentityrefTypeDefinition) {
  92
  93                 } else if (baseTypeDef instanceof EnumTypeDefinition) {
  94                     final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) baseTypeDef;
  95                     returnType = resolveEnumFromTypeDefinition(enumTypeDef,
  96                             typedefName);
  97                 } else {
  98                     final Module module = resolveModuleFromSchemaPath(schemaContext, typeDefinition
  99                                     .getPath());
 100
 101                     if (module != null) {
 102                         final Map<String, GeneratedTransferObject> genTOs = genTypeDefsContextMap
 103                                 .get(module.getName());
 104                         if (genTOs != null) {
 105                             returnType = genTOs.get(typedefName);
 106                         }
 107                     }
 108                 }
 109             } else {
 110                 if (typeDefinition instanceof LeafrefTypeDefinition) {
 111                     final LeafrefTypeDefinition leafref = (LeafrefTypeDefinition) typeDefinition;
 112                     returnType = provideTypeForLeafref(leafref);
 113                 } else if (typeDefinition instanceof EnumTypeDefinition) {
 114                     final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) typeDefinition;
 115                     returnType = resolveEnumFromTypeDefinition(enumTypeDef,
 116                             typedefName);
 117                 } else if (typeDefinition instanceof IdentityrefTypeDefinition) {
 118
 119                 } else {
 120                     returnType = BaseYangTypes.BASE_YANG_TYPES_PROVIDER
 121                             .javaTypeForSchemaDefinitionType(typeDefinition);
 122                 }
 123             }
 124         }
 125         return returnType;
 126     }
 127
 128     private TypeDefinition<?> baseTypeDefForExtendedType(
 129             final TypeDefinition<?> extendTypeDef) {
 130         if (extendTypeDef != null) {
 131             final TypeDefinition<?> baseTypeDef = extendTypeDef.getBaseType();
 132             if (baseTypeDef instanceof ExtendedType) {
 133                 return baseTypeDefForExtendedType(baseTypeDef);
 134             } else {
 135                 return baseTypeDef;
 136             }
 137         }
 138         return null;
 139     }
 140
 141     public Type baseTypeForExtendedType(final TypeDefinition<?> typeDefinition) {
 142         Type returnType = null;
 143         if (typeDefinition != null) {
 144             final TypeDefinition<?> baseTypeDefinition = baseTypeDefForExtendedType(typeDefinition);
 145
 146             if (baseTypeDefinition instanceof EnumTypeDefinition) {
 147                 final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) typeDefinition;
 148                 final String enumName = enumTypeDef.getQName().getLocalName();
 149                 return resolveEnumFromTypeDefinition(enumTypeDef, enumName);
 150             } else {
 151                 returnType = BaseYangTypes.BASE_YANG_TYPES_PROVIDER
 152                         .javaTypeForSchemaDefinitionType(typeDefinition);
 153             }
 154         }
 155         return returnType;
 156     }
 157
 158     public Type provideTypeForLeafref(final LeafrefTypeDefinition leafrefType) {
 159         Type returnType = null;
 160         if ((leafrefType != null) && (leafrefType.getPathStatement() != null)
 161                 && (leafrefType.getPath() != null)) {
 162
 163             final RevisionAwareXPath xpath = leafrefType.getPathStatement();
 164             final String strXPath = xpath.toString();
 165
 166             if (strXPath != null) {
 167                 if (strXPath.matches(".*//[.* | .*//].*")) {
 168                     returnType = Types.typeForClass(Object.class);
 169                 } else {
 170                     final Module module = resolveModuleFromSchemaPath(schemaContext, leafrefType.getPath());
 171                     if (module != null) {
 172                         final DataSchemaNode dataNode;
 173                         if (xpath.isAbsolute()) {
 174                             dataNode = findDataSchemaNode(schemaContext,
 175                                     module, xpath);
 176                         } else {
 177                             dataNode = findDataSchemaNodeForRelativeXPath(schemaContext, module,
 178                                             leafrefType, xpath);
 179                         }
 180                         returnType = resolveTypeFromDataSchemaNode(dataNode);
 181                     }
 182                 }
 183             }
 184         }
 185         return returnType;
 186     }
 187
 188     private EnumBuilder resolveEnumFromTypeDefinition(
 189             final EnumTypeDefinition enumTypeDef, final String enumName,
 190             final GeneratedTypeBuilder typeBuilder) {
 191         if ((enumTypeDef != null) && (typeBuilder != null)
 192                 && (enumTypeDef.getQName() != null)
 193                 && (enumTypeDef.getQName().getLocalName() != null)) {
 194
 195             final String enumerationName = BindingGeneratorUtil
 196                     .parseToClassName(enumName);
 197             final EnumBuilder enumBuilder = typeBuilder
 198                     .addEnumeration(enumerationName);
 199
 200             if (enumBuilder != null) {
 201                 final List<EnumPair> enums = enumTypeDef.getValues();
 202                 if (enums != null) {
 203                     int listIndex = 0;
 204                     for (final EnumPair enumPair : enums) {
 205                         if (enumPair != null) {
 206                             final String enumPairName = BindingGeneratorUtil
 207                                     .parseToClassName(enumPair.getName());
 208                             Integer enumPairValue = enumPair.getValue();
 209
 210                             if (enumPairValue == null) {
 211                                 enumPairValue = listIndex;
 212                             }
 213                             enumBuilder.addValue(enumPairName, enumPairValue);
 214                             listIndex++;
 215                         }
 216                     }
 217                 }
 218                 return enumBuilder;
 219             }
 220         }
 221         return null;
 222     }
 223
 224     private Enumeration resolveEnumFromTypeDefinition(
 225             final EnumTypeDefinition enumTypeDef, final String enumName) {
 226         if ((enumTypeDef != null) && (enumTypeDef.getQName() != null)
 227                 && (enumTypeDef.getQName().getLocalName() != null)) {
 228
 229             final String enumerationName = BindingGeneratorUtil
 230                     .parseToClassName(enumName);
 231
 232             Module module = resolveModuleFromSchemaPath(schemaContext, enumTypeDef.getPath());
 233             final String basePackageName = BindingGeneratorUtil
 234                     .moduleNamespaceToPackageName(module);
 235             final String packageName = BindingGeneratorUtil
 236                     .packageNameForGeneratedType(basePackageName,
 237                             enumTypeDef.getPath());
 238
 239             final EnumBuilder enumBuilder = new EnumerationBuilderImpl(
 240                     packageName, enumerationName);
 241
 242             if (enumBuilder != null) {
 243                 final List<EnumPair> enums = enumTypeDef.getValues();
 244                 if (enums != null) {
 245                     int listIndex = 0;
 246                     for (final EnumPair enumPair : enums) {
 247                         if (enumPair != null) {
 248                             final String enumPairName = BindingGeneratorUtil
 249                                     .parseToClassName(enumPair.getName());
 250                             Integer enumPairValue = enumPair.getValue();
 251
 252                             if (enumPairValue == null) {
 253                                 enumPairValue = listIndex;
 254                             }
 255                             enumBuilder.addValue(enumPairName, enumPairValue);
 256                             listIndex++;
 257                         }
 258                     }
 259                 }
 260                 return enumBuilder.toInstance(null);
 261             }
 262         }
 263         return null;
 264     }
 265
 266     private Type resolveTypeFromDataSchemaNode(final DataSchemaNode dataNode) {
 267         Type returnType = null;
 268         if (dataNode != null) {
 269             if (dataNode instanceof LeafSchemaNode) {
 270                 final LeafSchemaNode leaf = (LeafSchemaNode) dataNode;
 271                 returnType = javaTypeForSchemaDefinitionType(leaf.getType());
 272             } else if (dataNode instanceof LeafListSchemaNode) {
 273                 final LeafListSchemaNode leafList = (LeafListSchemaNode) dataNode;
 274                 returnType = javaTypeForSchemaDefinitionType(leafList.getType());
 275             }
 276         }
 277         return returnType;
 278     }
 279
 280     private List<GeneratedTransferObject> resolveTypeDefsFromContext() {
 281         final List<GeneratedTransferObject> genTypeDefs = new ArrayList<GeneratedTransferObject>();
 282         final Set<Module> modules = schemaContext.getModules();
 283         if (modules != null) {
 284             for (final Module module : modules) {
 285                 if (module != null) {
 286                     final String moduleName = module.getName();
 287                     final String basePackageName = BindingGeneratorUtil
 288                             .moduleNamespaceToPackageName(module);
 289
 290                     final Set<TypeDefinition<?>> typeDefinitions = module
 291                             .getTypeDefinitions();
 292
 293                     if ((typeDefinitions != null) && (basePackageName != null)) {
 294                         for (final TypeDefinition<?> typedef : typeDefinitions) {
 295                             final GeneratedTransferObject genTransObj = toGeneratedTransferObject(
 296                                     basePackageName, moduleName, typedef);
 297                             if (genTransObj != null) {
 298                                 genTypeDefs.add(genTransObj);
 299                             }
 300                         }
 301                         // for (final TypeDefinition<?> typedef :
 302                         // typeDefinitions) {
 303                         // addUnionGeneratedTypeDefinition(basePackageName,
 304                         // module.getName(), typedef);
 305                         // }
 306                     }
 307                 }
 308             }
 309         }
 310         return genTypeDefs;
 311     }
 312
 313     private GeneratedTransferObject toGeneratedTransferObject(
 314             final String basePackageName, final String moduleName,
 315             final TypeDefinition<?> typedef) {
 316         if ((basePackageName != null) && (moduleName != null)
 317                 && (typedef != null) && (typedef.getQName() != null)) {
 318             final GeneratedTOBuilder genTOBuilder = typedefToTransferObject(
 319                     basePackageName, typedef);
 320
 321             final String typedefName = typedef.getQName().getLocalName();
 322             final String propertyName = BindingGeneratorUtil
 323                     .parseToValidParamName(typedefName);
 324
 325             final TypeDefinition<?> baseTypeDefinition = baseTypeDefForExtendedType(typedef);
 326             if (!(baseTypeDefinition instanceof LeafrefTypeDefinition)
 327                     && !(baseTypeDefinition instanceof IdentityrefTypeDefinition)) {
 328                 Type returnType = null;
 329                 if (baseTypeDefinition instanceof EnumTypeDefinition) {
 330                     final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) baseTypeDefinition;
 331                     returnType = resolveEnumFromTypeDefinition(enumTypeDef,
 332                             typedefName);
 333                 } else {
 334                     returnType = BaseYangTypes.BASE_YANG_TYPES_PROVIDER
 335                             .javaTypeForSchemaDefinitionType(baseTypeDefinition);
 336                 }
 337
 338                 if (returnType != null) {
 339                     final GeneratedPropertyBuilder genPropBuilder = genTOBuilder
 340                             .addProperty(propertyName);
 341
 342                     genPropBuilder.addReturnType(returnType);
 343                     genTOBuilder.addEqualsIdentity(genPropBuilder);
 344                     genTOBuilder.addHashIdentity(genPropBuilder);
 345                     genTOBuilder.addToStringProperty(genPropBuilder);
 346
 347                     Map<String, GeneratedTransferObject> transferObjectsMap = genTypeDefsContextMap
 348                             .get(moduleName);
 349                     if (transferObjectsMap == null) {
 350                         transferObjectsMap = new HashMap<String, GeneratedTransferObject>();
 351                         genTypeDefsContextMap.put(moduleName,
 352                                 transferObjectsMap);
 353                     }
 354
 355                     final GeneratedTransferObject transferObject = genTOBuilder
 356                             .toInstance();
 357                     if (transferObject != null) {
 358                         transferObjectsMap.put(typedefName, transferObject);
 359                         return transferObject;
 360                     }
 361                 }
 362             }
 363         }
 364         return null;
 365     }
 366
 367     private void addUnionGeneratedTypeDefinition(final String basePackageName,
 368             final String moduleName, final TypeDefinition<?> typedef) {
 369         if ((basePackageName != null) && (moduleName != null)
 370                 && (typedef != null) && (typedef.getQName() != null)) {
 371             final TypeDefinition<?> baseTypeDefinition = baseTypeDefForExtendedType(typedef);
 372
 373             if ((baseTypeDefinition != null)
 374                     && (baseTypeDefinition instanceof UnionTypeDefinition)) {
 375                 final UnionTypeDefinition unionTypeDef = (UnionTypeDefinition) baseTypeDefinition;
 376
 377                 final List<TypeDefinition<?>> unionTypes = unionTypeDef
 378                         .getTypes();
 379                 final Map<String, GeneratedTransferObject> genTOsMap = genTypeDefsContextMap
 380                         .get(moduleName);
 381                 final GeneratedTOBuilder unionGenTransObject = typedefToTransferObject(
 382                         basePackageName, typedef);
 383                 if ((unionTypes != null) && (genTOsMap != null)
 384                         && (unionGenTransObject != null)) {
 385                     for (final TypeDefinition<?> unionType : unionTypes) {
 386                         final String typeName = unionType.getQName()
 387                                 .getLocalName();
 388                         final GeneratedTransferObject genTransferObject = genTOsMap
 389                                 .get(typeName);
 390
 391                         if (genTransferObject != null) {
 392                             unionGenTransObject
 393                                     .addProperty(
 394                                             BindingGeneratorUtil
 395                                                     .parseToValidParamName(genTransferObject
 396                                                             .getName()))
 397                                     .addReturnType(genTransferObject);
 398                         }
 399                     }
 400                     genTOsMap.put(unionTypeDef.getQName().getLocalName(),
 401                             unionGenTransObject.toInstance());
 402                 }
 403             }
 404         }
 405     }
 406
 407     private GeneratedTOBuilder typedefToTransferObject(
 408             final String basePackageName, final TypeDefinition<?> typedef) {
 409
 410         final String packageName = BindingGeneratorUtil
 411                 .packageNameForGeneratedType(basePackageName, typedef.getPath());
 412         final String typeDefTOName = typedef.getQName().getLocalName();
 413
 414         if ((packageName != null) && (typedef != null)
 415                 && (typeDefTOName != null)) {
 416             final String genTOName = BindingGeneratorUtil
 417                     .parseToClassName(typeDefTOName);
 418             final GeneratedTOBuilder newType = new GeneratedTOBuilderImpl(
 419                     packageName, genTOName);
 420
 421             return newType;
 422         }
 423         return null;
 424     }
 425 }