yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/ContainerSchemaNodeBuilder.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.yangtools.yang.parser.builder.impl;
   9
  10 import com.google.common.base.Preconditions;
  11 import com.google.common.collect.ImmutableList;
  12 import com.google.common.collect.ImmutableSet;
  13 import java.util.ArrayList;
  14 import java.util.List;
  15 import java.util.Objects;
  16 import org.opendaylight.yangtools.yang.common.QName;
  17 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
  18 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
  19 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  20 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
  21 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationTargetBuilder;
  22 import org.opendaylight.yangtools.yang.parser.builder.api.ConstraintsBuilder;
  23 import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
  24 import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
  25 import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
  26 import org.opendaylight.yangtools.yang.parser.builder.util.AbstractDocumentedDataNodeContainerBuilder;
  27
  28 /**
  29  * @deprecated Pre-Beryllium implementation, scheduled for removal.
  30  */
  31 @Deprecated
  32 public final class ContainerSchemaNodeBuilder extends AbstractDocumentedDataNodeContainerBuilder implements
  33         AugmentationTargetBuilder, DataSchemaNodeBuilder {
  34     private ContainerSchemaNodeImpl instance;
  35     private boolean presence;
  36     // SchemaNode args
  37     private SchemaPath path;
  38     // DataSchemaNode args
  39     private boolean augmenting;
  40     private boolean addedByUses;
  41     private boolean configuration;
  42     private ContainerSchemaNode originalNode;
  43     private ContainerSchemaNodeBuilder originalBuilder;
  44     private final ConstraintsBuilder constraints;
  45     // AugmentationTarget args
  46     private final List<AugmentationSchema> augmentations = new ArrayList<>();
  47     private final List<AugmentationSchemaBuilder> augmentationBuilders = new ArrayList<>();
  48
  49     public ContainerSchemaNodeBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
  50         super(moduleName, line, qname);
  51         this.path = Preconditions.checkNotNull(path, "Schema Path must not be null");
  52         this.constraints = new ConstraintsBuilderImpl(moduleName, line);
  53     }
  54
  55     // constructor for uses
  56     public ContainerSchemaNodeBuilder(final String moduleName, final int line, final QName qname,
  57             final SchemaPath path, final ContainerSchemaNode base) {
  58         super(moduleName, line, qname, path, base);
  59         this.path = Preconditions.checkNotNull(path, "Schema Path must not be null");
  60
  61         constraints = new ConstraintsBuilderImpl(moduleName, line, base.getConstraints());
  62
  63         augmenting = base.isAugmenting();
  64         addedByUses = base.isAddedByUses();
  65         originalNode = base;
  66         configuration = base.isConfiguration();
  67         presence = base.isPresenceContainer();
  68
  69         augmentations.addAll(base.getAvailableAugmentations());
  70
  71     }
  72
  73     @Override
  74     protected String getStatementName() {
  75         return "container";
  76     }
  77
  78     @Override
  79     public ContainerSchemaNode build() {
  80         if (instance != null) {
  81             return instance;
  82         }
  83
  84         buildChildren();
  85         instance = new ContainerSchemaNodeImpl(this);
  86
  87         instance.augmenting = augmenting;
  88         instance.addedByUses = addedByUses;
  89         instance.configuration = configuration;
  90         instance.constraints = constraints.build();
  91         instance.presence = presence;
  92
  93         // ORIGINAL NODE
  94         if (originalNode == null && originalBuilder != null) {
  95             originalNode = originalBuilder.build();
  96         }
  97         instance.original = originalNode;
  98
  99         // AUGMENTATIONS
 100         for (AugmentationSchemaBuilder builder : augmentationBuilders) {
 101             augmentations.add(builder.build());
 102         }
 103         instance.augmentations = ImmutableSet.copyOf(augmentations);
 104
 105         // UNKNOWN NODES
 106         for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
 107             unknownNodes.add(b.build());
 108         }
 109         instance.unknownNodes = ImmutableList.copyOf(unknownNodes);
 110
 111         return instance;
 112     }
 113
 114     public List<AugmentationSchemaBuilder> getAugmentationBuilders() {
 115         return augmentationBuilders;
 116     }
 117
 118     @Override
 119     public void addAugmentation(final AugmentationSchemaBuilder augment) {
 120         augmentationBuilders.add(augment);
 121     }
 122
 123     @Override
 124     public SchemaPath getPath() {
 125         return path;
 126     }
 127
 128     @Override
 129     public void setPath(final SchemaPath path) {
 130         this.path = path;
 131     }
 132
 133     @Override
 134     public boolean isAugmenting() {
 135         return augmenting;
 136     }
 137
 138     @Override
 139     public void setAugmenting(final boolean augmenting) {
 140         this.augmenting = augmenting;
 141     }
 142
 143     @Override
 144     public boolean isAddedByUses() {
 145         return addedByUses;
 146     }
 147
 148     @Override
 149     public void setAddedByUses(final boolean addedByUses) {
 150         this.addedByUses = addedByUses;
 151     }
 152
 153     @Override
 154     public ContainerSchemaNodeBuilder getOriginal() {
 155         return originalBuilder;
 156     }
 157
 158     @Override
 159     public void setOriginal(final SchemaNodeBuilder builder) {
 160         Preconditions.checkArgument(builder instanceof ContainerSchemaNodeBuilder, "Original of container cannot be "
 161                 + builder);
 162         this.originalBuilder = (ContainerSchemaNodeBuilder) builder;
 163     }
 164
 165     @Override
 166     public boolean isConfiguration() {
 167         return configuration;
 168     }
 169
 170     @Override
 171     public void setConfiguration(final boolean configuration) {
 172         this.configuration = configuration;
 173     }
 174
 175     @Override
 176     public ConstraintsBuilder getConstraints() {
 177         return constraints;
 178     }
 179
 180     public boolean isPresence() {
 181         return presence;
 182     }
 183
 184     public void setPresence(final boolean presence) {
 185         this.presence = presence;
 186     }
 187
 188     @Override
 189     public int hashCode() {
 190         final int prime = 31;
 191         int result = 1;
 192         result = prime * result + Objects.hashCode(path);
 193         return result;
 194     }
 195
 196     @Override
 197     public boolean equals(final Object obj) {
 198         if (this == obj) {
 199             return true;
 200         }
 201         if (obj == null) {
 202             return false;
 203         }
 204         if (getClass() != obj.getClass()) {
 205             return false;
 206         }
 207         ContainerSchemaNodeBuilder other = (ContainerSchemaNodeBuilder) obj;
 208         if (path == null) {
 209             if (other.path != null) {
 210                 return false;
 211             }
 212         } else if (!path.equals(other.path)) {
 213             return false;
 214         }
 215         if (getParent() == null) {
 216             if (other.getParent() != null) {
 217                 return false;
 218             }
 219         } else if (!getParent().equals(other.getParent())) {
 220             return false;
 221         }
 222         return true;
 223     }
 224
 225     @Override
 226     public String toString() {
 227         return "container " + qname.getLocalName();
 228     }
 229
 230 }