yang/yang-parser-impl/src/main/java/org/opendaylight/yangtools/yang/parser/impl/SchemaContextImpl.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.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.HashSet;
  15 import java.util.LinkedHashSet;
  16 import java.util.List;
  17 import java.util.Set;
  18 import java.util.TreeMap;
  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.ConstraintDefinition;
  23 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
  24 import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
  25 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
  26 import org.opendaylight.yangtools.yang.model.api.Module;
  27 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
  28 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
  29 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  30 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  31 import org.opendaylight.yangtools.yang.model.api.Status;
  32 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
  33 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
  34 import org.opendaylight.yangtools.yang.model.api.UsesNode;
  35 import org.opendaylight.yangtools.yang.parser.util.ModuleDependencySort;
  36
  37 final class SchemaContextImpl implements SchemaContext {
  38     private final Set<Module> modules;
  39
  40     SchemaContextImpl(final Set<Module> modules) {
  41         this.modules = modules;
  42     }
  43
  44     @Override
  45     public Set<DataSchemaNode> getDataDefinitions() {
  46         final Set<DataSchemaNode> dataDefs = new HashSet<DataSchemaNode>();
  47         for (Module m : modules) {
  48             dataDefs.addAll(m.getChildNodes());
  49         }
  50         return dataDefs;
  51     }
  52
  53     @Override
  54     public Set<Module> getModules() {
  55         List<Module> sorted = ModuleDependencySort.sort(modules.toArray(new Module[modules.size()]));
  56         return new LinkedHashSet<Module>(sorted);
  57     }
  58
  59     @Override
  60     public Set<NotificationDefinition> getNotifications() {
  61         final Set<NotificationDefinition> notifications = new HashSet<NotificationDefinition>();
  62         for (Module m : modules) {
  63             notifications.addAll(m.getNotifications());
  64         }
  65         return notifications;
  66     }
  67
  68     @Override
  69     public Set<RpcDefinition> getOperations() {
  70         final Set<RpcDefinition> rpcs = new HashSet<RpcDefinition>();
  71         for (Module m : modules) {
  72             rpcs.addAll(m.getRpcs());
  73         }
  74         return rpcs;
  75     }
  76
  77     @Override
  78     public Set<ExtensionDefinition> getExtensions() {
  79         final Set<ExtensionDefinition> extensions = new HashSet<ExtensionDefinition>();
  80         for (Module m : modules) {
  81             extensions.addAll(m.getExtensionSchemaNodes());
  82         }
  83         return extensions;
  84     }
  85
  86     @Override
  87     public Module findModuleByName(final String name, final Date revision) {
  88         if (name != null) {
  89             for (final Module module : modules) {
  90                 if (revision == null) {
  91                     if (module.getName().equals(name)) {
  92                         return module;
  93                     }
  94                 } else if (module.getName().equals(name) && module.getRevision().equals(revision)) {
  95                     return module;
  96                 }
  97             }
  98         }
  99         return null;
 100     }
 101
 102     @Override
 103     public Set<Module> findModuleByNamespace(final URI namespace) {
 104         final Set<Module> ret = new HashSet<Module>();
 105         if (namespace != null) {
 106             for (final Module module : modules) {
 107                 if (module.getNamespace().equals(namespace)) {
 108                     ret.add(module);
 109                 }
 110             }
 111         }
 112         return ret;
 113     }
 114
 115     @Override
 116     public Module findModuleByNamespaceAndRevision(URI namespace, Date revision) {
 117         if (namespace != null) {
 118             Set<Module> modules = findModuleByNamespace(namespace);
 119
 120             if (revision == null) {
 121                 TreeMap<Date, Module> map = new TreeMap<Date, Module>();
 122                 for (Module module : modules) {
 123                     map.put(module.getRevision(), module);
 124                 }
 125                 if (map.isEmpty()) {
 126                     return null;
 127                 }
 128                 return map.lastEntry().getValue();
 129             } else {
 130                 for (Module module : modules) {
 131                     if (module.getRevision().equals(revision)) {
 132                         return(module);
 133                     }
 134                 }
 135             }
 136         }
 137         return null;
 138     }
 139
 140     @Override
 141     public boolean isAugmenting() {
 142         return false;
 143     }
 144
 145     @Override
 146     public boolean isAddedByUses() {
 147         return false;
 148     }
 149
 150     @Override
 151     public boolean isConfiguration() {
 152         return false;
 153     }
 154
 155     @Override
 156     public ConstraintDefinition getConstraints() {
 157         return null;
 158     }
 159
 160     @Override
 161     public QName getQName() {
 162         return SchemaContext.NAME;
 163     }
 164
 165     @Override
 166     public SchemaPath getPath() {
 167         return null;
 168     }
 169
 170     @Override
 171     public String getDescription() {
 172         return null;
 173     }
 174
 175     @Override
 176     public String getReference() {
 177         return null;
 178     }
 179
 180     @Override
 181     public Status getStatus() {
 182         return Status.CURRENT;
 183     }
 184
 185     @Override
 186     public List<UnknownSchemaNode> getUnknownSchemaNodes() {
 187         final List<UnknownSchemaNode> result = new ArrayList<>();
 188         for (Module module : modules) {
 189             result.addAll(module.getUnknownSchemaNodes());
 190         }
 191         return Collections.unmodifiableList(result);
 192     }
 193
 194     @Override
 195     public Set<TypeDefinition<?>> getTypeDefinitions() {
 196         final Set<TypeDefinition<?>> result = new LinkedHashSet<>();
 197         for (Module module : modules) {
 198             result.addAll(module.getTypeDefinitions());
 199         }
 200         return Collections.unmodifiableSet(result);
 201     }
 202
 203     @Override
 204     public Set<DataSchemaNode> getChildNodes() {
 205         final Set<DataSchemaNode> result = new LinkedHashSet<>();
 206         for (Module module : modules) {
 207             result.addAll(module.getChildNodes());
 208         }
 209         return Collections.unmodifiableSet(result);
 210     }
 211
 212     @Override
 213     public Set<GroupingDefinition> getGroupings() {
 214         final Set<GroupingDefinition> result = new LinkedHashSet<>();
 215         for (Module module : modules) {
 216             result.addAll(module.getGroupings());
 217         }
 218         return Collections.unmodifiableSet(result);
 219     }
 220
 221     @Override
 222     public DataSchemaNode getDataChildByName(QName name) {
 223         DataSchemaNode result = null;
 224         for (Module module : modules) {
 225             result = module.getDataChildByName(name);
 226             if (result != null) {
 227                 break;
 228             }
 229         }
 230         return result;
 231     }
 232
 233     @Override
 234     public DataSchemaNode getDataChildByName(String name) {
 235         DataSchemaNode result = null;
 236         for (Module module : modules) {
 237             result = module.getDataChildByName(name);
 238             if (result != null) {
 239                 break;
 240             }
 241         }
 242         return result;
 243     }
 244
 245     @Override
 246     public Set<UsesNode> getUses() {
 247         return Collections.emptySet();
 248     }
 249
 250     @Override
 251     public boolean isPresenceContainer() {
 252         return false;
 253     }
 254
 255     @Override
 256     public Set<AugmentationSchema> getAvailableAugmentations() {
 257         return Collections.emptySet();
 258     }
 259
 260 }