import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.OperationDefinition;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
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.opendaylight.yangtools.yang.model.api.type.BinaryTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.Uint64TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.Uint8TypeDefinition;
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
-import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;
+import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
*/
- public ObjectNode convertToJsonSchema(final Module module, final SchemaContext schemaContext,
+ public ObjectNode convertToJsonSchema(final Module module, final EffectiveModelContext schemaContext,
final ObjectNode definitions, final DefinitionNames definitionNames,
final OAversion oaversion, final boolean isForSingleModule)
throws IOException {
return definitions;
}
- public ObjectNode convertToJsonSchema(final Module module, final SchemaContext schemaContext,
+ public ObjectNode convertToJsonSchema(final Module module, final EffectiveModelContext schemaContext,
final DefinitionNames definitionNames, final OAversion oaversion,
final boolean isForSingleModule)
throws IOException {
}
private void processModule(final Module module, final ObjectNode definitions, final DefinitionNames definitionNames,
- final SchemaContext schemaContext, final OAversion oaversion) {
+ final EffectiveModelContext schemaContext, final OAversion oaversion) {
final ObjectNode definition = JsonNodeFactory.instance.objectNode();
final ObjectNode properties = JsonNodeFactory.instance.objectNode();
final ArrayNode required = JsonNodeFactory.instance.arrayNode();
final String moduleName = module.getName();
final String definitionName = moduleName + MODULE_NAME_SUFFIX;
+ final SchemaInferenceStack stack = SchemaInferenceStack.of(schemaContext);
for (final DataSchemaNode node : module.getChildNodes()) {
+ stack.enterSchemaTree(node.getQName());
final String localName = node.getQName().getLocalName();
if (node.isConfiguration()) {
if (node instanceof ContainerSchemaNode || node instanceof ListSchemaNode) {
Add module name prefix to property name, when ServiceNow can process colons(second parameter
of processLeafNode).
*/
- processLeafNode((LeafSchemaNode) node, localName, properties, required, schemaContext,
+ processLeafNode((LeafSchemaNode) node, localName, properties, required, stack,
definitions, definitionNames, oaversion);
}
}
}
+ stack.exit();
}
definition.put(TITLE_KEY, definitionName);
definition.put(TYPE_KEY, OBJECT_TYPE);
}
private void processContainersAndLists(final Module module, final ObjectNode definitions,
- final DefinitionNames definitionNames, final SchemaContext schemaContext,
- final OAversion oaversion) throws IOException {
+ final DefinitionNames definitionNames, final EffectiveModelContext schemaContext, final OAversion oaversion)
+ throws IOException {
final String moduleName = module.getName();
-
+ final SchemaInferenceStack stack = SchemaInferenceStack.of(schemaContext);
for (final DataSchemaNode childNode : module.getChildNodes()) {
+ stack.enterSchemaTree(childNode.getQName());
// For every container and list in the module
if (childNode instanceof ContainerSchemaNode || childNode instanceof ListSchemaNode) {
if (childNode.isConfiguration()) {
processDataNodeContainer((DataNodeContainer) childNode, moduleName, definitions, definitionNames,
- true, schemaContext, oaversion);
+ true, stack, oaversion);
}
processDataNodeContainer((DataNodeContainer) childNode, moduleName, definitions, definitionNames,
- false, schemaContext, oaversion);
- processActionNodeContainer(childNode, moduleName, definitions, definitionNames, schemaContext,
- oaversion);
+ false, stack, oaversion);
+ processActionNodeContainer(childNode, moduleName, definitions, definitionNames, stack, oaversion);
}
+ stack.exit();
}
}
private void processActionNodeContainer(final DataSchemaNode childNode, final String moduleName,
final ObjectNode definitions, final DefinitionNames definitionNames,
- final SchemaContext schemaContext, final OAversion oaversion)
+ final SchemaInferenceStack stack, final OAversion oaversion)
throws IOException {
for (final ActionDefinition actionDef : ((ActionNodeContainer) childNode).getActions()) {
- processOperations(actionDef, moduleName, definitions, definitionNames, schemaContext, oaversion);
+ processOperations(actionDef, moduleName, definitions, definitionNames, stack, oaversion);
}
}
private void processRPCs(final Module module, final ObjectNode definitions, final DefinitionNames definitionNames,
- final SchemaContext schemaContext, final OAversion oaversion) throws IOException {
+ final EffectiveModelContext schemaContext, final OAversion oaversion) throws IOException {
final String moduleName = module.getName();
+ final SchemaInferenceStack stack = SchemaInferenceStack.of(schemaContext);
for (final RpcDefinition rpcDefinition : module.getRpcs()) {
- processOperations(rpcDefinition, moduleName, definitions, definitionNames, schemaContext, oaversion);
+ stack.enterSchemaTree(rpcDefinition.getQName());
+ processOperations(rpcDefinition, moduleName, definitions, definitionNames, stack, oaversion);
+ stack.exit();
}
}
-
private void processOperations(final OperationDefinition operationDef, final String parentName,
- final ObjectNode definitions, final DefinitionNames definitionNames,
- final SchemaContext schemaContext, final OAversion oaversion) throws IOException {
+ final ObjectNode definitions, final DefinitionNames definitionNames,
+ final SchemaInferenceStack stack, final OAversion oaversion)
+ throws IOException {
final String operationName = operationDef.getQName().getLocalName();
processOperationInputOutput(operationDef.getInput(), operationName, parentName, true, definitions,
- definitionNames, schemaContext, oaversion);
+ definitionNames, stack, oaversion);
processOperationInputOutput(operationDef.getOutput(), operationName, parentName, false, definitions,
- definitionNames, schemaContext, oaversion);
+ definitionNames, stack, oaversion);
}
private void processOperationInputOutput(final ContainerLike container, final String operationName,
final String parentName, final boolean isInput,
final ObjectNode definitions, final DefinitionNames definitionNames,
- final SchemaContext schemaContext, final OAversion oaversion)
+ final SchemaInferenceStack stack, final OAversion oaversion)
throws IOException {
+ stack.enterSchemaTree(container.getQName());
if (!container.getChildNodes().isEmpty()) {
final String filename = parentName + "_" + operationName + (isInput ? INPUT_SUFFIX : OUTPUT_SUFFIX);
final ObjectNode childSchema = JsonNodeFactory.instance.objectNode();
processChildren(childSchema, container.getChildNodes(), parentName, definitions, definitionNames,
- false, schemaContext, oaversion);
+ false, stack, oaversion);
childSchema.put(TYPE_KEY, OBJECT_TYPE);
final ObjectNode xml = JsonNodeFactory.instance.objectNode();
processTopData(filename, discriminator, definitions, container, oaversion);
}
+ stack.exit();
}
- private ObjectNode processTopData(final String filename, final String discriminator, final ObjectNode definitions,
- final SchemaNode schemaNode, final OAversion oaversion) {
+ private static ObjectNode processTopData(final String filename, final String discriminator,
+ final ObjectNode definitions, final SchemaNode schemaNode, final OAversion oaversion) {
final ObjectNode dataNodeProperties = JsonNodeFactory.instance.objectNode();
final String name = filename + discriminator;
final String ref = getAppropriateModelPrefix(oaversion) + name;
* @param definitionNames Store for definition names
*/
private static void processIdentities(final Module module, final ObjectNode definitions,
- final DefinitionNames definitionNames, final SchemaContext context) {
-
+ final DefinitionNames definitionNames, final EffectiveModelContext context) {
final String moduleName = module.getName();
final Collection<? extends IdentitySchemaNode> idNodes = module.getIdentities();
LOG.debug("Processing Identities for module {} . Found {} identity statements", moduleName, idNodes.size());
}
private static void populateEnumWithDerived(final Collection<? extends IdentitySchemaNode> derivedIds,
- final ArrayNode enumPayload, final SchemaContext context) {
+ final ArrayNode enumPayload, final EffectiveModelContext context) {
for (final IdentitySchemaNode derivedId : derivedIds) {
enumPayload.add(derivedId.getQName().getLocalName());
populateEnumWithDerived(context.getDerivedIdentities(derivedId), enumPayload, context);
private ObjectNode processDataNodeContainer(final DataNodeContainer dataNode, final String parentName,
final ObjectNode definitions, final DefinitionNames definitionNames,
- final boolean isConfig, final SchemaContext schemaContext,
+ final boolean isConfig, final SchemaInferenceStack stack,
final OAversion oaversion) throws IOException {
if (dataNode instanceof ListSchemaNode || dataNode instanceof ContainerSchemaNode) {
final Collection<? extends DataSchemaNode> containerChildren = dataNode.getChildNodes();
final String nameAsParent = parentName + "_" + localName;
final ObjectNode properties =
processChildren(childSchema, containerChildren, parentName + "_" + localName, definitions,
- definitionNames, isConfig, schemaContext, oaversion);
+ definitionNames, isConfig, stack, oaversion);
final String nodeName = parentName + (isConfig ? CONFIG : "") + "_" + localName;
final String postNodeName = parentName + CONFIG + "_" + localName + POST_SUFFIX;
return null;
}
- private ObjectNode createPostJsonSchema(final SchemaNode dataNode, final ObjectNode properties,
- final String postNodeName, final String description) {
+ private static ObjectNode createPostJsonSchema(final SchemaNode dataNode, final ObjectNode properties,
+ final String postNodeName, final String description) {
final ObjectNode postSchema = JsonNodeFactory.instance.objectNode();
final ObjectNode postItemProperties;
if (dataNode instanceof ListSchemaNode) {
return postSchema;
}
- private ObjectNode createListItemProperties(final ObjectNode properties, final ListSchemaNode listNode) {
+ private static ObjectNode createListItemProperties(final ObjectNode properties, final ListSchemaNode listNode) {
final ObjectNode postListItemProperties = JsonNodeFactory.instance.objectNode();
final List<QName> keyDefinition = listNode.getKeyDefinition();
final Set<String> keys = listNode.getChildNodes().stream()
private ObjectNode processChildren(
final ObjectNode parentNode, final Collection<? extends DataSchemaNode> nodes, final String parentName,
final ObjectNode definitions, final DefinitionNames definitionNames, final boolean isConfig,
- final SchemaContext schemaContext, final OAversion oaversion) throws IOException {
+ final SchemaInferenceStack stack, final OAversion oaversion) throws IOException {
final ObjectNode properties = JsonNodeFactory.instance.objectNode();
final ArrayNode required = JsonNodeFactory.instance.arrayNode();
for (final DataSchemaNode node : nodes) {
+ stack.enterSchemaTree(node.getQName());
if (!isConfig || node.isConfiguration()) {
/*
Add module name prefix to property name, when needed, when ServiceNow can process colons,
final ObjectNode property;
if (node instanceof LeafSchemaNode) {
processLeafNode((LeafSchemaNode) node, propertyName, properties,
- required, schemaContext, definitions, definitionNames, oaversion);
+ required, stack, definitions, definitionNames, oaversion);
} else if (node instanceof AnyxmlSchemaNode) {
processAnyXMLNode((AnyxmlSchemaNode) node, propertyName, properties,
required);
} else if (node instanceof AnydataSchemaNode) {
- processAnydataNode((AnydataSchemaNode) node, propertyName, properties,
- required);
+ processAnydataNode((AnydataSchemaNode) node, propertyName, properties, required);
} else {
if (node instanceof ListSchemaNode || node instanceof ContainerSchemaNode) {
property = processDataNodeContainer((DataNodeContainer) node, parentName, definitions,
- definitionNames, isConfig, schemaContext, oaversion);
+ definitionNames, isConfig, stack, oaversion);
if (!isConfig) {
- processActionNodeContainer(node, parentName, definitions, definitionNames, schemaContext,
+ processActionNodeContainer(node, parentName, definitions, definitionNames, stack,
oaversion);
}
} else if (node instanceof LeafListSchemaNode) {
- property = processLeafListNode((LeafListSchemaNode) node, schemaContext, definitions,
+ property = processLeafListNode((LeafListSchemaNode) node, stack, definitions,
definitionNames, oaversion);
} else if (node instanceof ChoiceSchemaNode) {
for (final CaseSchemaNode variant : ((ChoiceSchemaNode) node).getCases()) {
+ stack.enterSchemaTree(variant.getQName());
processChoiceNode(variant.getChildNodes(), parentName, definitions, definitionNames,
- isConfig, schemaContext, properties, oaversion);
+ isConfig, stack, properties, oaversion);
+ stack.exit();
}
+ stack.exit();
+ // FIXME dangerous statement here! Try to rework without continue.
continue;
-
} else {
throw new IllegalArgumentException("Unknown DataSchemaNode type: " + node.getClass());
}
properties.set(propertyName, property);
}
}
+ stack.exit();
}
parentNode.set(PROPERTIES_KEY, properties);
setRequiredIfNotEmpty(parentNode, required);
return properties;
}
- private ObjectNode processLeafListNode(final LeafListSchemaNode listNode, final SchemaContext schemaContext,
+ private ObjectNode processLeafListNode(final LeafListSchemaNode listNode, final SchemaInferenceStack stack,
final ObjectNode definitions, final DefinitionNames definitionNames,
final OAversion oaversion) {
final ObjectNode props = JsonNodeFactory.instance.objectNode();
final Optional<ElementCountConstraint> optConstraint = listNode.getElementCountConstraint();
processElementCount(optConstraint, props);
- processTypeDef(listNode.getType(), listNode, itemsVal, schemaContext, definitions, definitionNames, oaversion);
+ processTypeDef(listNode.getType(), listNode, itemsVal, stack, definitions, definitionNames, oaversion);
props.set(ITEMS_KEY, itemsVal);
props.put(DESCRIPTION_KEY, listNode.getDescription().orElse(""));
private void processChoiceNode(
final Iterable<? extends DataSchemaNode> nodes, final String parentName, final ObjectNode definitions,
final DefinitionNames definitionNames, final boolean isConfig,
- final SchemaContext schemaContext, final ObjectNode properties, final OAversion oaversion)
+ final SchemaInferenceStack stack, final ObjectNode properties, final OAversion oaversion)
throws IOException {
for (final DataSchemaNode node : nodes) {
+ stack.enterSchemaTree(node.getQName());
/*
Add module name prefix to property name, when needed, when ServiceNow can process colons,
use RestDocGenUtil#resolveNodesName for creating property name
*/
if (node instanceof LeafSchemaNode) {
processLeafNode((LeafSchemaNode) node, name, properties,
- JsonNodeFactory.instance.arrayNode(), schemaContext, definitions, definitionNames, oaversion);
+ JsonNodeFactory.instance.arrayNode(), stack, definitions, definitionNames, oaversion);
} else if (node instanceof AnyxmlSchemaNode) {
processAnyXMLNode((AnyxmlSchemaNode) node, name, properties,
JsonNodeFactory.instance.arrayNode());
} else {
if (node instanceof ListSchemaNode || node instanceof ContainerSchemaNode) {
property = processDataNodeContainer((DataNodeContainer) node, parentName, definitions,
- definitionNames, isConfig, schemaContext, oaversion);
+ definitionNames, isConfig, stack, oaversion);
if (!isConfig) {
- processActionNodeContainer(node, parentName, definitions, definitionNames, schemaContext,
+ processActionNodeContainer(node, parentName, definitions, definitionNames, stack,
oaversion);
}
} else if (node instanceof LeafListSchemaNode) {
- property = processLeafListNode((LeafListSchemaNode) node, schemaContext, definitions,
+ property = processLeafListNode((LeafListSchemaNode) node, stack, definitions,
definitionNames, oaversion);
} else if (node instanceof ChoiceSchemaNode) {
for (final CaseSchemaNode variant : ((ChoiceSchemaNode) node).getCases()) {
processChoiceNode(variant.getChildNodes(), parentName, definitions, definitionNames, isConfig,
- schemaContext, properties, oaversion);
+ stack, properties, oaversion);
}
continue;
} else {
}
properties.set(name, property);
}
+ stack.exit();
}
}
private ObjectNode processLeafNode(final LeafSchemaNode leafNode, final String jsonLeafName,
final ObjectNode properties, final ArrayNode required,
- final SchemaContext schemaContext, final ObjectNode definitions,
+ final SchemaInferenceStack stack, final ObjectNode definitions,
final DefinitionNames definitionNames, final OAversion oaversion) {
final ObjectNode property = JsonNodeFactory.instance.objectNode();
property.put(DESCRIPTION_KEY, leafDescription);
}
- processTypeDef(leafNode.getType(), leafNode, property, schemaContext, definitions, definitionNames, oaversion);
+ processTypeDef(leafNode.getType(), leafNode, property, stack, definitions, definitionNames, oaversion);
properties.set(jsonLeafName, property);
property.set(XML_KEY, buildXmlParameter(leafNode));
processMandatory(leafNode, jsonLeafName, required);
}
private String processTypeDef(final TypeDefinition<?> leafTypeDef, final DataSchemaNode node,
- final ObjectNode property, final SchemaContext schemaContext,
+ final ObjectNode property, final SchemaInferenceStack stack,
final ObjectNode definitions, final DefinitionNames definitionNames,
final OAversion oaversion) {
final String jsonType;
} else if (leafTypeDef instanceof IdentityrefTypeDefinition) {
jsonType = processIdentityRefType((IdentityrefTypeDefinition) leafTypeDef, property, definitions,
- definitionNames, oaversion, schemaContext);
+ definitionNames, oaversion, stack.getEffectiveModelContext());
} else if (leafTypeDef instanceof StringTypeDefinition) {
jsonType = processStringType(leafTypeDef, property, node.getQName().getLocalName());
} else if (leafTypeDef instanceof EmptyTypeDefinition) {
jsonType = OBJECT_TYPE;
} else if (leafTypeDef instanceof LeafrefTypeDefinition) {
- return processTypeDef(SchemaContextUtil.getBaseTypeForLeafRef((LeafrefTypeDefinition) leafTypeDef,
- schemaContext, node), node, property, schemaContext, definitions, definitionNames, oaversion);
+ return processTypeDef(stack.resolveLeafref((LeafrefTypeDefinition) leafTypeDef), node, property,
+ stack, definitions, definitionNames, oaversion);
} else if (leafTypeDef instanceof BooleanTypeDefinition) {
jsonType = BOOLEAN_TYPE;
setDefaultValue(property, true);
} else if (leafTypeDef instanceof RangeRestrictedTypeDefinition) {
- jsonType = processNumberType((RangeRestrictedTypeDefinition) leafTypeDef, property);
+ jsonType = processNumberType((RangeRestrictedTypeDefinition<?, ?>) leafTypeDef, property);
} else if (leafTypeDef instanceof InstanceIdentifierTypeDefinition) {
- jsonType = processInstanceIdentifierType(node, property, schemaContext);
+ jsonType = processInstanceIdentifierType(node, property, stack.getEffectiveModelContext());
} else {
jsonType = STRING_TYPE;
}
setDefaultValue(property, new BigDecimal(stringDefaultValue));
} else if (leafTypeDef instanceof RangeRestrictedTypeDefinition) {
//uint8,16,32 int8,16,32,64
- if (isHexadecimalOrOctal((RangeRestrictedTypeDefinition)leafTypeDef)) {
+ if (isHexadecimalOrOctal((RangeRestrictedTypeDefinition<?, ?>)leafTypeDef)) {
setDefaultValue(property, stringDefaultValue);
} else {
setDefaultValue(property, Long.valueOf(stringDefaultValue));
private String processIdentityRefType(final IdentityrefTypeDefinition leafTypeDef, final ObjectNode property,
final ObjectNode definitions, final DefinitionNames definitionNames,
- final OAversion oaversion, final SchemaContext schemaContext) {
+ final OAversion oaversion, final EffectiveModelContext schemaContext) {
final String definitionName;
if (isImported(leafTypeDef)) {
definitionName = addImportedIdentity(leafTypeDef, definitions, definitionNames, schemaContext);
private static String addImportedIdentity(final IdentityrefTypeDefinition leafTypeDef,
final ObjectNode definitions, final DefinitionNames definitionNames,
- final SchemaContext context) {
+ final EffectiveModelContext context) {
final IdentitySchemaNode idNode = leafTypeDef.getIdentities().iterator().next();
final String identityName = idNode.getQName().getLocalName();
if (!definitionNames.isListedNode(idNode)) {
}
}
- private static ObjectNode buildIdentityObject(final IdentitySchemaNode idNode, final SchemaContext context) {
+ private static ObjectNode buildIdentityObject(final IdentitySchemaNode idNode,
+ final EffectiveModelContext context) {
final ObjectNode identityObj = JsonNodeFactory.instance.objectNode();
final String identityName = idNode.getQName().getLocalName();
LOG.debug("Processing Identity: {}", identityName);
return STRING_TYPE;
}
- private String processNumberType(final RangeRestrictedTypeDefinition leafTypeDef, final ObjectNode property) {
+ private static String processNumberType(final RangeRestrictedTypeDefinition<?, ?> leafTypeDef,
+ final ObjectNode property) {
final Optional<Number> maybeLower = ((RangeRestrictedTypeDefinition<?, ?>) leafTypeDef).getRangeConstraint()
.map(RangeConstraint::getAllowedRanges).map(RangeSet::span).map(Range::lowerEndpoint);
return INTEGER_TYPE;
}
- private boolean isHexadecimalOrOctal(RangeRestrictedTypeDefinition typeDef) {
+ private static boolean isHexadecimalOrOctal(final RangeRestrictedTypeDefinition<?, ?> typeDef) {
final Optional<?> optDefaultValue = typeDef.getDefaultValue();
if (optDefaultValue.isPresent()) {
final String defaultValue = (String)optDefaultValue.get();
return false;
}
- private String processInstanceIdentifierType(final DataSchemaNode node, final ObjectNode property,
- final SchemaContext schemaContext) {
- SchemaPath path = node.getPath();
-
- while (path.getParent() != null && path.getParent().getPathFromRoot().iterator().hasNext()) {
- path = path.getParent();
+ private static String processInstanceIdentifierType(final DataSchemaNode node, final ObjectNode property,
+ final EffectiveModelContext schemaContext) {
+ // create example instance-identifier to the first container of node's module if exists or leave it empty
+ final var module = schemaContext.findModule(node.getQName().getModule());
+ if (module.isPresent()) {
+ final var container = module.get().getChildNodes().stream()
+ .filter(n -> n instanceof ContainerSchemaNode)
+ .findFirst();
+ container.ifPresent(c -> setDefaultValue(property, String.format("/%s:%s", module.get().getPrefix(),
+ c.getQName().getLocalName())));
}
- final QName rootContainer = path.getLastComponent();
- final String rootContainerName = rootContainer.getLocalName();
- final String prefix = schemaContext.findModule(rootContainer.getModule()).get().getPrefix();
- setDefaultValue(property, String.format("/%s:%s", prefix, rootContainerName));
return STRING_TYPE;
}
- private String processUnionType(final UnionTypeDefinition unionType) {
+ private static String processUnionType(final UnionTypeDefinition unionType) {
boolean isStringTakePlace = false;
boolean isNumberTakePlace = false;
boolean isBooleanTakePlace = false;
return NUMBER_TYPE;
}
- private static ObjectNode buildXmlParameter(SchemaNode node) {
+ private static ObjectNode buildXmlParameter(final SchemaNode node) {
final ObjectNode xml = JsonNodeFactory.instance.objectNode();
final QName qName = node.getQName();
xml.put(NAME_KEY, qName.getLocalName());
Code Review / netconf.git / blobdiff