*/
package org.opendaylight.mdsal.binding.generator.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
import com.google.common.collect.HashMultimap;
import java.util.List;
import java.util.Map;
import java.util.Set;
+import javax.annotation.concurrent.NotThreadSafe;
+import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
import org.opendaylight.mdsal.binding.model.api.Type;
-import org.opendaylight.mdsal.binding.model.api.type.builder.EnumBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder;
import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
+import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
-import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
+import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus;
+import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
+import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
+import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
+import org.opendaylight.yangtools.yang.model.api.OperationDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+@NotThreadSafe
public final class ModuleContext {
- private GeneratedTypeBuilder moduleNode;
- private final List<GeneratedTOBuilder> genTOs = new ArrayList<>();
- private final Map<SchemaPath, Type> typedefs = new HashMap<>();
+ private static final Logger LOG = LoggerFactory.getLogger(ModuleContext.class);
+
+ private final BiMap<Type, AugmentationSchemaNode> typeToAugmentation = HashBiMap.create();
private final Map<SchemaPath, GeneratedTypeBuilder> childNodes = new HashMap<>();
private final Map<SchemaPath, GeneratedTypeBuilder> groupings = new HashMap<>();
+ private final BiMap<Type, CaseSchemaNode> caseTypeToSchema = HashBiMap.create();
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 Map<QName, GeneratedTypeBuilder> identities = new HashMap<>();
private final List<GeneratedTypeBuilder> augmentations = new ArrayList<>();
- private final BiMap<Type, AugmentationSchema> typeToAugmentation = HashBiMap.create();
+ private final Multimap<Type, Type> choiceToCases = HashMultimap.create();
+ private final Set<GeneratedTypeBuilder> topLevelNodes = new HashSet<>();
+ private final Map<Type, WithStatus> typeToSchema = new HashMap<>();
+ private final List<GeneratedTOBuilder> genTOs = new ArrayList<>();
+ private final Map<SchemaPath, Type> innerTypes = new HashMap<>();
+ private final Map<SchemaPath, Type> typedefs = new HashMap<>();
+ private final Module module;
- private final Map<Type,Object> typeToSchema = new HashMap<>();
+ // Conflict mapping
+ private final Map<JavaTypeName, SchemaNode> nameMapping = new HashMap<>();
+ private GeneratedTypeBuilder moduleNode;
+ private String modulePackageName;
- private final Multimap<Type, Type> choiceToCases = HashMultimap.create();
- private final BiMap<Type, ChoiceCaseNode> caseTypeToSchema = HashBiMap.create();
+ ModuleContext(final Module module) {
+ this.module = requireNonNull(module);
+ }
- private final Map<SchemaPath, Type> innerTypes = new HashMap<>();
+ Module module() {
+ return module;
+ }
+
+ String modulePackageName() {
+ String ret = modulePackageName;
+ if (ret == null) {
+ modulePackageName = ret = BindingMapping.getRootPackageName(module.getQNameModule());
+ }
+ return ret;
+ }
List<Type> getGeneratedTypes() {
List<Type> result = new ArrayList<>();
if (moduleNode != null) {
- result.add(moduleNode.toInstance());
+ result.add(moduleNode.build());
}
for (GeneratedTOBuilder b : genTOs) {
- result.add(b.toInstance());
+ result.add(b.build());
}
for (Type b : typedefs.values()) {
if (b != null) {
}
}
for (GeneratedTypeBuilder b : childNodes.values()) {
- result.add(b.toInstance());
+ result.add(b.build());
}
for (GeneratedTypeBuilder b : groupings.values()) {
- result.add(b.toInstance());
+ result.add(b.build());
}
for (GeneratedTypeBuilder b : cases.values()) {
- result.add(b.toInstance());
+ result.add(b.build());
}
- for (GeneratedTOBuilder b : identities.values()) {
- result.add(b.toInstance());
+ for (GeneratedTypeBuilder b : identities.values()) {
+ result.add(b.build());
}
for (GeneratedTypeBuilder b : topLevelNodes) {
- result.add(b.toInstance());
+ result.add(b.build());
}
for (GeneratedTypeBuilder b : augmentations) {
- result.add(b.toInstance());
+ result.add(b.build());
}
return result;
}
genTOs.add(b);
}
- public void addChildNodeType(final SchemaNode p, final GeneratedTypeBuilder b) {
- childNodes.put(p.getPath(), b);
- typeToSchema.put(b,p);
+ public void addChildNodeType(final SchemaNode def, final GeneratedTypeBuilder b) {
+ checkNamingConflict(def, b.getIdentifier());
+ childNodes.put(def.getPath(), b);
+ typeToSchema.put(b, def);
}
- public void addGroupingType(final SchemaPath p, final GeneratedTypeBuilder b) {
- groupings.put(p, b);
+ public void addGroupingType(final GroupingDefinition def, final GeneratedTypeBuilder b) {
+ checkNamingConflict(def, b.getIdentifier());
+ groupings.put(def.getPath(), b);
}
- public void addTypedefType(final SchemaPath p, final Type t) {
- typedefs.put(p, t);
+ public void addTypedefType(final TypeDefinition<?> def, final Type t) {
+ final JavaTypeName name = t.getIdentifier();
+ final SchemaNode existingDef = nameMapping.putIfAbsent(name, def);
+ if (existingDef != null) {
+ if (!(existingDef instanceof TypeDefinition)) {
+ throw resolveNamingConfict(existingDef, def, name);
+ }
+
+ // This seems to be fine
+ LOG.debug("GeneratedType conflict between {} and {} on {}", def, existingDef, name);
+ }
+
+ typedefs.put(def.getPath(), t);
}
public void addCaseType(final SchemaPath p, final GeneratedTypeBuilder b) {
cases.put(p, b);
}
- public void addIdentityType(final QName name,final GeneratedTOBuilder b) {
- identities.put(name,b);
+ public void addIdentityType(final IdentitySchemaNode def, final GeneratedTypeBuilder b) {
+ checkNamingConflict(def, b.getIdentifier());
+ identities.put(def.getQName(), b);
}
public void addTopLevelNodeType(final GeneratedTypeBuilder b) {
return Collections.unmodifiableMap(cases);
}
- public Map<QName,GeneratedTOBuilder> getIdentities() {
+ public Map<QName, GeneratedTypeBuilder> getIdentities() {
return Collections.unmodifiableMap(identities);
}
return Collections.unmodifiableList(augmentations);
}
- public BiMap<Type, AugmentationSchema> getTypeToAugmentation() {
+ public BiMap<Type, AugmentationSchemaNode> getTypeToAugmentation() {
return Maps.unmodifiableBiMap(typeToAugmentation);
}
- public void addTypeToAugmentation(final GeneratedTypeBuilder builder, final AugmentationSchema schema) {
+ public void addTypeToAugmentation(final GeneratedTypeBuilder builder, final AugmentationSchemaNode schema) {
typeToAugmentation.put(builder, schema);
typeToSchema.put(builder, schema);
}
- public void addChoiceToCaseMapping(final Type choiceType, final Type caseType, final ChoiceCaseNode schema) {
+ public void addChoiceToCaseMapping(final Type choiceType, final Type caseType, final CaseSchemaNode schema) {
choiceToCases.put(choiceType, caseType);
caseTypeToSchema.put(caseType, schema);
typeToSchema.put(caseType, schema);
}
- public BiMap<Type, ChoiceCaseNode> getCaseTypeToSchemas() {
+ public BiMap<Type, CaseSchemaNode> getCaseTypeToSchemas() {
return Maps.unmodifiableBiMap(caseTypeToSchema);
}
/**
- *
* Returns mapping of type to its schema.
*
- * Valid values are only instances of {@link DataSchemaNode} or {@link AugmentationSchema}
+ * Valid values are only instances of {@link DataSchemaNode} or {@link AugmentationSchemaNode}
*
* @return Mapping from type to corresponding schema
*/
- public Map<Type, Object> getTypeToSchema() {
+ public Map<Type, WithStatus> getTypeToSchema() {
return Collections.unmodifiableMap(typeToSchema);
}
- protected void addTypeToSchema(Type type, TypeDefinition<?> typedef) {
+ protected void addTypeToSchema(final Type type, final TypeDefinition<?> typedef) {
typeToSchema.put(type, typedef);
}
/**
- * Adds mapping between schema path and inner enum.
+ * Adds mapping between schema path and an inner type.
*
* @param path
- * @param enumBuilder
+ * @param type
*/
- void addInnerTypedefType(SchemaPath path, EnumBuilder enumBuilder) {
- innerTypes.put(path, enumBuilder);
+ void addInnerTypedefType(final SchemaPath path, final Type type) {
+ innerTypes.put(path, type);
}
- public Type getInnerType(SchemaPath path) {
+ public Type getInnerType(final SchemaPath path) {
return innerTypes.get(path);
}
+ private void checkNamingConflict(final SchemaNode def, final JavaTypeName name) {
+ final SchemaNode existingDef = nameMapping.putIfAbsent(name, def);
+ if (existingDef != null) {
+ if (def.equals(existingDef)) {
+ if (LOG.isDebugEnabled()) {
+ // TODO: this should not really be happening
+ LOG.debug("Duplicate definition on {} as {}", name, def, new Throwable());
+ }
+ } else {
+ throw resolveNamingConfict(existingDef, def, name);
+ }
+ }
+ }
+
+ private static IllegalStateException resolveNamingConfict(final SchemaNode existing, final SchemaNode incoming,
+ final JavaTypeName name) {
+ if (existing instanceof IdentitySchemaNode) {
+ if (incoming instanceof GroupingDefinition || incoming instanceof TypeDefinition
+ || incoming instanceof DataSchemaNode || incoming instanceof NotificationDefinition
+ || incoming instanceof OperationDefinition) {
+ return new RenameMappingException(name, existing);
+ }
+ } else if (existing instanceof GroupingDefinition) {
+ if (incoming instanceof IdentitySchemaNode) {
+ return new RenameMappingException(name, incoming);
+ }
+ if (incoming instanceof TypeDefinition || incoming instanceof DataSchemaNode
+ || incoming instanceof NotificationDefinition || incoming instanceof OperationDefinition) {
+ return new RenameMappingException(name, existing);
+ }
+ } else if (existing instanceof TypeDefinition) {
+ if (incoming instanceof GroupingDefinition || incoming instanceof IdentitySchemaNode) {
+ return new RenameMappingException(name, incoming);
+ }
+ if (incoming instanceof DataSchemaNode || incoming instanceof NotificationDefinition
+ || incoming instanceof OperationDefinition) {
+ return new RenameMappingException(name, existing);
+ }
+ } else {
+ if (incoming instanceof GroupingDefinition || incoming instanceof IdentitySchemaNode
+ || incoming instanceof TypeDefinition) {
+ return new RenameMappingException(name, incoming);
+ }
+ }
+
+ return new IllegalStateException(String.format("Unhandled GeneratedType conflict between %s and %s on %s",
+ incoming, existing, name));
+ }
}