binding/mdsal-binding-model-ri/src/main/java/org/opendaylight/mdsal/binding/model/ri/generated/type/builder/AbstractGeneratedTOBuilder.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.base.Preconditions;
  12 import java.util.Collections;
  13 import java.util.List;
  14 import org.opendaylight.mdsal.binding.model.api.GeneratedProperty;
  15 import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
  16 import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
  17 import org.opendaylight.mdsal.binding.model.api.ParameterizedType;
  18 import org.opendaylight.mdsal.binding.model.api.Type;
  19 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedPropertyBuilder;
  20 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
  21 import org.opendaylight.mdsal.binding.model.api.type.builder.MethodSignatureBuilder;
  22 import org.opendaylight.yangtools.util.LazyCollections;
  23 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  24
  25 abstract class AbstractGeneratedTOBuilder extends AbstractGeneratedTypeBuilder<GeneratedTOBuilder>
  26         implements GeneratedTOBuilder {
  27
  28     // FIXME are these three referenced anywhere at runtime?
  29     private List<GeneratedPropertyBuilder> equalsProperties = Collections.emptyList();
  30     private List<GeneratedPropertyBuilder> hashProperties = Collections.emptyList();
  31     private List<GeneratedPropertyBuilder> toStringProperties = Collections.emptyList();
  32     private GeneratedTransferObject extendsType;
  33     private boolean isTypedef = false;
  34     private boolean isUnionType = false;
  35     private TypeDefinition<?> baseType = null;
  36
  37     AbstractGeneratedTOBuilder(final JavaTypeName identifier) {
  38         super(identifier);
  39         setAbstract(false);
  40     }
  41
  42     @Override
  43     public final GeneratedTOBuilder setExtendsType(final GeneratedTransferObject genTransObj) {
  44         Preconditions.checkArgument(genTransObj != null, "Generated Transfer Object cannot be null!");
  45         extendsType = genTransObj;
  46         return this;
  47     }
  48
  49     /**
  50      * Add new Method Signature definition for Generated Type Builder and
  51      * returns Method Signature Builder for specifying all Method parameters. <br>
  52      * Name of Method cannot be <code>null</code>, if it is <code>null</code>
  53      * the method SHOULD throw {@link IllegalArgumentException} <br>
  54      * By <i>Default</i> the MethodSignatureBuilder SHOULD be pre-set as
  55      * {@link MethodSignatureBuilder#setAbstract(boolean)},
  56      * {TypeMemberBuilder#setFinal(boolean)} and
  57      * {TypeMemberBuilder#setAccessModifier(boolean)}
  58      *
  59      * @param name
  60      *            Name of Method
  61      * @return <code>new</code> instance of Method Signature Builder.
  62      */
  63     @Override
  64     public final MethodSignatureBuilder addMethod(final String name) {
  65         final MethodSignatureBuilder builder = super.addMethod(name);
  66         builder.setAbstract(false);
  67         return builder;
  68     }
  69
  70     @Override
  71     public final GeneratedTOBuilder addEqualsIdentity(final GeneratedPropertyBuilder property) {
  72         equalsProperties = LazyCollections.lazyAdd(equalsProperties, property);
  73         return this;
  74     }
  75
  76     @Override
  77     public final GeneratedTOBuilder addHashIdentity(final GeneratedPropertyBuilder property) {
  78         hashProperties = LazyCollections.lazyAdd(hashProperties, property);
  79         return this;
  80     }
  81
  82     @Override
  83     public final GeneratedTOBuilder addToStringProperty(final GeneratedPropertyBuilder property) {
  84         toStringProperties = LazyCollections.lazyAdd(toStringProperties, property);
  85         return this;
  86     }
  87
  88     @Override
  89     protected final GeneratedTOBuilder thisInstance() {
  90         return this;
  91     }
  92
  93     @Override
  94     protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
  95         return super.addToStringAttributes(toStringHelper)
  96             .add("equalsProperties", equalsProperties)
  97             .add("hashCodeProperties", hashProperties)
  98             .add("stringProperties", toStringProperties);
  99     }
 100
 101     @Override
 102     public final void setTypedef(final boolean newIsTypedef) {
 103         isTypedef = newIsTypedef;
 104     }
 105
 106     @Override
 107     public final void setBaseType(final TypeDefinition<?> typeDef) {
 108         baseType = typeDef;
 109     }
 110
 111     @Override
 112     public final void setIsUnion(final boolean newIsUnion) {
 113         isUnionType = newIsUnion;
 114     }
 115
 116     @Override
 117     public final boolean isUnion() {
 118         return isUnionType;
 119     }
 120
 121     abstract static class AbstractGeneratedTransferObject extends AbstractGeneratedType implements
 122             GeneratedTransferObject {
 123
 124         private final List<GeneratedProperty> equalsProperties;
 125         private final List<GeneratedProperty> hashCodeProperties;
 126         private final List<GeneratedProperty> stringProperties;
 127         private final GeneratedTransferObject extendsType;
 128         private final boolean isTypedef;
 129         private final TypeDefinition<?> baseType;
 130         private final boolean isUnionType;
 131
 132         AbstractGeneratedTransferObject(final AbstractGeneratedTOBuilder builder) {
 133             super(builder);
 134             extendsType = builder.extendsType;
 135
 136             // FIXME: if these fields were guaranteed to be constant, we could perhaps
 137             //        cache and reuse them between instances...
 138             equalsProperties = toUnmodifiableProperties(builder.equalsProperties);
 139             hashCodeProperties = toUnmodifiableProperties(builder.hashProperties);
 140             stringProperties = toUnmodifiableProperties(builder.toStringProperties);
 141
 142             isTypedef = builder.isTypedef;
 143             baseType = builder.baseType;
 144             isUnionType = builder.isUnionType;
 145         }
 146
 147         @Override
 148         public final boolean isTypedef() {
 149             return isTypedef;
 150         }
 151
 152         @Override
 153         public final TypeDefinition<?> getBaseType() {
 154             return baseType;
 155         }
 156
 157         @Override
 158         public final boolean isUnionType() {
 159             return isUnionType;
 160         }
 161
 162         @Override
 163         public final GeneratedTransferObject getSuperType() {
 164             return extendsType;
 165         }
 166
 167         @Override
 168         public final List<GeneratedProperty> getEqualsIdentifiers() {
 169             return equalsProperties;
 170         }
 171
 172         @Override
 173         public final List<GeneratedProperty> getHashCodeIdentifiers() {
 174             return hashCodeProperties;
 175         }
 176
 177         @Override
 178         public final List<GeneratedProperty> getToStringIdentifiers() {
 179             return stringProperties;
 180         }
 181
 182         @Override
 183         protected ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
 184             return super.addToStringAttributes(toStringHelper)
 185                 .omitNullValues()
 186                 .add("annotations", getAnnotations())
 187                 .add("comment", getComment())
 188                 .add("extends", getSuperType())
 189                 .add("implements", getImplements())
 190                 .add("enclosedTypes", getEnclosedTypes())
 191                 .add("constants", getConstantDefinitions())
 192                 .add("enumerations", getEnumerations())
 193                 .add("properties", getProperties())
 194                 .add("equalsProperties", equalsProperties)
 195                 .add("hashCodeProperties", hashCodeProperties)
 196                 .add("stringProperties", stringProperties)
 197                 .add("methods", getMethodDefinitions());
 198         }
 199
 200         public static final String serializeTypedef(final Type type) {
 201             if (!(type instanceof ParameterizedType)) {
 202                 return type.getFullyQualifiedName();
 203             }
 204
 205             final ParameterizedType parameterizedType = (ParameterizedType) type;
 206             final StringBuilder sb = new StringBuilder();
 207             sb.append(parameterizedType.getRawType().getFullyQualifiedName()).append('<');
 208             boolean first = true;
 209             for (final Type parameter : parameterizedType.getActualTypeArguments()) {
 210                 if (first) {
 211                     first = false;
 212                 } else {
 213                     sb.append(',');
 214                 }
 215                 sb.append(serializeTypedef(parameter));
 216             }
 217             return sb.append('>').toString();
 218         }
 219     }
 220 }