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.Date;
  13 import java.util.List;
  14 import java.util.Set;
  15
  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.NotificationDefinition;
  19 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  20 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
  21 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
  22 import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationTargetBuilder;
  23 import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
  24 import org.opendaylight.yangtools.yang.parser.builder.api.UnknownSchemaNodeBuilder;
  25 import org.opendaylight.yangtools.yang.parser.builder.util.AbstractDocumentedDataNodeContainer;
  26 import org.opendaylight.yangtools.yang.parser.builder.util.AbstractDocumentedDataNodeContainerBuilder;
  27 import org.opendaylight.yangtools.yang.parser.util.YangParseException;
  28
  29 import com.google.common.base.Preconditions;
  30 import com.google.common.collect.ImmutableList;
  31 import com.google.common.collect.ImmutableSet;
  32
  33 public final class NotificationBuilder extends AbstractDocumentedDataNodeContainerBuilder implements SchemaNodeBuilder,
  34         AugmentationTargetBuilder {
  35     private NotificationDefinitionImpl instance;
  36     // SchemaNode args
  37     private SchemaPath schemaPath;
  38     // AugmentationTarget args
  39     private final List<AugmentationSchema> augmentations = new ArrayList<>();
  40     private final List<AugmentationSchemaBuilder> augmentationBuilders = new ArrayList<>();
  41
  42     NotificationBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path) {
  43         super(moduleName, line, qname);
  44         this.schemaPath = Preconditions.checkNotNull(path, "Schema Path must not be null");
  45     }
  46
  47     NotificationBuilder(final String moduleName, final int line, final QName qname, final SchemaPath path,
  48             final NotificationDefinition base) {
  49         super(moduleName, line, qname, path, base);
  50         this.schemaPath = Preconditions.checkNotNull(path, "Schema Path must not be null");
  51
  52         URI ns = qname.getNamespace();
  53         Date rev = qname.getRevision();
  54         String pref = qname.getPrefix();
  55         addedUnknownNodes.addAll(BuilderUtils.wrapUnknownNodes(moduleName, line, base.getUnknownSchemaNodes(), path,
  56                 ns, rev, pref));
  57
  58         augmentations.addAll(base.getAvailableAugmentations());
  59
  60     }
  61
  62     @Override
  63     public NotificationDefinition build() {
  64         if (!(getParent() instanceof ModuleBuilder)) {
  65             throw new YangParseException(getModuleName(), getLine(),
  66                     "Notification can be defined only under module (was " + getParent() + ")");
  67         }
  68         if (instance != null) {
  69             return instance;
  70         }
  71         buildChildren();
  72
  73         instance = new NotificationDefinitionImpl(qname, schemaPath, this);
  74
  75         // AUGMENTATIONS
  76         for (AugmentationSchemaBuilder builder : augmentationBuilders) {
  77             augmentations.add(builder.build());
  78         }
  79         instance.augmentations = ImmutableSet.copyOf(augmentations);
  80
  81         // UNKNOWN NODES
  82         for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
  83             unknownNodes.add(b.build());
  84         }
  85         instance.unknownNodes = ImmutableList.copyOf(unknownNodes);
  86
  87         return instance;
  88     }
  89
  90     @Override
  91     public SchemaPath getPath() {
  92         return schemaPath;
  93     }
  94
  95     @Override
  96     public void setPath(final SchemaPath path) {
  97         this.schemaPath = path;
  98     }
  99
 100     @Override
 101     public void addAugmentation(final AugmentationSchemaBuilder augment) {
 102         augmentationBuilders.add(augment);
 103     }
 104
 105     @Override
 106     public String toString() {
 107         return "notification " + getQName().getLocalName();
 108     }
 109
 110     @Override
 111     protected String getStatementName() {
 112         return "notification";
 113     }
 114
 115     private static final class NotificationDefinitionImpl extends AbstractDocumentedDataNodeContainer implements
 116             NotificationDefinition {
 117         private final QName qname;
 118         private final SchemaPath path;
 119         private ImmutableSet<AugmentationSchema> augmentations;
 120         private ImmutableList<UnknownSchemaNode> unknownNodes;
 121
 122         NotificationDefinitionImpl(final QName qname, final SchemaPath path, final NotificationBuilder builder) {
 123             super(builder);
 124             // TODO Auto-generated constructor stub
 125             this.qname = qname;
 126             this.path = path;
 127         }
 128
 129         @Override
 130         public QName getQName() {
 131             return qname;
 132         }
 133
 134         @Override
 135         public SchemaPath getPath() {
 136             return path;
 137         }
 138
 139         @Override
 140         public Set<AugmentationSchema> getAvailableAugmentations() {
 141             return augmentations;
 142         }
 143
 144         @Override
 145         public List<UnknownSchemaNode> getUnknownSchemaNodes() {
 146             return unknownNodes;
 147         }
 148
 149         @Override
 150         public int hashCode() {
 151             final int prime = 31;
 152             int result = 1;
 153             result = prime * result + ((qname == null) ? 0 : qname.hashCode());
 154             result = prime * result + ((path == null) ? 0 : path.hashCode());
 155             return result;
 156         }
 157
 158         @Override
 159         public boolean equals(final Object obj) {
 160             if (this == obj) {
 161                 return true;
 162             }
 163             if (obj == null) {
 164                 return false;
 165             }
 166             if (getClass() != obj.getClass()) {
 167                 return false;
 168             }
 169             final NotificationDefinitionImpl other = (NotificationDefinitionImpl) obj;
 170             if (qname == null) {
 171                 if (other.qname != null) {
 172                     return false;
 173                 }
 174             } else if (!qname.equals(other.qname)) {
 175                 return false;
 176             }
 177             if (path == null) {
 178                 if (other.path != null) {
 179                     return false;
 180                 }
 181             } else if (!path.equals(other.path)) {
 182                 return false;
 183             }
 184             return true;
 185         }
 186
 187         @Override
 188         public String toString() {
 189             StringBuilder sb = new StringBuilder(NotificationDefinitionImpl.class.getSimpleName());
 190             sb.append("[qname=" + qname + ", path=" + path + "]");
 191             return sb.toString();
 192         }
 193     }
 194
 195 }