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