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 = toUnmodifiableConstants(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     protected List<Constant> toUnmodifiableConstants(
  98             List<Constant> constants) {
  99         for (final Constant constant : constants) {
 100             constants.add(new ConstantImpl(this, constant.getType(),
 101                     constant.getName(), constant.getValue()));
 102         }
 103         return Collections.unmodifiableList(constants);
 104     }
 105
 106     @Override
 107     public Type getParentType() {
 108         return parent;
 109     }
 110
 111     @Override
 112     public String getComment() {
 113         return comment;
 114     }
 115
 116     @Override
 117     public List<AnnotationType> getAnnotations() {
 118         return annotations;
 119     }
 120
 121     @Override
 122     public boolean isAbstract() {
 123        return isAbstract;
 124     }
 125
 126      @Override
 127     public List<Type> getImplements() {
 128         return implementsTypes;
 129     }
 130
 131     @Override
 132     public List<GeneratedType> getEnclosedTypes() {
 133         return enclosedTypes;
 134     }
 135
 136     @Override
 137     public List<Enumeration> getEnumerations() {
 138         return enumerations;
 139     }
 140
 141     @Override
 142     public List<Constant> getConstantDefinitions() {
 143         return constants;
 144     }
 145
 146     @Override
 147     public List<MethodSignature> getMethodDefinitions() {
 148         return methodSignatures;
 149     }
 150
 151     @Override
 152     public String toString() {
 153         StringBuilder builder = new StringBuilder();
 154         builder.append("GeneratedType [packageName=");
 155         builder.append(getPackageName());
 156         builder.append(", name=");
 157         builder.append(getName());
 158         if (parent != null) {
 159             builder.append(", parent=");
 160             builder.append(parent.getFullyQualifiedName());
 161         } else {
 162             builder.append(", parent=null");
 163         }
 164         builder.append(", comment=");
 165         builder.append(comment);
 166         builder.append(", annotations=");
 167         builder.append(annotations);
 168         builder.append(", enclosedTypes=");
 169         builder.append(enclosedTypes);
 170         builder.append(", enumerations=");
 171         builder.append(enumerations);
 172         builder.append(", constants=");
 173         builder.append(constants);
 174         builder.append(", methodSignatures=");
 175         builder.append(methodSignatures);
 176         builder.append("]");
 177         return builder.toString();
 178     }
 179 }