import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
private final List<GeneratedTOBuilder> genTOs = new ArrayList<>();
private final Map<SchemaPath, Type> typedefs = new HashMap<>();
private final Map<SchemaPath, GeneratedTypeBuilder> childNodes = new HashMap<>();
+ private final BiMap<String, GeneratedTypeBuilder> dataTypes = HashBiMap.create();
private final Map<SchemaPath, GeneratedTypeBuilder> groupings = new HashMap<>();
private final Map<SchemaPath, GeneratedTypeBuilder> cases = new HashMap<>();
private final Map<QName,GeneratedTOBuilder> identities = new HashMap<>();
private final Set<GeneratedTypeBuilder> topLevelNodes = new HashSet<>();
private final List<GeneratedTypeBuilder> augmentations = new ArrayList<>();
private final BiMap<Type,AugmentationSchema> typeToAugmentation = HashBiMap.create();
+ private final BiMap<SchemaPath,Type> targetToAugmentation = HashBiMap.create();
private final Map<Type,Object> typeToSchema = new HashMap<>();
private final Multimap<Type, Type> choiceToCases = HashMultimap.create();
private final BiMap<Type,ChoiceCaseNode> caseTypeToSchema = HashBiMap.create();
private final Map<SchemaPath, Type> innerTypes = new HashMap<>();
+
List<Type> getGeneratedTypes() {
final List<Type> result = new ArrayList<>();
result.addAll(this.genTOs.stream().map(GeneratedTOBuilder::toInstance).collect(Collectors.toList()));
result.addAll(this.typedefs.values().stream().filter(b -> b != null).collect(Collectors.toList()));
- result.addAll(this.childNodes.values().stream().map(GeneratedTypeBuilder::toInstance).collect(Collectors.toList()));
+ result.addAll(this.dataTypes.values().stream().map(GeneratedTypeBuilder::toInstance).collect(Collectors.toList()));
result.addAll(this.groupings.values().stream().map(GeneratedTypeBuilder::toInstance).collect(Collectors.toList()));
result.addAll(this.cases.values().stream().map(GeneratedTypeBuilder::toInstance).collect(Collectors.toList()));
result.addAll(this.identities.values().stream().map(GeneratedTOBuilder::toInstance).collect(Collectors.toList()));
public void addChildNodeType(final SchemaNode p, final GeneratedTypeBuilder b) {
this.childNodes.put(p.getPath(), b);
this.typeToSchema.put(b,p);
+ this.dataTypes.put(b.getFullyQualifiedName(), b);
}
- public void addGroupingType(final SchemaPath p, final GeneratedTypeBuilder b) {
- this.groupings.put(p, b);
+ public void addGroupingType(final GroupingDefinition p, final GeneratedTypeBuilder b) {
+ this.groupings.put(p.getPath(), b);
+ this.typeToSchema.put(b, p);
}
public void addTypedefType(final SchemaPath p, final Type t) {
return Maps.unmodifiableBiMap(this.typeToAugmentation);
}
+ public BiMap<SchemaPath, Type> getTargetToAugmentation() {
+ return Maps.unmodifiableBiMap(this.targetToAugmentation);
+ }
+
public void addTypeToAugmentation(final GeneratedTypeBuilder builder, final AugmentationSchema schema) {
this.typeToAugmentation.put(builder, schema);
this.typeToSchema.put(builder, schema);
}
+ public void addTargetToAugmentation(final GeneratedTypeBuilder builder, final SchemaPath augmentTarget) {
+ this.targetToAugmentation.put(augmentTarget, builder);
+ }
+
public void addChoiceToCaseMapping(final Type choiceType, final Type caseType, final ChoiceCaseNode schema) {
this.choiceToCases.put(choiceType, caseType);
this.caseTypeToSchema.put(caseType, schema);