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