Switch to Objects.requireNonNull
[mdsal.git] / binding2 / mdsal-binding2-generator-util / src / main / java / org / opendaylight / mdsal / binding / javav2 / generator / util / generated / type / builder / AbstractGeneratedTypeBuilder.java
1 /*
2  * Copyright (c) 2017 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
9 package org.opendaylight.mdsal.binding.javav2.generator.util.generated.type.builder;
10
11 import static java.util.Objects.requireNonNull;
12
13 import com.google.common.annotations.Beta;
14 import com.google.common.base.Preconditions;
15 import com.google.common.collect.ImmutableList;
16
17 import java.util.List;
18 import java.util.Objects;
19 import java.util.Optional;
20
21 import org.opendaylight.mdsal.binding.javav2.generator.context.ModuleContext;
22 import org.opendaylight.mdsal.binding.javav2.generator.util.AbstractBaseType;
23 import org.opendaylight.mdsal.binding.javav2.model.api.AccessModifier;
24 import org.opendaylight.mdsal.binding.javav2.model.api.Constant;
25 import org.opendaylight.mdsal.binding.javav2.model.api.Type;
26 import org.opendaylight.mdsal.binding.javav2.model.api.TypeComment;
27 import org.opendaylight.mdsal.binding.javav2.model.api.YangSourceDefinition;
28 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.AnnotationTypeBuilder;
29 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.EnumBuilder;
30 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedPropertyBuilder;
31 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTOBuilder;
32 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTypeBuilder;
33 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.GeneratedTypeBuilderBase;
34 import org.opendaylight.mdsal.binding.javav2.model.api.type.builder.MethodSignatureBuilder;
35 import org.opendaylight.mdsal.binding.javav2.spec.runtime.BindingNamespaceType;
36 import org.opendaylight.yangtools.util.LazyCollections;
37
38 @Beta
39 abstract class AbstractGeneratedTypeBuilder<T extends GeneratedTypeBuilderBase<T>> extends AbstractBaseType
40         implements GeneratedTypeBuilderBase<T> {
41
42     private List<AnnotationTypeBuilder> annotationBuilders = ImmutableList.of();
43     private List<Type> implementsTypes = ImmutableList.of();
44     private List<EnumBuilder> enumDefinitions = ImmutableList.of();
45     private List<Constant> constants = ImmutableList.of();
46     private List<MethodSignatureBuilder> methodDefinitions = ImmutableList.of();
47     private final List<GeneratedTypeBuilder> enclosedTypes = ImmutableList.of();
48     private List<GeneratedTOBuilder> enclosedTransferObjects = ImmutableList.of();
49     private List<GeneratedPropertyBuilder> properties = ImmutableList.of();
50     private TypeComment comment;
51     private boolean isAbstract;
52     private Type parentTypeForBuilder;
53     private YangSourceDefinition yangSourceDefinition;
54     private BindingNamespaceType namespaceType;
55
56     protected AbstractGeneratedTypeBuilder(final String packageName, final String name, ModuleContext context) {
57         super(packageName, name, context);
58     }
59
60     protected AbstractGeneratedTypeBuilder(final String packageName, final String name, final boolean isNormalized,
61                                            ModuleContext context) {
62         super(packageName, name, true, null);
63     }
64
65     protected AbstractGeneratedTypeBuilder(final String packageName, final String name,
66             final boolean isPkNameNormalized, final boolean isTypeNormalized, ModuleContext context) {
67         super(packageName, name, isPkNameNormalized, isTypeNormalized, context);
68     }
69
70     protected TypeComment getComment() {
71         return this.comment;
72     }
73
74     protected List<AnnotationTypeBuilder> getAnnotations() {
75         return annotationBuilders;
76     }
77
78     @Override
79     public boolean isAbstract() {
80         return isAbstract;
81     }
82
83     @Override
84     public List<Type> getImplementsTypes() {
85         return implementsTypes;
86     }
87
88     protected List<EnumBuilder> getEnumerations() {
89         return enumDefinitions;
90     }
91
92     protected List<Constant> getConstants() {
93         return constants;
94     }
95
96     @Override
97     public List<MethodSignatureBuilder> getMethodDefinitions() {
98         return methodDefinitions;
99     }
100
101     protected List<GeneratedTypeBuilder> getEnclosedTypes() {
102         return enclosedTypes;
103     }
104
105     protected List<GeneratedTOBuilder> getEnclosedTransferObjects() {
106         return enclosedTransferObjects;
107     }
108
109     protected abstract T thisInstance();
110
111     @Override
112     public GeneratedTOBuilder addEnclosingTransferObject(final String name) {
113         Preconditions.checkArgument(name != null, "Name for Enclosing Generated Transfer Object cannot be null!");
114         GeneratedTOBuilder builder = new GeneratedTOBuilderImpl(getFullyQualifiedName(), name, true);
115
116         Preconditions.checkArgument(!enclosedTransferObjects.contains(builder),
117                 "This generated type already contains equal enclosing transfer object.");
118         enclosedTransferObjects = LazyCollections.lazyAdd(enclosedTransferObjects, builder);
119         return builder;
120     }
121
122     @Override
123     public T addEnclosingTransferObject(final GeneratedTOBuilder genTOBuilder) {
124         Preconditions.checkArgument(genTOBuilder != null, "Parameter genTOBuilder cannot be null!");
125         Preconditions.checkArgument(!enclosedTransferObjects.contains(genTOBuilder),
126                 "This generated type already contains equal enclosing transfer object.");
127         enclosedTransferObjects = LazyCollections.lazyAdd(enclosedTransferObjects, genTOBuilder);
128         return thisInstance();
129     }
130
131     @Override
132     public T addComment(final TypeComment typeComment) {
133         this.comment = requireNonNull(typeComment);
134         return thisInstance();
135     }
136
137     @Override
138     public AnnotationTypeBuilder addAnnotation(final String packageName, final String name) {
139         Preconditions.checkArgument(packageName != null, "Package Name for Annotation Type cannot be null!");
140         Preconditions.checkArgument(name != null, "Name of Annotation Type cannot be null!");
141
142         final AnnotationTypeBuilder builder = new AnnotationTypeBuilderImpl(packageName, name);
143
144         Preconditions.checkArgument(!annotationBuilders.contains(builder),
145                 "This generated type already contains equal annotation.");
146         annotationBuilders = LazyCollections.lazyAdd(annotationBuilders, builder);
147         return builder;
148     }
149
150     @Override
151     public T setAbstract(final boolean isabstract) {
152         this.isAbstract = isabstract;
153         return thisInstance();
154     }
155
156     @Override
157     public T addImplementsType(final Type genType) {
158         Preconditions.checkArgument(genType != null, "Type cannot be null");
159         Preconditions.checkArgument(!implementsTypes.contains(genType),
160                 "This generated type already contains equal implements type.");
161         implementsTypes = LazyCollections.lazyAdd(implementsTypes, genType);
162         return thisInstance();
163     }
164
165     @Override
166     public Constant addConstant(final Type type, final String name, final Object value) {
167         Preconditions.checkArgument(type != null, "Returning Type for Constant cannot be null!");
168         Preconditions.checkArgument(name != null, "Name of constant cannot be null!");
169         Preconditions.checkArgument(!containsConstant(name),
170                 "This generated type already contains constant with the same name.");
171
172         final Constant constant = new ConstantImpl(this, type, name, value);
173         constants = LazyCollections.lazyAdd(constants, constant);
174         return constant;
175     }
176
177
178     @Override
179     public Type setParentTypeForBuilder(Type type) {
180         return this.parentTypeForBuilder = type;
181     }
182
183     @Override
184     public BindingNamespaceType getBindingNamespaceType() {
185         return namespaceType;
186     }
187
188     @Override
189     public void setBindingNamespaceType(BindingNamespaceType type) {
190         this.namespaceType = type;
191     }
192
193     public boolean containsConstant(final String name) {
194         Preconditions.checkArgument(name != null, "Parameter name can't be null");
195         for (Constant constant : constants) {
196             if (name.equals(constant.getName())) {
197                 return true;
198             }
199         }
200         return false;
201     }
202
203     @Override
204     public EnumBuilder addEnumeration(final String name, ModuleContext context) {
205         Preconditions.checkArgument(name != null, "Name of enumeration cannot be null!");
206         final EnumBuilder builder = new EnumerationBuilderImpl(getFullyQualifiedName(), name, true, false,
207                 context);
208
209         Preconditions.checkArgument(!enumDefinitions.contains(builder),
210                 "This generated type already contains equal enumeration.");
211         enumDefinitions = LazyCollections.lazyAdd(enumDefinitions, builder);
212         return builder;
213     }
214
215     @Override
216     public MethodSignatureBuilder addMethod(final String name) {
217         Preconditions.checkArgument(name != null, "Name of method cannot be null!");
218         final MethodSignatureBuilder builder = new MethodSignatureBuilderImpl(name);
219         builder.setAccessModifier(AccessModifier.PUBLIC);
220         builder.setAbstract(true);
221         methodDefinitions = LazyCollections.lazyAdd(methodDefinitions, builder);
222         return builder;
223     }
224
225     @Override
226     public boolean containsMethod(final String name) {
227         Preconditions.checkArgument(name != null, "Parameter name can't be null");
228         for (MethodSignatureBuilder methodDefinition : methodDefinitions) {
229             if (name.equals(methodDefinition.getName())) {
230                 return true;
231             }
232         }
233         return false;
234     }
235
236     @Override
237     public GeneratedPropertyBuilder addProperty(final String name) {
238         Preconditions.checkArgument(name != null, "Parameter name can't be null");
239         Preconditions.checkArgument(!containsProperty(name),
240                 "This generated type already contains property with the same name.");
241
242         final GeneratedPropertyBuilder builder = new GeneratedPropertyBuilderImpl(name);
243         builder.setAccessModifier(AccessModifier.PUBLIC);
244         properties = LazyCollections.lazyAdd(properties, builder);
245         return builder;
246     }
247
248     @Override
249     public boolean containsProperty(final String name) {
250         Preconditions.checkArgument(name != null, "Parameter name can't be null");
251         for (GeneratedPropertyBuilder property : properties) {
252             if (name.equals(property.getName())) {
253                 return true;
254             }
255         }
256         return false;
257     }
258
259     @Override
260     public Optional<YangSourceDefinition> getYangSourceDefinition() {
261         return Optional.ofNullable(yangSourceDefinition);
262     }
263
264
265     @Override
266     public void setYangSourceDefinition(final YangSourceDefinition definition) {
267         yangSourceDefinition = requireNonNull(definition);
268     }
269
270     @Override
271     public int hashCode() {
272         return Objects.hash(getName(), getPackageName());
273     }
274
275     @Override
276     public boolean equals(final Object obj) {
277         if (this == obj) {
278             return true;
279         }
280         if (obj == null) {
281             return false;
282         }
283         if (getClass() != obj.getClass()) {
284             return false;
285         }
286
287         if (!(obj instanceof AbstractGeneratedTypeBuilder)) {
288             return false;
289         }
290
291         AbstractGeneratedTypeBuilder<?> other = (AbstractGeneratedTypeBuilder<?>) obj;
292         return Objects.equals(getFullyQualifiedName(), other.getFullyQualifiedName());
293     }
294
295     public Type getParent() {
296         return null;
297     }
298
299     @Override
300     public Type getParentTypeForBuilder() {
301         return parentTypeForBuilder;
302     }
303
304     @Override
305     public List<GeneratedPropertyBuilder> getProperties() {
306         return properties;
307     }
308
309 }