opendaylight/sal/yang-prototype/code-generator/binding-java-api-generator/src/main/java/org/opendaylight/controller/sal/java/api/generator/GeneratorUtil.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.java.api.generator;
   9
  10 import static org.opendaylight.controller.sal.java.api.generator.Constants.*;
  11
  12 import java.util.ArrayList;
  13 import java.util.HashMap;
  14 import java.util.LinkedHashMap;
  15 import java.util.List;
  16 import java.util.Map;
  17
  18 import org.opendaylight.controller.sal.binding.model.api.AnnotationType;
  19 import org.opendaylight.controller.sal.binding.model.api.Constant;
  20 import org.opendaylight.controller.sal.binding.model.api.Enumeration;
  21 import org.opendaylight.controller.sal.binding.model.api.Enumeration.Pair;
  22 import org.opendaylight.controller.sal.binding.model.api.GeneratedProperty;
  23 import org.opendaylight.controller.sal.binding.model.api.GeneratedTransferObject;
  24 import org.opendaylight.controller.sal.binding.model.api.GeneratedType;
  25 import org.opendaylight.controller.sal.binding.model.api.MethodSignature;
  26 import org.opendaylight.controller.sal.binding.model.api.MethodSignature.Parameter;
  27 import org.opendaylight.controller.sal.binding.model.api.ParameterizedType;
  28 import org.opendaylight.controller.sal.binding.model.api.Type;
  29
  30 public class GeneratorUtil {
  31
  32     private GeneratorUtil() {
  33     }
  34
  35     public static String createIfcDeclaration(final GeneratedType genType,
  36             final String indent,
  37             final Map<String, LinkedHashMap<String, Integer>> availableImports) {
  38         return createFileDeclaration(IFC, genType, indent, availableImports);
  39     }
  40
  41     public static String createClassDeclaration(
  42             final GeneratedTransferObject genTransferObject,
  43             final String indent,
  44             final Map<String, LinkedHashMap<String, Integer>> availableImports) {
  45         return createFileDeclaration(CLASS, genTransferObject, indent,
  46                 availableImports);
  47     }
  48
  49     public static String createPackageDeclaration(final String packageName) {
  50         return PKG + GAP + packageName + SC;
  51     }
  52
  53     private static String createFileDeclaration(final String type,
  54             final GeneratedType genType, final String indent,
  55             final Map<String, LinkedHashMap<String, Integer>> availableImports) {
  56         final StringBuilder builder = new StringBuilder();
  57         final String currentPkg = genType.getPackageName();
  58
  59         createComment(builder, genType.getComment(), indent);
  60
  61         if (!genType.getAnnotations().isEmpty()) {
  62             final List<AnnotationType> annotations = genType.getAnnotations();
  63             appendAnnotations(builder, annotations);
  64             builder.append(NL);
  65         }
  66         builder.append(PUBLIC + GAP + type + GAP + genType.getName() + GAP);
  67
  68         if (genType instanceof GeneratedTransferObject) {
  69             GeneratedTransferObject genTO = (GeneratedTransferObject) genType;
  70
  71             if (genTO.getExtends() != null) {
  72                 builder.append(EXTENDS + GAP);
  73                 builder.append(genTO.getExtends() + GAP);
  74             }
  75         }
  76
  77         final List<Type> genImplements = genType.getImplements();
  78         if (!genImplements.isEmpty()) {
  79             if (genType instanceof GeneratedTransferObject) {
  80                 builder.append(IMPLEMENTS + GAP);
  81             } else {
  82                 builder.append(EXTENDS + GAP);
  83             }
  84             builder.append(getExplicitType(genImplements.get(0),
  85                     availableImports, currentPkg));
  86
  87             for (int i = 1; i < genImplements.size(); ++i) {
  88                 builder.append(", ");
  89                 builder.append(getExplicitType(genImplements.get(i),
  90                         availableImports, currentPkg));
  91             }
  92         }
  93
  94         builder.append(GAP + LCB);
  95         return builder.toString();
  96     }
  97
  98     private static StringBuilder appendAnnotations(final StringBuilder builder,
  99             final List<AnnotationType> annotations) {
 100         if ((builder != null) && (annotations != null)) {
 101             for (final AnnotationType annotation : annotations) {
 102                 builder.append("@");
 103                 builder.append(annotation.getPackageName());
 104                 builder.append(".");
 105                 builder.append(annotation.getName());
 106
 107                 if (annotation.containsParameters()) {
 108                     builder.append("(");
 109                     final List<AnnotationType.Parameter> parameters = annotation
 110                             .getParameters();
 111                     appendAnnotationParams(builder, parameters);
 112                     builder.append(")");
 113                 }
 114             }
 115         }
 116         return builder;
 117     }
 118
 119     private static StringBuilder appendAnnotationParams(
 120             final StringBuilder builder,
 121             final List<AnnotationType.Parameter> parameters) {
 122         if (parameters != null) {
 123             int i = 0;
 124             for (final AnnotationType.Parameter param : parameters) {
 125                 if (param == null) {
 126                     continue;
 127                 }
 128                 if (i > 0) {
 129                     builder.append(", ");
 130                 }
 131                 final String paramName = param.getName();
 132                 if (param.getValue() != null) {
 133                     builder.append(paramName);
 134                     builder.append(" = ");
 135                     builder.append(param.getValue());
 136                 } else {
 137                     builder.append(paramName);
 138                     builder.append(" = {");
 139                     final List<String> values = param.getValues();
 140                     builder.append(values.get(0));
 141                     for (int j = 1; j < values.size(); ++j) {
 142                         builder.append(", ");
 143                         builder.append(values.get(j));
 144                     }
 145                     builder.append("}");
 146                 }
 147                 i++;
 148             }
 149         }
 150         return builder;
 151     }
 152
 153     public static String createConstant(final Constant constant,
 154             final String indent,
 155             final Map<String, LinkedHashMap<String, Integer>> availableImports,
 156             final String currentPkg) {
 157         final StringBuilder builder = new StringBuilder();
 158         builder.append(indent + PUBLIC + GAP + STATIC + GAP + FINAL + GAP);
 159         builder.append(getExplicitType(constant.getType(), availableImports,
 160                 currentPkg) + GAP + constant.getName());
 161         builder.append(GAP + "=" + GAP);
 162         builder.append(constant.getValue() + SC);
 163         return builder.toString();
 164     }
 165
 166     public static String createField(final GeneratedProperty property,
 167             final String indent,
 168             Map<String, LinkedHashMap<String, Integer>> availableImports,
 169             final String currentPkg) {
 170         final StringBuilder builder = new StringBuilder();
 171         builder.append(indent);
 172         if (!property.getAnnotations().isEmpty()) {
 173             final List<AnnotationType> annotations = property.getAnnotations();
 174             appendAnnotations(builder, annotations);
 175             builder.append(NL);
 176         }
 177         builder.append(indent + PRIVATE + GAP);
 178         builder.append(getExplicitType(property.getReturnType(),
 179                 availableImports, currentPkg) + GAP + property.getName());
 180         builder.append(SC);
 181         return builder.toString();
 182     }
 183
 184     /**
 185      * Create method declaration in interface.
 186      *
 187      * @param method
 188      * @param indent
 189      * @return
 190      */
 191     public static String createMethodDeclaration(final MethodSignature method,
 192             final String indent,
 193             Map<String, LinkedHashMap<String, Integer>> availableImports,
 194             final String currentPkg) {
 195         final StringBuilder builder = new StringBuilder();
 196
 197         if (method == null) {
 198             throw new IllegalArgumentException(
 199                     "Method Signature parameter MUST be specified and cannot be NULL!");
 200         }
 201
 202         final String comment = method.getComment();
 203         final String name = method.getName();
 204         if (name == null) {
 205             throw new IllegalStateException("Method Name cannot be NULL!");
 206         }
 207
 208         final Type type = method.getReturnType();
 209         if (type == null) {
 210             throw new IllegalStateException(
 211                     "Method Return type cannot be NULL!");
 212         }
 213
 214         final List<Parameter> parameters = method.getParameters();
 215
 216         createComment(builder, comment, indent);
 217         builder.append(NL);
 218         builder.append(indent);
 219
 220         if (!method.getAnnotations().isEmpty()) {
 221             final List<AnnotationType> annotations = method.getAnnotations();
 222             appendAnnotations(builder, annotations);
 223             builder.append(NL);
 224         }
 225
 226         builder.append(indent
 227                 + getExplicitType(type, availableImports, currentPkg) + GAP
 228                 + name);
 229         builder.append(LB);
 230         for (int i = 0; i < parameters.size(); i++) {
 231             Parameter p = parameters.get(i);
 232             String separator = COMMA;
 233             if (i + 1 == parameters.size()) {
 234                 separator = "";
 235             }
 236             builder.append(getExplicitType(p.getType(), availableImports,
 237                     currentPkg) + GAP + p.getName() + separator);
 238         }
 239         builder.append(RB);
 240         builder.append(SC);
 241
 242         return builder.toString();
 243     }
 244
 245     public static String createConstructor(
 246             GeneratedTransferObject genTransferObject, final String indent,
 247             Map<String, LinkedHashMap<String, Integer>> availableImports) {
 248         final StringBuilder builder = new StringBuilder();
 249
 250         final String currentPkg = genTransferObject.getPackageName();
 251         final List<GeneratedProperty> properties = genTransferObject
 252                 .getProperties();
 253         final List<GeneratedProperty> ctorParams = new ArrayList<GeneratedProperty>();
 254         for (final GeneratedProperty property : properties) {
 255             if (property.isReadOnly()) {
 256                 ctorParams.add(property);
 257             }
 258         }
 259
 260         builder.append(indent);
 261         builder.append(PUBLIC);
 262         builder.append(GAP);
 263         builder.append(genTransferObject.getName());
 264         builder.append(LB);
 265
 266         if (!ctorParams.isEmpty()) {
 267             builder.append(getExplicitType(ctorParams.get(0).getReturnType(),
 268                     availableImports, currentPkg));
 269             builder.append(" ");
 270             builder.append(ctorParams.get(0).getName());
 271             for (int i = 1; i < ctorParams.size(); ++i) {
 272                 final GeneratedProperty param = ctorParams.get(i);
 273                 builder.append(", ");
 274                 builder.append(getExplicitType(param.getReturnType(),
 275                         availableImports, currentPkg));
 276                 builder.append(GAP);
 277                 builder.append(param.getName());
 278             }
 279         }
 280         builder.append(RB + GAP + LCB + NL + indent + TAB + "super();" + NL);
 281         if (!ctorParams.isEmpty()) {
 282             for (final GeneratedProperty property : ctorParams) {
 283                 builder.append(indent);
 284                 builder.append(TAB);
 285                 builder.append("this.");
 286                 builder.append(property.getName());
 287                 builder.append(" = ");
 288                 builder.append(property.getName());
 289                 builder.append(SC);
 290                 builder.append(NL);
 291             }
 292         }
 293         builder.append(indent);
 294         builder.append(RCB);
 295         return builder.toString();
 296     }
 297
 298     public static String createGetter(final GeneratedProperty property,
 299             final String indent,
 300             Map<String, LinkedHashMap<String, Integer>> availableImports,
 301             final String currentPkg) {
 302         final StringBuilder builder = new StringBuilder();
 303
 304         final Type type = property.getReturnType();
 305         final String varName = property.getName();
 306         final char first = Character.toUpperCase(varName.charAt(0));
 307         final String methodName = "get" + first + varName.substring(1);
 308
 309         builder.append(indent + PUBLIC + GAP
 310                 + getExplicitType(type, availableImports, currentPkg) + GAP
 311                 + methodName);
 312         builder.append(LB + RB + LCB + NL);
 313
 314         String currentIndent = indent + TAB;
 315
 316         builder.append(currentIndent + "return " + varName + SC + NL);
 317
 318         builder.append(indent + RCB);
 319         return builder.toString();
 320     }
 321
 322     public static String createSetter(final GeneratedProperty property,
 323             final String indent,
 324             Map<String, LinkedHashMap<String, Integer>> availableImports,
 325             String currentPkg) {
 326         final StringBuilder builder = new StringBuilder();
 327
 328         final Type type = property.getReturnType();
 329         final String varName = property.getName();
 330         final char first = Character.toUpperCase(varName.charAt(0));
 331         final String methodName = "set" + first + varName.substring(1);
 332
 333         builder.append(indent + PUBLIC + GAP + "void" + GAP + methodName);
 334         builder.append(LB + getExplicitType(type, availableImports, currentPkg)
 335                 + GAP + varName + RB + LCB + NL);
 336         String currentIndent = indent + TAB;
 337         builder.append(currentIndent + "this." + varName + " = " + varName + SC
 338                 + NL);
 339         builder.append(indent + RCB);
 340         return builder.toString();
 341     }
 342
 343     public static String createHashCode(
 344             final List<GeneratedProperty> properties, final String indent) {
 345         StringBuilder builder = new StringBuilder();
 346         builder.append(indent + "public int hashCode() {" + NL);
 347         builder.append(indent + TAB + "final int prime = 31;" + NL);
 348         builder.append(indent + TAB + "int result = 1;" + NL);
 349
 350         for (GeneratedProperty property : properties) {
 351             String fieldName = property.getName();
 352             builder.append(indent + TAB + "result = prime * result + (("
 353                     + fieldName + " == null) ? 0 : " + fieldName
 354                     + ".hashCode());" + NL);
 355         }
 356
 357         builder.append(indent + TAB + "return result;" + NL);
 358         builder.append(indent + RCB + NL);
 359         return builder.toString();
 360     }
 361
 362     public static String createEquals(final GeneratedTransferObject type,
 363             final List<GeneratedProperty> properties, final String indent) {
 364         StringBuilder builder = new StringBuilder();
 365         final String indent1 = indent + TAB;
 366         final String indent2 = indent1 + TAB;
 367         final String indent3 = indent2 + TAB;
 368
 369         builder.append(indent + "public boolean equals(Object obj) {" + NL);
 370         builder.append(indent1 + "if (this == obj) {" + NL);
 371         builder.append(indent2 + "return true;" + NL);
 372         builder.append(indent1 + "}" + NL);
 373         builder.append(indent1 + "if (obj == null) {" + NL);
 374         builder.append(indent2 + "return false;" + NL);
 375         builder.append(indent1 + "}" + NL);
 376         builder.append(indent1 + "if (getClass() != obj.getClass()) {" + NL);
 377         builder.append(indent2 + "return false;" + NL);
 378         builder.append(indent1 + "}" + NL);
 379
 380         String typeStr = type.getName();
 381         builder.append(indent1 + typeStr + " other = (" + typeStr + ") obj;"
 382                 + NL);
 383
 384         for (GeneratedProperty property : properties) {
 385             String fieldName = property.getName();
 386             builder.append(indent1 + "if (" + fieldName + " == null) {" + NL);
 387             builder.append(indent2 + "if (other." + fieldName + " != null) {"
 388                     + NL);
 389             builder.append(indent3 + "return false;" + NL);
 390             builder.append(indent2 + "}" + NL);
 391             builder.append(indent1 + "} else if (!" + fieldName
 392                     + ".equals(other." + fieldName + ")) {" + NL);
 393             builder.append(indent2 + "return false;" + NL);
 394             builder.append(indent1 + "}" + NL);
 395         }
 396
 397         builder.append(indent1 + "return true;" + NL);
 398
 399         builder.append(indent + RCB + NL);
 400         return builder.toString();
 401     }
 402
 403     public static String createToString(final GeneratedTransferObject type,
 404             final List<GeneratedProperty> properties, final String indent) {
 405         StringBuilder builder = new StringBuilder();
 406         builder.append(indent);
 407         builder.append("public String toString() {");
 408         builder.append(NL);
 409         builder.append(indent);
 410         builder.append(TAB);
 411         builder.append("StringBuilder builder = new StringBuilder();");
 412         builder.append(NL);
 413         builder.append(indent);
 414         builder.append(TAB);
 415         builder.append("builder.append(\"");
 416         builder.append(type.getName());
 417         builder.append(" [");
 418
 419         boolean first = true;
 420         for (GeneratedProperty property : properties) {
 421             if (first) {
 422                 builder.append(property.getName());
 423                 builder.append("=\");");
 424                 builder.append(NL);
 425                 builder.append(indent);
 426                 builder.append(TAB);
 427                 builder.append("builder.append(");
 428                 builder.append(property.getName());
 429                 builder.append(");");
 430                 first = false;
 431             } else {
 432                 builder.append(NL);
 433                 builder.append(indent);
 434                 builder.append(TAB);
 435                 builder.append("builder.append(\", ");
 436                 builder.append(property.getName());
 437                 builder.append("=\");");
 438                 builder.append(NL);
 439                 builder.append(indent);
 440                 builder.append(TAB);
 441                 builder.append("builder.append(\", ");
 442                 builder.append(property.getName());
 443                 builder.append(");");
 444             }
 445         }
 446         builder.append(NL);
 447         builder.append(indent);
 448         builder.append(TAB);
 449         builder.append("builder.append(\"]\");");
 450         builder.append(NL);
 451         builder.append(indent);
 452         builder.append(TAB);
 453         builder.append("return builder.toString();");
 454
 455         builder.append(NL);
 456         builder.append(indent);
 457         builder.append(RCB);
 458         builder.append(NL);
 459         return builder.toString();
 460     }
 461
 462     public static String createEnum(final Enumeration enumeration,
 463             final String indent) {
 464         final StringBuilder builder = new StringBuilder(indent + ENUM + GAP
 465                 + enumeration.getName() + GAP + LCB + NL);
 466
 467         String separator = COMMA;
 468         final List<Pair> values = enumeration.getValues();
 469         builder.append(indent + TAB);
 470         for (int i = 0; i < values.size(); i++) {
 471             if (i + 1 == values.size()) {
 472                 separator = SC;
 473             }
 474             builder.append(values.get(i).getName() + separator);
 475         }
 476         builder.append(NL);
 477         builder.append(indent + RCB);
 478         return builder.toString();
 479     }
 480
 481     private static String getExplicitType(final Type type,
 482             Map<String, LinkedHashMap<String, Integer>> availableImports,
 483             final String currentPkg) {
 484         if (type == null) {
 485             throw new IllegalArgumentException(
 486                     "Type parameter MUST be specified and cannot be NULL!");
 487         }
 488         String packageName = type.getPackageName();
 489
 490         LinkedHashMap<String, Integer> imports = availableImports.get(type
 491                 .getName());
 492
 493         if ((imports != null && packageName
 494                 .equals(findMaxValue(imports).get(0)))
 495                 || packageName.equals(currentPkg)) {
 496             final StringBuilder builder = new StringBuilder(type.getName());
 497             if (type instanceof ParameterizedType) {
 498                 ParameterizedType pType = (ParameterizedType) type;
 499                 Type[] pTypes = pType.getActualTypeArguments();
 500                 builder.append("<");
 501                 builder.append(getParameters(pTypes, availableImports,
 502                         currentPkg));
 503                 builder.append(">");
 504             }
 505             if (builder.toString().equals("Void")) {
 506                 return "void";
 507             }
 508             return builder.toString();
 509         } else {
 510             final StringBuilder builder = new StringBuilder();
 511             if (packageName.startsWith("java.lang")) {
 512                 builder.append(type.getName());
 513             } else {
 514                 builder.append(packageName + "." + type.getName());
 515             }
 516             if (type instanceof ParameterizedType) {
 517                 ParameterizedType pType = (ParameterizedType) type;
 518                 Type[] pTypes = pType.getActualTypeArguments();
 519                 builder.append("<");
 520                 builder.append(getParameters(pTypes, availableImports,
 521                         currentPkg));
 522                 builder.append(">");
 523             }
 524             if (builder.toString().equals("Void")) {
 525                 return "void";
 526             }
 527             return builder.toString();
 528         }
 529     }
 530
 531     private static String getParameters(final Type[] pTypes,
 532             Map<String, LinkedHashMap<String, Integer>> availableImports,
 533             String currentPkg) {
 534         final StringBuilder builder = new StringBuilder();
 535         for (int i = 0; i < pTypes.length; i++) {
 536             Type t = pTypes[i];
 537
 538             String separator = COMMA;
 539             if (i + 1 == pTypes.length) {
 540                 separator = "";
 541             }
 542             builder.append(getExplicitType(t, availableImports, currentPkg)
 543                     + separator);
 544         }
 545         return builder.toString();
 546     }
 547
 548     private static List<String> findMaxValue(
 549             LinkedHashMap<String, Integer> imports) {
 550         final List<String> result = new ArrayList<String>();
 551
 552         int maxValue = 0;
 553         int currentValue = 0;
 554         for (Map.Entry<String, Integer> entry : imports.entrySet()) {
 555             currentValue = entry.getValue();
 556             if (currentValue > maxValue) {
 557                 result.clear();
 558                 result.add(entry.getKey());
 559             } else if (currentValue == maxValue) {
 560                 result.add(entry.getKey());
 561             }
 562         }
 563         return result;
 564     }
 565
 566     private static void createComment(final StringBuilder builder,
 567             final String comment, final String indent) {
 568         if (comment != null && comment.length() > 0) {
 569             builder.append(indent + "/*" + NL);
 570             builder.append(indent + comment + NL);
 571             builder.append(indent + "*/" + NL);
 572         }
 573     }
 574
 575     public static Map<String, LinkedHashMap<String, Integer>> createImports(
 576             GeneratedType genType) {
 577         final Map<String, LinkedHashMap<String, Integer>> imports = new HashMap<String, LinkedHashMap<String, Integer>>();
 578         final String genTypePkg = genType.getPackageName();
 579
 580         final List<Constant> constants = genType.getConstantDefinitions();
 581         final List<MethodSignature> methods = genType.getMethodDefinitions();
 582         List<Type> impl = genType.getImplements();
 583
 584         // IMPLEMENTATIONS
 585         if (impl != null) {
 586             for (Type t : impl) {
 587                 addTypeToImports(t, imports, genTypePkg);
 588             }
 589         }
 590
 591         // CONSTANTS
 592         if (constants != null) {
 593             for (Constant c : constants) {
 594                 Type ct = c.getType();
 595                 addTypeToImports(ct, imports, genTypePkg);
 596             }
 597         }
 598
 599         // METHODS
 600         if (methods != null) {
 601             for (MethodSignature m : methods) {
 602                 Type ct = m.getReturnType();
 603                 addTypeToImports(ct, imports, genTypePkg);
 604                 for (MethodSignature.Parameter p : m.getParameters()) {
 605                     addTypeToImports(p.getType(), imports, genTypePkg);
 606                 }
 607             }
 608         }
 609
 610         // PROPERTIES
 611         if (genType instanceof GeneratedTransferObject) {
 612             GeneratedTransferObject genTO = (GeneratedTransferObject) genType;
 613
 614             List<GeneratedProperty> props = genTO.getProperties();
 615             if (props != null) {
 616                 for (GeneratedProperty prop : props) {
 617                     Type pt = prop.getReturnType();
 618                     addTypeToImports(pt, imports, genTypePkg);
 619                 }
 620             }
 621         }
 622
 623         return imports;
 624     }
 625
 626     private static void addTypeToImports(Type type,
 627             Map<String, LinkedHashMap<String, Integer>> importedTypes,
 628             String genTypePkg) {
 629         String typeName = type.getName();
 630         String typePkg = type.getPackageName();
 631         if (typePkg.startsWith("java.lang") || typePkg.equals(genTypePkg)) {
 632             return;
 633         }
 634         LinkedHashMap<String, Integer> packages = importedTypes.get(typeName);
 635         if (packages == null) {
 636             packages = new LinkedHashMap<String, Integer>();
 637             packages.put(typePkg, 1);
 638             importedTypes.put(typeName, packages);
 639         } else {
 640             Integer occurrence = packages.get(typePkg);
 641             if (occurrence == null) {
 642                 packages.put(typePkg, 1);
 643             } else {
 644                 occurrence++;
 645                 packages.put(typePkg, occurrence);
 646             }
 647         }
 648
 649         if (type instanceof ParameterizedType) {
 650             ParameterizedType pt = (ParameterizedType) type;
 651             Type[] params = pt.getActualTypeArguments();
 652             for (Type param : params) {
 653                 addTypeToImports(param, importedTypes, genTypePkg);
 654             }
 655         }
 656     }
 657
 658     public static List<String> createImportLines(
 659             Map<String, LinkedHashMap<String, Integer>> imports) {
 660         List<String> importLines = new ArrayList<String>();
 661
 662         for (Map.Entry<String, LinkedHashMap<String, Integer>> entry : imports
 663                 .entrySet()) {
 664             String typeName = entry.getKey();
 665             LinkedHashMap<String, Integer> typePkgMap = entry.getValue();
 666             String typePkg = typePkgMap.keySet().iterator().next();
 667             importLines.add("import " + typePkg + "." + typeName + SC);
 668         }
 669         return importLines;
 670     }
 671
 672 }