binding/mdsal-binding-model-ri/src/main/java/org/opendaylight/mdsal/binding/model/ri/generated/type/builder/AnnotationTypeBuilderImpl.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.mdsal.binding.model.ri.generated.type.builder;
   9
  10 import com.google.common.base.MoreObjects.ToStringHelper;
  11 import com.google.common.collect.ImmutableList;
  12 import java.util.ArrayList;
  13 import java.util.Collections;
  14 import java.util.List;
  15 import java.util.Objects;
  16 import org.opendaylight.mdsal.binding.model.api.AbstractType;
  17 import org.opendaylight.mdsal.binding.model.api.AnnotationType;
  18 import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
  19 import org.opendaylight.mdsal.binding.model.api.type.builder.AnnotationTypeBuilder;
  20 import org.opendaylight.yangtools.util.LazyCollections;
  21
  22 final class AnnotationTypeBuilderImpl extends AbstractType implements AnnotationTypeBuilder {
  23
  24     private List<AnnotationTypeBuilder> annotationBuilders = Collections.emptyList();
  25     private List<AnnotationType.Parameter> parameters = Collections.emptyList();
  26
  27     AnnotationTypeBuilderImpl(final JavaTypeName identifier) {
  28         super(identifier);
  29     }
  30
  31     @Override
  32     public AnnotationTypeBuilder addAnnotation(final String packageName, final String name) {
  33         final var typeName = JavaTypeName.create(packageName, name);
  34         for (var builder : annotationBuilders) {
  35             if (typeName.equals(builder.getIdentifier())) {
  36                 return builder;
  37             }
  38         }
  39
  40         final AnnotationTypeBuilder builder = new AnnotationTypeBuilderImpl(typeName);
  41         annotationBuilders = LazyCollections.lazyAdd(annotationBuilders, builder);
  42         return builder;
  43     }
  44
  45     private boolean addParameter(final ParameterImpl param) {
  46         if (parameters.contains(param)) {
  47             return false;
  48         }
  49         parameters = LazyCollections.lazyAdd(parameters, param);
  50         return true;
  51     }
  52
  53     @Override
  54     public boolean addParameter(final String paramName, final String value) {
  55         if (paramName != null && value != null) {
  56             final ParameterImpl param = new ParameterImpl(paramName, value);
  57             return addParameter(param);
  58         }
  59         return false;
  60     }
  61
  62     @Override
  63     public boolean addParameters(final String paramName, final List<String> values) {
  64         if (paramName != null && values != null) {
  65             final ParameterImpl param = new ParameterImpl(paramName, values);
  66             return addParameter(param);
  67         }
  68         return false;
  69     }
  70
  71     @Override
  72     public AnnotationType build() {
  73         return new AnnotationTypeImpl(getIdentifier(), annotationBuilders, parameters);
  74     }
  75
  76     @Override
  77     protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
  78         return super.addToStringAttributes(toStringHelper)
  79             .omitNullValues()
  80             .add("annotationBuilders", annotationBuilders)
  81             .add("parameters", parameters);
  82     }
  83
  84     private static final class AnnotationTypeImpl extends AbstractType implements AnnotationType {
  85         private final List<AnnotationType> annotations;
  86         private final List<AnnotationType.Parameter> parameters;
  87         private final List<String> paramNames;
  88
  89         AnnotationTypeImpl(final JavaTypeName identifier, final List<AnnotationTypeBuilder> annotationBuilders,
  90                 final List<AnnotationType.Parameter> parameters) {
  91             super(identifier);
  92
  93             final List<AnnotationType> a = new ArrayList<>();
  94             for (final AnnotationTypeBuilder builder : annotationBuilders) {
  95                 a.add(builder.build());
  96             }
  97             annotations = ImmutableList.copyOf(a);
  98
  99             final List<String> p = new ArrayList<>();
 100             for (final AnnotationType.Parameter parameter : parameters) {
 101                 p.add(parameter.getName());
 102             }
 103             paramNames = ImmutableList.copyOf(p);
 104
 105             this.parameters = parameters.isEmpty() ? Collections.emptyList() : Collections.unmodifiableList(parameters);
 106         }
 107
 108         @Override
 109         public List<AnnotationType> getAnnotations() {
 110             return annotations;
 111         }
 112
 113         @Override
 114         public Parameter getParameter(final String paramName) {
 115             if (paramName != null) {
 116                 for (final AnnotationType.Parameter parameter : parameters) {
 117                     if (parameter.getName().equals(paramName)) {
 118                         return parameter;
 119                     }
 120                 }
 121             }
 122             return null;
 123         }
 124
 125         @Override
 126         public List<Parameter> getParameters() {
 127             return parameters;
 128         }
 129
 130         @Override
 131         public List<String> getParameterNames() {
 132             return paramNames;
 133         }
 134
 135         @Override
 136         public boolean containsParameters() {
 137             return !parameters.isEmpty();
 138         }
 139
 140         @Override
 141         protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
 142             return super.addToStringAttributes(toStringHelper)
 143                 .omitNullValues()
 144                 .add("annotations", annotations)
 145                 .add("parameters", parameters);
 146         }
 147     }
 148
 149     private static final class ParameterImpl implements AnnotationType.Parameter {
 150
 151         private final String name;
 152         private final String value;
 153         private final List<String> values;
 154
 155         ParameterImpl(final String name, final String value) {
 156             this.name = name;
 157             this.value = value;
 158             values = Collections.emptyList();
 159         }
 160
 161         ParameterImpl(final String name, final List<String> values) {
 162             this.name = name;
 163             this.values = values;
 164             value = null;
 165         }
 166
 167         @Override
 168         public String getName() {
 169             return name;
 170         }
 171
 172         @Override
 173         public String getValue() {
 174             return value;
 175         }
 176
 177         @Override
 178         public List<String> getValues() {
 179             return values;
 180         }
 181
 182         @Override
 183         public int hashCode() {
 184             final int prime = 31;
 185             int result = 1;
 186             result = prime * result + Objects.hashCode(name);
 187             return result;
 188         }
 189
 190         @Override
 191         public boolean equals(final Object obj) {
 192             if (this == obj) {
 193                 return true;
 194             }
 195             if (obj == null) {
 196                 return false;
 197             }
 198             if (getClass() != obj.getClass()) {
 199                 return false;
 200             }
 201             final ParameterImpl other = (ParameterImpl) obj;
 202             return Objects.equals(name, other.name);
 203         }
 204
 205         @Override
 206         public String toString() {
 207             final StringBuilder builder = new StringBuilder();
 208             builder.append("ParameterImpl [name=");
 209             builder.append(name);
 210             builder.append(", value=");
 211             builder.append(value);
 212             builder.append(", values=");
 213             builder.append(values);
 214             builder.append("]");
 215             return builder.toString();
 216         }
 217     }
 218 }