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