yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/builder/impl/NotificationBuilder.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 java.net.URI;
  11 import java.util.ArrayList;
  12 import java.util.Collections;
  13 import java.util.Date;
  14 import java.util.HashMap;
  15 import java.util.HashSet;
  16 import java.util.List;
  17 import java.util.Map;
  18 import java.util.Set;
  19
  20 import org.opendaylight.yangtools.yang.common.QName;
  21 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
  22 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  23 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
  24 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
  25 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  26 import org.opendaylight.yangtools.yang.model.api.Status;
  27 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  28 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
  29 import org.opendaylight.yangtools.yang.model.api.UsesNode;
  30 import org.opendaylight.yangtools.yang.parser.builder.api.AbstractDataNodeContainerBuilder;
  31 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
  32 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationTargetBuilder;
  33 import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
  34 import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
  35 import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
  36 import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
  37 import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
  38 import org.opendaylight.yangtools.yang.parser.util.Comparators;
  39 import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
  40 import org.opendaylight.yangtools.yang.parser.util.YangParseException;
  41
  42 public final class NotificationBuilder extends AbstractDataNodeContainerBuilder implements SchemaNodeBuilder,
  43         AugmentationTargetBuilder {
  44     private boolean isBuilt;
  45     private final NotificationDefinitionImpl instance;
  46     private SchemaPath schemaPath;
  47     private final List<AugmentationSchema> augmentations = new ArrayList<>();
  48     private final List<AugmentationSchemaBuilder> augmentationBuilders = new ArrayList<>();
  49
  50     NotificationBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
  51         super(moduleName, line, qname);
  52         this.schemaPath = path;
  53         instance = new NotificationDefinitionImpl(qname, path);
  54     }
  55
  56     NotificationBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path, NotificationDefinition base) {
  57         super(moduleName, line, qname);
  58         this.schemaPath = path;
  59         instance = new NotificationDefinitionImpl(qname, path);
  60
  61         instance.description = base.getDescription();
  62         instance.reference = base.getReference();
  63         instance.status = base.getStatus();
  64         instance.augmentations.addAll(base.getAvailableAugmentations());
  65
  66         URI ns = qname.getNamespace();
  67         Date rev = qname.getRevision();
  68         String pref = qname.getPrefix();
  69         addedChildNodes.addAll(ParserUtils.wrapChildNodes(moduleName, line, base.getChildNodes(), path, ns, rev, pref));
  70         addedGroupings.addAll(ParserUtils.wrapGroupings(moduleName, line, base.getGroupings(), path, ns, rev, pref));
  71
  72         instance.groupings.addAll(base.getGroupings());
  73         instance.typeDefinitions.addAll(base.getTypeDefinitions());
  74         instance.uses.addAll(base.getUses());
  75         instance.unknownNodes.addAll(base.getUnknownSchemaNodes());
  76     }
  77
  78     @Override
  79     public NotificationDefinition build() {
  80         if (!(parentBuilder instanceof ModuleBuilder)) {
  81             throw new YangParseException(moduleName, line, "Notification can be defined only under module (was " + parentBuilder + ")");
  82         }
  83         if (!isBuilt) {
  84             // CHILD NODES
  85             for (DataSchemaNodeBuilder node : addedChildNodes) {
  86                 DataSchemaNode child = node.build();
  87                 childNodes.put(child.getQName(), child);
  88             }
  89             instance.setChildNodes(childNodes);
  90
  91             // GROUPINGS
  92             for (GroupingBuilder builder : addedGroupings) {
  93                 groupings.add(builder.build());
  94             }
  95             instance.setGroupings(groupings);
  96
  97             // TYPEDEFS
  98             for (TypeDefinitionBuilder entry : addedTypedefs) {
  99                 typedefs.add(entry.build());
 100             }
 101             instance.setTypeDefinitions(typedefs);
 102
 103             // USES
 104             for (UsesNodeBuilder builder : addedUsesNodes) {
 105                 usesNodes.add(builder.build());
 106             }
 107             instance.setUses(usesNodes);
 108
 109             // AUGMENTATIONS
 110             for (AugmentationSchemaBuilder builder : augmentationBuilders) {
 111                 augmentations.add(builder.build());
 112             }
 113             instance.setAvailableAugmentations(new HashSet<>(augmentations));
 114
 115             // UNKNOWN NODES
 116             for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
 117                 unknownNodes.add(b.build());
 118             }
 119             Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
 120             instance.setUnknownSchemaNodes(unknownNodes);
 121
 122             isBuilt = true;
 123         }
 124
 125         return instance;
 126     }
 127
 128
 129     @Override
 130     public Set<TypeDefinitionBuilder> getTypeDefinitionBuilders() {
 131         return addedTypedefs;
 132     }
 133
 134     @Override
 135     public void addTypedef(final TypeDefinitionBuilder type) {
 136         addedTypedefs.add(type);
 137     }
 138
 139     @Override
 140     public SchemaPath getPath() {
 141         return schemaPath;
 142     }
 143
 144     @Override
 145     public String getDescription() {
 146         return instance.description;
 147     }
 148
 149     @Override
 150     public void setDescription(final String description) {
 151         instance.description = description;
 152     }
 153
 154     @Override
 155     public String getReference() {
 156         return instance.reference;
 157     }
 158
 159     @Override
 160     public void setReference(final String reference) {
 161         instance.reference = reference;
 162     }
 163
 164     @Override
 165     public Status getStatus() {
 166         return instance.status;
 167     }
 168
 169     @Override
 170     public void setStatus(Status status) {
 171         if (status != null) {
 172             instance.status = status;
 173         }
 174     }
 175
 176     @Override
 177     public void addAugmentation(AugmentationSchemaBuilder augment) {
 178         augmentationBuilders.add(augment);
 179     }
 180
 181     @Override
 182     public String toString() {
 183         return "notification " + getQName().getLocalName();
 184     }
 185
 186     public final class NotificationDefinitionImpl implements NotificationDefinition {
 187         private final QName qname;
 188         private final SchemaPath path;
 189         private String description;
 190         private String reference;
 191         private Status status = Status.CURRENT;
 192         private final Map<QName, DataSchemaNode> childNodes = new HashMap<>();
 193         private final Set<GroupingDefinition> groupings = new HashSet<>();
 194         private final Set<TypeDefinition<?>> typeDefinitions = new HashSet<>();
 195         private final Set<UsesNode> uses = new HashSet<>();
 196         private final Set<AugmentationSchema> augmentations = new HashSet<>();
 197         private final List<UnknownSchemaNode> unknownNodes = new ArrayList<>();
 198
 199         private NotificationDefinitionImpl(final QName qname, final SchemaPath path) {
 200             this.qname = qname;
 201             this.path = path;
 202         }
 203
 204         @Override
 205         public QName getQName() {
 206             return qname;
 207         }
 208
 209         @Override
 210         public SchemaPath getPath() {
 211             return path;
 212         }
 213
 214         @Override
 215         public String getDescription() {
 216             return description;
 217         }
 218
 219         @Override
 220         public String getReference() {
 221             return reference;
 222         }
 223
 224         @Override
 225         public Status getStatus() {
 226             return status;
 227         }
 228
 229         @Override
 230         public Set<DataSchemaNode> getChildNodes() {
 231             return Collections.unmodifiableSet(new HashSet<DataSchemaNode>(childNodes.values()));
 232         }
 233
 234         private void setChildNodes(Map<QName, DataSchemaNode> childNodes) {
 235             if (childNodes != null) {
 236                 this.childNodes.putAll(childNodes);
 237             }
 238         }
 239
 240         @Override
 241         public Set<GroupingDefinition> getGroupings() {
 242             return Collections.unmodifiableSet(groupings);
 243         }
 244
 245         private void setGroupings(Set<GroupingDefinition> groupings) {
 246             if (groupings != null) {
 247                 this.groupings.addAll(groupings);
 248             }
 249         }
 250
 251         @Override
 252         public Set<UsesNode> getUses() {
 253             return Collections.unmodifiableSet(uses);
 254         }
 255
 256         private void setUses(Set<UsesNode> uses) {
 257             if (uses != null) {
 258                 this.uses.addAll(uses);
 259             }
 260         }
 261
 262         @Override
 263         public Set<TypeDefinition<?>> getTypeDefinitions() {
 264             return Collections.unmodifiableSet(typeDefinitions);
 265         }
 266
 267         private void setTypeDefinitions(final Set<TypeDefinition<?>> typeDefinitions) {
 268             if (typeDefinitions != null) {
 269                 this.typeDefinitions.addAll(typeDefinitions);
 270             }
 271         }
 272
 273         @Override
 274         public Set<AugmentationSchema> getAvailableAugmentations() {
 275             return Collections.unmodifiableSet(augmentations);
 276         }
 277
 278         private void setAvailableAugmentations(Set<AugmentationSchema> augmentations) {
 279             if (augmentations != null) {
 280                 this.augmentations.addAll(augmentations);
 281             }
 282         }
 283
 284         @Override
 285         public List<UnknownSchemaNode> getUnknownSchemaNodes() {
 286             return Collections.unmodifiableList(unknownNodes);
 287         }
 288
 289         private void setUnknownSchemaNodes(final List<UnknownSchemaNode> unknownNodes) {
 290             if (unknownNodes != null) {
 291                 this.unknownNodes.addAll(unknownNodes);
 292             }
 293         }
 294
 295         @Override
 296         public DataSchemaNode getDataChildByName(QName name) {
 297             return childNodes.get(name);
 298         }
 299
 300         @Override
 301         public DataSchemaNode getDataChildByName(String name) {
 302             DataSchemaNode result = null;
 303             for (Map.Entry<QName, DataSchemaNode> entry : childNodes.entrySet()) {
 304                 if (entry.getKey().getLocalName().equals(name)) {
 305                     result = entry.getValue();
 306                     break;
 307                 }
 308             }
 309             return result;
 310         }
 311
 312         @Override
 313         public int hashCode() {
 314             final int prime = 31;
 315             int result = 1;
 316             result = prime * result + ((qname == null) ? 0 : qname.hashCode());
 317             result = prime * result + ((path == null) ? 0 : path.hashCode());
 318             return result;
 319         }
 320
 321         @Override
 322         public boolean equals(Object obj) {
 323             if (this == obj) {
 324                 return true;
 325             }
 326             if (obj == null) {
 327                 return false;
 328             }
 329             if (getClass() != obj.getClass()) {
 330                 return false;
 331             }
 332             final NotificationDefinitionImpl other = (NotificationDefinitionImpl) obj;
 333             if (qname == null) {
 334                 if (other.qname != null) {
 335                     return false;
 336                 }
 337             } else if (!qname.equals(other.qname)) {
 338                 return false;
 339             }
 340             if (path == null) {
 341                 if (other.path != null) {
 342                     return false;
 343                 }
 344             } else if (!path.equals(other.path)) {
 345                 return false;
 346             }
 347             return true;
 348         }
 349
 350         @Override
 351         public String toString() {
 352             StringBuilder sb = new StringBuilder(NotificationDefinitionImpl.class.getSimpleName());
 353             sb.append("[qname=" + qname + ", path=" + path + "]");
 354             return sb.toString();
 355         }
 356     }
 357
 358 }