opendaylight/sal/yang-prototype/code-generator/binding-generator-util/src/main/java/org/opendaylight/controller/binding/generator/util/generated/type/builder/AbstractGeneratedType.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.binding.generator.util.generated.type.builder;
   9
  10
  11 import org.opendaylight.controller.binding.generator.util.AbstractBaseType;
  12 import org.opendaylight.controller.sal.binding.model.api.*;
  13 import org.opendaylight.controller.sal.binding.model.api.type.builder.*;
  14
  15 import java.util.ArrayList;
  16 import java.util.Collections;
  17 import java.util.List;
  18
  19 abstract class AbstractGeneratedType extends AbstractBaseType implements GeneratedType {
  20
  21     private final Type parent;
  22     private final String comment;
  23     private final List<AnnotationType> annotations;
  24     private final List<Type> implementsTypes;
  25     private final List<Enumeration> enumerations;
  26     private final List<Constant> constants;
  27     private final List<MethodSignature> methodSignatures;
  28     private final List<GeneratedType> enclosedTypes;
  29     private final boolean isAbstract;
  30
  31     public AbstractGeneratedType(final Type parent, final String packageName,
  32                              final String name, final String comment,
  33                              final List<AnnotationTypeBuilder> annotationBuilders,
  34                              final boolean isAbstract,
  35                              final List<Type> implementsTypes,
  36                              final List<GeneratedTypeBuilder> enclosedGenTypeBuilders,
  37                              final List<GeneratedTOBuilder> enclosedGenTOBuilders,
  38                              final List<EnumBuilder> enumBuilders,
  39                              final List<Constant> constants,
  40                              final List<MethodSignatureBuilder> methodBuilders) {
  41         super(packageName, name);
  42         this.parent = parent;
  43         this.comment = comment;
  44         this.annotations = toUnmodifiableAnnotations(annotationBuilders);
  45         this.implementsTypes = Collections.unmodifiableList(implementsTypes);
  46         this.constants = Collections.unmodifiableList(constants);
  47         this.enumerations = toUnmodifiableEnumerations(enumBuilders);
  48         this.methodSignatures = toUnmodifiableMethods(methodBuilders);
  49         this.enclosedTypes = toUnmodifiableEnclosedTypes(enclosedGenTypeBuilders, enclosedGenTOBuilders);
  50         this.isAbstract = isAbstract;
  51     }
  52
  53     private List<GeneratedType> toUnmodifiableEnclosedTypes(final List<GeneratedTypeBuilder> enclosedGenTypeBuilders,
  54                                                             final List<GeneratedTOBuilder> enclosedGenTOBuilders) {
  55         final List<GeneratedType> enclosedTypes = new ArrayList<>();
  56         for (final GeneratedTypeBuilder builder : enclosedGenTypeBuilders) {
  57             if (builder != null) {
  58                 enclosedTypes.add(builder.toInstance());
  59             }
  60         }
  61
  62         for (final GeneratedTOBuilder builder : enclosedGenTOBuilders) {
  63             if (builder != null) {
  64                 enclosedTypes.add(builder.toInstance());
  65             }
  66         }
  67         return enclosedTypes;
  68     }
  69
  70     protected List<AnnotationType> toUnmodifiableAnnotations(
  71             final List<AnnotationTypeBuilder> annotationBuilders) {
  72         final List<AnnotationType> annotations = new ArrayList<>();
  73         for (final AnnotationTypeBuilder builder : annotationBuilders) {
  74             annotations.add(builder.toInstance());
  75         }
  76         return Collections.unmodifiableList(annotations);
  77     }
  78
  79     protected List<MethodSignature> toUnmodifiableMethods(
  80             List<MethodSignatureBuilder> methodBuilders) {
  81         final List<MethodSignature> methods = new ArrayList<>();
  82         for (final MethodSignatureBuilder methodBuilder : methodBuilders) {
  83             methods.add(methodBuilder.toInstance(this));
  84         }
  85         return Collections.unmodifiableList(methods);
  86     }
  87
  88     protected List<Enumeration> toUnmodifiableEnumerations(
  89             List<EnumBuilder> enumBuilders) {
  90         final List<Enumeration> enums = new ArrayList<>();
  91         for (final EnumBuilder enumBuilder : enumBuilders) {
  92             enums.add(enumBuilder.toInstance(this));
  93         }
  94         return Collections.unmodifiableList(enums);
  95     }
  96
  97     @Override
  98     public Type getParentType() {
  99         return parent;
 100     }
 101
 102     @Override
 103     public String getComment() {
 104         return comment;
 105     }
 106
 107     @Override
 108     public List<AnnotationType> getAnnotations() {
 109         return annotations;
 110     }
 111
 112     @Override
 113     public boolean isAbstract() {
 114        return isAbstract;
 115     }
 116
 117      @Override
 118     public List<Type> getImplements() {
 119         return implementsTypes;
 120     }
 121
 122     @Override
 123     public List<GeneratedType> getEnclosedTypes() {
 124         return enclosedTypes;
 125     }
 126
 127     @Override
 128     public List<Enumeration> getEnumerations() {
 129         return enumerations;
 130     }
 131
 132     @Override
 133     public List<Constant> getConstantDefinitions() {
 134         return constants;
 135     }
 136
 137     @Override
 138     public List<MethodSignature> getMethodDefinitions() {
 139         return methodSignatures;
 140     }
 141
 142     @Override
 143     public String toString() {
 144         StringBuilder builder = new StringBuilder();
 145         builder.append("GeneratedType [packageName=");
 146         builder.append(getPackageName());
 147         builder.append(", name=");
 148         builder.append(getName());
 149         if (parent != null) {
 150             builder.append(", parent=");
 151             builder.append(parent.getFullyQualifiedName());
 152         } else {
 153             builder.append(", parent=null");
 154         }
 155         builder.append(", comment=");
 156         builder.append(comment);
 157         builder.append(", annotations=");
 158         builder.append(annotations);
 159         builder.append(", enclosedTypes=");
 160         builder.append(enclosedTypes);
 161         builder.append(", enumerations=");
 162         builder.append(enumerations);
 163         builder.append(", constants=");
 164         builder.append(constants);
 165         builder.append(", methodSignatures=");
 166         builder.append(methodSignatures);
 167         builder.append("]");
 168         return builder.toString();
 169     }
 170 }