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