code-generator/binding-generator-impl/src/main/java/org/opendaylight/yangtools/sal/binding/generator/impl/ModuleContext.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.sal.binding.generator.impl;
   9
  10 import java.util.ArrayList;
  11 import java.util.HashMap;
  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.sal.binding.model.api.Type;
  18 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTOBuilder;
  19 import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTypeBuilder;
  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.SchemaPath;
  23
  24 public final class ModuleContext {
  25     private GeneratedTypeBuilder moduleNode;
  26     private final List<GeneratedTOBuilder> genTOs = new ArrayList<GeneratedTOBuilder>();
  27     private final Map<SchemaPath, Type> typedefs = new HashMap<SchemaPath, Type>();
  28     private final Map<SchemaPath, GeneratedTypeBuilder> childNodes = new HashMap<SchemaPath, GeneratedTypeBuilder>();
  29     private final Map<SchemaPath, GeneratedTypeBuilder> groupings = new HashMap<SchemaPath, GeneratedTypeBuilder>();
  30     private final Map<SchemaPath, GeneratedTypeBuilder> cases = new HashMap<SchemaPath, GeneratedTypeBuilder>();
  31     private final Map<QName,GeneratedTOBuilder> identities = new HashMap<>();
  32     private final Set<GeneratedTypeBuilder> topLevelNodes = new HashSet<GeneratedTypeBuilder>();
  33     private final List<GeneratedTypeBuilder> augmentations = new ArrayList<GeneratedTypeBuilder>();
  34     private final Map<Type,AugmentationSchema> typeToAugmentation = new HashMap<>();
  35
  36
  37
  38     List<Type> getGeneratedTypes() {
  39         List<Type> result = new ArrayList<>();
  40
  41         if (moduleNode != null) {
  42             result.add(moduleNode.toInstance());
  43         }
  44
  45         for (GeneratedTOBuilder b : genTOs) {
  46             result.add(b.toInstance());
  47         }
  48         for (Type b : typedefs.values()) {
  49             if (b != null) {
  50                 result.add(b);
  51             }
  52         }
  53         for (GeneratedTypeBuilder b : childNodes.values()) {
  54             result.add(b.toInstance());
  55         }
  56         for (GeneratedTypeBuilder b : groupings.values()) {
  57             result.add(b.toInstance());
  58         }
  59         for (GeneratedTypeBuilder b : cases.values()) {
  60             result.add(b.toInstance());
  61         }
  62         for (GeneratedTOBuilder b : identities.values()) {
  63             result.add(b.toInstance());
  64         }
  65         for (GeneratedTypeBuilder b : topLevelNodes) {
  66             result.add(b.toInstance());
  67         }
  68         for (GeneratedTypeBuilder b : augmentations) {
  69             result.add(b.toInstance());
  70         }
  71         return result;
  72     }
  73
  74     public GeneratedTypeBuilder getModuleNode() {
  75         return moduleNode;
  76     }
  77
  78     public GeneratedTypeBuilder getChildNode(SchemaPath p) {
  79         return childNodes.get(p);
  80     }
  81
  82     public GeneratedTypeBuilder getGrouping(SchemaPath p) {
  83         return groupings.get(p);
  84     }
  85
  86     public GeneratedTypeBuilder getCase(SchemaPath p) {
  87         return cases.get(p);
  88     }
  89
  90     public void addModuleNode(GeneratedTypeBuilder moduleNode) {
  91         this.moduleNode = moduleNode;
  92     }
  93
  94     public void addGeneratedTOBuilder(GeneratedTOBuilder b) {
  95         genTOs.add(b);
  96     }
  97
  98     public void addChildNodeType(SchemaPath p, GeneratedTypeBuilder b) {
  99         childNodes.put(p, b);
 100     }
 101
 102     public void addGroupingType(SchemaPath p, GeneratedTypeBuilder b) {
 103         groupings.put(p, b);
 104     }
 105
 106     public void addTypedefType(SchemaPath p, Type t) {
 107         typedefs.put(p, t);
 108     }
 109
 110     public void addCaseType(SchemaPath p, GeneratedTypeBuilder b) {
 111         cases.put(p, b);
 112     }
 113
 114     public void addIdentityType(QName name,GeneratedTOBuilder b) {
 115         identities.put(name,b);
 116     }
 117
 118     public void addTopLevelNodeType(GeneratedTypeBuilder b) {
 119         topLevelNodes.add(b);
 120     }
 121
 122     public void addAugmentType(GeneratedTypeBuilder b) {
 123         augmentations.add(b);
 124     }
 125
 126     public Map<SchemaPath, Type> getTypedefs() {
 127         return typedefs;
 128     }
 129
 130     public Map<SchemaPath, GeneratedTypeBuilder> getChildNodes() {
 131         return childNodes;
 132     }
 133
 134     public Map<SchemaPath, GeneratedTypeBuilder> getGroupings() {
 135         return groupings;
 136     }
 137
 138     public Map<SchemaPath, GeneratedTypeBuilder> getCases() {
 139         return cases;
 140     }
 141
 142     public Map<QName,GeneratedTOBuilder> getIdentities() {
 143         return identities;
 144     }
 145
 146     public Set<GeneratedTypeBuilder> getTopLevelNodes() {
 147         return topLevelNodes;
 148     }
 149
 150     public List<GeneratedTypeBuilder> getAugmentations() {
 151         return augmentations;
 152     }
 153
 154     public Map<Type, AugmentationSchema> getTypeToAugmentation() {
 155         return typeToAugmentation;
 156     }
 157
 158     public void addTypeToAugmentation(GeneratedTypeBuilder builder, AugmentationSchema schema) {
 159         typeToAugmentation.put(builder, schema);
 160     }
 161
 162 }