import static org.opendaylight.controller.sal.rest.doc.impl.BaseYangSwaggerGenerator.MODULE_NAME_SUFFIX;
import static org.opendaylight.controller.sal.rest.doc.model.builder.OperationBuilder.Post.METHOD_NAME;
import static org.opendaylight.controller.sal.rest.doc.util.RestDocgenUtil.resolveNodesName;
-
import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableMap.Builder;
import java.io.IOException;
import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
+import javax.annotation.concurrent.NotThreadSafe;
import org.apache.commons.lang3.BooleanUtils;
import org.json.JSONArray;
import org.json.JSONException;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
-import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
+import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ConstraintDefinition;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
/**
* Generates JSON Schema for data defined in Yang
*/
+@NotThreadSafe
public class ModelGenerator {
- private static Logger _logger = LoggerFactory.getLogger(ModelGenerator.class);
+ private static final Logger LOG = LoggerFactory.getLogger(ModelGenerator.class);
private static final String BASE_64 = "base64";
private static final String BINARY_ENCODING_KEY = "binaryEncoding";
private static final String ID_KEY = "id";
private static final String SUB_TYPES_KEY = "subTypes";
- private static final Map<Class<? extends TypeDefinition<?>>, String> YANG_TYPE_TO_JSON_TYPE_MAPPING;
+ private static final Map<Class<?>, String> YANG_TYPE_TO_JSON_TYPE_MAPPING;
static {
- Map<Class<? extends TypeDefinition<?>>, String> tempMap1 = new HashMap<Class<? extends TypeDefinition<?>>, String>(
- 10);
- tempMap1.put(StringType.class, STRING);
- tempMap1.put(BooleanType.class, BOOLEAN);
- tempMap1.put(Int8.class, INTEGER);
- tempMap1.put(Int16.class, INTEGER);
- tempMap1.put(Int32.class, INTEGER);
- tempMap1.put(Int64.class, INTEGER);
- tempMap1.put(Uint16.class, INTEGER);
- tempMap1.put(Uint32.class, INTEGER);
- tempMap1.put(Uint64.class, INTEGER);
- tempMap1.put(Uint8.class, INTEGER);
- tempMap1.put(Decimal64.class, NUMBER);
- tempMap1.put(EnumerationType.class, ENUM);
+ final Builder<Class<?>, String> b = ImmutableMap.builder();
+
+ b.put(StringType.class, STRING);
+ b.put(BooleanType.class, BOOLEAN);
+ b.put(Int8.class, INTEGER);
+ b.put(Int16.class, INTEGER);
+ b.put(Int32.class, INTEGER);
+ b.put(Int64.class, INTEGER);
+ b.put(Uint16.class, INTEGER);
+ b.put(Uint32.class, INTEGER);
+ b.put(Uint64.class, INTEGER);
+ b.put(Uint8.class, INTEGER);
+ b.put(Decimal64.class, NUMBER);
+ b.put(EnumerationType.class, ENUM);
// TODO: Binary type
- YANG_TYPE_TO_JSON_TYPE_MAPPING = Collections.unmodifiableMap(tempMap1);
+ YANG_TYPE_TO_JSON_TYPE_MAPPING = b.build();
}
private Module topLevelModule;
public ModelGenerator() {
}
- public JSONObject convertToJsonSchema(Module module, SchemaContext schemaContext) throws IOException, JSONException {
+ public JSONObject convertToJsonSchema(final Module module, final SchemaContext schemaContext) throws IOException, JSONException {
JSONObject models = new JSONObject();
topLevelModule = module;
processModules(module, models);
return models;
}
- private void processModules(Module module, JSONObject models) throws JSONException {
+ private void processModules(final Module module, final JSONObject models) throws JSONException {
createConcreteModelForPost(models, module.getName()+MODULE_NAME_SUFFIX, createPropertiesForPost(module));
}
- private void processContainersAndLists(Module module, JSONObject models, SchemaContext schemaContext)
+ private void processContainersAndLists(final Module module, final JSONObject models, final SchemaContext schemaContext)
throws IOException, JSONException {
String moduleName = module.getName();
* @throws JSONException
* @throws IOException
*/
- private void processRPCs(Module module, JSONObject models, SchemaContext schemaContext) throws JSONException,
+ private void processRPCs(final Module module, final JSONObject models, final SchemaContext schemaContext) throws JSONException,
IOException {
Set<RpcDefinition> rpcs = module.getRpcs();
* The JSONObject in which the parsed identity will be put as a 'model' obj
* @throws JSONException
*/
- private void processIdentities(Module module, JSONObject models) throws JSONException {
+ private void processIdentities(final Module module, final JSONObject models) throws JSONException {
String moduleName = module.getName();
Set<IdentitySchemaNode> idNodes = module.getIdentities();
- _logger.debug("Processing Identities for module {} . Found {} identity statements", moduleName, idNodes.size());
+ LOG.debug("Processing Identities for module {} . Found {} identity statements", moduleName, idNodes.size());
for (IdentitySchemaNode idNode : idNodes) {
JSONObject identityObj = new JSONObject();
String identityName = idNode.getQName().getLocalName();
- _logger.debug("Processing Identity: {}", identityName);
+ LOG.debug("Processing Identity: {}", identityName);
identityObj.put(ID_KEY, identityName);
identityObj.put(DESCRIPTION_KEY, idNode.getDescription());
* @throws JSONException
* @throws IOException
*/
- private JSONObject processDataNodeContainer(DataNodeContainer dataNode, String moduleName, JSONObject models,
- SchemaContext schemaContext) throws JSONException, IOException {
+ private JSONObject processDataNodeContainer(final DataNodeContainer dataNode, final String moduleName, final JSONObject models,
+ final SchemaContext schemaContext) throws JSONException, IOException {
return processDataNodeContainer(dataNode, moduleName, models, (Boolean) null, schemaContext);
}
- private JSONObject processDataNodeContainer(DataNodeContainer dataNode, String moduleName, JSONObject models,
- Boolean isConfig, SchemaContext schemaContext) throws JSONException, IOException {
+ private JSONObject processDataNodeContainer(final DataNodeContainer dataNode, final String moduleName, final JSONObject models,
+ final Boolean isConfig, final SchemaContext schemaContext) throws JSONException, IOException {
if (dataNode instanceof ListSchemaNode || dataNode instanceof ContainerSchemaNode) {
Preconditions.checkArgument(dataNode instanceof SchemaNode, "Data node should be also schema node");
Iterable<DataSchemaNode> containerChildren = dataNode.getChildNodes();
return properties;
}
- private JSONObject processChildren(Iterable<DataSchemaNode> nodes, QName parentQName, String moduleName,
- JSONObject models, SchemaContext schemaContext) throws JSONException, IOException {
+ private JSONObject processChildren(final Iterable<DataSchemaNode> nodes, final QName parentQName, final String moduleName,
+ final JSONObject models, final SchemaContext schemaContext) throws JSONException, IOException {
return processChildren(nodes, parentQName, moduleName, models, null, schemaContext);
}
* @throws JSONException
* @throws IOException
*/
- private JSONObject processChildren(Iterable<DataSchemaNode> nodes, QName parentQName, String moduleName,
- JSONObject models, Boolean isConfig, SchemaContext schemaContext) throws JSONException, IOException {
+ private JSONObject processChildren(final Iterable<DataSchemaNode> nodes, final QName parentQName, final String moduleName,
+ final JSONObject models, final Boolean isConfig, final SchemaContext schemaContext) throws JSONException, IOException {
JSONObject properties = new JSONObject();
} else if (node instanceof LeafListSchemaNode) {
property = processLeafListNode((LeafListSchemaNode) node);
- } else if (node instanceof ChoiceNode) {
- property = processChoiceNode((ChoiceNode) node, moduleName, models, schemaContext);
+ } else if (node instanceof ChoiceSchemaNode) {
+ property = processChoiceNode((ChoiceSchemaNode) node, moduleName, models, schemaContext);
} else if (node instanceof AnyXmlSchemaNode) {
property = processAnyXMLNode((AnyXmlSchemaNode) node);
* @param listNode
* @throws JSONException
*/
- private JSONObject processLeafListNode(LeafListSchemaNode listNode) throws JSONException {
+ private JSONObject processLeafListNode(final LeafListSchemaNode listNode) throws JSONException {
JSONObject props = new JSONObject();
props.put(TYPE_KEY, ARRAY_TYPE);
* @throws JSONException
* @throws IOException
*/
- private JSONObject processChoiceNode(ChoiceNode choiceNode, String moduleName, JSONObject models,
- SchemaContext schemaContext) throws JSONException, IOException {
+ private JSONObject processChoiceNode(final ChoiceSchemaNode choiceNode, final String moduleName, final JSONObject models,
+ final SchemaContext schemaContext) throws JSONException, IOException {
Set<ChoiceCaseNode> cases = choiceNode.getCases();
* @param props
* @throws JSONException
*/
- private void processConstraints(ConstraintDefinition constraints, JSONObject props) throws JSONException {
+ private void processConstraints(final ConstraintDefinition constraints, final JSONObject props) throws JSONException {
boolean isMandatory = constraints.isMandatory();
props.put(REQUIRED_KEY, isMandatory);
* @return
* @throws JSONException
*/
- private JSONObject processLeafNode(LeafSchemaNode leafNode) throws JSONException {
+ private JSONObject processLeafNode(final LeafSchemaNode leafNode) throws JSONException {
JSONObject property = new JSONObject();
String leafDescription = leafNode.getDescription();
* @return
* @throws JSONException
*/
- private JSONObject processAnyXMLNode(AnyXmlSchemaNode leafNode) throws JSONException {
+ private JSONObject processAnyXMLNode(final AnyXmlSchemaNode leafNode) throws JSONException {
JSONObject property = new JSONObject();
String leafDescription = leafNode.getDescription();
* @param property
* @throws JSONException
*/
- private void processTypeDef(TypeDefinition<?> leafTypeDef, JSONObject property) throws JSONException {
+ private void processTypeDef(final TypeDefinition<?> leafTypeDef, final JSONObject property) throws JSONException {
if (leafTypeDef instanceof ExtendedType) {
processExtendedType(leafTypeDef, property);
* @param property
* @throws JSONException
*/
- private void processExtendedType(TypeDefinition<?> leafTypeDef, JSONObject property) throws JSONException {
+ private void processExtendedType(final TypeDefinition<?> leafTypeDef, final JSONObject property) throws JSONException {
Object leafBaseType = leafTypeDef.getBaseType();
if (leafBaseType instanceof ExtendedType) {
// recursively process an extended type until we hit a base type
/*
*
*/
- private void processBinaryType(BinaryTypeDefinition binaryType, JSONObject property) throws JSONException {
+ private void processBinaryType(final BinaryTypeDefinition binaryType, final JSONObject property) throws JSONException {
property.put(TYPE_KEY, STRING);
JSONObject media = new JSONObject();
media.put(BINARY_ENCODING_KEY, BASE_64);
* @param property
* @throws JSONException
*/
- private void processEnumType(EnumerationType enumLeafType, JSONObject property) throws JSONException {
+ private void processEnumType(final EnumerationType enumLeafType, final JSONObject property) throws JSONException {
List<EnumPair> enumPairs = enumLeafType.getValues();
List<String> enumNames = new ArrayList<String>();
for (EnumPair enumPair : enumPairs) {
* @param property
* @throws JSONException
*/
- private void processBitsType(BitsTypeDefinition bitsType, JSONObject property) throws JSONException {
+ private void processBitsType(final BitsTypeDefinition bitsType, final JSONObject property) throws JSONException {
property.put(TYPE_KEY, ARRAY_TYPE);
property.put(MIN_ITEMS, 0);
property.put(UNIQUE_ITEMS_KEY, true);
* @param property
* @throws JSONException
*/
- private void processUnionType(UnionTypeDefinition unionType, JSONObject property) throws JSONException {
+ private void processUnionType(final UnionTypeDefinition unionType, final JSONObject property) throws JSONException {
StringBuilder type = new StringBuilder();
for (TypeDefinition<?> typeDef : unionType.getTypes()) {