<modelVersion>4.0.0</modelVersion>\r
<artifactId>binding-generator-impl</artifactId>\r
\r
+ <build>\r
+ <plugins>\r
+ <plugin>\r
+ <groupId>org.eclipse.xtend</groupId>\r
+ <artifactId>xtend-maven-plugin</artifactId>\r
+ <version>2.4.2</version>\r
+ <executions>\r
+ <execution>\r
+ <goals>\r
+ <goal>compile</goal>\r
+ </goals>\r
+ <configuration>\r
+ <outputDirectory>${basedir}/src/main/xtend-gen</outputDirectory>\r
+ </configuration>\r
+ </execution>\r
+ </executions>\r
+ </plugin>\r
+ <plugin>\r
+ <artifactId>maven-clean-plugin</artifactId>\r
+ <version>2.4.1</version>\r
+ <configuration>\r
+ <filesets>\r
+ <fileset>\r
+ <directory>${basedir}/src/main/xtend-gen</directory>\r
+ <includes>\r
+ <include>**</include>\r
+ </includes>\r
+ </fileset>\r
+ </filesets>\r
+ </configuration>\r
+ </plugin>\r
+ </plugins>\r
+ </build>\r
+\r
<dependencies>\r
<dependency>\r
<groupId>org.opendaylight.yangtools</groupId>\r
<dependency>\r
<groupId>com.google.guava</groupId>\r
<artifactId>guava</artifactId>\r
+ </dependency>\r
+ <dependency>\r
+ <groupId>org.eclipse.xtend</groupId>\r
+ <artifactId>org.eclipse.xtend.lib</artifactId>\r
+ <version>2.4.2</version>\r
</dependency>\r
</dependencies>\r
\r
--- /dev/null
+/xtend-gen
\r
import static org.opendaylight.yangtools.binding.generator.util.BindingGeneratorUtil.*;\r
import static org.opendaylight.yangtools.binding.generator.util.BindingTypes.*;\r
-import static org.opendaylight.yangtools.binding.generator.util.Types.BOOLEAN;\r
import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.*;\r
\r
import java.util.ArrayList;\r
import java.util.Collections;\r
-import java.util.Comparator;\r
import java.util.HashMap;\r
import java.util.List;\r
import java.util.Map;\r
import java.util.Set;\r
-import java.util.concurrent.Future;\r
\r
import org.opendaylight.yangtools.binding.generator.util.BindingTypes;\r
import org.opendaylight.yangtools.binding.generator.util.ReferencedTypeImpl;\r
import org.opendaylight.yangtools.sal.binding.generator.api.BindingGenerator;\r
import org.opendaylight.yangtools.sal.binding.generator.spi.TypeProvider;\r
import org.opendaylight.yangtools.sal.binding.model.api.AccessModifier;\r
-import org.opendaylight.yangtools.sal.binding.model.api.GeneratedTransferObject;\r
import org.opendaylight.yangtools.sal.binding.model.api.GeneratedType;\r
-import org.opendaylight.yangtools.sal.binding.model.api.ParameterizedType;\r
import org.opendaylight.yangtools.sal.binding.model.api.Type;\r
import org.opendaylight.yangtools.sal.binding.model.api.type.builder.EnumBuilder;\r
-import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedPropertyBuilder;\r
import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTOBuilder;\r
import org.opendaylight.yangtools.sal.binding.model.api.type.builder.GeneratedTypeBuilder;\r
import org.opendaylight.yangtools.sal.binding.model.api.type.builder.MethodSignatureBuilder;\r
import org.opendaylight.yangtools.sal.binding.yang.types.GroupingDefinitionDependencySort;\r
import org.opendaylight.yangtools.sal.binding.yang.types.TypeProviderImpl;\r
-import org.opendaylight.yangtools.yang.binding.DataRoot;\r
-import org.opendaylight.yangtools.yang.binding.Identifiable;\r
-import org.opendaylight.yangtools.yang.binding.Identifier;\r
import org.opendaylight.yangtools.yang.binding.RpcService;\r
-import org.opendaylight.yangtools.yang.common.QName;\r
import org.opendaylight.yangtools.yang.common.RpcResult;\r
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;\r
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;\r
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;\r
import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;\r
import org.opendaylight.yangtools.yang.model.api.Module;\r
-import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;\r
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;\r
import org.opendaylight.yangtools.yang.model.api.SchemaContext;\r
import org.opendaylight.yangtools.yang.model.api.SchemaNode;\r
import org.opendaylight.yangtools.yang.model.api.SchemaPath;\r
import org.opendaylight.yangtools.yang.model.api.TypeDefinition;\r
import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;\r
-import org.opendaylight.yangtools.yang.model.api.UsesNode;\r
import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;\r
import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;\r
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;\r
import org.opendaylight.yangtools.yang.model.util.ExtendedType;\r
import org.opendaylight.yangtools.yang.model.util.SchemaContextUtil;\r
import org.opendaylight.yangtools.yang.model.util.UnionType;\r
+import static com.google.common.base.Preconditions.*;\r
+import static extension org.opendaylight.yangtools.binding.generator.util.Types.*;\r
\r
-import com.google.common.base.Preconditions;\r
-\r
-public final class BindingGeneratorImpl implements BindingGenerator {\r
+public class BindingGeneratorImpl implements BindingGenerator {\r
\r
/**\r
* Outter key represents the package name. Outter value represents map of\r
/**\r
* Provide methods for converting YANG types to JAVA types.\r
*/\r
- private TypeProvider typeProvider;\r
+ private var TypeProvider typeProvider;\r
\r
/**\r
* Holds reference to schema context to resolve data of augmented elemnt\r
* when creating augmentation builder\r
*/\r
- private SchemaContext schemaContext;\r
+ private var SchemaContext schemaContext;\r
\r
/**\r
* Each grouping which is converted from schema node to generated type is\r
* Schema node the object of type <code>Type</code> is required. So in this\r
* case is used this map.\r
*/\r
- private final Map<SchemaPath, GeneratedType> allGroupings = new HashMap<SchemaPath, GeneratedType>();\r
+ private val allGroupings = new HashMap<SchemaPath, GeneratedType>();\r
+ \r
+ \r
+ private val yangToJavaMapping = new HashMap<SchemaPath, Type>();\r
\r
/**\r
* Constant with the concrete name of namespace.\r
*/\r
- private final static String YANG_EXT_NAMESPACE = "urn:opendaylight:yang:extension:yang-ext";\r
+ private val static String YANG_EXT_NAMESPACE = "urn:opendaylight:yang:extension:yang-ext";\r
\r
/**\r
* Constant with the concrete name of identifier.\r
*/\r
- private final static String AUGMENT_IDENTIFIER_NAME = "augment-identifier";\r
-\r
- /**\r
- * Only parent constructor is invoked.\r
- */\r
- public BindingGeneratorImpl() {\r
- super();\r
- }\r
+ private val static String AUGMENT_IDENTIFIER_NAME = "augment-identifier";\r
\r
+ \r
/**\r
* Resolves generated types from <code>context</code> schema nodes of all\r
* modules.\r
* @throws IllegalStateException\r
* if <code>context</code> contain no modules\r
*/\r
- @Override\r
- public List<Type> generateTypes(final SchemaContext context) {\r
- Preconditions.checkArgument(context != null,"Schema Context reference cannot be NULL.");\r
- Preconditions.checkState(context.getModules() != null,"Schema Context does not contain defined modules.");\r
- final List<Type> generatedTypes = new ArrayList<>();\r
+ override generateTypes(SchemaContext context) {\r
+ checkArgument(context !== null,"Schema Context reference cannot be NULL.");\r
+ checkState(context.modules !== null,"Schema Context does not contain defined modules.");\r
+ val List<Type> generatedTypes = new ArrayList();\r
schemaContext = context;\r
typeProvider = new TypeProviderImpl(context);\r
- final Set<Module> modules = context.getModules();\r
- genTypeBuilders = new HashMap<>();\r
- for (final Module module : modules) {\r
+ val Set<Module> modules = context.modules;\r
+ genTypeBuilders = new HashMap();\r
+ for (module : modules) {\r
\r
generatedTypes.addAll(allGroupingsToGenTypes(module));\r
\r
- if (false == module.getChildNodes().isEmpty()) {\r
+ if (false == module.childNodes.isEmpty()) {\r
generatedTypes.add(moduleToDataType(module));\r
}\r
generatedTypes.addAll(allTypeDefinitionsToGenTypes(module));\r
generatedTypes.addAll(allContainersToGenTypes(module));\r
generatedTypes.addAll(allListsToGenTypes(module));\r
generatedTypes.addAll(allChoicesToGenTypes(module));\r
- generatedTypes.addAll(allAugmentsToGenTypes(module));\r
generatedTypes.addAll(allRPCMethodsToGenType(module));\r
generatedTypes.addAll(allNotificationsToGenType(module));\r
generatedTypes.addAll(allIdentitiesToGenTypes(module, context));\r
-\r
+ }\r
+ for (module : modules) {\r
+ generatedTypes.addAll(allAugmentsToGenTypes(module));\r
+ \r
}\r
return generatedTypes;\r
}\r
* @throws IllegalStateException\r
* if <code>context</code> contain no modules\r
*/\r
- @Override\r
- public List<Type> generateTypes(final SchemaContext context, final Set<Module> modules) {\r
- Preconditions.checkArgument(context != null,"Schema Context reference cannot be NULL.");\r
- Preconditions.checkState(context.getModules() != null,"Schema Context does not contain defined modules.");\r
- Preconditions.checkArgument(modules != null,"Sef of Modules cannot be NULL.");\r
+ override generateTypes(SchemaContext context, Set<Module> modules) {\r
+ checkArgument(context !== null,"Schema Context reference cannot be NULL.");\r
+ checkState(context.modules !== null,"Schema Context does not contain defined modules.");\r
+ checkArgument(modules !== null,"Set of Modules cannot be NULL.");\r
\r
- final List<Type> filteredGenTypes = new ArrayList<>();\r
+ val List<Type> filteredGenTypes = new ArrayList();\r
schemaContext = context;\r
typeProvider = new TypeProviderImpl(context);\r
- final Set<Module> contextModules = context.getModules();\r
- genTypeBuilders = new HashMap<>();\r
- for (final Module contextModule : contextModules) {\r
- final List<Type> generatedTypes = new ArrayList<>();\r
+ val Set<Module> contextModules = context.modules;\r
+ genTypeBuilders = new HashMap();\r
+ \r
+ for (contextModule : contextModules) {\r
+ val List<Type> generatedTypes = new ArrayList();\r
\r
generatedTypes.addAll(allGroupingsToGenTypes(contextModule));\r
- if (false == contextModule.getChildNodes().isEmpty()) {\r
+ if (false == contextModule.childNodes.isEmpty()) {\r
generatedTypes.add(moduleToDataType(contextModule));\r
}\r
generatedTypes.addAll(allTypeDefinitionsToGenTypes(contextModule));\r
generatedTypes.addAll(allContainersToGenTypes(contextModule));\r
generatedTypes.addAll(allListsToGenTypes(contextModule));\r
generatedTypes.addAll(allChoicesToGenTypes(contextModule));\r
- generatedTypes.addAll(allAugmentsToGenTypes(contextModule));\r
generatedTypes.addAll(allRPCMethodsToGenType(contextModule));\r
generatedTypes.addAll(allNotificationsToGenType(contextModule));\r
generatedTypes.addAll(allIdentitiesToGenTypes(contextModule, context));\r
-\r
+ \r
if (modules.contains(contextModule)) {\r
filteredGenTypes.addAll(generatedTypes);\r
}\r
}\r
+ for (contextModule : contextModules) {\r
+ val generatedTypes = (allAugmentsToGenTypes(contextModule));\r
+ if (modules.contains(contextModule)) {\r
+ filteredGenTypes.addAll(generatedTypes);\r
+ }\r
+ \r
+ }\r
return filteredGenTypes;\r
}\r
\r
* </ul>\r
*\r
*/\r
- private List<Type> allTypeDefinitionsToGenTypes(final Module module) {\r
- Preconditions.checkArgument(module != null,"Module reference cannot be NULL.");\r
- Preconditions.checkArgument(module.getName() != null,"Module name cannot be NULL.");\r
- Preconditions.checkArgument(module.getTypeDefinitions() != null,"Type Definitions for module " + module.getName() + " cannot be NULL.");\r
-\r
- final Set<TypeDefinition<?>> typeDefinitions = module.getTypeDefinitions();\r
- final List<Type> generatedTypes = new ArrayList<>();\r
- for (final TypeDefinition<?> typedef : typeDefinitions) {\r
- if (typedef != null) {\r
- final Type type = ((TypeProviderImpl) typeProvider).generatedTypeForExtendedDefinitionType(typedef, typedef);\r
- if ((type != null) && !generatedTypes.contains(type)) {\r
+ private def List<Type> allTypeDefinitionsToGenTypes( Module module) {\r
+ checkArgument(module !== null,"Module reference cannot be NULL.");\r
+ checkArgument(module.name !== null,"Module name cannot be NULL.");\r
+ val Set<TypeDefinition<?>> typeDefinitions = module.typeDefinitions;\r
+ checkState(typeDefinitions !== null,'''Type Definitions for module «module.name» cannot be NULL.''');\r
+\r
+ \r
+ val List<Type> generatedTypes = new ArrayList();\r
+ for ( TypeDefinition<?> typedef : typeDefinitions) {\r
+ if (typedef !== null) {\r
+ val type = (typeProvider as TypeProviderImpl).generatedTypeForExtendedDefinitionType(typedef, typedef);\r
+ if ((type !== null) && !generatedTypes.contains(type)) {\r
generatedTypes.add(type);\r
}\r
}\r
* </ul>\r
*\r
*/\r
- private List<Type> allContainersToGenTypes(final Module module) {\r
- Preconditions.checkArgument(module != null,"Module reference cannot be NULL.");\r
+ private def List<Type> allContainersToGenTypes( Module module) {\r
+ checkArgument(module !== null,"Module reference cannot be NULL.");\r
\r
- Preconditions.checkArgument(module.getName() != null,"Module name cannot be NULL.");\r
+ checkArgument(module.name !== null,"Module name cannot be NULL.");\r
\r
- if (module.getChildNodes() == null) {\r
- throw new IllegalArgumentException("Reference to Set of Child Nodes in module " + module.getName()\r
+ if (module.childNodes === null) {\r
+ throw new IllegalArgumentException("Reference to Set of Child Nodes in module " + module.name\r
+ " cannot be NULL.");\r
}\r
\r
- final List<Type> generatedTypes = new ArrayList<>();\r
- final DataNodeIterator it = new DataNodeIterator(module);\r
- final List<ContainerSchemaNode> schemaContainers = it.allContainers();\r
- final String basePackageName = moduleNamespaceToPackageName(module);\r
- for (final ContainerSchemaNode container : schemaContainers) {\r
+ val List<Type> generatedTypes = new ArrayList();\r
+ val it = new DataNodeIterator(module);\r
+ val List<ContainerSchemaNode> schemaContainers = it.allContainers();\r
+ val basePackageName = moduleNamespaceToPackageName(module);\r
+ for (container : schemaContainers) {\r
if (!container.isAddedByUses()) {\r
generatedTypes.add(containerToGenType(basePackageName, container));\r
}\r
* </ul>\r
*\r
*/\r
- private List<Type> allListsToGenTypes(final Module module) {\r
- Preconditions.checkArgument(module != null,"Module reference cannot be NULL.");\r
-\r
- Preconditions.checkArgument(module.getName() != null,"Module name cannot be NULL.");\r
+ private def List<Type> allListsToGenTypes( Module module) {\r
+ checkArgument(module !== null,"Module reference cannot be NULL.");\r
+ checkArgument(module.name !== null,"Module name cannot be NULL.");\r
\r
- if (module.getChildNodes() == null) {\r
- throw new IllegalArgumentException("Reference to Set of Child Nodes in module " + module.getName()\r
+ if (module.childNodes === null) {\r
+ throw new IllegalArgumentException("Reference to Set of Child Nodes in module " + module.name\r
+ " cannot be NULL.");\r
}\r
\r
- final List<Type> generatedTypes = new ArrayList<>();\r
- final DataNodeIterator it = new DataNodeIterator(module);\r
- final List<ListSchemaNode> schemaLists = it.allLists();\r
- final String basePackageName = moduleNamespaceToPackageName(module);\r
- if (schemaLists != null) {\r
- for (final ListSchemaNode list : schemaLists) {\r
+ val List<Type> generatedTypes = new ArrayList();\r
+ val it = new DataNodeIterator(module);\r
+ val List<ListSchemaNode> schemaLists = it.allLists();\r
+ val basePackageName = moduleNamespaceToPackageName(module);\r
+ if (schemaLists !== null) {\r
+ for (list : schemaLists) {\r
if (!list.isAddedByUses()) {\r
generatedTypes.addAll(listToGenType(basePackageName, list));\r
}\r
* </ul>\r
*\r
*/\r
- private List<GeneratedType> allChoicesToGenTypes(final Module module) {\r
- Preconditions.checkArgument(module != null,"Module reference cannot be NULL.");\r
- Preconditions.checkArgument(module.getName() != null,"Module name cannot be NULL.");\r
+ private def List<GeneratedType> allChoicesToGenTypes( Module module) {\r
+ checkArgument(module !== null,"Module reference cannot be NULL.");\r
+ checkArgument(module.name !== null,"Module name cannot be NULL.");\r
\r
- final DataNodeIterator it = new DataNodeIterator(module);\r
- final List<ChoiceNode> choiceNodes = it.allChoices();\r
- final String basePackageName = moduleNamespaceToPackageName(module);\r
+ val it = new DataNodeIterator(module);\r
+ val choiceNodes = it.allChoices();\r
+ val basePackageName = moduleNamespaceToPackageName(module);\r
\r
- final List<GeneratedType> generatedTypes = new ArrayList<>();\r
- for (final ChoiceNode choice : choiceNodes) {\r
- if ((choice != null) && !choice.isAddedByUses()) {\r
+ val List<GeneratedType> generatedTypes = new ArrayList();\r
+ for (choice : choiceNodes) {\r
+ if ((choice !== null) && !choice.isAddedByUses()) {\r
generatedTypes.addAll(choiceToGeneratedType(basePackageName, choice));\r
}\r
}\r
* </ul>\r
*\r
*/\r
- private List<Type> allAugmentsToGenTypes(final Module module) {\r
- Preconditions.checkArgument(module != null,"Module reference cannot be NULL.");\r
- Preconditions.checkArgument(module.getName() != null,"Module name cannot be NULL.");\r
- if (module.getChildNodes() == null) {\r
+ private def List<Type> allAugmentsToGenTypes( Module module) {\r
+ checkArgument(module !== null,"Module reference cannot be NULL.");\r
+ checkArgument(module.name !== null,"Module name cannot be NULL.");\r
+ if (module.childNodes === null) {\r
throw new IllegalArgumentException("Reference to Set of Augmentation Definitions in module "\r
- + module.getName() + " cannot be NULL.");\r
+ + module.name + " cannot be NULL.");\r
}\r
\r
- final List<Type> generatedTypes = new ArrayList<>();\r
- final String basePackageName = moduleNamespaceToPackageName(module);\r
-
final List<AugmentationSchema> augmentations = resolveAugmentations(module);
\r- for (final AugmentationSchema augment : augmentations) {\r
+ val List<Type> generatedTypes = new ArrayList();\r
+ val basePackageName = moduleNamespaceToPackageName(module);\r
+
val List<AugmentationSchema> augmentations = resolveAugmentations(module);
\r+ for (augment : augmentations) {\r
generatedTypes.addAll(augmentationToGenTypes(basePackageName, augment));\r
}\r
return generatedTypes;\r
* </ul>\r
*\r
*/\r
- private List<AugmentationSchema> resolveAugmentations(final Module module) {\r
- Preconditions.checkArgument(module != null,"Module reference cannot be NULL.");\r
- Preconditions.checkState(module.getAugmentations() != null,"Augmentations Set cannot be NULL.");\r
-\r
- final Set<AugmentationSchema> augmentations = module.getAugmentations();\r
- final List<AugmentationSchema> sortedAugmentations = new ArrayList<>(augmentations);\r
- Collections.sort(sortedAugmentations, new Comparator<AugmentationSchema>() {\r
+ private def List<AugmentationSchema> resolveAugmentations( Module module) {\r
+ checkArgument(module !== null,"Module reference cannot be NULL.");\r
+ checkState(module.augmentations !== null,"Augmentations Set cannot be NULL.");\r
\r
- @Override\r
- public int compare(AugmentationSchema augSchema1, AugmentationSchema augSchema2) {\r
+ val Set<AugmentationSchema> augmentations = module.augmentations;\r
+ val List<AugmentationSchema> sortedAugmentations = new ArrayList(augmentations);\r
+ Collections.sort(sortedAugmentations, [augSchema1, augSchema2 |\r
\r
- if (augSchema1.getTargetPath().getPath().size() > augSchema2.getTargetPath().getPath().size()) {\r
+ if (augSchema1.targetPath.path.size() > augSchema2.targetPath.path.size()) {\r
return 1;\r
- } else if (augSchema1.getTargetPath().getPath().size() < augSchema2.getTargetPath().getPath().size()) {\r
+ } else if (augSchema1.targetPath.path.size() < augSchema2.targetPath.path.size()) {\r
return -1;\r
}\r
return 0;\r
-\r
- }\r
- });\r
-\r
+ ]);\r
return sortedAugmentations;\r
}\r
\r
/**\r
* Converts whole <b>module</b> to <code>GeneratedType</code> object.\r
- * Firstly is created the module builder object from which is finally\r
+ * Firstly is created the module builder object from which is vally\r
* obtained reference to <code>GeneratedType</code> object.\r
*\r
* @param module\r
* if the module equals null\r
*\r
*/\r
- private GeneratedType moduleToDataType(final Module module) {\r
- Preconditions.checkArgument(module != null,"Module reference cannot be NULL.");\r
+ private def GeneratedType moduleToDataType( Module module) {\r
+ checkArgument(module !== null,"Module reference cannot be NULL.");\r
\r
- final GeneratedTypeBuilder moduleDataTypeBuilder = moduleTypeBuilder(module, "Data");\r
+ val moduleDataTypeBuilder = moduleTypeBuilder(module, "Data");\r
addImplementedInterfaceFromUses(module, moduleDataTypeBuilder);\r
- moduleDataTypeBuilder.addImplementsType(Types.typeForClass(DataRoot.class));\r
+ moduleDataTypeBuilder.addImplementsType(DATA_ROOT);\r
\r
- final String basePackageName = moduleNamespaceToPackageName(module);\r
- if (moduleDataTypeBuilder != null) {\r
- final Set<DataSchemaNode> dataNodes = module.getChildNodes();\r
+ val basePackageName = moduleNamespaceToPackageName(module);\r
+ if (moduleDataTypeBuilder !== null) {\r
+ val Set<DataSchemaNode> dataNodes = module.childNodes;\r
resolveDataSchemaNodes(basePackageName, moduleDataTypeBuilder, dataNodes);\r
}\r
return moduleDataTypeBuilder.toInstance();\r
* </ul>\r
*\r
*/\r
- private List<Type> allRPCMethodsToGenType(final Module module) {\r
- Preconditions.checkArgument(module != null,"Module reference cannot be NULL.");\r
+ private def List<Type> allRPCMethodsToGenType( Module module) {\r
+ checkArgument(module !== null,"Module reference cannot be NULL.");\r
\r
- Preconditions.checkArgument(module.getName() != null,"Module name cannot be NULL.");\r
+ checkArgument(module.name !== null,"Module name cannot be NULL.");\r
\r
- if (module.getChildNodes() == null) {\r
+ if (module.childNodes === null) {\r
throw new IllegalArgumentException("Reference to Set of RPC Method Definitions in module "\r
- + module.getName() + " cannot be NULL.");\r
+ + module.name + " cannot be NULL.");\r
}\r
\r
- final String basePackageName = moduleNamespaceToPackageName(module);\r
- final Set<RpcDefinition> rpcDefinitions = module.getRpcs();\r
+ val basePackageName = moduleNamespaceToPackageName(module);\r
+ val Set<RpcDefinition> rpcDefinitions = module.rpcs;\r
\r
if (rpcDefinitions.isEmpty()) {\r
return Collections.emptyList();\r
}\r
\r
- final List<Type> genRPCTypes = new ArrayList<>();\r
- final GeneratedTypeBuilder interfaceBuilder = moduleTypeBuilder(module, "Service");\r
- interfaceBuilder.addImplementsType(Types.typeForClass(RpcService.class));\r
- final Type future = Types.typeForClass(Future.class);\r
- for (final RpcDefinition rpc : rpcDefinitions) {\r
- if (rpc != null) {\r
+ val List<Type> genRPCTypes = new ArrayList();\r
+ val interfaceBuilder = moduleTypeBuilder(module, "Service");\r
+ interfaceBuilder.addImplementsType(Types.typeForClass(RpcService));\r
+ for (rpc : rpcDefinitions) {\r
+ if (rpc !== null) {\r
\r
- String rpcName = parseToClassName(rpc.getQName().getLocalName());\r
- String rpcMethodName = parseToValidParamName(rpcName);\r
- MethodSignatureBuilder method = interfaceBuilder.addMethod(rpcMethodName);\r
+ val rpcName = parseToClassName(rpc.QName.localName);\r
+ val rpcMethodName = parseToValidParamName(rpcName);\r
+ val method = interfaceBuilder.addMethod(rpcMethodName);\r
\r
- final List<DataNodeIterator> rpcInOut = new ArrayList<>();\r
+ val rpcInOut = new ArrayList();\r
\r
- ContainerSchemaNode input = rpc.getInput();\r
- ContainerSchemaNode output = rpc.getOutput();\r
+ val input = rpc.input;\r
+ val output = rpc.output;\r
\r
- if (input != null) {\r
+ if (input !== null) {\r
rpcInOut.add(new DataNodeIterator(input));\r
- GeneratedTypeBuilder inType = addRawInterfaceDefinition(basePackageName, input, rpcName);\r
+ val inType = addRawInterfaceDefinition(basePackageName, input, rpcName);\r
addImplementedInterfaceFromUses(input, inType);\r
inType.addImplementsType(DATA_OBJECT);\r
inType.addImplementsType(augmentable(inType));\r
- resolveDataSchemaNodes(basePackageName, inType, input.getChildNodes());\r
- Type inTypeInstance = inType.toInstance();\r
+ resolveDataSchemaNodes(basePackageName, inType, input.childNodes);\r
+ val inTypeInstance = inType.toInstance();\r
genRPCTypes.add(inTypeInstance);\r
method.addParameter(inTypeInstance, "input");\r
}\r
\r
- Type outTypeInstance = Types.typeForClass(Void.class);\r
- if (output != null) {\r
+ var Type outTypeInstance = VOID;\r
+ if (output !== null) {\r
rpcInOut.add(new DataNodeIterator(output));\r
- GeneratedTypeBuilder outType = addRawInterfaceDefinition(basePackageName, output, rpcName);\r
+ val outType = addRawInterfaceDefinition(basePackageName, output, rpcName);\r
addImplementedInterfaceFromUses(output, outType);\r
outType.addImplementsType(DATA_OBJECT);\r
outType.addImplementsType(augmentable(outType));\r
\r
- resolveDataSchemaNodes(basePackageName, outType, output.getChildNodes());\r
+ resolveDataSchemaNodes(basePackageName, outType, output.childNodes);\r
outTypeInstance = outType.toInstance();\r
genRPCTypes.add(outTypeInstance);\r
\r
}\r
\r
- final Type rpcRes = Types.parameterizedTypeFor(Types.typeForClass(RpcResult.class), outTypeInstance);\r
- method.setReturnType(Types.parameterizedTypeFor(future, rpcRes));\r
- for (DataNodeIterator it : rpcInOut) {\r
- List<ContainerSchemaNode> nContainers = it.allContainers();\r
- if ((nContainers != null) && !nContainers.isEmpty()) {\r
- for (final ContainerSchemaNode container : nContainers) {\r
+ val rpcRes = Types.parameterizedTypeFor(Types.typeForClass(RpcResult), outTypeInstance);\r
+ method.setReturnType(Types.parameterizedTypeFor(FUTURE, rpcRes));\r
+ for (iter : rpcInOut) {\r
+ val List<ContainerSchemaNode> nContainers = iter.allContainers();\r
+ if ((nContainers !== null) && !nContainers.isEmpty()) {\r
+ for (container : nContainers) {\r
if (!container.isAddedByUses()) {\r
genRPCTypes.add(containerToGenType(basePackageName, container));\r
}\r
}\r
}\r
- List<ListSchemaNode> nLists = it.allLists();\r
- if ((nLists != null) && !nLists.isEmpty()) {\r
- for (final ListSchemaNode list : nLists) {\r
+ val List<ListSchemaNode> nLists = iter.allLists();\r
+ if ((nLists !== null) && !nLists.isEmpty()) {\r
+ for (list : nLists) {\r
if (!list.isAddedByUses()) {\r
genRPCTypes.addAll(listToGenType(basePackageName, list));\r
}\r
* </ul>\r
*\r
*/\r
- private List<Type> allNotificationsToGenType(final Module module) {\r
- Preconditions.checkArgument(module != null,"Module reference cannot be NULL.");\r
+ private def List<Type> allNotificationsToGenType( Module module) {\r
+ checkArgument(module !== null,"Module reference cannot be NULL.");\r
\r
- Preconditions.checkArgument(module.getName() != null,"Module name cannot be NULL.");\r
+ checkArgument(module.name !== null,"Module name cannot be NULL.");\r
\r
- if (module.getChildNodes() == null) {\r
+ if (module.childNodes === null) {\r
throw new IllegalArgumentException("Reference to Set of Notification Definitions in module "\r
- + module.getName() + " cannot be NULL.");\r
+ + module.name + " cannot be NULL.");\r
}\r
- final Set<NotificationDefinition> notifications = module.getNotifications();\r
+ val notifications = module.notifications;\r
if(notifications.isEmpty()) return Collections.emptyList();\r
\r
- final GeneratedTypeBuilder listenerInterface = moduleTypeBuilder(module, "Listener");\r
+ val listenerInterface = moduleTypeBuilder(module, "Listener");\r
listenerInterface.addImplementsType(BindingTypes.NOTIFICATION_LISTENER);\r
\r
\r
\r
- final String basePackageName = moduleNamespaceToPackageName(module);\r
- final List<Type> generatedTypes = new ArrayList<>();\r
+ val basePackageName = moduleNamespaceToPackageName(module);\r
+ val List<Type> generatedTypes = new ArrayList();\r
\r
\r
- for (final NotificationDefinition notification : notifications) {\r
- if (notification != null) {\r
- DataNodeIterator it = new DataNodeIterator(notification);\r
+ for ( notification : notifications) {\r
+ if (notification !== null) {\r
+ val iter = new DataNodeIterator(notification);\r
\r
// Containers\r
- for (ContainerSchemaNode node : it.allContainers()) {\r
+ for (node : iter.allContainers()) {\r
if (!node.isAddedByUses()) {\r
generatedTypes.add(containerToGenType(basePackageName, node));\r
}\r
}\r
// Lists\r
- for (ListSchemaNode node : it.allLists()) {\r
+ for (node : iter.allLists()) {\r
if (!node.isAddedByUses()) {\r
generatedTypes.addAll(listToGenType(basePackageName, node));\r
}\r
}\r
- final GeneratedTypeBuilder notificationInterface = addDefaultInterfaceDefinition(basePackageName,\r
+ val notificationInterface = addDefaultInterfaceDefinition(basePackageName,\r
notification);\r
- notificationInterface.addImplementsType(Types\r
- .typeForClass(org.opendaylight.yangtools.yang.binding.Notification.class));\r
+ notificationInterface.addImplementsType(NOTIFICATION);\r
// Notification object\r
- resolveDataSchemaNodes(basePackageName, notificationInterface, notification.getChildNodes());\r
+ resolveDataSchemaNodes(basePackageName, notificationInterface, notification.childNodes);\r
\r
- listenerInterface.addMethod("on"+notificationInterface.getName()) //\r
+ listenerInterface.addMethod("on"+notificationInterface.name) //\r
.setAccessModifier(AccessModifier.PUBLIC)\r
.addParameter(notificationInterface, "notification")\r
.setReturnType(Types.VOID);\r
* (object of type <code>IdentitySchemaNode</code>\r
*\r
*/\r
- private List<Type> allIdentitiesToGenTypes(final Module module, final SchemaContext context) {\r
- List<Type> genTypes = new ArrayList<>();\r
+ private def List<Type> allIdentitiesToGenTypes( Module module, SchemaContext context) {\r
+ val List<Type> genTypes = new ArrayList();\r
\r
- final Set<IdentitySchemaNode> schemaIdentities = module.getIdentities();\r
+ val Set<IdentitySchemaNode> schemaIdentities = module.identities;\r
\r
- final String basePackageName = moduleNamespaceToPackageName(module);\r
+ val basePackageName = moduleNamespaceToPackageName(module);\r
\r
- if (schemaIdentities != null && !schemaIdentities.isEmpty()) {\r
- for (final IdentitySchemaNode identity : schemaIdentities) {\r
+ if (schemaIdentities !== null && !schemaIdentities.isEmpty()) {\r
+ for (identity : schemaIdentities) {\r
genTypes.add(identityToGenType(basePackageName, identity, context));\r
}\r
}\r
* <code>IdentitySchemaNode</code>\r
*\r
*/\r
- private GeneratedType identityToGenType(final String basePackageName, final IdentitySchemaNode identity,\r
- final SchemaContext context) {\r
- if (identity == null) {\r
+ private def GeneratedType identityToGenType(String basePackageName, IdentitySchemaNode identity,\r
+ SchemaContext context) {\r
+ if (identity === null) {\r
return null;\r
}\r
\r
- final String packageName = packageNameForGeneratedType(basePackageName, identity.getPath());\r
- final String genTypeName = parseToClassName(identity.getQName().getLocalName());\r
- final GeneratedTOBuilderImpl newType = new GeneratedTOBuilderImpl(packageName, genTypeName);\r
+ val packageName = packageNameForGeneratedType(basePackageName, identity.path);\r
+ val genTypeName = parseToClassName(identity.QName.localName);\r
+ val newType = new GeneratedTOBuilderImpl(packageName, genTypeName);\r
\r
- IdentitySchemaNode baseIdentity = identity.getBaseIdentity();\r
- if (baseIdentity != null) {\r
- Module baseIdentityParentModule = SchemaContextUtil.findParentModule(context, baseIdentity);\r
+ val baseIdentity = identity.baseIdentity;\r
+ if (baseIdentity !== null) {\r
+ val baseIdentityParentModule = SchemaContextUtil.findParentModule(context, baseIdentity);\r
\r
- final String returnTypePkgName = moduleNamespaceToPackageName(baseIdentityParentModule);\r
- final String returnTypeName = parseToClassName(baseIdentity.getQName().getLocalName());\r
+ val returnTypePkgName = moduleNamespaceToPackageName(baseIdentityParentModule);\r
+ val returnTypeName = parseToClassName(baseIdentity.QName.localName);\r
\r
- GeneratedTransferObject gto = new GeneratedTOBuilderImpl(returnTypePkgName, returnTypeName).toInstance();\r
+ val gto = new GeneratedTOBuilderImpl(returnTypePkgName, returnTypeName).toInstance();\r
newType.setExtendsType(gto);\r
} else {\r
- newType.setExtendsType(Types.getBaseIdentityTO());\r
+ newType.setExtendsType(Types.baseIdentityTO);\r
}\r
newType.setAbstract(true);\r
return newType.toInstance();\r
* (object of type <code>GroupingDefinition</code>)\r
*\r
*/\r
- private List<Type> allGroupingsToGenTypes(final Module module) {\r
- Preconditions.checkArgument(module != null,"Module parameter can not be null");\r
- final List<Type> genTypes = new ArrayList<>();\r
- final String basePackageName = moduleNamespaceToPackageName(module);\r
- final Set<GroupingDefinition> groupings = module.getGroupings();\r
- List<GroupingDefinition> groupingsSortedByDependencies;\r
-\r
- groupingsSortedByDependencies = GroupingDefinitionDependencySort.sort(groupings);\r
-\r
- for (final GroupingDefinition grouping : groupingsSortedByDependencies) {\r
- GeneratedType genType = groupingToGenType(basePackageName, grouping);\r
+ private def List<Type> allGroupingsToGenTypes( Module module) {\r
+ checkArgument(module !== null,"Module parameter can not be null");\r
+ val List<Type> genTypes = new ArrayList();\r
+ val basePackageName = moduleNamespaceToPackageName(module);\r
+ val Set<GroupingDefinition> groupings = module.groupings;\r
+ val List<GroupingDefinition> groupingsSortedByDependencies = GroupingDefinitionDependencySort.sort(groupings);\r
+\r
+ for (grouping : groupingsSortedByDependencies) {\r
+ val genType = groupingToGenType(basePackageName, grouping);\r
genTypes.add(genType);\r
- SchemaPath schemaPath = grouping.getPath();\r
+ val schemaPath = grouping.path;\r
allGroupings.put(schemaPath, genType);\r
}\r
return genTypes;\r
* @return GeneratedType which is generated from grouping (object of type\r
* <code>GroupingDefinition</code>)\r
*/\r
- private GeneratedType groupingToGenType(final String basePackageName, GroupingDefinition grouping) {\r
- if (grouping == null) {\r
+ private def GeneratedType groupingToGenType( String basePackageName, GroupingDefinition grouping) {\r
+ if (grouping === null) {\r
return null;\r
}\r
\r
- final String packageName = packageNameForGeneratedType(basePackageName, grouping.getPath());\r
- final Set<DataSchemaNode> schemaNodes = grouping.getChildNodes();\r
- final GeneratedTypeBuilder typeBuilder = addDefaultInterfaceDefinition(packageName, grouping);\r
+ val packageName = packageNameForGeneratedType(basePackageName, grouping.path);\r
+ val Set<DataSchemaNode> schemaNodes = grouping.childNodes;\r
+ val typeBuilder = addDefaultInterfaceDefinition(packageName, grouping);\r
\r
resolveDataSchemaNodes(basePackageName, typeBuilder, schemaNodes);\r
return typeBuilder.toInstance();\r
* @return EnumTypeDefinition if it is found inside\r
* <code>typeDefinition</code> or <code>null</code> in other case\r
*/\r
- private EnumTypeDefinition enumTypeDefFromExtendedType(final TypeDefinition<?> typeDefinition) {\r
- if (typeDefinition != null) {\r
- if (typeDefinition.getBaseType() instanceof EnumTypeDefinition) {\r
- return (EnumTypeDefinition) typeDefinition.getBaseType();\r
- } else if (typeDefinition.getBaseType() instanceof ExtendedType) {\r
- return enumTypeDefFromExtendedType(typeDefinition.getBaseType());\r
+ private def EnumTypeDefinition enumTypeDefFromExtendedType( TypeDefinition<?> typeDefinition) {\r
+ if (typeDefinition !== null) {\r
+ if (typeDefinition.baseType instanceof EnumTypeDefinition) {\r
+ return typeDefinition.baseType as EnumTypeDefinition;\r
+ } else if (typeDefinition.baseType instanceof ExtendedType) {\r
+ return enumTypeDefFromExtendedType(typeDefinition.baseType);\r
}\r
}\r
return null;\r
* @return enumeration builder which contais data from\r
* <code>enumTypeDef</code>\r
*/\r
- private EnumBuilder resolveInnerEnumFromTypeDefinition(final EnumTypeDefinition enumTypeDef, final String enumName,\r
- final GeneratedTypeBuilder typeBuilder) {\r
- if ((enumTypeDef != null) && (typeBuilder != null) && (enumTypeDef.getQName() != null)\r
- && (enumTypeDef.getQName().getLocalName() != null)) {\r
+ private def EnumBuilder resolveInnerEnumFromTypeDefinition( EnumTypeDefinition enumTypeDef, String enumName,\r
+ GeneratedTypeBuilder typeBuilder) {\r
+ if ((enumTypeDef !== null) && (typeBuilder !== null) && (enumTypeDef.QName !== null)\r
+ && (enumTypeDef.QName.localName !== null)) {\r
\r
- final String enumerationName = parseToClassName(enumName);\r
- final EnumBuilder enumBuilder = typeBuilder.addEnumeration(enumerationName);\r
+ val enumerationName = parseToClassName(enumName);\r
+ val enumBuilder = typeBuilder.addEnumeration(enumerationName);\r
enumBuilder.updateEnumPairsFromEnumTypeDef(enumTypeDef);\r
\r
return enumBuilder;\r
* @throws IllegalArgumentException\r
* if <code>module</code> equals null\r
*/\r
- private GeneratedTypeBuilder moduleTypeBuilder(final Module module, final String postfix) {\r
- Preconditions.checkArgument(module != null,"Module reference cannot be NULL.");\r
- String packageName = moduleNamespaceToPackageName(module);\r
- final String moduleName = parseToClassName(module.getName()) + postfix;\r
+ private def GeneratedTypeBuilder moduleTypeBuilder( Module module, String postfix) {\r
+ checkArgument(module !== null,"Module reference cannot be NULL.");\r
+ val packageName = moduleNamespaceToPackageName(module);\r
+ val moduleName = parseToClassName(module.name) + postfix;\r
\r
return new GeneratedTypeBuilderImpl(packageName, moduleName);\r
\r
* <li>if target path of <code>augSchema</code> equals null</li>\r
* </ul>\r
*/\r
- private List<Type> augmentationToGenTypes(final String augmentPackageName, final AugmentationSchema augSchema) {\r
- Preconditions.checkArgument(augmentPackageName != null,"Package Name cannot be NULL.");\r
- Preconditions.checkArgument(augSchema != null,"Augmentation Schema cannot be NULL.");\r
- Preconditions.checkState(augSchema.getTargetPath() != null,"Augmentation Schema does not contain Target Path (Target Path is NULL).");\r
+ private def List<Type> augmentationToGenTypes( String augmentPackageName, AugmentationSchema augSchema) {\r
+ checkArgument(augmentPackageName !== null,"Package Name cannot be NULL.");\r
+ checkArgument(augSchema !== null,"Augmentation Schema cannot be NULL.");\r
+ checkState(augSchema.targetPath !== null,"Augmentation Schema does not contain Target Path (Target Path is NULL).");\r
\r
- final List<Type> genTypes = new ArrayList<>();\r
+ val List<Type> genTypes = new ArrayList();\r
\r
// EVERY augmented interface will extends Augmentation<T> interface\r
// and DataObject interface!!!\r
- final SchemaPath targetPath = augSchema.getTargetPath();\r
- final DataSchemaNode targetSchemaNode = findDataSchemaNode(schemaContext, targetPath);\r
- if ((targetSchemaNode != null) && (targetSchemaNode.getQName() != null)\r
- && (targetSchemaNode.getQName().getLocalName() != null)) {\r
- final Module targetModule = findParentModule(schemaContext, targetSchemaNode);\r
- final String targetBasePackage = moduleNamespaceToPackageName(targetModule);\r
- final String targetPackageName = packageNameForGeneratedType(targetBasePackage, targetSchemaNode.getPath());\r
- final String targetSchemaNodeName = targetSchemaNode.getQName().getLocalName();\r
- final Set<DataSchemaNode> augChildNodes = augSchema.getChildNodes();\r
+ val targetPath = augSchema.targetPath;\r
+ val targetSchemaNode = findDataSchemaNode(schemaContext, targetPath);\r
+ val targetType = yangToJavaMapping.get(targetSchemaNode.path);\r
+ if ((targetSchemaNode !== null) && (targetSchemaNode.QName !== null)\r
+ && (targetSchemaNode.QName.localName !== null)) {\r
+ \r
+ val targetPackageName = targetType.packageName;\r
+ val targetSchemaNodeName = targetType.name;\r
+ \r
+ \r
+ val augChildNodes = augSchema.childNodes;\r
\r
if (!(targetSchemaNode instanceof ChoiceNode)) {\r
- final GeneratedTypeBuilder augTypeBuilder = addRawAugmentGenTypeDefinition(augmentPackageName,\r
- targetPackageName, targetSchemaNodeName, augSchema);\r
- final GeneratedType augType = augTypeBuilder.toInstance();\r
+ val augTypeBuilder = addRawAugmentGenTypeDefinition(augmentPackageName,\r
+ targetType, augSchema);\r
+ val augType = augTypeBuilder.toInstance();\r
genTypes.add(augType);\r
} else {\r
- final Type refChoiceType = new ReferencedTypeImpl(targetPackageName,\r
+ val refChoiceType = new ReferencedTypeImpl(targetPackageName,\r
parseToClassName(targetSchemaNodeName));\r
- final ChoiceNode choiceTarget = (ChoiceNode) targetSchemaNode;\r
- final Set<ChoiceCaseNode> choiceCaseNodes = choiceTarget.getCases();\r
+ val choiceTarget = targetSchemaNode as ChoiceNode;\r
+ val choiceCaseNodes = choiceTarget.cases;\r
genTypes.addAll(generateTypesFromAugmentedChoiceCases(augmentPackageName, refChoiceType,\r
choiceCaseNodes));\r
}\r
* and uses of augment\r
* @return generated type builder for augment\r
*/\r
- private GeneratedTypeBuilder addRawAugmentGenTypeDefinition(final String augmentPackageName,\r
- final String targetPackageName, final String targetSchemaNodeName, final AugmentationSchema augSchema) {\r
- final String targetTypeName = parseToClassName(targetSchemaNodeName);\r
- Map<String, GeneratedTypeBuilder> augmentBuilders = genTypeBuilders.get(augmentPackageName);\r
- if (augmentBuilders == null) {\r
- augmentBuilders = new HashMap<>();\r
+ private def GeneratedTypeBuilder addRawAugmentGenTypeDefinition( String augmentPackageName,\r
+ Type targetTypeRef, AugmentationSchema augSchema) {\r
+ var Map<String, GeneratedTypeBuilder> augmentBuilders = genTypeBuilders.get(augmentPackageName);\r
+ if (augmentBuilders === null) {\r
+ augmentBuilders = new HashMap();\r
genTypeBuilders.put(augmentPackageName, augmentBuilders);\r
}\r
- final String augIdentifier = getAugmentIdentifier(augSchema.getUnknownSchemaNodes());\r
+ val augIdentifier = getAugmentIdentifier(augSchema.unknownSchemaNodes);\r
\r
- final String augTypeName = augIdentifier != null ? parseToClassName(augIdentifier) : augGenTypeName(\r
- augmentBuilders, targetTypeName);\r
- final Type targetTypeRef = new ReferencedTypeImpl(targetPackageName, targetTypeName);\r
- final Set<DataSchemaNode> augChildNodes = augSchema.getChildNodes();\r
+ val augTypeName = if (augIdentifier !== null ) { \r
+ parseToClassName(augIdentifier)\r
+ } else {\r
+ augGenTypeName(augmentBuilders, targetTypeRef.name);\r
+ }\r
+ val Set<DataSchemaNode> augChildNodes = augSchema.childNodes;\r
\r
- final GeneratedTypeBuilder augTypeBuilder = new GeneratedTypeBuilderImpl(augmentPackageName, augTypeName);\r
+ val augTypeBuilder = new GeneratedTypeBuilderImpl(augmentPackageName, augTypeName);\r
\r
augTypeBuilder.addImplementsType(DATA_OBJECT);\r
augTypeBuilder.addImplementsType(Types.augmentationTypeFor(targetTypeRef));\r
* @param unknownSchemaNodes\r
* @return\r
*/\r
- private String getAugmentIdentifier(List<UnknownSchemaNode> unknownSchemaNodes) {\r
- String ret = null;\r
- for (UnknownSchemaNode unknownSchemaNode : unknownSchemaNodes) {\r
- QName nodeType = unknownSchemaNode.getNodeType();\r
- if (AUGMENT_IDENTIFIER_NAME.equals(nodeType.getLocalName())\r
- && YANG_EXT_NAMESPACE.equals(nodeType.getNamespace().toString())) {\r
- return unknownSchemaNode.getNodeParameter();\r
+ private def String getAugmentIdentifier(List<UnknownSchemaNode> unknownSchemaNodes) {\r
+ for (unknownSchemaNode : unknownSchemaNodes) {\r
+ val nodeType = unknownSchemaNode.nodeType;\r
+ if (AUGMENT_IDENTIFIER_NAME.equals(nodeType.localName)\r
+ && YANG_EXT_NAMESPACE.equals(nodeType.namespace.toString())) {\r
+ return unknownSchemaNode.nodeParameter;\r
}\r
}\r
- return ret;\r
+ return null;\r
}\r
\r
/**\r
* @return list of <code>Type</code> which represents container, list and\r
* choice subnodes of augment\r
*/\r
- private List<Type> augmentationBodyToGenTypes(final String augBasePackageName,\r
- final Set<DataSchemaNode> augChildNodes) {\r
- final List<Type> genTypes = new ArrayList<>();\r
- final List<DataNodeIterator> augSchemaIts = new ArrayList<>();\r
- for (final DataSchemaNode childNode : augChildNodes) {\r
+ private def List<Type> augmentationBodyToGenTypes( String augBasePackageName,\r
+ Set<DataSchemaNode> augChildNodes) {\r
+ val List<Type> genTypes = new ArrayList();\r
+ val List<DataNodeIterator> augSchemaIts = new ArrayList();\r
+ for (childNode : augChildNodes) {\r
if (childNode instanceof DataNodeContainer) {\r
- augSchemaIts.add(new DataNodeIterator((DataNodeContainer) childNode));\r
+ augSchemaIts.add(new DataNodeIterator(childNode as DataNodeContainer));\r
\r
if (childNode instanceof ContainerSchemaNode) {\r
- genTypes.add(containerToGenType(augBasePackageName, (ContainerSchemaNode) childNode));\r
+ genTypes.add(containerToGenType(augBasePackageName, childNode as ContainerSchemaNode));\r
} else if (childNode instanceof ListSchemaNode) {\r
- genTypes.addAll(listToGenType(augBasePackageName, (ListSchemaNode) childNode));\r
+ genTypes.addAll(listToGenType(augBasePackageName, childNode as ListSchemaNode));\r
}\r
} else if (childNode instanceof ChoiceNode) {\r
- final ChoiceNode choice = (ChoiceNode) childNode;\r
- for (final ChoiceCaseNode caseNode : choice.getCases()) {\r
+ val choice = childNode as ChoiceNode;\r
+ for (caseNode : choice.cases) {\r
augSchemaIts.add(new DataNodeIterator(caseNode));\r
}\r
- genTypes.addAll(choiceToGeneratedType(augBasePackageName, (ChoiceNode) childNode));\r
+ genTypes.addAll(choiceToGeneratedType(augBasePackageName, childNode as ChoiceNode));\r
}\r
}\r
\r
- for (final DataNodeIterator it : augSchemaIts) {\r
- final List<ContainerSchemaNode> augContainers = it.allContainers();\r
- final List<ListSchemaNode> augLists = it.allLists();\r
- final List<ChoiceNode> augChoices = it.allChoices();\r
+ for (it : augSchemaIts) {\r
+ val List<ContainerSchemaNode> augContainers = it.allContainers();\r
+ val List<ListSchemaNode> augLists = it.allLists();\r
+ val List<ChoiceNode> augChoices = it.allChoices();\r
\r
- if (augContainers != null) {\r
- for (final ContainerSchemaNode container : augContainers) {\r
+ if (augContainers !== null) {\r
+ for (container : augContainers) {\r
genTypes.add(containerToGenType(augBasePackageName, container));\r
}\r
}\r
- if (augLists != null) {\r
- for (final ListSchemaNode list : augLists) {\r
+ if (augLists !== null) {\r
+ for (list : augLists) {\r
genTypes.addAll(listToGenType(augBasePackageName, list));\r
}\r
}\r
- if (augChoices != null) {\r
- for (final ChoiceNode choice : augChoices) {\r
+ if (augChoices !== null) {\r
+ for (choice : augChoices) {\r
genTypes.addAll(choiceToGeneratedType(augBasePackageName, choice));\r
}\r
}\r
* string with name of augmented node\r
* @return string with unique name for augmentation builder\r
*/\r
- private String augGenTypeName(final Map<String, GeneratedTypeBuilder> builders, final String genTypeName) {\r
- String augTypeName = genTypeName;\r
-\r
- int index = 1;\r
- while ((builders != null) && builders.containsKey(genTypeName + index)) {\r
- index++;\r
+ private def String augGenTypeName( Map<String, GeneratedTypeBuilder> builders, String genTypeName) {\r
+ var index = 1;\r
+ while ((builders !== null) && builders.containsKey(genTypeName + index)) {\r
+ index = index + 1;\r
}\r
- augTypeName += index;\r
- return augTypeName;\r
+ return genTypeName + index;\r
}\r
\r
/**\r
* schema paths\r
* @return generated type for <code>containerNode</code>\r
*/\r
- private GeneratedType containerToGenType(final String basePackageName, ContainerSchemaNode containerNode) {\r
- if (containerNode == null) {\r
+ private def GeneratedType containerToGenType( String basePackageName, ContainerSchemaNode containerNode) {\r
+ if (containerNode === null) {\r
return null;\r
}\r
\r
- final String packageName = packageNameForGeneratedType(basePackageName, containerNode.getPath());\r
- final Set<DataSchemaNode> schemaNodes = containerNode.getChildNodes();\r
- final GeneratedTypeBuilder typeBuilder = addDefaultInterfaceDefinition(packageName, containerNode);\r
+ val packageName = packageNameForGeneratedType(basePackageName, containerNode.path);\r
+ val schemaNodes = containerNode.childNodes;\r
+ val typeBuilder = addDefaultInterfaceDefinition(packageName, containerNode);\r
\r
resolveDataSchemaNodes(basePackageName, typeBuilder, schemaNodes);\r
return typeBuilder.toInstance();\r
* parameter. The getter methods (representing child nodes) could be\r
* added to it.\r
*/\r
- private GeneratedTypeBuilder resolveDataSchemaNodes(final String basePackageName,\r
- final GeneratedTypeBuilder typeBuilder, final Set<DataSchemaNode> schemaNodes) {\r
- if ((schemaNodes != null) && (typeBuilder != null)) {\r
- for (final DataSchemaNode schemaNode : schemaNodes) {\r
- if (schemaNode.isAugmenting() || schemaNode.isAddedByUses()) {\r
- continue;\r
+ private def GeneratedTypeBuilder resolveDataSchemaNodes( String basePackageName,\r
+ GeneratedTypeBuilder typeBuilder, Set<DataSchemaNode> schemaNodes) {\r
+ if ((schemaNodes !== null) && (typeBuilder !== null)) {\r
+ for (schemaNode : schemaNodes) {\r
+ if (!schemaNode.isAugmenting() && !schemaNode.isAddedByUses()) {\r
+ addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder);\r
}\r
- addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder);\r
+ \r
}\r
}\r
return typeBuilder;\r
* parameter <code>typeBuilder</code>. The getter method could be\r
* added to it.\r
*/\r
- private GeneratedTypeBuilder augSchemaNodeToMethods(final String basePackageName,\r
- final GeneratedTypeBuilder typeBuilder, final Set<DataSchemaNode> schemaNodes) {\r
- if ((schemaNodes != null) && (typeBuilder != null)) {\r
- for (final DataSchemaNode schemaNode : schemaNodes) {\r
+ private def GeneratedTypeBuilder augSchemaNodeToMethods( String basePackageName,\r
+ GeneratedTypeBuilder typeBuilder, Set<DataSchemaNode> schemaNodes) {\r
+ if ((schemaNodes !== null) && (typeBuilder !== null)) {\r
+ for (schemaNode : schemaNodes) {\r
if (schemaNode.isAugmenting()) {\r
addSchemaNodeToBuilderAsMethod(basePackageName, schemaNode, typeBuilder);\r
}\r
* generated type builder to which is <code>schemaNode</code>\r
* added as a method.\r
*/\r
- private void addSchemaNodeToBuilderAsMethod(final String basePackageName, final DataSchemaNode schemaNode,\r
- final GeneratedTypeBuilder typeBuilder) {\r
- if (schemaNode != null && typeBuilder != null) {\r
- if (schemaNode instanceof LeafSchemaNode) {\r
- resolveLeafSchemaNodeAsMethod(typeBuilder, (LeafSchemaNode) schemaNode);\r
- } else if (schemaNode instanceof LeafListSchemaNode) {\r
- resolveLeafListSchemaNode(typeBuilder, (LeafListSchemaNode) schemaNode);\r
- } else if (schemaNode instanceof ContainerSchemaNode) {\r
- resolveContainerSchemaNode(basePackageName, typeBuilder, (ContainerSchemaNode) schemaNode);\r
- } else if (schemaNode instanceof ListSchemaNode) {\r
- resolveListSchemaNode(basePackageName, typeBuilder, (ListSchemaNode) schemaNode);\r
- } else if (schemaNode instanceof ChoiceNode) {\r
- resolveChoiceSchemaNode(basePackageName, typeBuilder, (ChoiceNode) schemaNode);\r
+ private def void addSchemaNodeToBuilderAsMethod( String basePackageName, DataSchemaNode node,\r
+ GeneratedTypeBuilder typeBuilder) {\r
+ if (node !== null && typeBuilder !== null) {\r
+ switch(node) {\r
+ case node instanceof LeafSchemaNode: resolveLeafSchemaNodeAsMethod(typeBuilder, node as LeafSchemaNode)\r
+ case node instanceof LeafListSchemaNode: resolveLeafListSchemaNode(typeBuilder, node as LeafListSchemaNode)\r
+ case node instanceof ContainerSchemaNode: resolveContainerSchemaNode(basePackageName, typeBuilder, node as ContainerSchemaNode)\r
+ case node instanceof ListSchemaNode: resolveListSchemaNode(basePackageName, typeBuilder, node as ListSchemaNode)\r
+ case node instanceof ChoiceNode: resolveChoiceSchemaNode(basePackageName, typeBuilder, node as ChoiceNode)\r
}\r
}\r
}\r
* </ul>\r
*\r
*/\r
- private void resolveChoiceSchemaNode(final String basePackageName, final GeneratedTypeBuilder typeBuilder,\r
- final ChoiceNode choiceNode) {\r
- Preconditions.checkArgument(basePackageName != null,"Base Package Name cannot be NULL.");\r
- Preconditions.checkArgument(typeBuilder != null,"Generated Type Builder cannot be NULL.");\r
- Preconditions.checkArgument(choiceNode != null,"Choice Schema Node cannot be NULL.");\r
-\r
- final String choiceName = choiceNode.getQName().getLocalName();\r
- if (choiceName != null && !choiceNode.isAddedByUses()) {\r
- final String packageName = packageNameForGeneratedType(basePackageName, choiceNode.getPath());\r
- final GeneratedTypeBuilder choiceType = addDefaultInterfaceDefinition(packageName, choiceNode);\r
- constructGetter(typeBuilder, choiceName, choiceNode.getDescription(), choiceType);\r
+ private def void resolveChoiceSchemaNode( String basePackageName, GeneratedTypeBuilder typeBuilder,\r
+ ChoiceNode choiceNode) {\r
+ checkArgument(basePackageName !== null,"Base Package Name cannot be NULL.");\r
+ checkArgument(typeBuilder !== null,"Generated Type Builder cannot be NULL.");\r
+ checkArgument(choiceNode !== null,"Choice Schema Node cannot be NULL.");\r
+\r
+ val choiceName = choiceNode.QName.localName;\r
+ if (choiceName !== null && !choiceNode.isAddedByUses()) {\r
+ val packageName = packageNameForGeneratedType(basePackageName, choiceNode.path);\r
+ val choiceType = addDefaultInterfaceDefinition(packageName, choiceNode);\r
+ constructGetter(typeBuilder, choiceName, choiceNode.description, choiceType);\r
}\r
}\r
\r
* </ul>\r
*\r
*/\r
- private List<GeneratedType> choiceToGeneratedType(final String basePackageName, final ChoiceNode choiceNode) {\r
- Preconditions.checkArgument(basePackageName != null,"Base Package Name cannot be NULL.");\r
- Preconditions.checkArgument(choiceNode != null,"Choice Schema Node cannot be NULL.");\r
+ private def List<GeneratedType> choiceToGeneratedType( String basePackageName, ChoiceNode choiceNode) {\r
+ checkArgument(basePackageName !== null,"Base Package Name cannot be NULL.");\r
+ checkArgument(choiceNode !== null,"Choice Schema Node cannot be NULL.");\r
\r
- final List<GeneratedType> generatedTypes = new ArrayList<>();\r
- final String packageName = packageNameForGeneratedType(basePackageName, choiceNode.getPath());\r
- final GeneratedTypeBuilder choiceTypeBuilder = addRawInterfaceDefinition(packageName, choiceNode);\r
- choiceTypeBuilder.addImplementsType(DATA_OBJECT);\r
- final GeneratedType choiceType = choiceTypeBuilder.toInstance();\r
+ val List<GeneratedType> generatedTypes = new ArrayList();\r
+ val packageName = packageNameForGeneratedType(basePackageName, choiceNode.path);\r
+ val choiceTypeBuilder = addRawInterfaceDefinition(packageName, choiceNode);\r
+ //choiceTypeBuilder.addImplementsType(DATA_OBJECT);\r
+ val choiceType = choiceTypeBuilder.toInstance();\r
\r
generatedTypes.add(choiceType);\r
- final Set<ChoiceCaseNode> caseNodes = choiceNode.getCases();\r
- if ((caseNodes != null) && !caseNodes.isEmpty()) {\r
+ val Set<ChoiceCaseNode> caseNodes = choiceNode.cases;\r
+ if ((caseNodes !== null) && !caseNodes.isEmpty()) {\r
generatedTypes.addAll(generateTypesFromChoiceCases(basePackageName, choiceType, caseNodes));\r
}\r
return generatedTypes;\r
* </ul>\r
* *\r
*/\r
- private List<GeneratedType> generateTypesFromChoiceCases(final String basePackageName, final Type refChoiceType,\r
- final Set<ChoiceCaseNode> caseNodes) {\r
- Preconditions.checkArgument(basePackageName != null,"Base Package Name cannot be NULL.");\r
- Preconditions.checkArgument(refChoiceType != null,"Referenced Choice Type cannot be NULL.");\r
- Preconditions.checkArgument(caseNodes != null,"Set of Choice Case Nodes cannot be NULL.");\r
-\r
- final List<GeneratedType> generatedTypes = new ArrayList<>();\r
- for (final ChoiceCaseNode caseNode : caseNodes) {\r
- if (caseNode != null && !caseNode.isAddedByUses() && !caseNode.isAugmenting()) {\r
- final String packageName = packageNameForGeneratedType(basePackageName, caseNode.getPath());\r
- final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(packageName, caseNode);\r
+ private def List<GeneratedType> generateTypesFromChoiceCases( String basePackageName, Type refChoiceType,\r
+ Set<ChoiceCaseNode> caseNodes) {\r
+ checkArgument(basePackageName !== null,"Base Package Name cannot be NULL.");\r
+ checkArgument(refChoiceType !== null,"Referenced Choice Type cannot be NULL.");\r
+ checkArgument(caseNodes !== null,"Set of Choice Case Nodes cannot be NULL.");\r
+\r
+ val List<GeneratedType> generatedTypes = new ArrayList();\r
+ for (caseNode : caseNodes) {\r
+ if (caseNode !== null && !caseNode.isAddedByUses() && !caseNode.isAugmenting()) {\r
+ val packageName = packageNameForGeneratedType(basePackageName, caseNode.path);\r
+ val caseTypeBuilder = addDefaultInterfaceDefinition(packageName, caseNode);\r
caseTypeBuilder.addImplementsType(refChoiceType);\r
\r
- final Set<DataSchemaNode> childNodes = caseNode.getChildNodes();\r
- if (childNodes != null) {\r
+ val Set<DataSchemaNode> childNodes = caseNode.childNodes;\r
+ if (childNodes !== null) {\r
resolveDataSchemaNodes(basePackageName, caseTypeBuilder, childNodes);\r
}\r
generatedTypes.add(caseTypeBuilder.toInstance());\r
* <li>if <code>caseNodes</code> equals null</li>\r
* </ul>\r
*/\r
- private List<GeneratedType> generateTypesFromAugmentedChoiceCases(final String basePackageName,\r
- final Type refChoiceType, final Set<ChoiceCaseNode> caseNodes) {\r
- Preconditions.checkArgument(basePackageName != null,"Base Package Name cannot be NULL.");\r
- Preconditions.checkArgument(refChoiceType != null,"Referenced Choice Type cannot be NULL.");\r
- Preconditions.checkArgument(caseNodes != null,"Set of Choice Case Nodes cannot be NULL.");\r
-\r
- final List<GeneratedType> generatedTypes = new ArrayList<>();\r
- for (final ChoiceCaseNode caseNode : caseNodes) {\r
- if (caseNode != null && caseNode.isAugmenting()) {\r
- final String packageName = packageNameForGeneratedType(basePackageName, caseNode.getPath());\r
- final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(packageName, caseNode);\r
+ private def List<GeneratedType> generateTypesFromAugmentedChoiceCases( String basePackageName,\r
+ Type refChoiceType, Set<ChoiceCaseNode> caseNodes) {\r
+ checkArgument(basePackageName !== null,"Base Package Name cannot be NULL.");\r
+ checkArgument(refChoiceType !== null,"Referenced Choice Type cannot be NULL.");\r
+ checkArgument(caseNodes !== null,"Set of Choice Case Nodes cannot be NULL.");\r
+\r
+ val List<GeneratedType> generatedTypes = new ArrayList();\r
+ for (caseNode : caseNodes) {\r
+ if (caseNode !== null && caseNode.isAugmenting()) {\r
+ val packageName = packageNameForGeneratedType(basePackageName, caseNode.path);\r
+ val caseTypeBuilder = addDefaultInterfaceDefinition(packageName, caseNode);\r
caseTypeBuilder.addImplementsType(refChoiceType);\r
\r
- final Set<DataSchemaNode> childNodes = caseNode.getChildNodes();\r
- if (childNodes != null) {\r
+ val Set<DataSchemaNode> childNodes = caseNode.childNodes;\r
+ if (childNodes !== null) {\r
resolveDataSchemaNodes(basePackageName, caseTypeBuilder, childNodes);\r
}\r
generatedTypes.add(caseTypeBuilder.toInstance());\r
* <li>true - in other cases</li>\r
* </ul>\r
*/\r
- private boolean resolveLeafSchemaNodeAsMethod(final GeneratedTypeBuilder typeBuilder, final LeafSchemaNode leaf) {\r
- if ((leaf != null) && (typeBuilder != null)) {\r
- final String leafName = leaf.getQName().getLocalName();\r
- String leafDesc = leaf.getDescription();\r
- if (leafDesc == null) {\r
+ private def boolean resolveLeafSchemaNodeAsMethod( GeneratedTypeBuilder typeBuilder, LeafSchemaNode leaf) {\r
+ if ((leaf !== null) && (typeBuilder !== null)) {\r
+ val leafName = leaf.QName.localName;\r
+ var String leafDesc = leaf.description;\r
+ if (leafDesc === null) {\r
leafDesc = "";\r
}\r
\r
- final Module parentModule = findParentModule(schemaContext, leaf);\r
- if (leafName != null && !leaf.isAddedByUses()) {\r
- final TypeDefinition<?> typeDef = leaf.getType();\r
+ val parentModule = findParentModule(schemaContext, leaf);\r
+ if (leafName !== null && !leaf.isAddedByUses()) {\r
+ val TypeDefinition<?> typeDef = leaf.type;\r
\r
- Type returnType = null;\r
+ var Type returnType = null;\r
if (typeDef instanceof EnumTypeDefinition) {\r
returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf);\r
- final EnumTypeDefinition enumTypeDef = enumTypeDefFromExtendedType(typeDef);\r
- final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition(enumTypeDef, leafName,\r
+ val enumTypeDef = enumTypeDefFromExtendedType(typeDef);\r
+ val enumBuilder = resolveInnerEnumFromTypeDefinition(enumTypeDef, leafName,\r
typeBuilder);\r
\r
- if (enumBuilder != null) {\r
- returnType = new ReferencedTypeImpl(enumBuilder.getPackageName(), enumBuilder.getName());\r
+ if (enumBuilder !== null) {\r
+ returnType = new ReferencedTypeImpl(enumBuilder.packageName, enumBuilder.name);\r
}\r
- ((TypeProviderImpl) typeProvider).putReferencedType(leaf.getPath(), returnType);\r
+ (typeProvider as TypeProviderImpl).putReferencedType(leaf.path, returnType);\r
} else if (typeDef instanceof UnionType) {\r
- GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leafName, leaf, parentModule);\r
- if (genTOBuilder != null) {\r
- returnType = new ReferencedTypeImpl(genTOBuilder.getPackageName(), genTOBuilder.getName());\r
+ val genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leafName, leaf, parentModule);\r
+ if (genTOBuilder !== null) {\r
+ returnType = new ReferencedTypeImpl(genTOBuilder.packageName, genTOBuilder.name);\r
}\r
} else if (typeDef instanceof BitsTypeDefinition) {\r
- GeneratedTOBuilder genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leafName, leaf, parentModule);\r
- if (genTOBuilder != null) {\r
- returnType = new ReferencedTypeImpl(genTOBuilder.getPackageName(), genTOBuilder.getName());\r
+ val genTOBuilder = addTOToTypeBuilder(typeDef, typeBuilder, leafName, leaf, parentModule);\r
+ if (genTOBuilder !== null) {\r
+ returnType = new ReferencedTypeImpl(genTOBuilder.packageName, genTOBuilder.name);\r
}\r
} else {\r
returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf);\r
}\r
- if (returnType != null) {\r
+ if (returnType !== null) {\r
constructGetter(typeBuilder, leafName, leafDesc, returnType);\r
return true;\r
}\r
* <li>true - other cases</li>\r
* </ul>\r
*/\r
- private boolean resolveLeafSchemaNodeAsProperty(final GeneratedTOBuilder toBuilder, final LeafSchemaNode leaf,\r
+ private def boolean resolveLeafSchemaNodeAsProperty( GeneratedTOBuilder toBuilder, LeafSchemaNode leaf,\r
boolean isReadOnly) {\r
- if ((leaf != null) && (toBuilder != null)) {\r
- final String leafName = leaf.getQName().getLocalName();\r
- String leafDesc = leaf.getDescription();\r
- if (leafDesc == null) {\r
+ if ((leaf !== null) && (toBuilder !== null)) {\r
+ val leafName = leaf.QName.localName;\r
+ var String leafDesc = leaf.description;\r
+ if (leafDesc === null) {\r
leafDesc = "";\r
}\r
\r
- if (leafName != null && !leaf.isAddedByUses()) {\r
- final TypeDefinition<?> typeDef = leaf.getType();\r
+ if (leafName !== null && !leaf.isAddedByUses()) {\r
+ val TypeDefinition<?> typeDef = leaf.type;\r
\r
// TODO: properly resolve enum types\r
- final Type returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf);\r
+ val returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf);\r
\r
- if (returnType != null) {\r
- final GeneratedPropertyBuilder propBuilder = toBuilder.addProperty(parseToClassName(leafName));\r
+ if (returnType !== null) {\r
+ val propBuilder = toBuilder.addProperty(parseToClassName(leafName));\r
\r
propBuilder.setReadOnly(isReadOnly);\r
propBuilder.setReturnType(returnType);\r
* <li>false - other cases</li>\r
* </ul>\r
*/\r
- private boolean resolveLeafListSchemaNode(final GeneratedTypeBuilder typeBuilder, final LeafListSchemaNode node) {\r
- if ((node != null) && (typeBuilder != null)) {\r
- final String nodeName = node.getQName().getLocalName();\r
- String nodeDesc = node.getDescription();\r
- if (nodeDesc == null) {\r
+ private def boolean resolveLeafListSchemaNode( GeneratedTypeBuilder typeBuilder, LeafListSchemaNode node) {\r
+ if ((node !== null) && (typeBuilder !== null)) {\r
+ val nodeName = node.QName.localName;\r
+ var String nodeDesc = node.description;\r
+ if (nodeDesc === null) {\r
nodeDesc = "";\r
}\r
\r
- if (nodeName != null && !node.isAddedByUses()) {\r
- final TypeDefinition<?> type = node.getType();\r
- final Type listType = Types.listTypeFor(typeProvider.javaTypeForSchemaDefinitionType(type, node));\r
+ if (nodeName !== null && !node.isAddedByUses()) {\r
+ val TypeDefinition<?> type = node.type;\r
+ val listType = Types.listTypeFor(typeProvider.javaTypeForSchemaDefinitionType(type, node));\r
\r
constructGetter(typeBuilder, nodeName, nodeDesc, listType);\r
return true;\r
* <li>true - other cases</li>\r
* </ul>\r
*/\r
- private boolean resolveContainerSchemaNode(final String basePackageName, final GeneratedTypeBuilder typeBuilder,\r
- final ContainerSchemaNode containerNode) {\r
- if ((containerNode != null) && (typeBuilder != null)) {\r
- final String nodeName = containerNode.getQName().getLocalName();\r
+ private def boolean resolveContainerSchemaNode( String basePackageName, GeneratedTypeBuilder typeBuilder,\r
+ ContainerSchemaNode containerNode) {\r
+ if ((containerNode !== null) && (typeBuilder !== null)) {\r
+ val nodeName = containerNode.QName.localName;\r
\r
- if (nodeName != null && !containerNode.isAddedByUses()) {\r
- final String packageName = packageNameForGeneratedType(basePackageName, containerNode.getPath());\r
+ if (nodeName !== null && !containerNode.isAddedByUses()) {\r
+ val packageName = packageNameForGeneratedType(basePackageName, containerNode.path);\r
\r
- final GeneratedTypeBuilder rawGenType = addDefaultInterfaceDefinition(packageName, containerNode);\r
- constructGetter(typeBuilder, nodeName, containerNode.getDescription(), rawGenType);\r
+ val rawGenType = addDefaultInterfaceDefinition(packageName, containerNode);\r
+ constructGetter(typeBuilder, nodeName, containerNode.description, rawGenType);\r
\r
return true;\r
}\r
* <li>true - other cases</li>\r
* </ul>\r
*/\r
- private boolean resolveListSchemaNode(final String basePackageName, final GeneratedTypeBuilder typeBuilder,\r
- final ListSchemaNode listNode) {\r
- if ((listNode != null) && (typeBuilder != null)) {\r
- final String listName = listNode.getQName().getLocalName();\r
-\r
- if (listName != null && !listNode.isAddedByUses()) {\r
- final String packageName = packageNameForGeneratedType(basePackageName, listNode.getPath());\r
- final GeneratedTypeBuilder rawGenType = addDefaultInterfaceDefinition(packageName, listNode);\r
- constructGetter(typeBuilder, listName, listNode.getDescription(), Types.listTypeFor(rawGenType));\r
+ private def boolean resolveListSchemaNode( String basePackageName, GeneratedTypeBuilder typeBuilder,\r
+ ListSchemaNode listNode) {\r
+ if ((listNode !== null) && (typeBuilder !== null)) {\r
+ val listName = listNode.QName.localName;\r
+\r
+ if (listName !== null && !listNode.isAddedByUses()) {\r
+ val packageName = packageNameForGeneratedType(basePackageName, listNode.path);\r
+ val rawGenType = addDefaultInterfaceDefinition(packageName, listNode);\r
+ constructGetter(typeBuilder, listName, listNode.description, Types.listTypeFor(rawGenType));\r
return true;\r
}\r
}\r
* schema node for which is created generated type builder\r
* @return generated type builder <code>schemaNode</code>\r
*/\r
- private GeneratedTypeBuilder addDefaultInterfaceDefinition(final String packageName, final SchemaNode schemaNode) {\r
- final GeneratedTypeBuilder builder = addRawInterfaceDefinition(packageName, schemaNode, "");\r
+ private def GeneratedTypeBuilder addDefaultInterfaceDefinition( String packageName, SchemaNode schemaNode) {\r
+ val builder = addRawInterfaceDefinition(packageName, schemaNode, "");\r
builder.addImplementsType(DATA_OBJECT);\r
if (!(schemaNode instanceof GroupingDefinition)) {\r
builder.addImplementsType(augmentable(builder));\r
}\r
\r
if (schemaNode instanceof DataNodeContainer) {\r
- addImplementedInterfaceFromUses((DataNodeContainer) schemaNode, builder);\r
+ addImplementedInterfaceFromUses( schemaNode as DataNodeContainer, builder);\r
}\r
\r
return builder;\r
* schema node which provide data about the schema node name\r
* @return generated type builder for <code>schemaNode</code>\r
*/\r
- private GeneratedTypeBuilder addRawInterfaceDefinition(final String packageName, final SchemaNode schemaNode) {\r
+ private def GeneratedTypeBuilder addRawInterfaceDefinition( String packageName, SchemaNode schemaNode) {\r
return addRawInterfaceDefinition(packageName, schemaNode, "");\r
}\r
\r
* </ul>\r
*\r
*/\r
- private GeneratedTypeBuilder addRawInterfaceDefinition(final String packageName, final SchemaNode schemaNode,\r
- final String prefix) {\r
- Preconditions.checkArgument(schemaNode != null,"Data Schema Node cannot be NULL.");\r
- Preconditions.checkArgument(packageName != null,"Package Name for Generated Type cannot be NULL.");\r
- Preconditions.checkArgument(schemaNode.getQName() != null,"QName for Data Schema Node cannot be NULL.");\r
- final String schemaNodeName = schemaNode.getQName().getLocalName();\r
- Preconditions.checkArgument(schemaNodeName != null,"Local Name of QName for Data Schema Node cannot be NULL.");\r
-\r
- final String genTypeName;\r
- if (prefix == null) {\r
+ private def GeneratedTypeBuilder addRawInterfaceDefinition( String packageName, SchemaNode schemaNode,\r
+ String prefix) {\r
+ checkArgument(schemaNode !== null,"Data Schema Node cannot be NULL.");\r
+ checkArgument(packageName !== null,"Package Name for Generated Type cannot be NULL.");\r
+ checkArgument(schemaNode.QName !== null,"QName for Data Schema Node cannot be NULL.");\r
+ val schemaNodeName = schemaNode.QName.localName;\r
+ checkArgument(schemaNodeName !== null,"Local Name of QName for Data Schema Node cannot be NULL.");\r
+\r
+ var String genTypeName;\r
+ if (prefix === null) {\r
genTypeName = parseToClassName(schemaNodeName);\r
} else {\r
genTypeName = prefix + parseToClassName(schemaNodeName);\r
}\r
-\r
- final GeneratedTypeBuilder newType = new GeneratedTypeBuilderImpl(packageName, genTypeName);\r
+ //FIXME: Validation of name conflict\r
+ val newType = new GeneratedTypeBuilderImpl(packageName, genTypeName);\r
+ yangToJavaMapping.put(schemaNode.path,newType);\r
if (!genTypeBuilders.containsKey(packageName)) {\r
- final Map<String, GeneratedTypeBuilder> builders = new HashMap<>();\r
+ val Map<String, GeneratedTypeBuilder> builders = new HashMap();\r
builders.put(genTypeName, newType);\r
genTypeBuilders.put(packageName, builders);\r
} else {\r
- final Map<String, GeneratedTypeBuilder> builders = genTypeBuilders.get(packageName);\r
+ val Map<String, GeneratedTypeBuilder> builders = genTypeBuilders.get(packageName);\r
if (!builders.containsKey(genTypeName)) {\r
builders.put(genTypeName, newType);\r
}\r
* @return string with the name of the getter method for\r
* <code>methodName</code> in JAVA method format\r
*/\r
- private String getterMethodName(final String methodName,Type returnType) {\r
- final StringBuilder method = new StringBuilder();\r
+ private def String getterMethodName( String methodName,Type returnType) {\r
+ val method = new StringBuilder();\r
if(BOOLEAN.equals(returnType)) {\r
method.append("is");\r
} else {\r
return method.toString();\r
}\r
\r
- /**\r
- * Creates the name of the setter method from <code>methodName</code>.\r
- *\r
- * @param methodName\r
- * string with the name of the setter method\r
- * @return string with the name of the setter method for\r
- * <code>methodName</code> in JAVA method format\r
- */\r
- private String setterMethodName(final String methodName) {\r
- final StringBuilder method = new StringBuilder();\r
- method.append("set");\r
- method.append(parseToClassName(methodName));\r
- return method.toString();\r
- }\r
-\r
/**\r
* Created a method signature builder as part of\r
* <code>interfaceBuilder</code>.\r
* @return method signature builder which represents the getter method of\r
* <code>interfaceBuilder</code>\r
*/\r
- private MethodSignatureBuilder constructGetter(final GeneratedTypeBuilder interfaceBuilder,\r
- final String schemaNodeName, final String comment, final Type returnType) {\r
+ private def MethodSignatureBuilder constructGetter( GeneratedTypeBuilder interfaceBuilder,\r
+ String schemaNodeName, String comment, Type returnType) {\r
\r
- final MethodSignatureBuilder getMethod = interfaceBuilder.addMethod(getterMethodName(schemaNodeName,returnType));\r
+ val getMethod = interfaceBuilder.addMethod(getterMethodName(schemaNodeName,returnType));\r
\r
getMethod.setComment(comment);\r
getMethod.setReturnType(returnType);\r
return getMethod;\r
}\r
\r
- private List<Type> listToGenType(final String basePackageName, final ListSchemaNode list) {\r
- Preconditions.checkArgument(basePackageName != null,"Package Name for Generated Type cannot be NULL.");\r
- Preconditions.checkArgument(list != null,"List Schema Node cannot be NULL.");\r
+ private def listToGenType( String basePackageName, ListSchemaNode list) {\r
+ checkArgument(basePackageName !== null,"Package Name for Generated Type cannot be NULL.");\r
+ checkArgument(list !== null,"List Schema Node cannot be NULL.");\r
\r
- final String packageName = packageNameForGeneratedType(basePackageName, list.getPath());\r
- // final GeneratedTypeBuilder typeBuilder =\r
+ val packageName = packageNameForGeneratedType(basePackageName, list.path);\r
+ // val typeBuilder =\r
// resolveListTypeBuilder(packageName, list);\r
- final GeneratedTypeBuilder typeBuilder = addDefaultInterfaceDefinition(packageName, list);\r
+ val typeBuilder = addDefaultInterfaceDefinition(packageName, list);\r
\r
- final List<String> listKeys = listKeys(list);\r
- GeneratedTOBuilder genTOBuilder = resolveListKeyTOBuilder(packageName, list);\r
+ val List<String> listKeys = listKeys(list);\r
+ val genTOBuilder = resolveListKeyTOBuilder(packageName, list);\r
\r
- if (genTOBuilder != null) {\r
- ParameterizedType identifierMarker = Types.parameterizedTypeFor(Types.typeForClass(Identifier.class),\r
- typeBuilder);\r
- ParameterizedType identifiableMarker = Types.parameterizedTypeFor(Types.typeForClass(Identifiable.class),\r
- genTOBuilder);\r
+ if (genTOBuilder !== null) {\r
+ val identifierMarker = IDENTIFIER.parameterizedTypeFor(typeBuilder);\r
+ val identifiableMarker = IDENTIFIABLE.parameterizedTypeFor(genTOBuilder);\r
genTOBuilder.addImplementsType(identifierMarker);\r
typeBuilder.addImplementsType(identifiableMarker);\r
}\r
- final Set<DataSchemaNode> schemaNodes = list.getChildNodes();\r
+ val schemaNodes = list.childNodes;\r
\r
- for (final DataSchemaNode schemaNode : schemaNodes) {\r
- if (schemaNode.isAugmenting()) {\r
- continue;\r
+ for (schemaNode : schemaNodes) {\r
+ if (!schemaNode.isAugmenting()) {\r
+ addSchemaNodeToListBuilders(basePackageName, schemaNode, typeBuilder, genTOBuilder, listKeys);\r
}\r
- addSchemaNodeToListBuilders(basePackageName, schemaNode, typeBuilder, genTOBuilder, listKeys);\r
}\r
return typeBuildersToGenTypes(typeBuilder, genTOBuilder);\r
}\r
* <li>if <code>typeBuilder</code> equals null</li>\r
* </ul>\r
*/\r
- private void addSchemaNodeToListBuilders(final String basePackageName, final DataSchemaNode schemaNode,\r
- final GeneratedTypeBuilder typeBuilder, final GeneratedTOBuilder genTOBuilder, final List<String> listKeys) {\r
- Preconditions.checkArgument(schemaNode != null,"Data Schema Node cannot be NULL.");\r
+ private def void addSchemaNodeToListBuilders( String basePackageName, DataSchemaNode schemaNode,\r
+ GeneratedTypeBuilder typeBuilder, GeneratedTOBuilder genTOBuilder, List<String> listKeys) {\r
+ checkArgument(schemaNode !== null,"Data Schema Node cannot be NULL.");\r
\r
- Preconditions.checkArgument(typeBuilder != null,"Generated Type Builder cannot be NULL.");\r
+ checkArgument(typeBuilder !== null,"Generated Type Builder cannot be NULL.");\r
\r
if (schemaNode instanceof LeafSchemaNode) {\r
- final LeafSchemaNode leaf = (LeafSchemaNode) schemaNode;\r
- final String leafName = leaf.getQName().getLocalName();\r
+ val leaf = schemaNode as LeafSchemaNode;\r
+ val leafName = leaf.QName.localName;\r
if (!listKeys.contains(leafName)) {\r
resolveLeafSchemaNodeAsMethod(typeBuilder, leaf);\r
} else {\r
resolveLeafSchemaNodeAsProperty(genTOBuilder, leaf, true);\r
}\r
} else if (schemaNode instanceof LeafListSchemaNode) {\r
- resolveLeafListSchemaNode(typeBuilder, (LeafListSchemaNode) schemaNode);\r
+ resolveLeafListSchemaNode(typeBuilder, schemaNode as LeafListSchemaNode);\r
} else if (schemaNode instanceof ContainerSchemaNode) {\r
- resolveContainerSchemaNode(basePackageName, typeBuilder, (ContainerSchemaNode) schemaNode);\r
+ resolveContainerSchemaNode(basePackageName, typeBuilder, schemaNode as ContainerSchemaNode);\r
} else if (schemaNode instanceof ListSchemaNode) {\r
- resolveListSchemaNode(basePackageName, typeBuilder, (ListSchemaNode) schemaNode);\r
+ resolveListSchemaNode(basePackageName, typeBuilder, schemaNode as ListSchemaNode);\r
}\r
}\r
\r
- private List<Type> typeBuildersToGenTypes(final GeneratedTypeBuilder typeBuilder, GeneratedTOBuilder genTOBuilder) {\r
- final List<Type> genTypes = new ArrayList<>();\r
- Preconditions.checkArgument(typeBuilder != null,"Generated Type Builder cannot be NULL.");\r
+ private def typeBuildersToGenTypes( GeneratedTypeBuilder typeBuilder, GeneratedTOBuilder genTOBuilder) {\r
+ val List<Type> genTypes = new ArrayList();\r
+ checkArgument(typeBuilder !== null,"Generated Type Builder cannot be NULL.");\r
\r
- if (genTOBuilder != null) {\r
- final GeneratedTransferObject genTO = genTOBuilder.toInstance();\r
+ if (genTOBuilder !== null) {\r
+ val genTO = genTOBuilder.toInstance();\r
constructGetter(typeBuilder, "key", "Returns Primary Key of Yang List Type", genTO);\r
genTypes.add(genTO);\r
}\r
* <code>list</code> contains no keys then the empty list is\r
* returned.\r
*/\r
- private List<String> listKeys(final ListSchemaNode list) {\r
- final List<String> listKeys = new ArrayList<>();\r
+ private def listKeys( ListSchemaNode list) {\r
+ val List<String> listKeys = new ArrayList();\r
\r
- if (list.getKeyDefinition() != null) {\r
- final List<QName> keyDefinitions = list.getKeyDefinition();\r
-\r
- for (final QName keyDefinition : keyDefinitions) {\r
- listKeys.add(keyDefinition.getLocalName());\r
+ if (list.keyDefinition !== null) {\r
+ val keyDefinitions = list.keyDefinition;\r
+ for (keyDefinition : keyDefinitions) {\r
+ listKeys.add(keyDefinition.localName);\r
}\r
}\r
return listKeys;\r
* <code>list</code> or null if <code>list</code> is null or list of\r
* key definitions is null or empty.\r
*/\r
- private GeneratedTOBuilder resolveListKeyTOBuilder(final String packageName, final ListSchemaNode list) {\r
- GeneratedTOBuilder genTOBuilder = null;\r
- if ((list.getKeyDefinition() != null) && (!list.getKeyDefinition().isEmpty())) {\r
- if (list != null) {\r
- final String listName = list.getQName().getLocalName() + "Key";\r
+ private def GeneratedTOBuilder resolveListKeyTOBuilder( String packageName, ListSchemaNode list) {\r
+ var GeneratedTOBuilder genTOBuilder = null;\r
+ if ((list.keyDefinition !== null) && (!list.keyDefinition.isEmpty())) {\r
+ if (list !== null) {\r
+ val listName = list.QName.localName + "Key";\r
genTOBuilder = schemaNodeToTransferObjectBuilder(packageName, listName);\r
}\r
}\r
* string with name for generated TO builder\r
* @return generated TO builder for <code>typeDef</code>\r
*/\r
- private GeneratedTOBuilder addTOToTypeBuilder(TypeDefinition<?> typeDef, GeneratedTypeBuilder typeBuilder,\r
+ private def GeneratedTOBuilder addTOToTypeBuilder(TypeDefinition<?> typeDef, GeneratedTypeBuilder typeBuilder,\r
String leafName, LeafSchemaNode leaf, Module parentModule) {\r
- final String classNameFromLeaf = parseToClassName(leafName);\r
- List<GeneratedTOBuilder> genTOBuilders = new ArrayList<>();\r
- final String packageName = typeBuilder.getFullyQualifiedName();\r
+ val classNameFromLeaf = parseToClassName(leafName);\r
+ val List<GeneratedTOBuilder> genTOBuilders = new ArrayList();\r
+ val packageName = typeBuilder.fullyQualifiedName;\r
if (typeDef instanceof UnionTypeDefinition) {\r
- genTOBuilders.addAll(((TypeProviderImpl) typeProvider).provideGeneratedTOBuildersForUnionTypeDef(\r
+ genTOBuilders.addAll((typeProvider as TypeProviderImpl).provideGeneratedTOBuildersForUnionTypeDef(\r
packageName, typeDef, classNameFromLeaf, leaf));\r
} else if (typeDef instanceof BitsTypeDefinition) {\r
- genTOBuilders.add(((TypeProviderImpl) typeProvider).provideGeneratedTOBuilderForBitsTypeDefinition(\r
+ genTOBuilders.add(((typeProvider as TypeProviderImpl) ).provideGeneratedTOBuilderForBitsTypeDefinition(\r
packageName, typeDef, classNameFromLeaf));\r
}\r
- if (genTOBuilders != null && !genTOBuilders.isEmpty()) {\r
- for (GeneratedTOBuilder genTOBuilder : genTOBuilders) {\r
+ if (genTOBuilders !== null && !genTOBuilders.isEmpty()) {\r
+ for (genTOBuilder : genTOBuilders) {\r
typeBuilder.addEnclosingTransferObject(genTOBuilder);\r
}\r
return genTOBuilders.get(0);\r
* The method passes through the list of <i>uses</i> in\r
* {@code dataNodeContainer}. For every <i>use</i> is obtained coresponding\r
* generated type from {@link BindingGeneratorImpl#allGroupings\r
- * allGroupings} which is adde as <i>implements type</i> to\r
+ * allGroupings} which is added as <i>implements type</i> to\r
* <code>builder</code>\r
*\r
* @param dataNodeContainer\r
* <code>dataNodeContainer</code>\r
* @return generated type builder with all implemented types\r
*/\r
- private GeneratedTypeBuilder addImplementedInterfaceFromUses(final DataNodeContainer dataNodeContainer,\r
- final GeneratedTypeBuilder builder) {\r
- for (UsesNode usesNode : dataNodeContainer.getUses()) {\r
- if (usesNode.getGroupingPath() != null) {\r
- GeneratedType genType = allGroupings.get(usesNode.getGroupingPath());\r
- if (genType == null) {\r
- throw new IllegalStateException("Grouping " + usesNode.getGroupingPath() + "is not resolved for "\r
- + builder.getName());\r
+ private def addImplementedInterfaceFromUses( DataNodeContainer dataNodeContainer,\r
+ GeneratedTypeBuilder builder) {\r
+ for (usesNode : dataNodeContainer.uses) {\r
+ if (usesNode.groupingPath !== null) {\r
+ val genType = allGroupings.get(usesNode.groupingPath);\r
+ if (genType === null) {\r
+ throw new IllegalStateException("Grouping " + usesNode.groupingPath + "is not resolved for "\r
+ + builder.name);\r
}\r
builder.addImplementsType(genType);\r
}\r
}\r
return builder;\r
}\r
-\r
}\r
} else {
final Module module = findParentModule(schemaContext, parentNode);
if (module != null) {
- final DataSchemaNode dataNode;
+ final SchemaNode dataNode;
if (xpath.isAbsolute()) {
dataNode = findDataSchemaNode(schemaContext, module, xpath);
} else {
* <li>false - other cases</li>
* </ul>
*/
- private boolean leafContainsEnumDefinition(final DataSchemaNode dataNode) {
+ private boolean leafContainsEnumDefinition(final SchemaNode dataNode) {
if (dataNode instanceof LeafSchemaNode) {
final LeafSchemaNode leaf = (LeafSchemaNode) dataNode;
if (leaf.getType() instanceof EnumTypeDefinition) {
* <li>false - other cases</li>
* </ul>
*/
- private boolean leafListContainsEnumDefinition(final DataSchemaNode dataNode) {
+ private boolean leafListContainsEnumDefinition(final SchemaNode dataNode) {
if (dataNode instanceof LeafListSchemaNode) {
final LeafListSchemaNode leafList = (LeafListSchemaNode) dataNode;
if (leafList.getType() instanceof EnumTypeDefinition) {
* contains information about YANG type
* @return JAVA <code>Type</code> representation of <code>dataNode</code>
*/
- private Type resolveTypeFromDataSchemaNode(final DataSchemaNode dataNode) {
+ private Type resolveTypeFromDataSchemaNode(final SchemaNode dataNode) {
Type returnType = null;
if (dataNode != null) {
if (dataNode instanceof LeafSchemaNode) {
<name>${project.artifactId}</name>\r
<description>${project.artifactId}</description>\r
\r
+\r
+ <build>\r
+ <plugins>\r
+ <plugin>\r
+ <groupId>org.eclipse.xtend</groupId>\r
+ <artifactId>xtend-maven-plugin</artifactId>\r
+ <version>2.4.2</version>\r
+ <executions>\r
+ <execution>\r
+ <goals>\r
+ <goal>compile</goal>\r
+ </goals>\r
+ <configuration>\r
+ <outputDirectory>${basedir}/src/main/xtend-gen</outputDirectory>\r
+ </configuration>\r
+ </execution>\r
+ </executions>\r
+ </plugin>\r
+ <plugin>\r
+ <artifactId>maven-clean-plugin</artifactId>\r
+ <version>2.4.1</version>\r
+ <configuration>\r
+ <filesets>\r
+ <fileset>\r
+ <directory>${basedir}/src/main/xtend-gen</directory>\r
+ <includes>\r
+ <include>**</include>\r
+ </includes>\r
+ </fileset>\r
+ </filesets>\r
+ </configuration>\r
+ </plugin>\r
+ </plugins>\r
+ </build>\r
+\r
<dependencies>\r
<dependency>\r
<groupId>${project.groupId}</groupId>\r
<artifactId>yang-model-api</artifactId>\r
</dependency>\r
+ <dependency>\r
+ <groupId>org.eclipse.xtend</groupId>\r
+ <artifactId>org.eclipse.xtend.lib</artifactId>\r
+ <version>2.4.2</version>\r
+ </dependency>\r
</dependencies>\r
-\r
</project>\r
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.RpcDefinition
+import org.opendaylight.yangtools.yang.model.api.NotificationDefinition
+import java.io.ObjectOutputStream.PutField
+import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode
/**
* The Schema Context Util contains support methods for searching through Schema Context modules for specified schema
*
* @author Lukas Sedlak <lsedlak@cisco.com>
*/
-public final class SchemaContextUtil {
+public class SchemaContextUtil {
- private SchemaContextUtil() {
+ private new() {
}
/**
* @return DataSchemaNode from the end of the Schema Path or
* <code>null</code> if the Node is not present.
*/
- public static DataSchemaNode findDataSchemaNode(final SchemaContext context, final SchemaPath schemaPath) {
+ public static def SchemaNode findDataSchemaNode( SchemaContext context, SchemaPath schemaPath) {
if (context == null) {
throw new IllegalArgumentException("Schema Context reference cannot be NULL!");
}
if (schemaPath == null) {
throw new IllegalArgumentException("Schema Path reference cannot be NULL");
}
-
- final Module module = resolveModuleFromSchemaPath(context, schemaPath);
- final Queue<QName> prefixedPath = new LinkedList<>(schemaPath.getPath());
-
- if ((module != null) && (prefixedPath != null)) {
- return findSchemaNodeForGivenPath(context, module, prefixedPath);
+ val prefixedPath = (schemaPath.getPath());
+ if (prefixedPath != null) {
+ return findNodeInSchemaContext(context,prefixedPath);
}
return null;
}
* @return Returns Data Schema Node for specified Schema Context for given Non-conditional Revision Aware XPath,
* or <code>null</code> if the DataSchemaNode is not present in Schema Context.
*/
- public static DataSchemaNode findDataSchemaNode(final SchemaContext context, final Module module,
- final RevisionAwareXPath nonCondXPath) {
+ public static def SchemaNode findDataSchemaNode( SchemaContext context, Module module,
+ RevisionAwareXPath nonCondXPath) {
if (context == null) {
throw new IllegalArgumentException("Schema Context reference cannot be NULL!");
}
throw new IllegalArgumentException("Non Conditional Revision Aware XPath cannot be NULL!");
}
- final String strXPath = nonCondXPath.toString();
+ val strXPath = nonCondXPath.toString();
if (strXPath != null) {
if (strXPath.contains("[")) {
throw new IllegalArgumentException("Revision Aware XPath cannot contains condition!");
}
if (nonCondXPath.isAbsolute()) {
- final Queue<QName> qnamedPath = xpathToQNamePath(context, module, strXPath);
+ val qnamedPath = xpathToQNamePath(context, module, strXPath);
if (qnamedPath != null) {
- final DataSchemaNode dataNode = findSchemaNodeForGivenPath(context, module, qnamedPath);
- return dataNode;
+ return findNodeInSchemaContext(context,qnamedPath);
}
}
}
* @return DataSchemaNode if is present in specified Schema Context for given relative Revision Aware XPath,
* otherwise will return <code>null</code>.
*/
- public static DataSchemaNode findDataSchemaNodeForRelativeXPath(final SchemaContext context, final Module module,
- final SchemaNode actualSchemaNode, final RevisionAwareXPath relativeXPath) {
+ public static def SchemaNode findDataSchemaNodeForRelativeXPath( SchemaContext context, Module module,
+ SchemaNode actualSchemaNode, RevisionAwareXPath relativeXPath) {
if (context == null) {
throw new IllegalArgumentException("Schema Context reference cannot be NULL!");
}
+ "for non relative Revision Aware XPath use findDataSchemaNode method!");
}
- final SchemaPath actualNodePath = actualSchemaNode.getPath();
+ val actualNodePath = actualSchemaNode.getPath();
if (actualNodePath != null) {
- final Queue<QName> qnamePath = resolveRelativeXPath(context, module, relativeXPath, actualSchemaNode);
+ val qnamePath = resolveRelativeXPath(context, module, relativeXPath, actualSchemaNode);
if (qnamePath != null) {
- final DataSchemaNode dataNode = findSchemaNodeForGivenPath(context, module, qnamePath);
- return dataNode;
+ return findNodeInSchemaContext(context,qnamePath);
}
}
return null;
}
- /**
- * Retrieve information from Schema Path and returns the module reference to which Schema Node belongs. The
- * search for correct Module is based on namespace within the last item in Schema Path. If schema context
- * contains module with namespace specified in last item of Schema Path, then operation will returns Module
- * reference, otherwise returns <code>null</code>
- * <br>
- * If Schema Context or Schema Node contains <code>null</code> references the method will throw IllegalArgumentException
- *
- * @throws IllegalArgumentException
- *
- * @param context Schema Context
- * @param schemaPath Schema Path
- * @return Module reference for given Schema Path if module is present in Schema Context,
- * otherwise returns <code>null</code>
- */
- private static Module resolveModuleFromSchemaPath(final SchemaContext context, final SchemaPath schemaPath) {
- if (context == null) {
- throw new IllegalArgumentException("Schema Context reference cannot be NULL!");
- }
- if (schemaPath == null) {
- throw new IllegalArgumentException("Schema Path reference cannot be NULL");
- }
-
- final List<QName> path = schemaPath.getPath();
- if (!path.isEmpty()) {
- final QName qname = path.get(path.size() - 1);
-
- if ((qname != null) && (qname.getNamespace() != null)) {
- return context.findModuleByNamespace(qname.getNamespace());
- }
- }
-
- return null;
- }
-
/**
* Returns parent Yang Module for specified Schema Context in which Schema Node is declared. If the Schema Node
* is not present in Schema Context the operation will return <code>null</code>.
* @return Yang Module for specified Schema Context and Schema Node, if Schema Node is NOT present,
* the method will returns <code>null</code>
*/
- public static Module findParentModule(final SchemaContext context, final SchemaNode schemaNode) {
+ public static def Module findParentModule( SchemaContext context, SchemaNode schemaNode) {
if (context == null) {
throw new IllegalArgumentException("Schema Context reference cannot be NULL!");
}
throw new IllegalArgumentException("Schema Node cannot be NULL!");
}
- final SchemaPath schemaPath = schemaNode.getPath();
+ val schemaPath = schemaNode.getPath();
if (schemaPath == null) {
throw new IllegalStateException("Schema Path for Schema Node is not "
+ "set properly (Schema Path is NULL)");
}
- final List<QName> qnamedPath = schemaPath.getPath();
+ val qnamedPath = schemaPath.getPath();
if (qnamedPath == null || qnamedPath.isEmpty()) {
throw new IllegalStateException("Schema Path contains invalid state of path parts."
+ "The Schema Path MUST contain at least ONE QName which defines namespace and Local name"
+ "of path.");
}
- final QName qname = qnamedPath.get(qnamedPath.size() - 1);
+ val qname = qnamedPath.get(qnamedPath.size() - 1);
return context.findModuleByNamespace(qname.getNamespace());
}
* @return DataSchemaNode if is present in Module(s) for specified Schema Context and given QNamed Path,
* otherwise will return <code>null</code>.
*/
- private static DataSchemaNode findSchemaNodeForGivenPath(final SchemaContext context, final Module module,
- final Queue<QName> qnamedPath) {
+ private static def SchemaNode findSchemaNodeForGivenPath( SchemaContext context, Module module,
+ Queue<QName> qnamedPath) {
if (context == null) {
throw new IllegalArgumentException("Schema Context reference cannot be NULL!");
}
+ "of path.");
}
- DataNodeContainer nextNode = module;
- final URI moduleNamespace = module.getNamespace();
+ var DataNodeContainer nextNode = module;
+ val moduleNamespace = module.getNamespace();
- QName childNodeQName;
- DataSchemaNode schemaNode = null;
+ var QName childNodeQName;
+ var SchemaNode schemaNode = null;
while ((nextNode != null) && !qnamedPath.isEmpty()) {
childNodeQName = qnamedPath.peek();
if (childNodeQName != null) {
- final URI childNodeNamespace = childNodeQName.getNamespace();
+ val URI childNodeNamespace = childNodeQName.getNamespace();
schemaNode = nextNode.getDataChildByName(childNodeQName.getLocalName());
+ if(schemaNode == null && nextNode instanceof Module) {
+ schemaNode = (nextNode as Module).getNotificationByName(childNodeQName);
+ }
+ if(schemaNode == null && nextNode instanceof Module) {
+
+ }
if (schemaNode != null) {
if (schemaNode instanceof ContainerSchemaNode) {
- nextNode = (ContainerSchemaNode) schemaNode;
+ nextNode = schemaNode as ContainerSchemaNode;
} else if (schemaNode instanceof ListSchemaNode) {
- nextNode = (ListSchemaNode) schemaNode;
+ nextNode = schemaNode as ListSchemaNode;
} else if (schemaNode instanceof ChoiceNode) {
- final ChoiceNode choice = (ChoiceNode) schemaNode;
+ val choice = schemaNode as ChoiceNode;
qnamedPath.poll();
if (!qnamedPath.isEmpty()) {
childNodeQName = qnamedPath.peek();
nextNode = choice.getCaseNodeByName(childNodeQName);
- schemaNode = (DataSchemaNode) nextNode;
+ schemaNode = nextNode as DataSchemaNode;
}
} else {
nextNode = null;
}
} else if (!childNodeNamespace.equals(moduleNamespace)) {
- final Module nextModule = context.findModuleByNamespace(childNodeNamespace);
+ val Module nextModule = context.findModuleByNamespace(childNodeNamespace);
schemaNode = findSchemaNodeForGivenPath(context, nextModule, qnamedPath);
return schemaNode;
}
}
return schemaNode;
}
+
+
+ private static def SchemaNode findNodeInSchemaContext(SchemaContext context, List<QName> path) {
+ val current = path.get(0);
+ val module = context.findModuleByNamespace(current.namespace);
+ if(module == null) return null;
+ return findNodeInModule(module,path);
+ }
+
+ private static def SchemaNode findNodeInModule(Module module, List<QName> path) {
+ val current = path.get(0);
+ var SchemaNode node = module.getDataChildByName(current);
+ if (node != null) return findNode(node as DataSchemaNode,path.nextLevel);
+ node = module.getRpcByName(current);
+ if (node != null) return findNodeInRpc(node as RpcDefinition,path.nextLevel)
+ node = module.getNotificationByName(current);
+ if (node != null) return findNodeInNotification(node as NotificationDefinition,path.nextLevel)
+ return null
+ }
+
+ private static def SchemaNode findNodeInRpc(RpcDefinition rpc,List<QName> path) {
+ if(path.empty) return rpc;
+ val current = path.get(0);
+ switch (current.localName) {
+ case "input": return findNode(rpc.input,path.nextLevel)
+ case "output": return findNode(rpc.output,path.nextLevel)
+ }
+ return null
+ }
+
+ private static def SchemaNode findNodeInNotification(NotificationDefinition rpc,List<QName> path) {
+ if(path.empty) return rpc;
+ val current = path.get(0);
+ val node = rpc.getDataChildByName(current)
+ if(node != null) return findNode(node,path.nextLevel)
+ return null
+ }
+
+ private static dispatch def SchemaNode findNode(ChoiceNode parent,List<QName> path) {
+ if(path.empty) return parent;
+ val current = path.get(0);
+ val node = parent.getCaseNodeByName(current)
+ if (node != null) return findNodeInCase(node,path.nextLevel)
+ return null
+ }
+
+ private static dispatch def SchemaNode findNode(ContainerSchemaNode parent,List<QName> path) {
+ if(path.empty) return parent;
+ val current = path.get(0);
+ val node = parent.getDataChildByName(current)
+ if (node != null) return findNode(node,path.nextLevel)
+ return null
+ }
+
+ private static dispatch def SchemaNode findNode(ListSchemaNode parent,List<QName> path) {
+ if(path.empty) return parent;
+ val current = path.get(0);
+ val node = parent.getDataChildByName(current)
+ if (node != null) return findNode(node,path.nextLevel)
+ return null
+ }
+
+ private static dispatch def SchemaNode findNode(DataSchemaNode parent,List<QName> path){
+ if(path.empty) {
+ return parent
+ } else {
+ throw new IllegalArgumentException("Path nesting violation");
+ }
+ }
+
+ public static def SchemaNode findNodeInCase(ChoiceCaseNode parent,List<QName> path) {
+ if(path.empty) return parent;
+ val current = path.get(0);
+ val node = parent.getDataChildByName(current)
+ if (node != null) return findNode(node,path.nextLevel)
+ return null
+ }
+
+
+ public static def RpcDefinition getRpcByName(Module module, QName name) {
+ for(notification : module.rpcs) {
+ if(notification.QName == name) {
+ return notification;
+ }
+ }
+ return null;
+ }
+
+
+ private static def nextLevel(List<QName> path){
+ return path.subList(1,path.size)
+ }
+
+ public static def NotificationDefinition getNotificationByName(Module module, QName name) {
+ for(notification : module.notifications) {
+ if(notification.QName == name) {
+ return notification;
+ }
+ }
+ return null;
+ }
/**
* Transforms string representation of XPath to Queue of QNames. The XPath is split by "/" and for each part of
* @param xpath XPath String
* @return
*/
- private static Queue<QName> xpathToQNamePath(final SchemaContext context, final Module parentModule,
- final String xpath) {
+ private static def xpathToQNamePath( SchemaContext context, Module parentModule,
+ String xpath) {
if (context == null) {
throw new IllegalArgumentException("Schema Context reference cannot be NULL!");
}
throw new IllegalArgumentException("XPath string reference cannot be NULL!");
}
- final Queue<QName> path = new LinkedList<>();
- final String[] prefixedPath = xpath.split("/");
- for (int i = 0; i < prefixedPath.length; ++i) {
- if (!prefixedPath[i].isEmpty()) {
- path.add(stringPathPartToQName(context, parentModule, prefixedPath[i]));
+ val path = new LinkedList<QName>();
+ val String[] prefixedPath = xpath.split("/");
+ for (pathComponent : prefixedPath) {
+ if (!pathComponent.isEmpty()) {
+ path.add(stringPathPartToQName(context, parentModule, pathComponent));
}
}
return path;
* @param prefixedPathPart Prefixed Path Part string
* @return QName from prefixed Path Part String.
*/
- private static QName stringPathPartToQName(final SchemaContext context, final Module parentModule,
- final String prefixedPathPart) {
+ private static def QName stringPathPartToQName( SchemaContext context, Module parentModule,
+ String prefixedPathPart) {
if (context == null) {
throw new IllegalArgumentException("Schema Context reference cannot be NULL!");
}
}
if (prefixedPathPart.contains(":")) {
- final String[] prefixedName = prefixedPathPart.split(":");
- final Module module = resolveModuleForPrefix(context, parentModule, prefixedName[0]);
+ val String[] prefixedName = prefixedPathPart.split(":");
+ val module = resolveModuleForPrefix(context, parentModule, prefixedName.get(0));
if (module != null) {
- return new QName(module.getNamespace(), module.getRevision(), prefixedName[1]);
+ return new QName(module.getNamespace(), module.getRevision(), prefixedName.get(1));
}
} else {
return new QName(parentModule.getNamespace(), parentModule.getRevision(), prefixedPathPart);
* @param prefix Module Prefix
* @return Module for given prefix in specified Schema Context if is present, otherwise returns <code>null</code>
*/
- private static Module resolveModuleForPrefix(final SchemaContext context, final Module module, final String prefix) {
+ private static def Module resolveModuleForPrefix( SchemaContext context, Module module, String prefix) {
if (context == null) {
throw new IllegalArgumentException("Schema Context reference cannot be NULL!");
}
return module;
}
- final Set<ModuleImport> imports = module.getImports();
- for (final ModuleImport mi : imports) {
+ val imports = module.getImports();
+ for ( ModuleImport mi : imports) {
if (prefix.equals(mi.getPrefix())) {
return context.findModuleByName(mi.getModuleName(), mi.getRevision());
}
* @param leafrefSchemaPath Schema Path for Leafref
* @return
*/
- private static Queue<QName> resolveRelativeXPath(final SchemaContext context, final Module module,
- final RevisionAwareXPath relativeXPath, final SchemaNode leafrefParentNode) {
- final Queue<QName> absolutePath = new LinkedList<>();
+ private static def resolveRelativeXPath( SchemaContext context, Module module,
+ RevisionAwareXPath relativeXPath, SchemaNode leafrefParentNode) {
+
if (context == null) {
throw new IllegalArgumentException("Schema Context reference cannot be NULL!");
}
if (leafrefParentNode.getPath() == null) {
throw new IllegalArgumentException("Schema Path reference for Leafref cannot be NULL!");
}
-
- final String strXPath = relativeXPath.toString();
+ val absolutePath = new LinkedList<QName>();
+ val String strXPath = relativeXPath.toString();
if (strXPath != null) {
- final String[] xpaths = strXPath.split("/");
+ val String[] xpaths = strXPath.split("/");
if (xpaths != null) {
- int colCount = 0;
- while (xpaths[colCount].contains("..")) {
- ++colCount;
+ var int colCount = 0;
+ while (xpaths.get(colCount).contains("..")) {
+ colCount = colCount+ 1;
}
- final List<QName> path = leafrefParentNode.getPath().getPath();
+ val path = leafrefParentNode.getPath().getPath();
if (path != null) {
- int lenght = path.size() - colCount;
- for (int i = 0; i < lenght; ++i) {
- absolutePath.add(path.get(i));
- }
- for (int i = colCount; i < xpaths.length; ++i) {
- absolutePath.add(stringPathPartToQName(context, module, xpaths[i]));
- }
+ val int lenght = path.size() - colCount;
+ absolutePath.addAll(path.subList(0,lenght));
+ absolutePath.addAll(
+ xpaths.subList(colCount,xpaths.length).map[stringPathPartToQName(context, module,it)]
+ )
}
}
}
<groupId>com.google.guava</groupId>\r
<artifactId>guava</artifactId>\r
</dependency>\r
+ <dependency>\r
+ <groupId>org.eclipse.xtend</groupId>\r
+ <artifactId>org.eclipse.xtend.lib</artifactId>\r
+ <version>2.4.2</version>\r
+ </dependency>\r
<dependency>\r
<groupId>junit</groupId>\r
<artifactId>junit</artifactId>\r
+ <scope>test</scope>\r
</dependency>\r
</dependencies>\r
\r
<build>\r
<plugins>\r
+ <plugin>\r
+ <artifactId>maven-clean-plugin</artifactId>\r
+ <version>2.4.1</version>\r
+ <configuration>\r
+ <filesets>\r
+ <fileset>\r
+ <directory>${basedir}/src/main/xtend-gen</directory>\r
+ <includes>\r
+ <include>**</include>\r
+ </includes>\r
+ </fileset>\r
+ </filesets>\r
+ </configuration>\r
+ </plugin>\r
<plugin>\r
<groupId>org.antlr</groupId>\r
<artifactId>antlr4-maven-plugin</artifactId>\r
</configuration>\r
</plugin>\r
<plugin>\r
+ <groupId>org.eclipse.xtend</groupId>\r
+ <artifactId>xtend-maven-plugin</artifactId>\r
+ <version>2.4.2</version>\r
+ <executions>\r
+ <execution>\r
+ <goals>\r
+ <goal>compile</goal>\r
+ </goals>\r
+ <configuration>\r
+ <outputDirectory>${basedir}/src/main/xtend-gen</outputDirectory>\r
+ </configuration>\r
+ </execution>\r
+ </executions>\r
+ </plugin><plugin>\r
<groupId>org.codehaus.mojo</groupId>\r
<artifactId>build-helper-maven-plugin</artifactId>\r
<version>1.7</version>\r
</execution>\r
</executions>\r
</plugin>\r
+ \r
<plugin>\r
<groupId>org.apache.maven.plugins</groupId>\r
<artifactId>maven-javadoc-plugin</artifactId>\r
--- /dev/null
+/xtend-gen
*/
Object build();
+
+ public interface Rebuildable<T extends Builder> {
+ T toBuilder();
+ }
}
-/*
- * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.builder.impl;
-
-import java.net.URI;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Date;
-import java.util.HashSet;
-import java.util.LinkedHashSet;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeMap;
-import java.util.TreeSet;
-
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
-import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.Deviation;
-import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
-import org.opendaylight.yangtools.yang.model.api.FeatureDefinition;
-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.ModuleImport;
-import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
-import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.UsesNode;
-import org.opendaylight.yangtools.yang.parser.builder.api.AbstractDataNodeContainerBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
-import org.opendaylight.yangtools.yang.parser.builder.api.DataNodeContainerBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.TypeAwareBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.util.Comparators;
-import org.opendaylight.yangtools.yang.parser.util.RefineHolder;
-import org.opendaylight.yangtools.yang.parser.util.YangParseException;
-
-/**
- * Builder of Module object. If this module is dependent on external
- * module/modules, these dependencies must be resolved before module is built,
- * otherwise result may not be valid.
- */
-public class ModuleBuilder extends AbstractDataNodeContainerBuilder {
- private final ModuleImpl instance;
- private final String name;
- private final SchemaPath schemaPath;
- private URI namespace;
- private String prefix;
- private Date revision;
-
- private final LinkedList<Builder> actualPath = new LinkedList<Builder>();
- private final Set<TypeAwareBuilder> dirtyNodes = new HashSet<TypeAwareBuilder>();
-
- private final Set<ModuleImport> imports = new HashSet<ModuleImport>();
- private final List<AugmentationSchemaBuilder> addedAugments = new ArrayList<AugmentationSchemaBuilder>();
- private final List<AugmentationSchemaBuilder> allAugments = new ArrayList<AugmentationSchemaBuilder>();
- private final Set<UsesNodeBuilder> addedUsesNodes = new HashSet<UsesNodeBuilder>();
- private final List<UsesNodeBuilder> allUsesNodes = new ArrayList<UsesNodeBuilder>();
- private final Set<RpcDefinitionBuilder> addedRpcs = new HashSet<RpcDefinitionBuilder>();
- private final Set<NotificationBuilder> addedNotifications = new HashSet<NotificationBuilder>();
- private final Set<IdentitySchemaNodeBuilder> addedIdentities = new HashSet<IdentitySchemaNodeBuilder>();
- private final Set<FeatureBuilder> addedFeatures = new HashSet<FeatureBuilder>();
- private final Set<DeviationBuilder> addedDeviations = new HashSet<DeviationBuilder>();
- private final Set<TypeDefinitionBuilder> addedTypedefs = new HashSet<TypeDefinitionBuilder>();
- private final List<ExtensionBuilder> addedExtensions = new ArrayList<ExtensionBuilder>();
- private final List<UnknownSchemaNodeBuilder> allUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();
-
- public ModuleBuilder(final String name) {
- super(name, 0, null);
- this.name = name;
- schemaPath = new SchemaPath(Collections.<QName>emptyList(), true);
- instance = new ModuleImpl(name);
- actualPath.push(this);
- }
-
- /**
- * Build new Module object based on this builder.
- */
- @Override
- public Module build() {
- instance.setPrefix(prefix);
- instance.setRevision(revision);
- instance.setImports(imports);
- instance.setNamespace(namespace);
-
- // TYPEDEFS
- final Set<TypeDefinition<?>> typedefs = new TreeSet<TypeDefinition<?>>(Comparators.SCHEMA_NODE_COMP);
- for (TypeDefinitionBuilder tdb : addedTypedefs) {
- typedefs.add(tdb.build());
- }
- instance.setTypeDefinitions(typedefs);
-
- // CHILD NODES
- final Map<QName, DataSchemaNode> children = new TreeMap<QName, DataSchemaNode>(Comparators.QNAME_COMP);
- for (DataSchemaNodeBuilder child : addedChildNodes) {
- children.put(child.getQName(), child.build());
- }
- instance.setChildNodes(children);
-
- // GROUPINGS
- final Set<GroupingDefinition> groupings = new TreeSet<GroupingDefinition>(Comparators.SCHEMA_NODE_COMP);
- for (GroupingBuilder gb : addedGroupings) {
- groupings.add(gb.build());
- }
- instance.setGroupings(groupings);
-
- // USES
- final Set<UsesNode> usesDefinitions = new HashSet<UsesNode>();
- for (UsesNodeBuilder unb : addedUsesNodes) {
- usesDefinitions.add(unb.build());
- }
- instance.setUses(usesDefinitions);
-
- // FEATURES
- final Set<FeatureDefinition> features = new TreeSet<FeatureDefinition>(Comparators.SCHEMA_NODE_COMP);
- for (FeatureBuilder fb : addedFeatures) {
- features.add(fb.build());
- }
- instance.setFeatures(features);
-
- // NOTIFICATIONS
- final Set<NotificationDefinition> notifications = new TreeSet<NotificationDefinition>(
- Comparators.SCHEMA_NODE_COMP);
- for (NotificationBuilder entry : addedNotifications) {
- notifications.add(entry.build());
- }
- instance.setNotifications(notifications);
-
- // AUGMENTATIONS
- final Set<AugmentationSchema> augmentations = new HashSet<AugmentationSchema>();
- for (AugmentationSchemaBuilder builder : addedAugments) {
- augmentations.add(builder.build());
- }
- instance.setAugmentations(augmentations);
-
- // RPCs
- final Set<RpcDefinition> rpcs = new TreeSet<RpcDefinition>(Comparators.SCHEMA_NODE_COMP);
- for (RpcDefinitionBuilder rpc : addedRpcs) {
- rpcs.add(rpc.build());
- }
- instance.setRpcs(rpcs);
-
- // DEVIATIONS
- final Set<Deviation> deviations = new HashSet<Deviation>();
- for (DeviationBuilder entry : addedDeviations) {
- deviations.add(entry.build());
- }
- instance.setDeviations(deviations);
-
- // EXTENSIONS
- final List<ExtensionDefinition> extensions = new ArrayList<ExtensionDefinition>();
- for (ExtensionBuilder eb : addedExtensions) {
- extensions.add(eb.build());
- }
- Collections.sort(extensions, Comparators.SCHEMA_NODE_COMP);
- instance.setExtensionSchemaNodes(extensions);
-
- // IDENTITIES
- final Set<IdentitySchemaNode> identities = new TreeSet<IdentitySchemaNode>(Comparators.SCHEMA_NODE_COMP);
- for (IdentitySchemaNodeBuilder id : addedIdentities) {
- identities.add(id.build());
- }
- instance.setIdentities(identities);
-
- // UNKNOWN NODES
- final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();
- for (UnknownSchemaNodeBuilder unb : addedUnknownNodes) {
- unknownNodes.add(unb.build());
- }
- instance.setUnknownSchemaNodes(unknownNodes);
-
- return instance;
- }
-
- public boolean isAllUsesDataCollected() {
- for(UsesNodeBuilder usesNode : allUsesNodes) {
- if(!usesNode.isDataCollected()) {
- return false;
- }
- }
- return true;
- }
-
- @Override
- public void setParent(Builder parent) {
- throw new YangParseException(name, 0, "Can not set parent to module");
- }
-
- @Override
- public SchemaPath getPath() {
- return schemaPath;
- }
-
- @Override
- public Set<TypeDefinitionBuilder> getTypeDefinitionBuilders() {
- return addedTypedefs;
- }
-
- public void enterNode(final Builder node) {
- actualPath.push(node);
- }
-
- public void exitNode() {
- actualPath.pop();
- }
-
- public Builder getActualNode() {
- if (actualPath.isEmpty()) {
- return null;
- } else {
- return actualPath.get(0);
- }
- }
-
- public Builder getActualParent() {
- if (actualPath.size() < 2) {
- return null;
- } else {
- return actualPath.get(1);
- }
- }
-
- public Set<TypeAwareBuilder> getDirtyNodes() {
- return dirtyNodes;
- }
-
- public List<AugmentationSchemaBuilder> getAllAugments() {
- return allAugments;
- }
-
- public Set<IdentitySchemaNodeBuilder> getIdentities() {
- return addedIdentities;
- }
-
- public List<UsesNodeBuilder> getAllUsesNodes() {
- return allUsesNodes;
- }
-
- public Set<DeviationBuilder> getDeviations() {
- return addedDeviations;
- }
-
- public List<ExtensionBuilder> getExtensions() {
- return addedExtensions;
- }
-
- public List<UnknownSchemaNodeBuilder> getAllUnknownNodes() {
- return allUnknownNodes;
- }
-
- public String getName() {
- return name;
- }
-
- public URI getNamespace() {
- return namespace;
- }
-
- public void setNamespace(final URI namespace) {
- this.namespace = namespace;
- }
-
- public String getPrefix() {
- return prefix;
- }
-
- public Date getRevision() {
- return revision;
- }
-
- public void markActualNodeDirty() {
- final TypeAwareBuilder nodeBuilder = (TypeAwareBuilder) getActualNode();
- dirtyNodes.add(nodeBuilder);
- }
-
- public void setRevision(final Date revision) {
- this.revision = revision;
- }
-
- public void setPrefix(final String prefix) {
- this.prefix = prefix;
- }
-
- public void setYangVersion(final String yangVersion) {
- instance.setYangVersion(yangVersion);
- }
-
- public void setDescription(final String description) {
- instance.setDescription(description);
- }
-
- public void setReference(final String reference) {
- instance.setReference(reference);
- }
-
- public void setOrganization(final String organization) {
- instance.setOrganization(organization);
- }
-
- public void setContact(final String contact) {
- instance.setContact(contact);
- }
-
- public boolean addModuleImport(final String moduleName, final Date revision, final String prefix) {
- final ModuleImport moduleImport = createModuleImport(moduleName, revision, prefix);
- return imports.add(moduleImport);
- }
-
- public Set<ModuleImport> getModuleImports() {
- return imports;
- }
-
- public ExtensionBuilder addExtension(final QName qname, final int line) {
- final String extName = qname.getLocalName();
- for (ExtensionBuilder addedExtension : addedExtensions) {
- if (addedExtension.getQName().getLocalName().equals(extName)) {
- throw new YangParseException(moduleName, line, "Can not add extension '" + extName
- + "': extension with same name already declared at line " + addedExtension.getLine());
- }
- }
- final ExtensionBuilder builder = new ExtensionBuilder(name, line, qname);
- addedExtensions.add(builder);
- return builder;
- }
-
- public ContainerSchemaNodeBuilder addContainerNode(final int line, final QName qname, final SchemaPath schemaPath) {
- final ContainerSchemaNodeBuilder builder = new ContainerSchemaNodeBuilder(name, line, qname, schemaPath);
-
- Builder parent = getActualNode();
- builder.setParent(parent);
- addChildToParent(parent, builder, qname.getLocalName());
-
- return builder;
- }
-
- public ListSchemaNodeBuilder addListNode(final int line, final QName qname, final SchemaPath schemaPath) {
- final ListSchemaNodeBuilder builder = new ListSchemaNodeBuilder(name, line, qname, schemaPath);
-
- Builder parent = getActualNode();
- builder.setParent(parent);
- addChildToParent(parent, builder, qname.getLocalName());
-
- return builder;
- }
-
- public LeafSchemaNodeBuilder addLeafNode(final int line, final QName qname, final SchemaPath schemaPath) {
- final LeafSchemaNodeBuilder builder = new LeafSchemaNodeBuilder(name, line, qname, schemaPath);
-
- Builder parent = getActualNode();
- builder.setParent(parent);
- addChildToParent(parent, builder, qname.getLocalName());
-
- return builder;
- }
-
- public LeafListSchemaNodeBuilder addLeafListNode(final int line, final QName qname, final SchemaPath schemaPath) {
- final LeafListSchemaNodeBuilder builder = new LeafListSchemaNodeBuilder(name, line, qname, schemaPath);
-
- Builder parent = getActualNode();
- builder.setParent(parent);
- addChildToParent(parent, builder, qname.getLocalName());
-
- return builder;
- }
-
- public GroupingBuilder addGrouping(final int line, final QName qname) {
- final GroupingBuilder builder = new GroupingBuilderImpl(name, line, qname);
-
- Builder parent = getActualNode();
- builder.setParent(parent);
-
- String groupingName = qname.getLocalName();
- if (parent.equals(this)) {
- for (GroupingBuilder addedGrouping : addedGroupings) {
- if (addedGrouping.getQName().getLocalName().equals(groupingName)) {
- throw new YangParseException(name, line, "grouping with same name '" + groupingName
- + "' already declared at line " + addedGrouping.getLine());
- }
- }
- addedGroupings.add(builder);
- } else {
- if (parent instanceof DataNodeContainerBuilder) {
- DataNodeContainerBuilder parentNode = (DataNodeContainerBuilder) parent;
- for (GroupingBuilder addedGrouping : parentNode.getGroupingBuilders()) {
- if (addedGrouping.getQName().getLocalName().equals(groupingName)) {
- throw new YangParseException(name, line, "grouping with same name '" + groupingName
- + "' already declared at line " + addedGrouping.getLine());
- }
- }
- parentNode.addGrouping(builder);
- } else if (parent instanceof RpcDefinitionBuilder) {
- RpcDefinitionBuilder parentNode = (RpcDefinitionBuilder) parent;
- for (GroupingBuilder child : parentNode.getGroupings()) {
- if (child.getQName().getLocalName().equals(groupingName)) {
- throw new YangParseException(name, line, "grouping with same name '" + groupingName
- + "' already declared at line " + child.getLine());
- }
- }
- parentNode.addGrouping(builder);
- } else {
- throw new YangParseException(name, line, "Unresolved parent of grouping " + groupingName);
- }
- }
-
- return builder;
- }
-
- public AugmentationSchemaBuilder addAugment(final int line, final String augmentTargetStr) {
- final AugmentationSchemaBuilder builder = new AugmentationSchemaBuilderImpl(name, line, augmentTargetStr);
-
- Builder parent = getActualNode();
- builder.setParent(parent);
-
- if (parent.equals(this)) {
- // augment can be declared only under 'module' ...
- addedAugments.add(builder);
- } else {
- // ... or 'uses' statement
- if (parent instanceof UsesNodeBuilder) {
- ((UsesNodeBuilder) parent).addAugment(builder);
- } else {
- throw new YangParseException(name, line, "Augment can be declared only under module or uses statement.");
- }
- }
- allAugments.add(builder);
-
- return builder;
- }
-
- @Override
- public Set<UsesNodeBuilder> getUsesNodes() {
- return addedUsesNodes;
- }
-
- @Override
- public void addUsesNode(UsesNodeBuilder usesBuilder) {
- addedUsesNodes.add(usesBuilder);
- allUsesNodes.add(usesBuilder);
- }
-
- public UsesNodeBuilder addUsesNode(final int line, final String groupingPathStr) {
- final UsesNodeBuilder usesBuilder = new UsesNodeBuilderImpl(name, line, groupingPathStr);
-
- Builder parent = getActualNode();
- usesBuilder.setParent(parent);
-
- if (parent.equals(this)) {
- addedUsesNodes.add(usesBuilder);
- } else {
- if (!(parent instanceof DataNodeContainerBuilder)) {
- throw new YangParseException(name, line, "Unresolved parent of uses '" + groupingPathStr + "'.");
- }
- ((DataNodeContainerBuilder) parent).addUsesNode(usesBuilder);
- }
- allUsesNodes.add(usesBuilder);
- return usesBuilder;
- }
-
- public void addRefine(final RefineHolder refine) {
- final Builder parent = getActualNode();
- if (!(parent instanceof UsesNodeBuilder)) {
- throw new YangParseException(name, refine.getLine(), "refine can be defined only in uses statement");
- }
- ((UsesNodeBuilder) parent).addRefine(refine);
- refine.setParent(parent);
- }
-
- public RpcDefinitionBuilder addRpc(final int line, final QName qname) {
- Builder parent = getActualNode();
- if (!(parent.equals(this))) {
- throw new YangParseException(name, line, "rpc can be defined only in module or submodule");
- }
-
- final RpcDefinitionBuilder rpcBuilder = new RpcDefinitionBuilder(name, line, qname);
- rpcBuilder.setParent(parent);
-
- String rpcName = qname.getLocalName();
- for (RpcDefinitionBuilder rpc : addedRpcs) {
- if (rpc.getQName().getLocalName().equals(rpcName)) {
- throw new YangParseException(name, line, "rpc with same name '" + rpcName
- + "' already declared at line " + rpc.getLine());
- }
- }
- for (DataSchemaNodeBuilder addedChild : addedChildNodes) {
- if (addedChild.getQName().getLocalName().equals(rpcName)) {
- throw new YangParseException(name, line, "Can not add rpc: node with same name '" + rpcName
- + "' already declared at line " + addedChild.getLine());
- }
- }
- for (NotificationBuilder addedNotification : addedNotifications) {
- if (addedNotification.getQName().getLocalName().equals(rpcName)) {
- throw new YangParseException(name, line, "Can not add rpc: notification with same name '" + rpcName
- + "' already declared at line " + addedNotification.getLine());
- }
- }
- addedRpcs.add(rpcBuilder);
- return rpcBuilder;
- }
-
- public ContainerSchemaNodeBuilder addRpcInput(final int line, final QName qname, final SchemaPath schemaPath) {
- final Builder parent = getActualNode();
- if (!(parent instanceof RpcDefinitionBuilder)) {
- throw new YangParseException(name, line, "input can be defined only in rpc statement");
- }
- final RpcDefinitionBuilder rpc = (RpcDefinitionBuilder) parent;
-
- final ContainerSchemaNodeBuilder inputBuilder = new ContainerSchemaNodeBuilder(name, line, qname, schemaPath);
- inputBuilder.setParent(rpc);
-
- rpc.setInput(inputBuilder);
- return inputBuilder;
- }
-
- public ContainerSchemaNodeBuilder addRpcOutput(final SchemaPath schemaPath, final QName qname, final int line) {
- final Builder parent = getActualNode();
- if (!(parent instanceof RpcDefinitionBuilder)) {
- throw new YangParseException(name, line, "output can be defined only in rpc statement");
- }
- final RpcDefinitionBuilder rpc = (RpcDefinitionBuilder) parent;
-
- final ContainerSchemaNodeBuilder outputBuilder = new ContainerSchemaNodeBuilder(name, line, qname, schemaPath);
- outputBuilder.setParent(rpc);
-
- rpc.setOutput(outputBuilder);
- return outputBuilder;
- }
-
- public NotificationBuilder addNotification(final int line, final QName qname) {
- final Builder parent = getActualNode();
- if (!(parent.equals(this))) {
- throw new YangParseException(name, line, "notification can be defined only in module or submodule");
- }
-
- String notificationName = qname.getLocalName();
- for (NotificationBuilder nb : addedNotifications) {
- if (nb.getQName().equals(qname)) {
- throw new YangParseException(name, line, "notification with same name '" + notificationName
- + "' already declared at line " + nb.getLine());
- }
- }
- for (RpcDefinitionBuilder rpc : addedRpcs) {
- if (rpc.getQName().getLocalName().equals(notificationName)) {
- throw new YangParseException(name, line, "Can not add notification: rpc with same name '"
- + notificationName + "' already declared at line " + rpc.getLine());
- }
- }
- for (DataSchemaNodeBuilder addedChild : addedChildNodes) {
- if (addedChild.getQName().getLocalName().equals(notificationName)) {
- throw new YangParseException(name, line, "Can not add notification: node with same name '"
- + notificationName + "' already declared at line " + addedChild.getLine());
- }
- }
-
- final NotificationBuilder builder = new NotificationBuilder(name, line, qname);
- builder.setParent(parent);
- addedNotifications.add(builder);
-
- return builder;
- }
-
- public FeatureBuilder addFeature(final int line, final QName qname) {
- Builder parent = getActualNode();
- if (!(parent.equals(this))) {
- throw new YangParseException(name, line, "feature can be defined only in module or submodule");
- }
-
- final FeatureBuilder builder = new FeatureBuilder(name, line, qname);
- builder.setParent(parent);
-
- String featureName = qname.getLocalName();
- for (FeatureBuilder addedFeature : addedFeatures) {
- if (addedFeature.getQName().getLocalName().equals(featureName)) {
- throw new YangParseException(name, line, "feature with same name '" + featureName
- + "' already declared at line " + addedFeature.getLine());
- }
- }
- addedFeatures.add(builder);
- return builder;
- }
-
- public ChoiceBuilder addChoice(final int line, final QName qname) {
- final ChoiceBuilder builder = new ChoiceBuilder(name, line, qname);
-
- Builder parent = getActualNode();
- builder.setParent(parent);
- addChildToParent(parent, builder, qname.getLocalName());
-
- return builder;
- }
-
- public ChoiceCaseBuilder addCase(final int line, final QName qname) {
- Builder parent = getActualNode();
- if (parent == null || parent.equals(this)) {
- throw new YangParseException(name, line, "'case' parent not found");
- }
-
- final ChoiceCaseBuilder builder = new ChoiceCaseBuilder(name, line, qname);
- builder.setParent(parent);
-
- if (parent instanceof ChoiceBuilder) {
- ((ChoiceBuilder) parent).addCase(builder);
- } else if (parent instanceof AugmentationSchemaBuilder) {
- ((AugmentationSchemaBuilder) parent).addChildNode(builder);
- } else {
- throw new YangParseException(name, line, "Unresolved parent of 'case' " + qname.getLocalName());
- }
-
- return builder;
- }
-
- public AnyXmlBuilder addAnyXml(final int line, final QName qname, final SchemaPath schemaPath) {
- final AnyXmlBuilder builder = new AnyXmlBuilder(name, line, qname, schemaPath);
-
- Builder parent = getActualNode();
- builder.setParent(parent);
- addChildToParent(parent, builder, qname.getLocalName());
-
- return builder;
- }
-
- @Override
- public void addTypedef(TypeDefinitionBuilder typedefBuilder) {
- String nodeName = typedefBuilder.getQName().getLocalName();
- for (TypeDefinitionBuilder tdb : addedTypedefs) {
- if (tdb.getQName().getLocalName().equals(nodeName)) {
- throw new YangParseException(name, typedefBuilder.getLine(), "typedef with same name '" + nodeName
- + "' already declared at line " + tdb.getLine());
- }
- }
- addedTypedefs.add(typedefBuilder);
- }
-
- public TypeDefinitionBuilderImpl addTypedef(final int line, final QName qname) {
- final TypeDefinitionBuilderImpl builder = new TypeDefinitionBuilderImpl(name, line, qname);
-
- Builder parent = getActualNode();
- builder.setParent(parent);
-
- String typedefName = qname.getLocalName();
- if (parent.equals(this)) {
- for (TypeDefinitionBuilder tdb : addedTypedefs) {
- if (tdb.getQName().getLocalName().equals(typedefName)) {
- throw new YangParseException(name, line, "typedef with same name '" + typedefName
- + "' already declared at line " + tdb.getLine());
- }
- }
- addedTypedefs.add(builder);
- } else {
- if (parent instanceof DataNodeContainerBuilder) {
- DataNodeContainerBuilder parentNode = (DataNodeContainerBuilder) parent;
- for (TypeDefinitionBuilder child : parentNode.getTypeDefinitionBuilders()) {
- if (child.getQName().getLocalName().equals(typedefName)) {
- throw new YangParseException(name, line, "typedef with same name '" + typedefName
- + "' already declared at line " + child.getLine());
- }
- }
- parentNode.addTypedef(builder);
- } else if (parent instanceof RpcDefinitionBuilder) {
- RpcDefinitionBuilder rpcParent = (RpcDefinitionBuilder) parent;
- for (TypeDefinitionBuilder tdb : rpcParent.getTypeDefinitions()) {
- if (tdb.getQName().getLocalName().equals(builder.getQName().getLocalName())) {
- throw new YangParseException(name, line, "typedef with same name '" + typedefName
- + "' already declared at line " + tdb.getLine());
- }
- }
- rpcParent.addTypedef(builder);
- } else {
- throw new YangParseException(name, line, "Unresolved parent of typedef " + typedefName);
- }
- }
-
- return builder;
- }
-
- public void setType(final TypeDefinition<?> type) {
- Builder parent = getActualNode();
- if (parent == null || !(parent instanceof TypeAwareBuilder)) {
- throw new YangParseException("Failed to set type '" + type.getQName().getLocalName()
- + "'. Invalid parent node: " + parent);
- }
- ((TypeAwareBuilder) parent).setType(type);
- }
-
- public UnionTypeBuilder addUnionType(final int line, final URI namespace, final Date revision) {
- final Builder parent = getActualNode();
- if (parent == null) {
- throw new YangParseException(name, line, "Unresolved parent of union type");
- } else {
- final UnionTypeBuilder union = new UnionTypeBuilder(name, line);
- if (parent instanceof TypeAwareBuilder) {
- ((TypeAwareBuilder) parent).setTypedef(union);
- return union;
- } else {
- throw new YangParseException(name, line, "Invalid parent of union type.");
- }
- }
- }
-
- public void addIdentityrefType(final int line, final SchemaPath schemaPath, final String baseString) {
- final IdentityrefTypeBuilder identityref = new IdentityrefTypeBuilder(name, line, baseString, schemaPath);
-
- final Builder parent = getActualNode();
- if (parent == null) {
- throw new YangParseException(name, line, "Unresolved parent of identityref type.");
- } else {
- if (parent instanceof TypeAwareBuilder) {
- final TypeAwareBuilder typeParent = (TypeAwareBuilder) parent;
- typeParent.setTypedef(identityref);
- dirtyNodes.add(typeParent);
- } else {
- throw new YangParseException(name, line, "Invalid parent of identityref type.");
- }
- }
- }
-
- public DeviationBuilder addDeviation(final int line, final String targetPath) {
- Builder parent = getActualNode();
- if (!(parent.equals(this))) {
- throw new YangParseException(name, line, "deviation can be defined only in module or submodule");
- }
-
- final DeviationBuilder builder = new DeviationBuilder(name, line, targetPath);
- builder.setParent(parent);
- addedDeviations.add(builder);
- return builder;
- }
-
- public IdentitySchemaNodeBuilder addIdentity(final QName qname, final int line) {
- Builder parent = getActualNode();
- if (!(parent.equals(this))) {
- throw new YangParseException(name, line, "identity can be defined only in module or submodule");
- }
- String identityName = qname.getLocalName();
- for (IdentitySchemaNodeBuilder idBuilder : addedIdentities) {
- if (idBuilder.getQName().equals(qname)) {
- throw new YangParseException(name, line, "identity with same name '" + identityName
- + "' already declared at line " + idBuilder.getLine());
- }
- }
-
- final IdentitySchemaNodeBuilder builder = new IdentitySchemaNodeBuilder(name, line, qname);
- builder.setParent(parent);
- addedIdentities.add(builder);
- return builder;
- }
-
- @Override
- public void addUnknownNodeBuilder(final UnknownSchemaNodeBuilder builder) {
- addedUnknownNodes.add(builder);
- allUnknownNodes.add(builder);
- }
-
- public UnknownSchemaNodeBuilder addUnknownSchemaNode(final int line, final QName qname) {
- final Builder parent = getActualNode();
- final UnknownSchemaNodeBuilder builder = new UnknownSchemaNodeBuilder(name, line, qname);
- builder.setParent(parent);
- allUnknownNodes.add(builder);
-
- if (parent.equals(this)) {
- addedUnknownNodes.add(builder);
- } else {
- if (parent instanceof SchemaNodeBuilder) {
- ((SchemaNodeBuilder) parent).addUnknownNodeBuilder(builder);
- } else if (parent instanceof DataNodeContainerBuilder) {
- ((DataNodeContainerBuilder) parent).addUnknownNodeBuilder(builder);
- } else if (parent instanceof RefineHolder) {
- ((RefineHolder) parent).addUnknownNodeBuilder(builder);
- } else {
- throw new YangParseException(name, line, "Unresolved parent of unknown node '" + qname.getLocalName()
- + "'");
- }
- }
-
- return builder;
- }
-
- @Override
- public String toString() {
- return "module " + name;
- }
-
- private final class ModuleImpl implements Module {
- private URI namespace;
- private final String name;
- private Date revision;
- private String prefix;
- private String yangVersion;
- private String description;
- private String reference;
- private String organization;
- private String contact;
- private Set<ModuleImport> imports = Collections.emptySet();
- private Set<FeatureDefinition> features = Collections.emptySet();
- private Set<TypeDefinition<?>> typeDefinitions = Collections.emptySet();
- private Set<NotificationDefinition> notifications = Collections.emptySet();
- private Set<AugmentationSchema> augmentations = Collections.emptySet();
- private Set<RpcDefinition> rpcs = Collections.emptySet();
- private Set<Deviation> deviations = Collections.emptySet();
- private Map<QName, DataSchemaNode> childNodes = Collections.emptyMap();
- private Set<GroupingDefinition> groupings = Collections.emptySet();
- private Set<UsesNode> uses = Collections.emptySet();
- private List<ExtensionDefinition> extensionNodes = Collections.emptyList();
- private Set<IdentitySchemaNode> identities = Collections.emptySet();
- private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
-
- private ModuleImpl(String name) {
- this.name = name;
- }
-
- @Override
- public URI getNamespace() {
- return namespace;
- }
-
- private void setNamespace(URI namespace) {
- this.namespace = namespace;
- }
-
- @Override
- public String getName() {
- return name;
- }
-
- @Override
- public Date getRevision() {
- return revision;
- }
-
- private void setRevision(Date revision) {
- this.revision = revision;
- }
-
- @Override
- public String getPrefix() {
- return prefix;
- }
-
- private void setPrefix(String prefix) {
- this.prefix = prefix;
- }
-
- @Override
- public String getYangVersion() {
- return yangVersion;
- }
-
- private void setYangVersion(String yangVersion) {
- this.yangVersion = yangVersion;
- }
-
- @Override
- public String getDescription() {
- return description;
- }
-
- private void setDescription(String description) {
- this.description = description;
- }
-
- @Override
- public String getReference() {
- return reference;
- }
-
- private void setReference(String reference) {
- this.reference = reference;
- }
-
- @Override
- public String getOrganization() {
- return organization;
- }
-
- private void setOrganization(String organization) {
- this.organization = organization;
- }
-
- @Override
- public String getContact() {
- return contact;
- }
-
- private void setContact(String contact) {
- this.contact = contact;
- }
-
- @Override
- public Set<ModuleImport> getImports() {
- return imports;
- }
-
- private void setImports(Set<ModuleImport> imports) {
- if (imports != null) {
- this.imports = imports;
- }
- }
-
- @Override
- public Set<FeatureDefinition> getFeatures() {
- return features;
- }
-
- private void setFeatures(Set<FeatureDefinition> features) {
- if (features != null) {
- this.features = features;
- }
- }
-
- @Override
- public Set<TypeDefinition<?>> getTypeDefinitions() {
- return typeDefinitions;
- }
-
- private void setTypeDefinitions(Set<TypeDefinition<?>> typeDefinitions) {
- if (typeDefinitions != null) {
- this.typeDefinitions = typeDefinitions;
- }
- }
-
- @Override
- public Set<NotificationDefinition> getNotifications() {
- return notifications;
- }
-
- private void setNotifications(Set<NotificationDefinition> notifications) {
- if (notifications != null) {
- this.notifications = notifications;
- }
- }
-
- @Override
- public Set<AugmentationSchema> getAugmentations() {
- return augmentations;
- }
-
- private void setAugmentations(Set<AugmentationSchema> augmentations) {
- if (augmentations != null) {
- this.augmentations = augmentations;
- }
- }
-
- @Override
- public Set<RpcDefinition> getRpcs() {
- return rpcs;
- }
-
- private void setRpcs(Set<RpcDefinition> rpcs) {
- if (rpcs != null) {
- this.rpcs = rpcs;
- }
- }
-
- @Override
- public Set<Deviation> getDeviations() {
- return deviations;
- }
-
- private void setDeviations(Set<Deviation> deviations) {
- if (deviations != null) {
- this.deviations = deviations;
- }
- }
-
- @Override
- public Set<DataSchemaNode> getChildNodes() {
- return new LinkedHashSet<DataSchemaNode>(childNodes.values());
- }
-
- private void setChildNodes(Map<QName, DataSchemaNode> childNodes) {
- if (childNodes != null) {
- this.childNodes = childNodes;
- }
- }
-
- @Override
- public Set<GroupingDefinition> getGroupings() {
- return groupings;
- }
-
- private void setGroupings(Set<GroupingDefinition> groupings) {
- if (groupings != null) {
- this.groupings = groupings;
- }
- }
-
- @Override
- public Set<UsesNode> getUses() {
- return uses;
- }
-
- private void setUses(Set<UsesNode> uses) {
- if (uses != null) {
- this.uses = uses;
- }
- }
-
- @Override
- public List<ExtensionDefinition> getExtensionSchemaNodes() {
- return extensionNodes;
- }
-
- private void setExtensionSchemaNodes(final List<ExtensionDefinition> extensionNodes) {
- if (extensionNodes != null) {
- this.extensionNodes = extensionNodes;
- }
- }
-
- @Override
- public Set<IdentitySchemaNode> getIdentities() {
- return identities;
- }
-
- private void setIdentities(final Set<IdentitySchemaNode> identities) {
- if (identities != null) {
- this.identities = identities;
- }
- }
-
- @Override
- public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return unknownNodes;
- }
-
- private void setUnknownSchemaNodes(final List<UnknownSchemaNode> unknownNodes) {
- if (unknownNodes != null) {
- this.unknownNodes = unknownNodes;
- }
- }
-
- @Override
- public DataSchemaNode getDataChildByName(QName name) {
- return childNodes.get(name);
- }
-
- @Override
- public DataSchemaNode getDataChildByName(String name) {
- DataSchemaNode result = null;
- for (Map.Entry<QName, DataSchemaNode> entry : childNodes.entrySet()) {
- if (entry.getKey().getLocalName().equals(name)) {
- result = entry.getValue();
- break;
- }
- }
- return result;
- }
-
- @Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result + ((namespace == null) ? 0 : namespace.hashCode());
- result = prime * result + ((name == null) ? 0 : name.hashCode());
- result = prime * result + ((revision == null) ? 0 : revision.hashCode());
- result = prime * result + ((prefix == null) ? 0 : prefix.hashCode());
- result = prime * result + ((yangVersion == null) ? 0 : yangVersion.hashCode());
- return result;
- }
-
- @Override
- public boolean equals(Object obj) {
- if (this == obj) {
- return true;
- }
- if (obj == null) {
- return false;
- }
- if (getClass() != obj.getClass()) {
- return false;
- }
- ModuleImpl other = (ModuleImpl) obj;
- if (namespace == null) {
- if (other.namespace != null) {
- return false;
- }
- } else if (!namespace.equals(other.namespace)) {
- return false;
- }
- if (name == null) {
- if (other.name != null) {
- return false;
- }
- } else if (!name.equals(other.name)) {
- return false;
- }
- if (revision == null) {
- if (other.revision != null) {
- return false;
- }
- } else if (!revision.equals(other.revision)) {
- return false;
- }
- if (prefix == null) {
- if (other.prefix != null) {
- return false;
- }
- } else if (!prefix.equals(other.prefix)) {
- return false;
- }
- if (yangVersion == null) {
- if (other.yangVersion != null) {
- return false;
- }
- } else if (!yangVersion.equals(other.yangVersion)) {
- return false;
- }
- return true;
- }
-
- @Override
- public String toString() {
- StringBuilder sb = new StringBuilder(ModuleImpl.class.getSimpleName());
- sb.append("[");
- sb.append("name=" + name);
- sb.append(", namespace=" + namespace);
- sb.append(", revision=" + revision);
- sb.append(", prefix=" + prefix);
- sb.append(", yangVersion=" + yangVersion);
- sb.append("]");
- return sb.toString();
- }
- }
-
- /**
- * Add child to parent. Method checks for duplicates and add given child
- * node to parent. If node with same name is found, throws exception. If
- * parent is null, child node will be added directly to module.
- *
- * @param parent
- * @param child
- * @param childName
- */
- private void addChildToParent(final Builder parent, final DataSchemaNodeBuilder child, final String childName) {
- final int line = child.getLine();
- if (parent.equals(this)) {
- // if parent == null => node is defined under module
- // All leafs, leaf-lists, lists, containers, choices, rpcs,
- // notifications, and anyxmls defined within a parent node or at the
- // top level of the module or its submodules share the same
- // identifier namespace.
- for (DataSchemaNodeBuilder childNode : addedChildNodes) {
- if (childNode.getQName().getLocalName().equals(childName)) {
- throw new YangParseException(name, line, "Can not add '" + child
- + "': node with same name already declared at line " + childNode.getLine());
- }
- }
- for (RpcDefinitionBuilder rpc : addedRpcs) {
- if (rpc.getQName().getLocalName().equals(childName)) {
- throw new YangParseException(name, line, "Can not add '" + child
- + "': rpc with same name already declared at line " + rpc.getLine());
- }
- }
- for (NotificationBuilder notification : addedNotifications) {
- if (notification.getQName().getLocalName().equals(childName)) {
- throw new YangParseException(name, line, "Can not add '" + child
- + "': notification with same name already declared at line " + notification.getLine());
- }
- }
- addedChildNodes.add(child);
- } else {
- if(parent instanceof AugmentationSchemaBuilder) {
- child.setAugmenting(true);
- }
- // no need for checking rpc and notification because they can be
- // defined only under module or submodule
- if (parent instanceof DataNodeContainerBuilder) {
- DataNodeContainerBuilder parentNode = (DataNodeContainerBuilder) parent;
- for (DataSchemaNodeBuilder childNode : parentNode.getChildNodeBuilders()) {
- if (childNode.getQName().getLocalName().equals(childName)) {
- throw new YangParseException(name, line, "Can not add '" + child + "': node with same name '"
- + childName + "' already declared at line " + childNode.getLine());
- }
- }
- parentNode.addChildNode(child);
- } else if (parent instanceof ChoiceBuilder) {
- ChoiceBuilder parentNode = (ChoiceBuilder) parent;
- for (ChoiceCaseBuilder caseBuilder : parentNode.getCases()) {
- if (caseBuilder.getQName().getLocalName().equals(childName)) {
- throw new YangParseException(name, line, "Can not add '" + child + "': case with same name '"
- + childName + "' already declared at line " + caseBuilder.getLine());
- }
- }
- parentNode.addCase(child);
- } else {
- throw new YangParseException(name, line, "Unresolved parent of node '" + childName + "'.");
- }
- }
- }
-
- private ModuleImport createModuleImport(final String moduleName, final Date revision, final String prefix) {
- final ModuleImport moduleImport = new ModuleImport() {
- @Override
- public String getModuleName() {
- return moduleName;
- }
-
- @Override
- public Date getRevision() {
- return revision;
- }
-
- @Override
- public String getPrefix() {
- return prefix;
- }
-
- @Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result + ((moduleName == null) ? 0 : moduleName.hashCode());
- result = prime * result + ((revision == null) ? 0 : revision.hashCode());
- result = prime * result + ((prefix == null) ? 0 : prefix.hashCode());
- return result;
- }
-
- @Override
- public boolean equals(Object obj) {
- if (this == obj) {
- return true;
- }
- if (obj == null) {
- return false;
- }
- if (getClass() != obj.getClass()) {
- return false;
- }
- ModuleImport other = (ModuleImport) obj;
- if (getModuleName() == null) {
- if (other.getModuleName() != null) {
- return false;
- }
- } else if (!getModuleName().equals(other.getModuleName())) {
- return false;
- }
- if (getRevision() == null) {
- if (other.getRevision() != null) {
- return false;
- }
- } else if (!getRevision().equals(other.getRevision())) {
- return false;
- }
- if (getPrefix() == null) {
- if (other.getPrefix() != null) {
- return false;
- }
- } else if (!getPrefix().equals(other.getPrefix())) {
- return false;
- }
- return true;
- }
-
- @Override
- public String toString() {
- return "ModuleImport[moduleName=" + moduleName + ", revision=" + revision + ", prefix=" + prefix + "]";
- }
- };
- return moduleImport;
- }
-
-}
+/*\r
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+package org.opendaylight.yangtools.yang.parser.builder.impl;\r
+\r
+import java.net.URI;\r
+import java.util.ArrayList;\r
+import java.util.Collections;\r
+import java.util.Date;\r
+import java.util.HashSet;\r
+import java.util.LinkedHashSet;\r
+import java.util.LinkedList;\r
+import java.util.List;\r
+import java.util.Map;\r
+import java.util.Set;\r
+import java.util.TreeMap;\r
+import java.util.TreeSet;\r
+\r
+import org.opendaylight.yangtools.yang.common.QName;\r
+import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;\r
+import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;\r
+import org.opendaylight.yangtools.yang.model.api.Deviation;\r
+import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;\r
+import org.opendaylight.yangtools.yang.model.api.FeatureDefinition;\r
+import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;\r
+import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;\r
+import org.opendaylight.yangtools.yang.model.api.Module;\r
+import org.opendaylight.yangtools.yang.model.api.ModuleImport;\r
+import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;\r
+import org.opendaylight.yangtools.yang.model.api.RpcDefinition;\r
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;\r
+import org.opendaylight.yangtools.yang.model.api.TypeDefinition;\r
+import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;\r
+import org.opendaylight.yangtools.yang.model.api.UsesNode;\r
+import org.opendaylight.yangtools.yang.parser.builder.api.AbstractDataNodeContainerBuilder;\r
+import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;\r
+import org.opendaylight.yangtools.yang.parser.builder.api.Builder;\r
+import org.opendaylight.yangtools.yang.parser.builder.api.DataNodeContainerBuilder;\r
+import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;\r
+import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;\r
+import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;\r
+import org.opendaylight.yangtools.yang.parser.builder.api.TypeAwareBuilder;\r
+import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;\r
+import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;\r
+import org.opendaylight.yangtools.yang.parser.util.Comparators;\r
+import org.opendaylight.yangtools.yang.parser.util.RefineHolder;\r
+import org.opendaylight.yangtools.yang.parser.util.YangParseException;\r
+\r
+/**\r
+ * Builder of Module object. If this module is dependent on external\r
+ * module/modules, these dependencies must be resolved before module is built,\r
+ * otherwise result may not be valid.\r
+ */\r
+public class ModuleBuilder extends AbstractDataNodeContainerBuilder {\r
+ private final ModuleImpl instance;\r
+ private final String name;\r
+ private final SchemaPath schemaPath;\r
+ private URI namespace;\r
+ private String prefix;\r
+ private Date revision;\r
+\r
+ private final LinkedList<Builder> actualPath = new LinkedList<Builder>();\r
+ private final Set<TypeAwareBuilder> dirtyNodes = new HashSet<TypeAwareBuilder>();\r
+\r
+ private final Set<ModuleImport> imports = new HashSet<ModuleImport>();\r
+ private final List<AugmentationSchemaBuilder> addedAugments = new ArrayList<AugmentationSchemaBuilder>();\r
+ private final List<AugmentationSchemaBuilder> allAugments = new ArrayList<AugmentationSchemaBuilder>();\r
+ private final Set<UsesNodeBuilder> addedUsesNodes = new HashSet<UsesNodeBuilder>();\r
+ private final List<UsesNodeBuilder> allUsesNodes = new ArrayList<UsesNodeBuilder>();\r
+ private final Set<RpcDefinitionBuilder> addedRpcs = new HashSet<RpcDefinitionBuilder>();\r
+ private final Set<NotificationBuilder> addedNotifications = new HashSet<NotificationBuilder>();\r
+ private final Set<IdentitySchemaNodeBuilder> addedIdentities = new HashSet<IdentitySchemaNodeBuilder>();\r
+ private final Set<FeatureBuilder> addedFeatures = new HashSet<FeatureBuilder>();\r
+ private final Set<DeviationBuilder> addedDeviations = new HashSet<DeviationBuilder>();\r
+ private final Set<TypeDefinitionBuilder> addedTypedefs = new HashSet<TypeDefinitionBuilder>();\r
+ private final List<ExtensionBuilder> addedExtensions = new ArrayList<ExtensionBuilder>();\r
+ private final List<UnknownSchemaNodeBuilder> allUnknownNodes = new ArrayList<UnknownSchemaNodeBuilder>();\r
+\r
+ public ModuleBuilder(final String name) {\r
+ super(name, 0, null);\r
+ this.name = name;\r
+ schemaPath = new SchemaPath(Collections.<QName>emptyList(), true);\r
+ instance = new ModuleImpl(name);\r
+ actualPath.push(this);\r
+ }\r
+\r
+ /**\r
+ * Build new Module object based on this builder.\r
+ */\r
+ @Override\r
+ public Module build() {\r
+ instance.setPrefix(prefix);\r
+ instance.setRevision(revision);\r
+ instance.setImports(imports);\r
+ instance.setNamespace(namespace);\r
+\r
+ // TYPEDEFS\r
+ final Set<TypeDefinition<?>> typedefs = new TreeSet<TypeDefinition<?>>(Comparators.SCHEMA_NODE_COMP);\r
+ for (TypeDefinitionBuilder tdb : addedTypedefs) {\r
+ typedefs.add(tdb.build());\r
+ }\r
+ instance.setTypeDefinitions(typedefs);\r
+\r
+ // CHILD NODES\r
+ final Map<QName, DataSchemaNode> children = new TreeMap<QName, DataSchemaNode>(Comparators.QNAME_COMP);\r
+ for (DataSchemaNodeBuilder child : addedChildNodes) {\r
+ children.put(child.getQName(), child.build());\r
+ }\r
+ instance.setChildNodes(children);\r
+\r
+ // GROUPINGS\r
+ final Set<GroupingDefinition> groupings = new TreeSet<GroupingDefinition>(Comparators.SCHEMA_NODE_COMP);\r
+ for (GroupingBuilder gb : addedGroupings) {\r
+ groupings.add(gb.build());\r
+ }\r
+ instance.setGroupings(groupings);\r
+\r
+ // USES\r
+ final Set<UsesNode> usesDefinitions = new HashSet<UsesNode>();\r
+ for (UsesNodeBuilder unb : addedUsesNodes) {\r
+ usesDefinitions.add(unb.build());\r
+ }\r
+ instance.setUses(usesDefinitions);\r
+\r
+ // FEATURES\r
+ final Set<FeatureDefinition> features = new TreeSet<FeatureDefinition>(Comparators.SCHEMA_NODE_COMP);\r
+ for (FeatureBuilder fb : addedFeatures) {\r
+ features.add(fb.build());\r
+ }\r
+ instance.setFeatures(features);\r
+\r
+ // NOTIFICATIONS\r
+ final Set<NotificationDefinition> notifications = new TreeSet<NotificationDefinition>(\r
+ Comparators.SCHEMA_NODE_COMP);\r
+ for (NotificationBuilder entry : addedNotifications) {\r
+ notifications.add(entry.build());\r
+ }\r
+ instance.setNotifications(notifications);\r
+\r
+ // AUGMENTATIONS\r
+ final Set<AugmentationSchema> augmentations = new HashSet<AugmentationSchema>();\r
+ for (AugmentationSchemaBuilder builder : addedAugments) {\r
+ augmentations.add(builder.build());\r
+ }\r
+ instance.setAugmentations(augmentations);\r
+\r
+ // RPCs\r
+ final Set<RpcDefinition> rpcs = new TreeSet<RpcDefinition>(Comparators.SCHEMA_NODE_COMP);\r
+ for (RpcDefinitionBuilder rpc : addedRpcs) {\r
+ rpcs.add(rpc.build());\r
+ }\r
+ instance.setRpcs(rpcs);\r
+\r
+ // DEVIATIONS\r
+ final Set<Deviation> deviations = new HashSet<Deviation>();\r
+ for (DeviationBuilder entry : addedDeviations) {\r
+ deviations.add(entry.build());\r
+ }\r
+ instance.setDeviations(deviations);\r
+\r
+ // EXTENSIONS\r
+ final List<ExtensionDefinition> extensions = new ArrayList<ExtensionDefinition>();\r
+ for (ExtensionBuilder eb : addedExtensions) {\r
+ extensions.add(eb.build());\r
+ }\r
+ Collections.sort(extensions, Comparators.SCHEMA_NODE_COMP);\r
+ instance.setExtensionSchemaNodes(extensions);\r
+\r
+ // IDENTITIES\r
+ final Set<IdentitySchemaNode> identities = new TreeSet<IdentitySchemaNode>(Comparators.SCHEMA_NODE_COMP);\r
+ for (IdentitySchemaNodeBuilder id : addedIdentities) {\r
+ identities.add(id.build());\r
+ }\r
+ instance.setIdentities(identities);\r
+\r
+ // UNKNOWN NODES\r
+ final List<UnknownSchemaNode> unknownNodes = new ArrayList<UnknownSchemaNode>();\r
+ for (UnknownSchemaNodeBuilder unb : addedUnknownNodes) {\r
+ unknownNodes.add(unb.build());\r
+ }\r
+ instance.setUnknownSchemaNodes(unknownNodes);\r
+\r
+ return instance;\r
+ }\r
+\r
+ public boolean isAllUsesDataCollected() {\r
+ for(UsesNodeBuilder usesNode : allUsesNodes) {\r
+ if(!usesNode.isDataCollected()) {\r
+ return false;\r
+ }\r
+ }\r
+ return true;\r
+ }\r
+\r
+ @Override\r
+ public void setParent(Builder parent) {\r
+ throw new YangParseException(name, 0, "Can not set parent to module");\r
+ }\r
+\r
+ @Override\r
+ public SchemaPath getPath() {\r
+ return schemaPath;\r
+ }\r
+\r
+ @Override\r
+ public Set<TypeDefinitionBuilder> getTypeDefinitionBuilders() {\r
+ return addedTypedefs;\r
+ }\r
+\r
+ public void enterNode(final Builder node) {\r
+ actualPath.push(node);\r
+ }\r
+\r
+ public void exitNode() {\r
+ actualPath.pop();\r
+ }\r
+\r
+ public Builder getActualNode() {\r
+ if (actualPath.isEmpty()) {\r
+ return null;\r
+ } else {\r
+ return actualPath.get(0);\r
+ }\r
+ }\r
+\r
+ public Builder getActualParent() {\r
+ if (actualPath.size() < 2) {\r
+ return null;\r
+ } else {\r
+ return actualPath.get(1);\r
+ }\r
+ }\r
+\r
+ public Set<TypeAwareBuilder> getDirtyNodes() {\r
+ return dirtyNodes;\r
+ }\r
+\r
+ public List<AugmentationSchemaBuilder> getAllAugments() {\r
+ return allAugments;\r
+ }\r
+\r
+ public Set<IdentitySchemaNodeBuilder> getIdentities() {\r
+ return addedIdentities;\r
+ }\r
+\r
+ public List<UsesNodeBuilder> getAllUsesNodes() {\r
+ return allUsesNodes;\r
+ }\r
+\r
+ public Set<DeviationBuilder> getDeviations() {\r
+ return addedDeviations;\r
+ }\r
+\r
+ public List<ExtensionBuilder> getExtensions() {\r
+ return addedExtensions;\r
+ }\r
+\r
+ public List<UnknownSchemaNodeBuilder> getAllUnknownNodes() {\r
+ return allUnknownNodes;\r
+ }\r
+\r
+ public String getName() {\r
+ return name;\r
+ }\r
+\r
+ public URI getNamespace() {\r
+ return namespace;\r
+ }\r
+\r
+ public void setNamespace(final URI namespace) {\r
+ this.namespace = namespace;\r
+ }\r
+\r
+ public String getPrefix() {\r
+ return prefix;\r
+ }\r
+\r
+ public Date getRevision() {\r
+ return revision;\r
+ }\r
+\r
+ public void markActualNodeDirty() {\r
+ final TypeAwareBuilder nodeBuilder = (TypeAwareBuilder) getActualNode();\r
+ dirtyNodes.add(nodeBuilder);\r
+ }\r
+\r
+ public void setRevision(final Date revision) {\r
+ this.revision = revision;\r
+ }\r
+\r
+ public void setPrefix(final String prefix) {\r
+ this.prefix = prefix;\r
+ }\r
+\r
+ public void setYangVersion(final String yangVersion) {\r
+ instance.setYangVersion(yangVersion);\r
+ }\r
+\r
+ public void setDescription(final String description) {\r
+ instance.setDescription(description);\r
+ }\r
+\r
+ public void setReference(final String reference) {\r
+ instance.setReference(reference);\r
+ }\r
+\r
+ public void setOrganization(final String organization) {\r
+ instance.setOrganization(organization);\r
+ }\r
+\r
+ public void setContact(final String contact) {\r
+ instance.setContact(contact);\r
+ }\r
+\r
+ public boolean addModuleImport(final String moduleName, final Date revision, final String prefix) {\r
+ final ModuleImport moduleImport = createModuleImport(moduleName, revision, prefix);\r
+ return imports.add(moduleImport);\r
+ }\r
+\r
+ public Set<ModuleImport> getModuleImports() {\r
+ return imports;\r
+ }\r
+\r
+ public ExtensionBuilder addExtension(final QName qname, final int line) {\r
+ final String extName = qname.getLocalName();\r
+ for (ExtensionBuilder addedExtension : addedExtensions) {\r
+ if (addedExtension.getQName().getLocalName().equals(extName)) {\r
+ throw new YangParseException(moduleName, line, "Can not add extension '" + extName\r
+ + "': extension with same name already declared at line " + addedExtension.getLine());\r
+ }\r
+ }\r
+ final ExtensionBuilder builder = new ExtensionBuilder(name, line, qname);\r
+ addedExtensions.add(builder);\r
+ return builder;\r
+ }\r
+\r
+ public ContainerSchemaNodeBuilder addContainerNode(final int line, final QName qname, final SchemaPath schemaPath) {\r
+ final ContainerSchemaNodeBuilder builder = new ContainerSchemaNodeBuilder(name, line, qname, schemaPath);\r
+\r
+ Builder parent = getActualNode();\r
+ builder.setParent(parent);\r
+ addChildToParent(parent, builder, qname.getLocalName());\r
+\r
+ return builder;\r
+ }\r
+\r
+ public ListSchemaNodeBuilder addListNode(final int line, final QName qname, final SchemaPath schemaPath) {\r
+ final ListSchemaNodeBuilder builder = new ListSchemaNodeBuilder(name, line, qname, schemaPath);\r
+\r
+ Builder parent = getActualNode();\r
+ builder.setParent(parent);\r
+ addChildToParent(parent, builder, qname.getLocalName());\r
+\r
+ return builder;\r
+ }\r
+\r
+ public LeafSchemaNodeBuilder addLeafNode(final int line, final QName qname, final SchemaPath schemaPath) {\r
+ final LeafSchemaNodeBuilder builder = new LeafSchemaNodeBuilder(name, line, qname, schemaPath);\r
+\r
+ Builder parent = getActualNode();\r
+ builder.setParent(parent);\r
+ addChildToParent(parent, builder, qname.getLocalName());\r
+\r
+ return builder;\r
+ }\r
+\r
+ public LeafListSchemaNodeBuilder addLeafListNode(final int line, final QName qname, final SchemaPath schemaPath) {\r
+ final LeafListSchemaNodeBuilder builder = new LeafListSchemaNodeBuilder(name, line, qname, schemaPath);\r
+\r
+ Builder parent = getActualNode();\r
+ builder.setParent(parent);\r
+ addChildToParent(parent, builder, qname.getLocalName());\r
+\r
+ return builder;\r
+ }\r
+\r
+ public GroupingBuilder addGrouping(final int line, final QName qname) {\r
+ final GroupingBuilder builder = new GroupingBuilderImpl(name, line, qname);\r
+\r
+ Builder parent = getActualNode();\r
+ builder.setParent(parent);\r
+\r
+ String groupingName = qname.getLocalName();\r
+ if (parent.equals(this)) {\r
+ for (GroupingBuilder addedGrouping : addedGroupings) {\r
+ if (addedGrouping.getQName().getLocalName().equals(groupingName)) {\r
+ throw new YangParseException(name, line, "grouping with same name '" + groupingName\r
+ + "' already declared at line " + addedGrouping.getLine());\r
+ }\r
+ }\r
+ addedGroupings.add(builder);\r
+ } else {\r
+ if (parent instanceof DataNodeContainerBuilder) {\r
+ DataNodeContainerBuilder parentNode = (DataNodeContainerBuilder) parent;\r
+ for (GroupingBuilder addedGrouping : parentNode.getGroupingBuilders()) {\r
+ if (addedGrouping.getQName().getLocalName().equals(groupingName)) {\r
+ throw new YangParseException(name, line, "grouping with same name '" + groupingName\r
+ + "' already declared at line " + addedGrouping.getLine());\r
+ }\r
+ }\r
+ parentNode.addGrouping(builder);\r
+ } else if (parent instanceof RpcDefinitionBuilder) {\r
+ RpcDefinitionBuilder parentNode = (RpcDefinitionBuilder) parent;\r
+ for (GroupingBuilder child : parentNode.getGroupings()) {\r
+ if (child.getQName().getLocalName().equals(groupingName)) {\r
+ throw new YangParseException(name, line, "grouping with same name '" + groupingName\r
+ + "' already declared at line " + child.getLine());\r
+ }\r
+ }\r
+ parentNode.addGrouping(builder);\r
+ } else {\r
+ throw new YangParseException(name, line, "Unresolved parent of grouping " + groupingName);\r
+ }\r
+ }\r
+\r
+ return builder;\r
+ }\r
+\r
+ public AugmentationSchemaBuilder addAugment(final int line, final String augmentTargetStr) {\r
+ final AugmentationSchemaBuilder builder = new AugmentationSchemaBuilderImpl(name, line, augmentTargetStr);\r
+\r
+ Builder parent = getActualNode();\r
+ builder.setParent(parent);\r
+\r
+ if (parent.equals(this)) {\r
+ // augment can be declared only under 'module' ...\r
+ addedAugments.add(builder);\r
+ } else {\r
+ // ... or 'uses' statement\r
+ if (parent instanceof UsesNodeBuilder) {\r
+ ((UsesNodeBuilder) parent).addAugment(builder);\r
+ } else {\r
+ throw new YangParseException(name, line, "Augment can be declared only under module or uses statement.");\r
+ }\r
+ }\r
+ allAugments.add(builder);\r
+\r
+ return builder;\r
+ }\r
+\r
+ @Override\r
+ public Set<UsesNodeBuilder> getUsesNodes() {\r
+ return addedUsesNodes;\r
+ }\r
+\r
+ @Override\r
+ public void addUsesNode(UsesNodeBuilder usesBuilder) {\r
+ addedUsesNodes.add(usesBuilder);\r
+ allUsesNodes.add(usesBuilder);\r
+ }\r
+\r
+ public UsesNodeBuilder addUsesNode(final int line, final String groupingPathStr) {\r
+ final UsesNodeBuilder usesBuilder = new UsesNodeBuilderImpl(name, line, groupingPathStr);\r
+\r
+ Builder parent = getActualNode();\r
+ usesBuilder.setParent(parent);\r
+\r
+ if (parent.equals(this)) {\r
+ addedUsesNodes.add(usesBuilder);\r
+ } else {\r
+ if (!(parent instanceof DataNodeContainerBuilder)) {\r
+ throw new YangParseException(name, line, "Unresolved parent of uses '" + groupingPathStr + "'.");\r
+ }\r
+ ((DataNodeContainerBuilder) parent).addUsesNode(usesBuilder);\r
+ }\r
+ allUsesNodes.add(usesBuilder);\r
+ return usesBuilder;\r
+ }\r
+\r
+ public void addRefine(final RefineHolder refine) {\r
+ final Builder parent = getActualNode();\r
+ if (!(parent instanceof UsesNodeBuilder)) {\r
+ throw new YangParseException(name, refine.getLine(), "refine can be defined only in uses statement");\r
+ }\r
+ ((UsesNodeBuilder) parent).addRefine(refine);\r
+ refine.setParent(parent);\r
+ }\r
+\r
+ public RpcDefinitionBuilder addRpc(final int line, final QName qname) {\r
+ Builder parent = getActualNode();\r
+ if (!(parent.equals(this))) {\r
+ throw new YangParseException(name, line, "rpc can be defined only in module or submodule");\r
+ }\r
+\r
+ final RpcDefinitionBuilder rpcBuilder = new RpcDefinitionBuilder(name, line, qname);\r
+ rpcBuilder.setParent(parent);\r
+\r
+ String rpcName = qname.getLocalName();\r
+ for (RpcDefinitionBuilder rpc : addedRpcs) {\r
+ if (rpc.getQName().getLocalName().equals(rpcName)) {\r
+ throw new YangParseException(name, line, "rpc with same name '" + rpcName\r
+ + "' already declared at line " + rpc.getLine());\r
+ }\r
+ }\r
+ for (DataSchemaNodeBuilder addedChild : addedChildNodes) {\r
+ if (addedChild.getQName().getLocalName().equals(rpcName)) {\r
+ throw new YangParseException(name, line, "Can not add rpc: node with same name '" + rpcName\r
+ + "' already declared at line " + addedChild.getLine());\r
+ }\r
+ }\r
+ for (NotificationBuilder addedNotification : addedNotifications) {\r
+ if (addedNotification.getQName().getLocalName().equals(rpcName)) {\r
+ throw new YangParseException(name, line, "Can not add rpc: notification with same name '" + rpcName\r
+ + "' already declared at line " + addedNotification.getLine());\r
+ }\r
+ }\r
+ addedRpcs.add(rpcBuilder);\r
+ return rpcBuilder;\r
+ }\r
+\r
+ public ContainerSchemaNodeBuilder addRpcInput(final int line, final QName qname, final SchemaPath schemaPath) {\r
+ final Builder parent = getActualNode();\r
+ if (!(parent instanceof RpcDefinitionBuilder)) {\r
+ throw new YangParseException(name, line, "input can be defined only in rpc statement");\r
+ }\r
+ final RpcDefinitionBuilder rpc = (RpcDefinitionBuilder) parent;\r
+\r
+ final ContainerSchemaNodeBuilder inputBuilder = new ContainerSchemaNodeBuilder(name, line, qname, schemaPath);\r
+ inputBuilder.setParent(rpc);\r
+\r
+ rpc.setInput(inputBuilder);\r
+ return inputBuilder;\r
+ }\r
+\r
+ public ContainerSchemaNodeBuilder addRpcOutput(final SchemaPath schemaPath, final QName qname, final int line) {\r
+ final Builder parent = getActualNode();\r
+ if (!(parent instanceof RpcDefinitionBuilder)) {\r
+ throw new YangParseException(name, line, "output can be defined only in rpc statement");\r
+ }\r
+ final RpcDefinitionBuilder rpc = (RpcDefinitionBuilder) parent;\r
+\r
+ final ContainerSchemaNodeBuilder outputBuilder = new ContainerSchemaNodeBuilder(name, line, qname, schemaPath);\r
+ outputBuilder.setParent(rpc);\r
+\r
+ rpc.setOutput(outputBuilder);\r
+ return outputBuilder;\r
+ }\r
+\r
+ public NotificationBuilder addNotification(final int line, final QName qname) {\r
+ final Builder parent = getActualNode();\r
+ if (!(parent.equals(this))) {\r
+ throw new YangParseException(name, line, "notification can be defined only in module or submodule");\r
+ }\r
+\r
+ String notificationName = qname.getLocalName();\r
+ for (NotificationBuilder nb : addedNotifications) {\r
+ if (nb.getQName().equals(qname)) {\r
+ throw new YangParseException(name, line, "notification with same name '" + notificationName\r
+ + "' already declared at line " + nb.getLine());\r
+ }\r
+ }\r
+ for (RpcDefinitionBuilder rpc : addedRpcs) {\r
+ if (rpc.getQName().getLocalName().equals(notificationName)) {\r
+ throw new YangParseException(name, line, "Can not add notification: rpc with same name '"\r
+ + notificationName + "' already declared at line " + rpc.getLine());\r
+ }\r
+ }\r
+ for (DataSchemaNodeBuilder addedChild : addedChildNodes) {\r
+ if (addedChild.getQName().getLocalName().equals(notificationName)) {\r
+ throw new YangParseException(name, line, "Can not add notification: node with same name '"\r
+ + notificationName + "' already declared at line " + addedChild.getLine());\r
+ }\r
+ }\r
+\r
+ final NotificationBuilder builder = new NotificationBuilder(name, line, qname);\r
+ builder.setParent(parent);\r
+ addedNotifications.add(builder);\r
+\r
+ return builder;\r
+ }\r
+\r
+ public FeatureBuilder addFeature(final int line, final QName qname) {\r
+ Builder parent = getActualNode();\r
+ if (!(parent.equals(this))) {\r
+ throw new YangParseException(name, line, "feature can be defined only in module or submodule");\r
+ }\r
+\r
+ final FeatureBuilder builder = new FeatureBuilder(name, line, qname);\r
+ builder.setParent(parent);\r
+\r
+ String featureName = qname.getLocalName();\r
+ for (FeatureBuilder addedFeature : addedFeatures) {\r
+ if (addedFeature.getQName().getLocalName().equals(featureName)) {\r
+ throw new YangParseException(name, line, "feature with same name '" + featureName\r
+ + "' already declared at line " + addedFeature.getLine());\r
+ }\r
+ }\r
+ addedFeatures.add(builder);\r
+ return builder;\r
+ }\r
+\r
+ public ChoiceBuilder addChoice(final int line, final QName qname) {\r
+ final ChoiceBuilder builder = new ChoiceBuilder(name, line, qname);\r
+\r
+ Builder parent = getActualNode();\r
+ builder.setParent(parent);\r
+ addChildToParent(parent, builder, qname.getLocalName());\r
+\r
+ return builder;\r
+ }\r
+\r
+ public ChoiceCaseBuilder addCase(final int line, final QName qname) {\r
+ Builder parent = getActualNode();\r
+ if (parent == null || parent.equals(this)) {\r
+ throw new YangParseException(name, line, "'case' parent not found");\r
+ }\r
+\r
+ final ChoiceCaseBuilder builder = new ChoiceCaseBuilder(name, line, qname);\r
+ builder.setParent(parent);\r
+\r
+ if (parent instanceof ChoiceBuilder) {\r
+ ((ChoiceBuilder) parent).addCase(builder);\r
+ } else if (parent instanceof AugmentationSchemaBuilder) {\r
+ ((AugmentationSchemaBuilder) parent).addChildNode(builder);\r
+ } else {\r
+ throw new YangParseException(name, line, "Unresolved parent of 'case' " + qname.getLocalName());\r
+ }\r
+\r
+ return builder;\r
+ }\r
+\r
+ public AnyXmlBuilder addAnyXml(final int line, final QName qname, final SchemaPath schemaPath) {\r
+ final AnyXmlBuilder builder = new AnyXmlBuilder(name, line, qname, schemaPath);\r
+\r
+ Builder parent = getActualNode();\r
+ builder.setParent(parent);\r
+ addChildToParent(parent, builder, qname.getLocalName());\r
+\r
+ return builder;\r
+ }\r
+\r
+ @Override\r
+ public void addTypedef(TypeDefinitionBuilder typedefBuilder) {\r
+ String nodeName = typedefBuilder.getQName().getLocalName();\r
+ for (TypeDefinitionBuilder tdb : addedTypedefs) {\r
+ if (tdb.getQName().getLocalName().equals(nodeName)) {\r
+ throw new YangParseException(name, typedefBuilder.getLine(), "typedef with same name '" + nodeName\r
+ + "' already declared at line " + tdb.getLine());\r
+ }\r
+ }\r
+ addedTypedefs.add(typedefBuilder);\r
+ }\r
+\r
+ public TypeDefinitionBuilderImpl addTypedef(final int line, final QName qname) {\r
+ final TypeDefinitionBuilderImpl builder = new TypeDefinitionBuilderImpl(name, line, qname);\r
+\r
+ Builder parent = getActualNode();\r
+ builder.setParent(parent);\r
+\r
+ String typedefName = qname.getLocalName();\r
+ if (parent.equals(this)) {\r
+ for (TypeDefinitionBuilder tdb : addedTypedefs) {\r
+ if (tdb.getQName().getLocalName().equals(typedefName)) {\r
+ throw new YangParseException(name, line, "typedef with same name '" + typedefName\r
+ + "' already declared at line " + tdb.getLine());\r
+ }\r
+ }\r
+ addedTypedefs.add(builder);\r
+ } else {\r
+ if (parent instanceof DataNodeContainerBuilder) {\r
+ DataNodeContainerBuilder parentNode = (DataNodeContainerBuilder) parent;\r
+ for (TypeDefinitionBuilder child : parentNode.getTypeDefinitionBuilders()) {\r
+ if (child.getQName().getLocalName().equals(typedefName)) {\r
+ throw new YangParseException(name, line, "typedef with same name '" + typedefName\r
+ + "' already declared at line " + child.getLine());\r
+ }\r
+ }\r
+ parentNode.addTypedef(builder);\r
+ } else if (parent instanceof RpcDefinitionBuilder) {\r
+ RpcDefinitionBuilder rpcParent = (RpcDefinitionBuilder) parent;\r
+ for (TypeDefinitionBuilder tdb : rpcParent.getTypeDefinitions()) {\r
+ if (tdb.getQName().getLocalName().equals(builder.getQName().getLocalName())) {\r
+ throw new YangParseException(name, line, "typedef with same name '" + typedefName\r
+ + "' already declared at line " + tdb.getLine());\r
+ }\r
+ }\r
+ rpcParent.addTypedef(builder);\r
+ } else {\r
+ throw new YangParseException(name, line, "Unresolved parent of typedef " + typedefName);\r
+ }\r
+ }\r
+\r
+ return builder;\r
+ }\r
+\r
+ public void setType(final TypeDefinition<?> type) {\r
+ Builder parent = getActualNode();\r
+ if (parent == null || !(parent instanceof TypeAwareBuilder)) {\r
+ throw new YangParseException("Failed to set type '" + type.getQName().getLocalName()\r
+ + "'. Invalid parent node: " + parent);\r
+ }\r
+ ((TypeAwareBuilder) parent).setType(type);\r
+ }\r
+\r
+ public UnionTypeBuilder addUnionType(final int line, final URI namespace, final Date revision) {\r
+ final Builder parent = getActualNode();\r
+ if (parent == null) {\r
+ throw new YangParseException(name, line, "Unresolved parent of union type");\r
+ } else {\r
+ final UnionTypeBuilder union = new UnionTypeBuilder(name, line);\r
+ if (parent instanceof TypeAwareBuilder) {\r
+ ((TypeAwareBuilder) parent).setTypedef(union);\r
+ return union;\r
+ } else {\r
+ throw new YangParseException(name, line, "Invalid parent of union type.");\r
+ }\r
+ }\r
+ }\r
+\r
+ public void addIdentityrefType(final int line, final SchemaPath schemaPath, final String baseString) {\r
+ final IdentityrefTypeBuilder identityref = new IdentityrefTypeBuilder(name, line, baseString, schemaPath);\r
+\r
+ final Builder parent = getActualNode();\r
+ if (parent == null) {\r
+ throw new YangParseException(name, line, "Unresolved parent of identityref type.");\r
+ } else {\r
+ if (parent instanceof TypeAwareBuilder) {\r
+ final TypeAwareBuilder typeParent = (TypeAwareBuilder) parent;\r
+ typeParent.setTypedef(identityref);\r
+ dirtyNodes.add(typeParent);\r
+ } else {\r
+ throw new YangParseException(name, line, "Invalid parent of identityref type.");\r
+ }\r
+ }\r
+ }\r
+\r
+ public DeviationBuilder addDeviation(final int line, final String targetPath) {\r
+ Builder parent = getActualNode();\r
+ if (!(parent.equals(this))) {\r
+ throw new YangParseException(name, line, "deviation can be defined only in module or submodule");\r
+ }\r
+\r
+ final DeviationBuilder builder = new DeviationBuilder(name, line, targetPath);\r
+ builder.setParent(parent);\r
+ addedDeviations.add(builder);\r
+ return builder;\r
+ }\r
+\r
+ public IdentitySchemaNodeBuilder addIdentity(final QName qname, final int line) {\r
+ Builder parent = getActualNode();\r
+ if (!(parent.equals(this))) {\r
+ throw new YangParseException(name, line, "identity can be defined only in module or submodule");\r
+ }\r
+ String identityName = qname.getLocalName();\r
+ for (IdentitySchemaNodeBuilder idBuilder : addedIdentities) {\r
+ if (idBuilder.getQName().equals(qname)) {\r
+ throw new YangParseException(name, line, "identity with same name '" + identityName\r
+ + "' already declared at line " + idBuilder.getLine());\r
+ }\r
+ }\r
+\r
+ final IdentitySchemaNodeBuilder builder = new IdentitySchemaNodeBuilder(name, line, qname);\r
+ builder.setParent(parent);\r
+ addedIdentities.add(builder);\r
+ return builder;\r
+ }\r
+\r
+ @Override\r
+ public void addUnknownNodeBuilder(final UnknownSchemaNodeBuilder builder) {\r
+ addedUnknownNodes.add(builder);\r
+ allUnknownNodes.add(builder);\r
+ }\r
+\r
+ public UnknownSchemaNodeBuilder addUnknownSchemaNode(final int line, final QName qname) {\r
+ final Builder parent = getActualNode();\r
+ final UnknownSchemaNodeBuilder builder = new UnknownSchemaNodeBuilder(name, line, qname);\r
+ builder.setParent(parent);\r
+ allUnknownNodes.add(builder);\r
+\r
+ if (parent.equals(this)) {\r
+ addedUnknownNodes.add(builder);\r
+ } else {\r
+ if (parent instanceof SchemaNodeBuilder) {\r
+ ((SchemaNodeBuilder) parent).addUnknownNodeBuilder(builder);\r
+ } else if (parent instanceof DataNodeContainerBuilder) {\r
+ ((DataNodeContainerBuilder) parent).addUnknownNodeBuilder(builder);\r
+ } else if (parent instanceof RefineHolder) {\r
+ ((RefineHolder) parent).addUnknownNodeBuilder(builder);\r
+ } else {\r
+ throw new YangParseException(name, line, "Unresolved parent of unknown node '" + qname.getLocalName()\r
+ + "'");\r
+ }\r
+ }\r
+\r
+ return builder;\r
+ }\r
+ \r
+ public Set<RpcDefinitionBuilder> getRpcs() {\r
+ return addedRpcs;\r
+ }\r
+\r
+ public Set<NotificationBuilder> getNotifications() {\r
+ return addedNotifications;\r
+ }\r
+ \r
+ @Override\r
+ public String toString() {\r
+ return "module " + name;\r
+ }\r
+\r
+ private final class ModuleImpl implements Module {\r
+ private URI namespace;\r
+ private final String name;\r
+ private Date revision;\r
+ private String prefix;\r
+ private String yangVersion;\r
+ private String description;\r
+ private String reference;\r
+ private String organization;\r
+ private String contact;\r
+ private Set<ModuleImport> imports = Collections.emptySet();\r
+ private Set<FeatureDefinition> features = Collections.emptySet();\r
+ private Set<TypeDefinition<?>> typeDefinitions = Collections.emptySet();\r
+ private Set<NotificationDefinition> notifications = Collections.emptySet();\r
+ private Set<AugmentationSchema> augmentations = Collections.emptySet();\r
+ private Set<RpcDefinition> rpcs = Collections.emptySet();\r
+ private Set<Deviation> deviations = Collections.emptySet();\r
+ private Map<QName, DataSchemaNode> childNodes = Collections.emptyMap();\r
+ private Set<GroupingDefinition> groupings = Collections.emptySet();\r
+ private Set<UsesNode> uses = Collections.emptySet();\r
+ private List<ExtensionDefinition> extensionNodes = Collections.emptyList();\r
+ private Set<IdentitySchemaNode> identities = Collections.emptySet();\r
+ private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();\r
+\r
+ private ModuleImpl(String name) {\r
+ this.name = name;\r
+ }\r
+\r
+ @Override\r
+ public URI getNamespace() {\r
+ return namespace;\r
+ }\r
+\r
+ private void setNamespace(URI namespace) {\r
+ this.namespace = namespace;\r
+ }\r
+\r
+ @Override\r
+ public String getName() {\r
+ return name;\r
+ }\r
+\r
+ @Override\r
+ public Date getRevision() {\r
+ return revision;\r
+ }\r
+\r
+ private void setRevision(Date revision) {\r
+ this.revision = revision;\r
+ }\r
+\r
+ @Override\r
+ public String getPrefix() {\r
+ return prefix;\r
+ }\r
+\r
+ private void setPrefix(String prefix) {\r
+ this.prefix = prefix;\r
+ }\r
+\r
+ @Override\r
+ public String getYangVersion() {\r
+ return yangVersion;\r
+ }\r
+\r
+ private void setYangVersion(String yangVersion) {\r
+ this.yangVersion = yangVersion;\r
+ }\r
+\r
+ @Override\r
+ public String getDescription() {\r
+ return description;\r
+ }\r
+\r
+ private void setDescription(String description) {\r
+ this.description = description;\r
+ }\r
+\r
+ @Override\r
+ public String getReference() {\r
+ return reference;\r
+ }\r
+\r
+ private void setReference(String reference) {\r
+ this.reference = reference;\r
+ }\r
+\r
+ @Override\r
+ public String getOrganization() {\r
+ return organization;\r
+ }\r
+\r
+ private void setOrganization(String organization) {\r
+ this.organization = organization;\r
+ }\r
+\r
+ @Override\r
+ public String getContact() {\r
+ return contact;\r
+ }\r
+\r
+ private void setContact(String contact) {\r
+ this.contact = contact;\r
+ }\r
+\r
+ @Override\r
+ public Set<ModuleImport> getImports() {\r
+ return imports;\r
+ }\r
+\r
+ private void setImports(Set<ModuleImport> imports) {\r
+ if (imports != null) {\r
+ this.imports = imports;\r
+ }\r
+ }\r
+\r
+ @Override\r
+ public Set<FeatureDefinition> getFeatures() {\r
+ return features;\r
+ }\r
+\r
+ private void setFeatures(Set<FeatureDefinition> features) {\r
+ if (features != null) {\r
+ this.features = features;\r
+ }\r
+ }\r
+\r
+ @Override\r
+ public Set<TypeDefinition<?>> getTypeDefinitions() {\r
+ return typeDefinitions;\r
+ }\r
+\r
+ private void setTypeDefinitions(Set<TypeDefinition<?>> typeDefinitions) {\r
+ if (typeDefinitions != null) {\r
+ this.typeDefinitions = typeDefinitions;\r
+ }\r
+ }\r
+\r
+ @Override\r
+ public Set<NotificationDefinition> getNotifications() {\r
+ return notifications;\r
+ }\r
+\r
+ private void setNotifications(Set<NotificationDefinition> notifications) {\r
+ if (notifications != null) {\r
+ this.notifications = notifications;\r
+ }\r
+ }\r
+\r
+ @Override\r
+ public Set<AugmentationSchema> getAugmentations() {\r
+ return augmentations;\r
+ }\r
+\r
+ private void setAugmentations(Set<AugmentationSchema> augmentations) {\r
+ if (augmentations != null) {\r
+ this.augmentations = augmentations;\r
+ }\r
+ }\r
+\r
+ @Override\r
+ public Set<RpcDefinition> getRpcs() {\r
+ return rpcs;\r
+ }\r
+\r
+ private void setRpcs(Set<RpcDefinition> rpcs) {\r
+ if (rpcs != null) {\r
+ this.rpcs = rpcs;\r
+ }\r
+ }\r
+\r
+ @Override\r
+ public Set<Deviation> getDeviations() {\r
+ return deviations;\r
+ }\r
+\r
+ private void setDeviations(Set<Deviation> deviations) {\r
+ if (deviations != null) {\r
+ this.deviations = deviations;\r
+ }\r
+ }\r
+\r
+ @Override\r
+ public Set<DataSchemaNode> getChildNodes() {\r
+ return new LinkedHashSet<DataSchemaNode>(childNodes.values());\r
+ }\r
+\r
+ private void setChildNodes(Map<QName, DataSchemaNode> childNodes) {\r
+ if (childNodes != null) {\r
+ this.childNodes = childNodes;\r
+ }\r
+ }\r
+\r
+ @Override\r
+ public Set<GroupingDefinition> getGroupings() {\r
+ return groupings;\r
+ }\r
+\r
+ private void setGroupings(Set<GroupingDefinition> groupings) {\r
+ if (groupings != null) {\r
+ this.groupings = groupings;\r
+ }\r
+ }\r
+\r
+ @Override\r
+ public Set<UsesNode> getUses() {\r
+ return uses;\r
+ }\r
+\r
+ private void setUses(Set<UsesNode> uses) {\r
+ if (uses != null) {\r
+ this.uses = uses;\r
+ }\r
+ }\r
+\r
+ @Override\r
+ public List<ExtensionDefinition> getExtensionSchemaNodes() {\r
+ return extensionNodes;\r
+ }\r
+\r
+ private void setExtensionSchemaNodes(final List<ExtensionDefinition> extensionNodes) {\r
+ if (extensionNodes != null) {\r
+ this.extensionNodes = extensionNodes;\r
+ }\r
+ }\r
+\r
+ @Override\r
+ public Set<IdentitySchemaNode> getIdentities() {\r
+ return identities;\r
+ }\r
+\r
+ private void setIdentities(final Set<IdentitySchemaNode> identities) {\r
+ if (identities != null) {\r
+ this.identities = identities;\r
+ }\r
+ }\r
+\r
+ @Override\r
+ public List<UnknownSchemaNode> getUnknownSchemaNodes() {\r
+ return unknownNodes;\r
+ }\r
+\r
+ private void setUnknownSchemaNodes(final List<UnknownSchemaNode> unknownNodes) {\r
+ if (unknownNodes != null) {\r
+ this.unknownNodes = unknownNodes;\r
+ }\r
+ }\r
+\r
+ @Override\r
+ public DataSchemaNode getDataChildByName(QName name) {\r
+ return childNodes.get(name);\r
+ }\r
+\r
+ @Override\r
+ public DataSchemaNode getDataChildByName(String name) {\r
+ DataSchemaNode result = null;\r
+ for (Map.Entry<QName, DataSchemaNode> entry : childNodes.entrySet()) {\r
+ if (entry.getKey().getLocalName().equals(name)) {\r
+ result = entry.getValue();\r
+ break;\r
+ }\r
+ }\r
+ return result;\r
+ }\r
+\r
+ @Override\r
+ public int hashCode() {\r
+ final int prime = 31;\r
+ int result = 1;\r
+ result = prime * result + ((namespace == null) ? 0 : namespace.hashCode());\r
+ result = prime * result + ((name == null) ? 0 : name.hashCode());\r
+ result = prime * result + ((revision == null) ? 0 : revision.hashCode());\r
+ result = prime * result + ((prefix == null) ? 0 : prefix.hashCode());\r
+ result = prime * result + ((yangVersion == null) ? 0 : yangVersion.hashCode());\r
+ return result;\r
+ }\r
+\r
+ @Override\r
+ public boolean equals(Object obj) {\r
+ if (this == obj) {\r
+ return true;\r
+ }\r
+ if (obj == null) {\r
+ return false;\r
+ }\r
+ if (getClass() != obj.getClass()) {\r
+ return false;\r
+ }\r
+ ModuleImpl other = (ModuleImpl) obj;\r
+ if (namespace == null) {\r
+ if (other.namespace != null) {\r
+ return false;\r
+ }\r
+ } else if (!namespace.equals(other.namespace)) {\r
+ return false;\r
+ }\r
+ if (name == null) {\r
+ if (other.name != null) {\r
+ return false;\r
+ }\r
+ } else if (!name.equals(other.name)) {\r
+ return false;\r
+ }\r
+ if (revision == null) {\r
+ if (other.revision != null) {\r
+ return false;\r
+ }\r
+ } else if (!revision.equals(other.revision)) {\r
+ return false;\r
+ }\r
+ if (prefix == null) {\r
+ if (other.prefix != null) {\r
+ return false;\r
+ }\r
+ } else if (!prefix.equals(other.prefix)) {\r
+ return false;\r
+ }\r
+ if (yangVersion == null) {\r
+ if (other.yangVersion != null) {\r
+ return false;\r
+ }\r
+ } else if (!yangVersion.equals(other.yangVersion)) {\r
+ return false;\r
+ }\r
+ return true;\r
+ }\r
+\r
+ @Override\r
+ public String toString() {\r
+ StringBuilder sb = new StringBuilder(ModuleImpl.class.getSimpleName());\r
+ sb.append("[");\r
+ sb.append("name=" + name);\r
+ sb.append(", namespace=" + namespace);\r
+ sb.append(", revision=" + revision);\r
+ sb.append(", prefix=" + prefix);\r
+ sb.append(", yangVersion=" + yangVersion);\r
+ sb.append("]");\r
+ return sb.toString();\r
+ }\r
+ }\r
+\r
+ /**\r
+ * Add child to parent. Method checks for duplicates and add given child\r
+ * node to parent. If node with same name is found, throws exception. If\r
+ * parent is null, child node will be added directly to module.\r
+ *\r
+ * @param parent\r
+ * @param child\r
+ * @param childName\r
+ */\r
+ private void addChildToParent(final Builder parent, final DataSchemaNodeBuilder child, final String childName) {\r
+ final int line = child.getLine();\r
+ if (parent.equals(this)) {\r
+ // if parent == null => node is defined under module\r
+ // All leafs, leaf-lists, lists, containers, choices, rpcs,\r
+ // notifications, and anyxmls defined within a parent node or at the\r
+ // top level of the module or its submodules share the same\r
+ // identifier namespace.\r
+ for (DataSchemaNodeBuilder childNode : addedChildNodes) {\r
+ if (childNode.getQName().getLocalName().equals(childName)) {\r
+ throw new YangParseException(name, line, "Can not add '" + child\r
+ + "': node with same name already declared at line " + childNode.getLine());\r
+ }\r
+ }\r
+ for (RpcDefinitionBuilder rpc : addedRpcs) {\r
+ if (rpc.getQName().getLocalName().equals(childName)) {\r
+ throw new YangParseException(name, line, "Can not add '" + child\r
+ + "': rpc with same name already declared at line " + rpc.getLine());\r
+ }\r
+ }\r
+ for (NotificationBuilder notification : addedNotifications) {\r
+ if (notification.getQName().getLocalName().equals(childName)) {\r
+ throw new YangParseException(name, line, "Can not add '" + child\r
+ + "': notification with same name already declared at line " + notification.getLine());\r
+ }\r
+ }\r
+ addedChildNodes.add(child);\r
+ } else {\r
+ if(parent instanceof AugmentationSchemaBuilder) {\r
+ child.setAugmenting(true);\r
+ }\r
+ // no need for checking rpc and notification because they can be\r
+ // defined only under module or submodule\r
+ if (parent instanceof DataNodeContainerBuilder) {\r
+ DataNodeContainerBuilder parentNode = (DataNodeContainerBuilder) parent;\r
+ for (DataSchemaNodeBuilder childNode : parentNode.getChildNodeBuilders()) {\r
+ if (childNode.getQName().getLocalName().equals(childName)) {\r
+ throw new YangParseException(name, line, "Can not add '" + child + "': node with same name '"\r
+ + childName + "' already declared at line " + childNode.getLine());\r
+ }\r
+ }\r
+ parentNode.addChildNode(child);\r
+ } else if (parent instanceof ChoiceBuilder) {\r
+ ChoiceBuilder parentNode = (ChoiceBuilder) parent;\r
+ for (ChoiceCaseBuilder caseBuilder : parentNode.getCases()) {\r
+ if (caseBuilder.getQName().getLocalName().equals(childName)) {\r
+ throw new YangParseException(name, line, "Can not add '" + child + "': case with same name '"\r
+ + childName + "' already declared at line " + caseBuilder.getLine());\r
+ }\r
+ }\r
+ parentNode.addCase(child);\r
+ } else {\r
+ throw new YangParseException(name, line, "Unresolved parent of node '" + childName + "'.");\r
+ }\r
+ }\r
+ }\r
+\r
+ private ModuleImport createModuleImport(final String moduleName, final Date revision, final String prefix) {\r
+ final ModuleImport moduleImport = new ModuleImport() {\r
+ @Override\r
+ public String getModuleName() {\r
+ return moduleName;\r
+ }\r
+\r
+ @Override\r
+ public Date getRevision() {\r
+ return revision;\r
+ }\r
+\r
+ @Override\r
+ public String getPrefix() {\r
+ return prefix;\r
+ }\r
+\r
+ @Override\r
+ public int hashCode() {\r
+ final int prime = 31;\r
+ int result = 1;\r
+ result = prime * result + ((moduleName == null) ? 0 : moduleName.hashCode());\r
+ result = prime * result + ((revision == null) ? 0 : revision.hashCode());\r
+ result = prime * result + ((prefix == null) ? 0 : prefix.hashCode());\r
+ return result;\r
+ }\r
+\r
+ @Override\r
+ public boolean equals(Object obj) {\r
+ if (this == obj) {\r
+ return true;\r
+ }\r
+ if (obj == null) {\r
+ return false;\r
+ }\r
+ if (getClass() != obj.getClass()) {\r
+ return false;\r
+ }\r
+ ModuleImport other = (ModuleImport) obj;\r
+ if (getModuleName() == null) {\r
+ if (other.getModuleName() != null) {\r
+ return false;\r
+ }\r
+ } else if (!getModuleName().equals(other.getModuleName())) {\r
+ return false;\r
+ }\r
+ if (getRevision() == null) {\r
+ if (other.getRevision() != null) {\r
+ return false;\r
+ }\r
+ } else if (!getRevision().equals(other.getRevision())) {\r
+ return false;\r
+ }\r
+ if (getPrefix() == null) {\r
+ if (other.getPrefix() != null) {\r
+ return false;\r
+ }\r
+ } else if (!getPrefix().equals(other.getPrefix())) {\r
+ return false;\r
+ }\r
+ return true;\r
+ }\r
+\r
+ @Override\r
+ public String toString() {\r
+ return "ModuleImport[moduleName=" + moduleName + ", revision=" + revision + ", prefix=" + prefix + "]";\r
+ }\r
+ };\r
+ return moduleImport;\r
+ }\r
+\r
+}\r
-/*
- * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.builder.impl;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.TreeSet;
-
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
-import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.api.Status;
-import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
-import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
-import org.opendaylight.yangtools.yang.parser.builder.api.AbstractSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;
-import org.opendaylight.yangtools.yang.parser.util.Comparators;
-
-public final class RpcDefinitionBuilder extends AbstractSchemaNodeBuilder {
- private boolean isBuilt;
- private final RpcDefinitionImpl instance;
- private ContainerSchemaNodeBuilder inputBuilder;
- private ContainerSchemaNodeBuilder outputBuilder;
- private final Set<TypeDefinitionBuilder> addedTypedefs = new HashSet<TypeDefinitionBuilder>();
- private final Set<GroupingBuilder> addedGroupings = new HashSet<GroupingBuilder>();
-
- RpcDefinitionBuilder(final String moduleName, final int line, final QName qname) {
- super(moduleName, line, qname);
- this.instance = new RpcDefinitionImpl(qname);
- }
-
- @Override
- public RpcDefinition build() {
- if (!isBuilt) {
- instance.setDescription(description);
- instance.setReference(reference);
- instance.setStatus(status);
-
- final ContainerSchemaNode input = inputBuilder == null ? null : inputBuilder.build();
- final ContainerSchemaNode output = outputBuilder == null ? null : outputBuilder.build();
- instance.setInput(input);
- instance.setOutput(output);
-
- instance.setPath(schemaPath);
-
- // TYPEDEFS
- final Set<TypeDefinition<?>> typedefs = new TreeSet<TypeDefinition<?>>(Comparators.SCHEMA_NODE_COMP);
- for (TypeDefinitionBuilder entry : addedTypedefs) {
- typedefs.add(entry.build());
- }
- instance.setTypeDefinitions(typedefs);
-
- // GROUPINGS
- final Set<GroupingDefinition> groupings = new TreeSet<GroupingDefinition>(Comparators.SCHEMA_NODE_COMP);
- for (GroupingBuilder entry : addedGroupings) {
- groupings.add(entry.build());
- }
- instance.setGroupings(groupings);
-
- // UNKNOWN NODES
- if (unknownNodes == null) {
- unknownNodes = new ArrayList<UnknownSchemaNode>();
- for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {
- unknownNodes.add(b.build());
- }
- Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);
- }
- instance.setUnknownSchemaNodes(unknownNodes);
-
- isBuilt = true;
- }
- return instance;
- }
-
- void setInput(final ContainerSchemaNodeBuilder inputBuilder) {
- this.inputBuilder = inputBuilder;
- }
-
- void setOutput(final ContainerSchemaNodeBuilder outputBuilder) {
- this.outputBuilder = outputBuilder;
- }
-
- public Set<TypeDefinitionBuilder> getTypeDefinitions() {
- return addedTypedefs;
- }
-
- public void addTypedef(final TypeDefinitionBuilder type) {
- addedTypedefs.add(type);
- }
-
- public Set<GroupingBuilder> getGroupings() {
- return addedGroupings;
- }
-
- public void addGrouping(GroupingBuilder grouping) {
- addedGroupings.add(grouping);
- }
-
- @Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result + ((qname == null) ? 0 : qname.hashCode());
- result = prime * result + ((schemaPath == null) ? 0 : schemaPath.hashCode());
- return result;
- }
-
- @Override
- public boolean equals(Object obj) {
- if (obj == null) {
- return false;
- }
- if (!(obj instanceof RpcDefinitionBuilder)) {
- return false;
- }
- final RpcDefinitionBuilder other = (RpcDefinitionBuilder) obj;
- if (other.qname == null) {
- if (this.qname != null) {
- return false;
- }
- } else if (!other.qname.equals(this.qname)) {
- return false;
- }
- if (other.schemaPath == null) {
- if (this.schemaPath != null) {
- return false;
- }
- } else if (!other.schemaPath.equals(this.schemaPath)) {
- return false;
- }
- return true;
- }
-
- @Override
- public String toString() {
- return "rpc " + qname.getLocalName();
- }
-
- private final class RpcDefinitionImpl implements RpcDefinition {
- private final QName qname;
- private SchemaPath path;
- private String description;
- private String reference;
- private Status status;
- private ContainerSchemaNode input;
- private ContainerSchemaNode output;
- private Set<TypeDefinition<?>> typeDefinitions;
- private Set<GroupingDefinition> groupings;
- private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();
-
- private RpcDefinitionImpl(final QName qname) {
- this.qname = qname;
- }
-
- @Override
- public QName getQName() {
- return qname;
- }
-
- @Override
- public SchemaPath getPath() {
- return path;
- }
-
- private void setPath(SchemaPath path) {
- this.path = path;
- }
-
- @Override
- public String getDescription() {
- return description;
- }
-
- private void setDescription(String description) {
- this.description = description;
- }
-
- @Override
- public String getReference() {
- return reference;
- }
-
- private void setReference(String reference) {
- this.reference = reference;
- }
-
- @Override
- public Status getStatus() {
- return status;
- }
-
- private void setStatus(Status status) {
- this.status = status;
- }
-
- @Override
- public ContainerSchemaNode getInput() {
- return input;
- }
-
- private void setInput(ContainerSchemaNode input) {
- this.input = input;
- }
-
- @Override
- public ContainerSchemaNode getOutput() {
- return output;
- }
-
- private void setOutput(ContainerSchemaNode output) {
- this.output = output;
- }
-
- @Override
- public Set<TypeDefinition<?>> getTypeDefinitions() {
- return typeDefinitions;
- }
-
- private void setTypeDefinitions(Set<TypeDefinition<?>> typeDefinitions) {
- this.typeDefinitions = typeDefinitions;
- }
-
- @Override
- public Set<GroupingDefinition> getGroupings() {
- return groupings;
- }
-
- private void setGroupings(Set<GroupingDefinition> groupings) {
- this.groupings = groupings;
- }
-
- @Override
- public List<UnknownSchemaNode> getUnknownSchemaNodes() {
- return unknownNodes;
- }
-
- private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {
- if (unknownNodes != null) {
- this.unknownNodes = unknownNodes;
- }
- }
-
- @Override
- public int hashCode() {
- final int prime = 31;
- int result = 1;
- result = prime * result + ((qname == null) ? 0 : qname.hashCode());
- result = prime * result + ((path == null) ? 0 : path.hashCode());
- return result;
- }
-
- @Override
- public boolean equals(Object obj) {
- if (this == obj) {
- return true;
- }
- if (obj == null) {
- return false;
- }
- if (getClass() != obj.getClass()) {
- return false;
- }
- final RpcDefinitionImpl other = (RpcDefinitionImpl) obj;
- if (qname == null) {
- if (other.qname != null) {
- return false;
- }
- } else if (!qname.equals(other.qname)) {
- return false;
- }
- if (path == null) {
- if (other.path != null) {
- return false;
- }
- } else if (!path.equals(other.path)) {
- return false;
- }
- return true;
- }
-
- @Override
- public String toString() {
- StringBuilder sb = new StringBuilder(RpcDefinitionImpl.class.getSimpleName() + "[");
- sb.append("qname=" + qname);
- sb.append(", path=" + path);
- sb.append(", input=" + input);
- sb.append(", output=" + output + "]");
- return sb.toString();
- }
- }
-
-}
+/*\r
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+package org.opendaylight.yangtools.yang.parser.builder.impl;\r
+\r
+import java.util.ArrayList;\r
+import java.util.Collections;\r
+import java.util.HashSet;\r
+import java.util.List;\r
+import java.util.Set;\r
+import java.util.TreeSet;\r
+\r
+import org.opendaylight.yangtools.yang.common.QName;\r
+import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;\r
+import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;\r
+import org.opendaylight.yangtools.yang.model.api.RpcDefinition;\r
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;\r
+import org.opendaylight.yangtools.yang.model.api.Status;\r
+import org.opendaylight.yangtools.yang.model.api.TypeDefinition;\r
+import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;\r
+import org.opendaylight.yangtools.yang.parser.builder.api.AbstractSchemaNodeBuilder;\r
+import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;\r
+import org.opendaylight.yangtools.yang.parser.builder.api.TypeDefinitionBuilder;\r
+import org.opendaylight.yangtools.yang.parser.util.Comparators;\r
+\r
+public final class RpcDefinitionBuilder extends AbstractSchemaNodeBuilder {\r
+ private boolean isBuilt;\r
+ private final RpcDefinitionImpl instance;\r
+ private ContainerSchemaNodeBuilder inputBuilder;\r
+ private ContainerSchemaNodeBuilder outputBuilder;\r
+ private final Set<TypeDefinitionBuilder> addedTypedefs = new HashSet<TypeDefinitionBuilder>();\r
+ private final Set<GroupingBuilder> addedGroupings = new HashSet<GroupingBuilder>();\r
+\r
+ public ContainerSchemaNodeBuilder getInput() {\r
+ return inputBuilder;\r
+ }\r
+ \r
+ public ContainerSchemaNodeBuilder getOutput() {\r
+ return outputBuilder;\r
+ }\r
+ \r
+ RpcDefinitionBuilder(final String moduleName, final int line, final QName qname) {\r
+ super(moduleName, line, qname);\r
+ this.instance = new RpcDefinitionImpl(qname);\r
+ }\r
+\r
+ @Override\r
+ public RpcDefinition build() {\r
+ if (!isBuilt) {\r
+ instance.setDescription(description);\r
+ instance.setReference(reference);\r
+ instance.setStatus(status);\r
+\r
+ final ContainerSchemaNode input = inputBuilder == null ? null : inputBuilder.build();\r
+ final ContainerSchemaNode output = outputBuilder == null ? null : outputBuilder.build();\r
+ instance.setInput(input);\r
+ instance.setOutput(output);\r
+\r
+ instance.setPath(schemaPath);\r
+\r
+ // TYPEDEFS\r
+ final Set<TypeDefinition<?>> typedefs = new TreeSet<TypeDefinition<?>>(Comparators.SCHEMA_NODE_COMP);\r
+ for (TypeDefinitionBuilder entry : addedTypedefs) {\r
+ typedefs.add(entry.build());\r
+ }\r
+ instance.setTypeDefinitions(typedefs);\r
+\r
+ // GROUPINGS\r
+ final Set<GroupingDefinition> groupings = new TreeSet<GroupingDefinition>(Comparators.SCHEMA_NODE_COMP);\r
+ for (GroupingBuilder entry : addedGroupings) {\r
+ groupings.add(entry.build());\r
+ }\r
+ instance.setGroupings(groupings);\r
+\r
+ // UNKNOWN NODES\r
+ if (unknownNodes == null) {\r
+ unknownNodes = new ArrayList<UnknownSchemaNode>();\r
+ for (UnknownSchemaNodeBuilder b : addedUnknownNodes) {\r
+ unknownNodes.add(b.build());\r
+ }\r
+ Collections.sort(unknownNodes, Comparators.SCHEMA_NODE_COMP);\r
+ }\r
+ instance.setUnknownSchemaNodes(unknownNodes);\r
+\r
+ isBuilt = true;\r
+ }\r
+ return instance;\r
+ }\r
+\r
+ void setInput(final ContainerSchemaNodeBuilder inputBuilder) {\r
+ this.inputBuilder = inputBuilder;\r
+ }\r
+\r
+ void setOutput(final ContainerSchemaNodeBuilder outputBuilder) {\r
+ this.outputBuilder = outputBuilder;\r
+ }\r
+\r
+ public Set<TypeDefinitionBuilder> getTypeDefinitions() {\r
+ return addedTypedefs;\r
+ }\r
+\r
+ public void addTypedef(final TypeDefinitionBuilder type) {\r
+ addedTypedefs.add(type);\r
+ }\r
+\r
+ public Set<GroupingBuilder> getGroupings() {\r
+ return addedGroupings;\r
+ }\r
+\r
+ public void addGrouping(GroupingBuilder grouping) {\r
+ addedGroupings.add(grouping);\r
+ }\r
+\r
+ @Override\r
+ public int hashCode() {\r
+ final int prime = 31;\r
+ int result = 1;\r
+ result = prime * result + ((qname == null) ? 0 : qname.hashCode());\r
+ result = prime * result + ((schemaPath == null) ? 0 : schemaPath.hashCode());\r
+ return result;\r
+ }\r
+\r
+ @Override\r
+ public boolean equals(Object obj) {\r
+ if (obj == null) {\r
+ return false;\r
+ }\r
+ if (!(obj instanceof RpcDefinitionBuilder)) {\r
+ return false;\r
+ }\r
+ final RpcDefinitionBuilder other = (RpcDefinitionBuilder) obj;\r
+ if (other.qname == null) {\r
+ if (this.qname != null) {\r
+ return false;\r
+ }\r
+ } else if (!other.qname.equals(this.qname)) {\r
+ return false;\r
+ }\r
+ if (other.schemaPath == null) {\r
+ if (this.schemaPath != null) {\r
+ return false;\r
+ }\r
+ } else if (!other.schemaPath.equals(this.schemaPath)) {\r
+ return false;\r
+ }\r
+ return true;\r
+ }\r
+\r
+ @Override\r
+ public String toString() {\r
+ return "rpc " + qname.getLocalName();\r
+ }\r
+\r
+ private final class RpcDefinitionImpl implements RpcDefinition {\r
+ private final QName qname;\r
+ private SchemaPath path;\r
+ private String description;\r
+ private String reference;\r
+ private Status status;\r
+ private ContainerSchemaNode input;\r
+ private ContainerSchemaNode output;\r
+ private Set<TypeDefinition<?>> typeDefinitions;\r
+ private Set<GroupingDefinition> groupings;\r
+ private List<UnknownSchemaNode> unknownNodes = Collections.emptyList();\r
+\r
+ private RpcDefinitionImpl(final QName qname) {\r
+ this.qname = qname;\r
+ }\r
+\r
+ @Override\r
+ public QName getQName() {\r
+ return qname;\r
+ }\r
+\r
+ @Override\r
+ public SchemaPath getPath() {\r
+ return path;\r
+ }\r
+\r
+ private void setPath(SchemaPath path) {\r
+ this.path = path;\r
+ }\r
+\r
+ @Override\r
+ public String getDescription() {\r
+ return description;\r
+ }\r
+\r
+ private void setDescription(String description) {\r
+ this.description = description;\r
+ }\r
+\r
+ @Override\r
+ public String getReference() {\r
+ return reference;\r
+ }\r
+\r
+ private void setReference(String reference) {\r
+ this.reference = reference;\r
+ }\r
+\r
+ @Override\r
+ public Status getStatus() {\r
+ return status;\r
+ }\r
+\r
+ private void setStatus(Status status) {\r
+ this.status = status;\r
+ }\r
+\r
+ @Override\r
+ public ContainerSchemaNode getInput() {\r
+ return input;\r
+ }\r
+\r
+ private void setInput(ContainerSchemaNode input) {\r
+ this.input = input;\r
+ }\r
+\r
+ @Override\r
+ public ContainerSchemaNode getOutput() {\r
+ return output;\r
+ }\r
+\r
+ private void setOutput(ContainerSchemaNode output) {\r
+ this.output = output;\r
+ }\r
+\r
+ @Override\r
+ public Set<TypeDefinition<?>> getTypeDefinitions() {\r
+ return typeDefinitions;\r
+ }\r
+\r
+ private void setTypeDefinitions(Set<TypeDefinition<?>> typeDefinitions) {\r
+ this.typeDefinitions = typeDefinitions;\r
+ }\r
+\r
+ @Override\r
+ public Set<GroupingDefinition> getGroupings() {\r
+ return groupings;\r
+ }\r
+\r
+ private void setGroupings(Set<GroupingDefinition> groupings) {\r
+ this.groupings = groupings;\r
+ }\r
+\r
+ @Override\r
+ public List<UnknownSchemaNode> getUnknownSchemaNodes() {\r
+ return unknownNodes;\r
+ }\r
+\r
+ private void setUnknownSchemaNodes(List<UnknownSchemaNode> unknownNodes) {\r
+ if (unknownNodes != null) {\r
+ this.unknownNodes = unknownNodes;\r
+ }\r
+ }\r
+\r
+ @Override\r
+ public int hashCode() {\r
+ final int prime = 31;\r
+ int result = 1;\r
+ result = prime * result + ((qname == null) ? 0 : qname.hashCode());\r
+ result = prime * result + ((path == null) ? 0 : path.hashCode());\r
+ return result;\r
+ }\r
+\r
+ @Override\r
+ public boolean equals(Object obj) {\r
+ if (this == obj) {\r
+ return true;\r
+ }\r
+ if (obj == null) {\r
+ return false;\r
+ }\r
+ if (getClass() != obj.getClass()) {\r
+ return false;\r
+ }\r
+ final RpcDefinitionImpl other = (RpcDefinitionImpl) obj;\r
+ if (qname == null) {\r
+ if (other.qname != null) {\r
+ return false;\r
+ }\r
+ } else if (!qname.equals(other.qname)) {\r
+ return false;\r
+ }\r
+ if (path == null) {\r
+ if (other.path != null) {\r
+ return false;\r
+ }\r
+ } else if (!path.equals(other.path)) {\r
+ return false;\r
+ }\r
+ return true;\r
+ }\r
+\r
+ @Override\r
+ public String toString() {\r
+ StringBuilder sb = new StringBuilder(RpcDefinitionImpl.class.getSimpleName() + "[");\r
+ sb.append("qname=" + qname);\r
+ sb.append(", path=" + path);\r
+ sb.append(", input=" + input);\r
+ sb.append(", output=" + output + "]");\r
+ return sb.toString();\r
+ }\r
+ }\r
+\r
+}\r
-/*
- * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.impl;
-
-import static org.opendaylight.yangtools.yang.parser.util.ParserUtils.*;
-import static org.opendaylight.yangtools.yang.parser.util.TypeUtils.*;
-
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-import java.util.TreeMap;
-
-import org.antlr.v4.runtime.ANTLRInputStream;
-import org.antlr.v4.runtime.CommonTokenStream;
-import org.antlr.v4.runtime.tree.ParseTree;
-import org.antlr.v4.runtime.tree.ParseTreeWalker;
-import org.opendaylight.yangtools.antlrv4.code.gen.YangLexer;
-import org.opendaylight.yangtools.antlrv4.code.gen.YangParser;
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
-import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;
-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.SchemaContext;
-import org.opendaylight.yangtools.yang.model.api.SchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
-import org.opendaylight.yangtools.yang.model.parser.api.YangModelParser;
-import org.opendaylight.yangtools.yang.model.util.IdentityrefType;
-import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
-import org.opendaylight.yangtools.yang.parser.builder.api.DataNodeContainerBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.TypeAwareBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.DeviationBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ExtensionBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.IdentitySchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.IdentityrefTypeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.UnionTypeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.util.GroupingUtils;
-import org.opendaylight.yangtools.yang.parser.util.ModuleDependencySort;
-import org.opendaylight.yangtools.yang.parser.util.ParserUtils;
-import org.opendaylight.yangtools.yang.parser.util.YangParseException;
-import org.opendaylight.yangtools.yang.validator.YangModelBasicValidator;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-import com.google.common.collect.Sets;
-
-public final class YangParserImpl implements YangModelParser {
- private static final Logger LOG = LoggerFactory.getLogger(YangParserImpl.class);
-
- @Override
- public Set<Module> parseYangModels(final List<File> yangFiles) {
- return Sets.newLinkedHashSet(parseYangModelsMapped(yangFiles).values());
- }
-
- @Override
- public Set<Module> parseYangModels(final List<File> yangFiles, final SchemaContext context) {
- if (yangFiles != null) {
- final Map<InputStream, File> inputStreams = Maps.newHashMap();
-
- for (final File yangFile : yangFiles) {
- try {
- inputStreams.put(new FileInputStream(yangFile), yangFile);
- } catch (FileNotFoundException e) {
- LOG.warn("Exception while reading yang file: " + yangFile.getName(), e);
- }
- }
-
- Map<ModuleBuilder, InputStream> builderToStreamMap = Maps.newHashMap();
-
- final Map<String, TreeMap<Date, ModuleBuilder>> modules = resolveModuleBuilders(
- Lists.newArrayList(inputStreams.keySet()), builderToStreamMap);
-
- for (InputStream is : inputStreams.keySet()) {
- try {
- is.close();
- } catch (IOException e) {
- LOG.debug("Failed to close stream.");
- }
- }
-
- return new LinkedHashSet<Module>(buildWithContext(modules, context).values());
- }
- return Collections.emptySet();
- }
-
- @Override
- public Set<Module> parseYangModelsFromStreams(final List<InputStream> yangModelStreams) {
- return Sets.newHashSet(parseYangModelsFromStreamsMapped(yangModelStreams).values());
- }
-
- @Override
- public Set<Module> parseYangModelsFromStreams(final List<InputStream> yangModelStreams, SchemaContext context) {
- if (yangModelStreams != null) {
- Map<ModuleBuilder, InputStream> builderToStreamMap = Maps.newHashMap();
- final Map<String, TreeMap<Date, ModuleBuilder>> modules = resolveModuleBuildersWithContext(
- yangModelStreams, builderToStreamMap, context);
- return new LinkedHashSet<Module>(buildWithContext(modules, context).values());
- }
- return Collections.emptySet();
- }
-
- @Override
- public Map<File, Module> parseYangModelsMapped(List<File> yangFiles) {
- if (yangFiles != null) {
- final Map<InputStream, File> inputStreams = Maps.newHashMap();
-
- for (final File yangFile : yangFiles) {
- try {
- inputStreams.put(new FileInputStream(yangFile), yangFile);
- } catch (FileNotFoundException e) {
- LOG.warn("Exception while reading yang file: " + yangFile.getName(), e);
- }
- }
-
- Map<ModuleBuilder, InputStream> builderToStreamMap = Maps.newHashMap();
- final Map<String, TreeMap<Date, ModuleBuilder>> modules = resolveModuleBuilders(
- Lists.newArrayList(inputStreams.keySet()), builderToStreamMap);
-
- for (InputStream is : inputStreams.keySet()) {
- try {
- is.close();
- } catch (IOException e) {
- LOG.debug("Failed to close stream.");
- }
- }
-
- Map<File, Module> retVal = Maps.newLinkedHashMap();
- Map<ModuleBuilder, Module> builderToModuleMap = build(modules);
-
- for (Entry<ModuleBuilder, Module> builderToModule : builderToModuleMap.entrySet()) {
- retVal.put(inputStreams.get(builderToStreamMap.get(builderToModule.getKey())),
- builderToModule.getValue());
- }
-
- return retVal;
- }
- return Collections.emptyMap();
- }
-
- @Override
- public Map<InputStream, Module> parseYangModelsFromStreamsMapped(final List<InputStream> yangModelStreams) {
- Map<ModuleBuilder, InputStream> builderToStreamMap = Maps.newHashMap();
-
- final Map<String, TreeMap<Date, ModuleBuilder>> modules = resolveModuleBuilders(yangModelStreams,
- builderToStreamMap);
- Map<InputStream, Module> retVal = Maps.newLinkedHashMap();
- Map<ModuleBuilder, Module> builderToModuleMap = build(modules);
-
- for (Entry<ModuleBuilder, Module> builderToModule : builderToModuleMap.entrySet()) {
- retVal.put(builderToStreamMap.get(builderToModule.getKey()), builderToModule.getValue());
- }
- return retVal;
- }
-
- @Override
- public SchemaContext resolveSchemaContext(final Set<Module> modules) {
- return new SchemaContextImpl(modules);
- }
-
- private ModuleBuilder[] parseModuleBuilders(List<InputStream> inputStreams,
- Map<ModuleBuilder, InputStream> streamToBuilderMap) {
-
- final ParseTreeWalker walker = new ParseTreeWalker();
- final List<ParseTree> trees = parseStreams(inputStreams);
- final ModuleBuilder[] builders = new ModuleBuilder[trees.size()];
-
- // validate yang
- new YangModelBasicValidator(walker).validate(trees);
-
- YangParserListenerImpl yangModelParser = null;
- for (int i = 0; i < trees.size(); i++) {
- yangModelParser = new YangParserListenerImpl();
- walker.walk(yangModelParser, trees.get(i));
- ModuleBuilder moduleBuilder = yangModelParser.getModuleBuilder();
-
- // We expect the order of trees and streams has to be the same
- streamToBuilderMap.put(moduleBuilder, inputStreams.get(i));
- builders[i] = moduleBuilder;
- }
- return builders;
- }
-
- private Map<String, TreeMap<Date, ModuleBuilder>> resolveModuleBuilders(final List<InputStream> yangFileStreams,
- Map<ModuleBuilder, InputStream> streamToBuilderMap) {
- return resolveModuleBuildersWithContext(yangFileStreams, streamToBuilderMap, null);
- }
-
- private Map<String, TreeMap<Date, ModuleBuilder>> resolveModuleBuildersWithContext(
- final List<InputStream> yangFileStreams, final Map<ModuleBuilder, InputStream> streamToBuilderMap,
- final SchemaContext context) {
- final ModuleBuilder[] builders = parseModuleBuilders(yangFileStreams, streamToBuilderMap);
-
- // LinkedHashMap must be used to preserve order
- final LinkedHashMap<String, TreeMap<Date, ModuleBuilder>> modules = new LinkedHashMap<String, TreeMap<Date, ModuleBuilder>>();
-
- // module dependency graph sorted
- List<ModuleBuilder> sorted = null;
- if (context == null) {
- sorted = ModuleDependencySort.sort(builders);
- } else {
- sorted = ModuleDependencySort.sortWithContext(context, builders);
- }
-
- for (final ModuleBuilder builder : sorted) {
- if (builder == null) {
- continue;
- }
- final String builderName = builder.getName();
- Date builderRevision = builder.getRevision();
- if (builderRevision == null) {
- builderRevision = new Date(0L);
- }
- TreeMap<Date, ModuleBuilder> builderByRevision = modules.get(builderName);
- if (builderByRevision == null) {
- builderByRevision = new TreeMap<Date, ModuleBuilder>();
- }
- builderByRevision.put(builderRevision, builder);
- modules.put(builderName, builderByRevision);
- }
- return modules;
- }
-
- private List<ParseTree> parseStreams(final List<InputStream> yangStreams) {
- final List<ParseTree> trees = new ArrayList<ParseTree>();
- for (InputStream yangStream : yangStreams) {
- trees.add(parseStream(yangStream));
- }
- return trees;
- }
-
- private ParseTree parseStream(final InputStream yangStream) {
- ParseTree result = null;
- try {
- final ANTLRInputStream input = new ANTLRInputStream(yangStream);
- final YangLexer lexer = new YangLexer(input);
- final CommonTokenStream tokens = new CommonTokenStream(lexer);
- final YangParser parser = new YangParser(tokens);
- parser.removeErrorListeners();
- parser.addErrorListener(new YangErrorListener());
-
- result = parser.yang();
- } catch (IOException e) {
- LOG.warn("Exception while reading yang file: " + yangStream, e);
- }
- return result;
- }
-
- private Map<ModuleBuilder, Module> build(final Map<String, TreeMap<Date, ModuleBuilder>> modules) {
- // fix unresolved nodes
- findUsesTargets(modules, null);
- resolveDirtyNodes(modules);
- resolveAugments(modules);
- resolveUses(modules);
- resolveDeviations(modules);
-
- // build
- final Map<ModuleBuilder, Module> result = new LinkedHashMap<ModuleBuilder, Module>();
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
- final Map<Date, Module> modulesByRevision = new HashMap<Date, Module>();
- for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue().entrySet()) {
- final ModuleBuilder moduleBuilder = childEntry.getValue();
- final Module module = moduleBuilder.build();
- modulesByRevision.put(childEntry.getKey(), module);
- result.put(moduleBuilder, module);
- }
- }
- return result;
- }
-
- private Map<ModuleBuilder, Module> buildWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final SchemaContext context) {
- // fix unresolved nodes
- findUsesTargets(modules, context);
- resolvedDirtyNodesWithContext(modules, context);
- resolveAugmentsWithContext(modules, context);
- resolveUsesWithContext(modules, context);
- resolveDeviationsWithContext(modules, context);
-
- // build
- final Map<ModuleBuilder, Module> result = new LinkedHashMap<ModuleBuilder, Module>();
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
- final Map<Date, Module> modulesByRevision = new HashMap<Date, Module>();
- for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue().entrySet()) {
- final ModuleBuilder moduleBuilder = childEntry.getValue();
- final Module module = moduleBuilder.build();
- modulesByRevision.put(childEntry.getKey(), module);
- result.put(moduleBuilder, module);
- }
- }
- return result;
- }
-
- private void resolveDirtyNodes(final Map<String, TreeMap<Date, ModuleBuilder>> modules) {
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
- for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue().entrySet()) {
- final ModuleBuilder module = childEntry.getValue();
- resolveDirtyNodes(modules, module);
- resolveIdentities(modules, module);
- resolveUnknownNodes(modules, module);
- }
- }
- }
-
- private void resolvedDirtyNodesWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final SchemaContext context) {
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
- for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue().entrySet()) {
- final ModuleBuilder module = childEntry.getValue();
- resolveDirtyNodesWithContext(modules, module, context);
- resolveIdentitiesWithContext(modules, module, context);
- resolveUnknownNodesWithContext(modules, module, context);
- }
- }
- }
-
- /**
- * Search for dirty nodes (node which contains UnknownType) and resolve
- * unknown types.
- *
- * @param modules
- * all available modules
- * @param module
- * current module
- */
- private void resolveDirtyNodes(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {
- final Set<TypeAwareBuilder> dirtyNodes = module.getDirtyNodes();
- if (!dirtyNodes.isEmpty()) {
- for (TypeAwareBuilder nodeToResolve : dirtyNodes) {
- if (nodeToResolve instanceof UnionTypeBuilder) {
- // special handling for union types
- resolveTypeUnion((UnionTypeBuilder) nodeToResolve, modules, module);
- } else if (nodeToResolve.getTypedef() instanceof IdentityrefTypeBuilder) {
- // special handling for identityref types
- IdentityrefTypeBuilder idref = (IdentityrefTypeBuilder) nodeToResolve.getTypedef();
- nodeToResolve.setType(new IdentityrefType(findFullQName(modules, module, idref), idref.getPath()));
- } else {
- resolveType(nodeToResolve, modules, module);
- }
- }
- }
- }
-
- private void resolveDirtyNodesWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final ModuleBuilder module, SchemaContext context) {
- final Set<TypeAwareBuilder> dirtyNodes = module.getDirtyNodes();
- if (!dirtyNodes.isEmpty()) {
- for (TypeAwareBuilder nodeToResolve : dirtyNodes) {
- if (nodeToResolve instanceof UnionTypeBuilder) {
- // special handling for union types
- resolveTypeUnionWithContext((UnionTypeBuilder) nodeToResolve, modules, module, context);
- } else if (nodeToResolve.getTypedef() instanceof IdentityrefTypeBuilder) {
- // special handling for identityref types
- IdentityrefTypeBuilder idref = (IdentityrefTypeBuilder) nodeToResolve.getTypedef();
- nodeToResolve.setType(new IdentityrefType(findFullQName(modules, module, idref), idref.getPath()));
- } else {
- resolveTypeWithContext(nodeToResolve, modules, module, context);
- }
- }
- }
- }
-
- /**
- * Go through all augment definitions and perform augmentation. It is
- * expected that modules are already sorted by their dependencies.
- *
- * @param modules
- * all loaded modules
- */
- private void resolveAugments(final Map<String, TreeMap<Date, ModuleBuilder>> modules) {
- // collect augments from all loaded modules
- final List<AugmentationSchemaBuilder> allAugments = new ArrayList<>();
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
- for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {
- allAugments.addAll(inner.getValue().getAllAugments());
- }
- }
-
- for (int i = 0; i < allAugments.size(); i++) {
- // pick one augment
- final AugmentationSchemaBuilder augment = allAugments.get(i);
- // create collection of others
- List<AugmentationSchemaBuilder> others = new ArrayList<>(allAugments);
- others.remove(augment);
-
- // try to resolve it
- boolean resolved = resolveAugment(modules, augment);
- // while not resolved
- int j = 0;
- while (!(resolved) && j < others.size()) {
- // try to resolve next augment
- resolveAugment(modules, others.get(j));
- // then try to resolve first again
- resolved = resolveAugment(modules, augment);
- j++;
-
- }
-
- if (!resolved) {
- throw new YangParseException(augment.getModuleName(), augment.getLine(),
- "Error in augment parsing: failed to find augment target");
- }
- }
- }
-
- /**
- * Search for augment target and perform augmentation.
- *
- * @param modules
- * all loaded modules
- * @param augmentBuilder
- * augment to resolve
- * @return true if target node found, false otherwise
- */
- private boolean resolveAugment(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final AugmentationSchemaBuilder augmentBuilder) {
- if (augmentBuilder.isResolved()) {
- return true;
- }
-
- int line = augmentBuilder.getLine();
- ModuleBuilder module = getParentModule(augmentBuilder);
- List<QName> path = augmentBuilder.getTargetPath().getPath();
- Builder augmentParent = augmentBuilder.getParent();
-
- Builder firstNodeParent = null;
- if (augmentParent instanceof ModuleBuilder) {
- // if augment is defined under module, parent of first node is
- // target module
- final QName firstNameInPath = path.get(0);
- String prefix = firstNameInPath.getPrefix();
- if (prefix == null) {
- prefix = module.getPrefix();
- }
- firstNodeParent = findDependentModuleBuilder(modules, module, prefix, line);
- } else if (augmentParent instanceof UsesNodeBuilder) {
- firstNodeParent = augmentParent.getParent();
- } else {
- // augment can be defined only under module or uses
- throw new YangParseException(augmentBuilder.getModuleName(), line,
- "Failed to parse augment: Unresolved parent of augment: " + augmentParent);
- }
-
- return processAugmentation(augmentBuilder, firstNodeParent, path);
- }
-
- /**
- * Go through all augment definitions and resolve them. This method works in
- * same way as {@link #resolveAugments(Map)} except that if target node is
- * not found in loaded modules, it search for target node in given context.
- *
- * @param modules
- * all loaded modules
- * @param context
- * SchemaContext containing already resolved modules
- */
- private void resolveAugmentsWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final SchemaContext context) {
- // collect augments from all loaded modules
- final List<AugmentationSchemaBuilder> allAugments = new ArrayList<>();
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
- for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {
- allAugments.addAll(inner.getValue().getAllAugments());
- }
- }
-
- for (int i = 0; i < allAugments.size(); i++) {
- // pick augment from list
- final AugmentationSchemaBuilder augment = allAugments.get(i);
- // try to resolve it
- boolean resolved = resolveAugmentWithContext(modules, augment, context);
- // while not resolved
- int j = i + 1;
- while (!(resolved) && j < allAugments.size()) {
- // try to resolve next augment
- resolveAugmentWithContext(modules, allAugments.get(j), context);
- // then try to resolve first again
- resolved = resolveAugmentWithContext(modules, augment, context);
- j++;
- }
-
- if (!resolved) {
- throw new YangParseException(augment.getModuleName(), augment.getLine(),
- "Error in augment parsing: failed to find augment target");
- }
- }
- }
-
- /**
- * Search for augment target and perform augmentation.
- *
- * @param modules
- * all loaded modules
- * @param augment
- * augment to resolve
- * @param context
- * SchemaContext containing already resolved modules
- * @return true if target node found, false otherwise
- */
- private boolean resolveAugmentWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final AugmentationSchemaBuilder augment, final SchemaContext context) {
- if (augment.isResolved()) {
- return true;
- }
- int line = augment.getLine();
- ModuleBuilder module = getParentModule(augment);
- List<QName> path = augment.getTargetPath().getPath();
- final QName firstNameInPath = path.get(0);
- String prefix = firstNameInPath.getPrefix();
- if (prefix == null) {
- prefix = module.getPrefix();
- }
- Builder augmentParent = augment.getParent();
- Builder currentParent = null;
-
- if (augmentParent instanceof ModuleBuilder) {
- // if augment is defined under module, first parent is target module
- currentParent = findDependentModuleBuilder(modules, module, prefix, line);
- } else if (augmentParent instanceof UsesNodeBuilder) {
- currentParent = augmentParent.getParent();
- } else {
- // augment can be defined only under module or uses
- throw new YangParseException(augment.getModuleName(), augment.getLine(),
- "Error in augment parsing: Unresolved parent of augment: " + augmentParent);
- }
-
- if (currentParent == null) {
- return processAugmentationOnContext(augment, path, module, prefix, context);
- } else {
- return processAugmentation(augment, currentParent, path);
- }
- }
-
- /**
- * Go through identity statements defined in current module and resolve
- * their 'base' statement if present.
- *
- * @param modules
- * all modules
- * @param module
- * module being resolved
- */
- private void resolveIdentities(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {
- final Set<IdentitySchemaNodeBuilder> identities = module.getIdentities();
- for (IdentitySchemaNodeBuilder identity : identities) {
- final String baseIdentityName = identity.getBaseIdentityName();
- if (baseIdentityName != null) {
- String baseIdentityPrefix = null;
- String baseIdentityLocalName = null;
- if (baseIdentityName.contains(":")) {
- final String[] splitted = baseIdentityName.split(":");
- baseIdentityPrefix = splitted[0];
- baseIdentityLocalName = splitted[1];
- } else {
- baseIdentityPrefix = module.getPrefix();
- baseIdentityLocalName = baseIdentityName;
- }
- final ModuleBuilder dependentModule = findDependentModuleBuilder(modules, module, baseIdentityPrefix,
- identity.getLine());
-
- final Set<IdentitySchemaNodeBuilder> dependentModuleIdentities = dependentModule.getIdentities();
- for (IdentitySchemaNodeBuilder idBuilder : dependentModuleIdentities) {
- if (idBuilder.getQName().getLocalName().equals(baseIdentityLocalName)) {
- identity.setBaseIdentity(idBuilder);
- }
- }
- }
- }
- }
-
- /**
- * Go through identity statements defined in current module and resolve
- * their 'base' statement. Method tries to find base identity in given
- * modules. If base identity is not found, method will search it in context.
- *
- * @param modules
- * all loaded modules
- * @param module
- * current module
- * @param context
- * SchemaContext containing already resolved modules
- */
- private void resolveIdentitiesWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final ModuleBuilder module, final SchemaContext context) {
- final Set<IdentitySchemaNodeBuilder> identities = module.getIdentities();
- for (IdentitySchemaNodeBuilder identity : identities) {
- final String baseIdentityName = identity.getBaseIdentityName();
- if (baseIdentityName != null) {
- String baseIdentityPrefix = null;
- String baseIdentityLocalName = null;
- if (baseIdentityName.contains(":")) {
- final String[] splitted = baseIdentityName.split(":");
- baseIdentityPrefix = splitted[0];
- baseIdentityLocalName = splitted[1];
- } else {
- baseIdentityPrefix = module.getPrefix();
- baseIdentityLocalName = baseIdentityName;
- }
- final ModuleBuilder dependentModuleBuilder = findDependentModuleBuilder(modules, module,
- baseIdentityPrefix, identity.getLine());
-
- if (dependentModuleBuilder == null) {
- final Module dependentModule = findModuleFromContext(context, module, baseIdentityPrefix,
- identity.getLine());
- final Set<IdentitySchemaNode> dependentModuleIdentities = dependentModule.getIdentities();
- for (IdentitySchemaNode idNode : dependentModuleIdentities) {
- if (idNode.getQName().getLocalName().equals(baseIdentityLocalName)) {
- identity.setBaseIdentity(idNode);
- }
- }
- } else {
- final Set<IdentitySchemaNodeBuilder> dependentModuleIdentities = dependentModuleBuilder
- .getIdentities();
- for (IdentitySchemaNodeBuilder idBuilder : dependentModuleIdentities) {
- if (idBuilder.getQName().getLocalName().equals(baseIdentityLocalName)) {
- identity.setBaseIdentity(idBuilder);
- }
- }
- }
- }
- }
- }
-
- /**
- * Find and add reference of uses target grouping.
- *
- * @param modules
- * all loaded modules
- * @param context
- * SchemaContext containing already resolved modules or null if
- * context is not available
- */
- private void findUsesTargets(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final SchemaContext context) {
- final List<UsesNodeBuilder> allUses = new ArrayList<>();
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
- for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {
- allUses.addAll(inner.getValue().getAllUsesNodes());
- }
- }
- for (UsesNodeBuilder usesNode : allUses) {
- ModuleBuilder module = ParserUtils.getParentModule(usesNode);
- final GroupingBuilder targetGroupingBuilder = GroupingUtils.getTargetGroupingFromModules(usesNode, modules,
- module);
- if (targetGroupingBuilder == null) {
- if (context == null) {
- throw new YangParseException(module.getName(), usesNode.getLine(), "Referenced grouping '"
- + usesNode.getGroupingPathAsString() + "' not found.");
- } else {
- GroupingDefinition targetGroupingDefinition = GroupingUtils.getTargetGroupingFromContext(usesNode,
- module, context);
- usesNode.setGroupingDefinition(targetGroupingDefinition);
- }
- } else {
- usesNode.setGrouping(targetGroupingBuilder);
- }
- }
- }
-
- /**
- * Copy data from uses target, update uses parent and perform refinement.
- * Augmentations have to be resolved already.
- *
- * @param modules
- * all loaded modules
- */
- private void resolveUses(final Map<String, TreeMap<Date, ModuleBuilder>> modules) {
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
- for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {
- ModuleBuilder module = inner.getValue();
- List<UsesNodeBuilder> usesNodes = null;
- boolean dataCollected = module.isAllUsesDataCollected();
-
- while (!dataCollected) {
- usesNodes = new ArrayList<>(module.getAllUsesNodes());
- for (UsesNodeBuilder usesNode : usesNodes) {
- if (!usesNode.isDataCollected()) {
- GroupingUtils.collectUsesData(usesNode);
- }
- }
- dataCollected = module.isAllUsesDataCollected();
- }
- }
- }
-
- // new loop is must because in collecting data process new uses could
- // be created
- final List<UsesNodeBuilder> allModulesUses = new ArrayList<>();
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
- for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {
- allModulesUses.addAll(inner.getValue().getAllUsesNodes());
- }
- }
-
- for (UsesNodeBuilder usesNode : allModulesUses) {
- GroupingUtils.updateUsesParent(usesNode);
- GroupingUtils.performRefine(usesNode);
- }
- for (UsesNodeBuilder usesNode : allModulesUses) {
- GroupingUtils.fixUsesNodesPath(usesNode);
- }
-
- for (UsesNodeBuilder usesNode : allModulesUses) {
- if (usesNode.isCopy()) {
- usesNode.getParent().getUsesNodes().remove(usesNode);
- }
- }
- }
-
- /**
- * Copy data from uses target, update uses parent and perform refinement.
- * Augmentations have to be resolved already.
- *
- * @param modules
- * all loaded modules
- * @param context
- * SchemaContext containing already resolved modules
- */
- private void resolveUsesWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final SchemaContext context) {
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
- for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {
- ModuleBuilder module = inner.getValue();
- List<UsesNodeBuilder> usesNodes = null;
- boolean dataCollected = module.isAllUsesDataCollected();
-
- while (!dataCollected) {
- usesNodes = new ArrayList<>(module.getAllUsesNodes());
- for (UsesNodeBuilder usesNode : usesNodes) {
- if (!usesNode.isDataCollected()) {
- if (usesNode.getGroupingBuilder() == null) {
- GroupingUtils.collectUsesDataFromContext(usesNode);
- } else {
- GroupingUtils.collectUsesData(usesNode);
- }
- }
- }
- dataCollected = module.isAllUsesDataCollected();
- }
- }
- }
-
- // new loop is must because in collecting data process new uses could
- // be created
- final List<UsesNodeBuilder> allModulesUses = new ArrayList<>();
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
- for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {
- allModulesUses.addAll(inner.getValue().getAllUsesNodes());
- }
- }
-
- for (UsesNodeBuilder usesNode : allModulesUses) {
- GroupingUtils.updateUsesParent(usesNode);
- GroupingUtils.performRefine(usesNode);
- }
- for (UsesNodeBuilder usesNode : allModulesUses) {
- GroupingUtils.fixUsesNodesPath(usesNode);
- }
- }
-
- private void resolveUnknownNodes(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {
- for (UnknownSchemaNodeBuilder usnb : module.getAllUnknownNodes()) {
- QName nodeType = usnb.getNodeType();
- try {
- ModuleBuilder dependentModule = findDependentModuleBuilder(modules, module, nodeType.getPrefix(),
- usnb.getLine());
- for (ExtensionBuilder extension : dependentModule.getExtensions()) {
- if (extension.getQName().getLocalName().equals(nodeType.getLocalName())) {
- usnb.setNodeType(extension.getQName());
- usnb.setExtensionBuilder(extension);
- break;
- }
- }
- } catch (YangParseException e) {
- throw new YangParseException(module.getName(), usnb.getLine(), "Failed to resolve node " + usnb
- + ": no such extension definition found.");
- }
- }
- }
-
- private void resolveUnknownNodesWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final ModuleBuilder module, final SchemaContext context) {
- for (UnknownSchemaNodeBuilder usnb : module.getAllUnknownNodes()) {
- QName nodeType = usnb.getNodeType();
- try {
- ModuleBuilder dependentModuleBuilder = findDependentModuleBuilder(modules, module,
- nodeType.getPrefix(), usnb.getLine());
-
- if (dependentModuleBuilder == null) {
- Module dependentModule = findModuleFromContext(context, module, nodeType.getPrefix(),
- usnb.getLine());
- for (ExtensionDefinition e : dependentModule.getExtensionSchemaNodes()) {
- if (e.getQName().getLocalName().equals(nodeType.getLocalName())) {
- usnb.setNodeType(new QName(e.getQName().getNamespace(), e.getQName().getRevision(),
- nodeType.getPrefix(), e.getQName().getLocalName()));
- usnb.setExtensionDefinition(e);
- break;
- }
- }
- } else {
- for (ExtensionBuilder extension : dependentModuleBuilder.getExtensions()) {
- if (extension.getQName().getLocalName().equals(nodeType.getLocalName())) {
- usnb.setExtensionBuilder(extension);
- break;
- }
- }
- }
-
- } catch (YangParseException e) {
- throw new YangParseException(module.getName(), usnb.getLine(), "Failed to resolve node " + usnb
- + ": no such extension definition found.");
- }
-
- }
- }
-
- /**
- * Traverse through modules and resolve their deviation statements.
- *
- * @param modules
- * all loaded modules
- */
- private void resolveDeviations(final Map<String, TreeMap<Date, ModuleBuilder>> modules) {
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
- for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {
- ModuleBuilder b = inner.getValue();
- resolveDeviation(modules, b);
- }
- }
- }
-
- /**
- * Traverse through module and resolve its deviation statements.
- *
- * @param modules
- * all loaded modules
- * @param module
- * module in which resolve deviations
- */
- private void resolveDeviation(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {
- for (DeviationBuilder dev : module.getDeviations()) {
- int line = dev.getLine();
- SchemaPath targetPath = dev.getTargetPath();
- List<QName> path = targetPath.getPath();
- QName q0 = path.get(0);
- String prefix = q0.getPrefix();
- if (prefix == null) {
- prefix = module.getPrefix();
- }
-
- ModuleBuilder dependentModuleBuilder = findDependentModuleBuilder(modules, module, prefix, line);
- processDeviation(dev, dependentModuleBuilder, path, module);
- }
- }
-
- /**
- * Traverse through modules and resolve their deviation statements with
- * given context.
- *
- * @param modules
- * all loaded modules
- * @param context
- * already resolved context
- */
- private void resolveDeviationsWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final SchemaContext context) {
- for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {
- for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {
- ModuleBuilder b = inner.getValue();
- resolveDeviationWithContext(modules, b, context);
- }
- }
- }
-
- /**
- * Traverse through module and resolve its deviation statements with given
- * context.
- *
- * @param modules
- * all loaded modules
- * @param module
- * module in which resolve deviations
- * @param context
- * already resolved context
- */
- private void resolveDeviationWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final ModuleBuilder module, final SchemaContext context) {
- for (DeviationBuilder dev : module.getDeviations()) {
- int line = dev.getLine();
- SchemaPath targetPath = dev.getTargetPath();
- List<QName> path = targetPath.getPath();
- QName q0 = path.get(0);
- String prefix = q0.getPrefix();
- if (prefix == null) {
- prefix = module.getPrefix();
- }
- String name = null;
-
- ModuleBuilder dependentModuleBuilder = findDependentModuleBuilder(modules, module, prefix, line);
- if (dependentModuleBuilder == null) {
- Module dependentModule = findModuleFromContext(context, module, prefix, line);
- Object currentParent = dependentModule;
-
- for (int i = 0; i < path.size(); i++) {
- if (currentParent == null) {
- throw new YangParseException(module.getName(), line, "Failed to find deviation target.");
- }
- QName q = path.get(i);
- name = q.getLocalName();
- if (currentParent instanceof DataNodeContainer) {
- currentParent = ((DataNodeContainer) currentParent).getDataChildByName(name);
- }
- }
-
- if (currentParent == null) {
- throw new YangParseException(module.getName(), line, "Failed to find deviation target.");
- }
- if (currentParent instanceof SchemaNode) {
- dev.setTargetPath(((SchemaNode) currentParent).getPath());
- }
-
- } else {
- processDeviation(dev, dependentModuleBuilder, path, module);
- }
- }
- }
-
- /**
- * Correct deviation target path in deviation builder.
- *
- * @param dev
- * deviation
- * @param dependentModuleBuilder
- * module containing deviation target
- * @param path
- * current deviation target path
- * @param module
- * current module
- */
- private void processDeviation(final DeviationBuilder dev, final ModuleBuilder dependentModuleBuilder,
- final List<QName> path, final ModuleBuilder module) {
- final int line = dev.getLine();
- Builder currentParent = dependentModuleBuilder;
-
- for (int i = 0; i < path.size(); i++) {
- if (currentParent == null) {
- throw new YangParseException(module.getName(), line, "Failed to find deviation target.");
- }
- QName q = path.get(i);
- String name = q.getLocalName();
- if (currentParent instanceof DataNodeContainerBuilder) {
- currentParent = ((DataNodeContainerBuilder) currentParent).getDataChildByName(name);
- }
- }
-
- if (currentParent == null || !(currentParent instanceof SchemaNodeBuilder)) {
- throw new YangParseException(module.getName(), line, "Failed to find deviation target.");
- }
- dev.setTargetPath(((SchemaNodeBuilder) currentParent).getPath());
- }
-
-}
+/*\r
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+package org.opendaylight.yangtools.yang.parser.impl;\r
+\r
+import static org.opendaylight.yangtools.yang.parser.util.ParserUtils.*;\r
+import static org.opendaylight.yangtools.yang.parser.util.TypeUtils.*;\r
+\r
+import java.io.File;\r
+import java.io.FileInputStream;\r
+import java.io.FileNotFoundException;\r
+import java.io.IOException;\r
+import java.io.InputStream;\r
+import java.util.ArrayList;\r
+import java.util.Collections;\r
+import java.util.Date;\r
+import java.util.HashMap;\r
+import java.util.LinkedHashMap;\r
+import java.util.LinkedHashSet;\r
+import java.util.List;\r
+import java.util.Map;\r
+import java.util.Map.Entry;\r
+import java.util.Set;\r
+import java.util.TreeMap;\r
+\r
+import org.antlr.v4.runtime.ANTLRInputStream;\r
+import org.antlr.v4.runtime.CommonTokenStream;\r
+import org.antlr.v4.runtime.tree.ParseTree;\r
+import org.antlr.v4.runtime.tree.ParseTreeWalker;\r
+import org.opendaylight.yangtools.antlrv4.code.gen.YangLexer;\r
+import org.opendaylight.yangtools.antlrv4.code.gen.YangParser;\r
+import org.opendaylight.yangtools.yang.common.QName;\r
+import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;\r
+import org.opendaylight.yangtools.yang.model.api.ExtensionDefinition;\r
+import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;\r
+import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;\r
+import org.opendaylight.yangtools.yang.model.api.Module;\r
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;\r
+import org.opendaylight.yangtools.yang.model.api.SchemaNode;\r
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;\r
+import org.opendaylight.yangtools.yang.model.parser.api.YangModelParser;\r
+import org.opendaylight.yangtools.yang.model.util.IdentityrefType;\r
+import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationSchemaBuilder;\r
+import org.opendaylight.yangtools.yang.parser.builder.api.Builder;\r
+import org.opendaylight.yangtools.yang.parser.builder.api.DataNodeContainerBuilder;\r
+import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;\r
+import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;\r
+import org.opendaylight.yangtools.yang.parser.builder.api.TypeAwareBuilder;\r
+import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;\r
+import org.opendaylight.yangtools.yang.parser.builder.impl.DeviationBuilder;\r
+import org.opendaylight.yangtools.yang.parser.builder.impl.ExtensionBuilder;\r
+import org.opendaylight.yangtools.yang.parser.builder.impl.IdentitySchemaNodeBuilder;\r
+import org.opendaylight.yangtools.yang.parser.builder.impl.IdentityrefTypeBuilder;\r
+import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;\r
+import org.opendaylight.yangtools.yang.parser.builder.impl.UnionTypeBuilder;\r
+import org.opendaylight.yangtools.yang.parser.builder.impl.UnknownSchemaNodeBuilder;\r
+import org.opendaylight.yangtools.yang.parser.util.GroupingUtils;\r
+import org.opendaylight.yangtools.yang.parser.util.ModuleDependencySort;\r
+import org.opendaylight.yangtools.yang.parser.util.ParserUtils;\r
+import org.opendaylight.yangtools.yang.parser.util.YangParseException;\r
+import org.opendaylight.yangtools.yang.validator.YangModelBasicValidator;\r
+import org.slf4j.Logger;\r
+import org.slf4j.LoggerFactory;\r
+\r
+import com.google.common.collect.Lists;\r
+import com.google.common.collect.Maps;\r
+import com.google.common.collect.Sets;\r
+\r
+public final class YangParserImpl implements YangModelParser {\r
+ private static final Logger LOG = LoggerFactory.getLogger(YangParserImpl.class);\r
+\r
+ @Override\r
+ public Set<Module> parseYangModels(final List<File> yangFiles) {\r
+ return Sets.newLinkedHashSet(parseYangModelsMapped(yangFiles).values());\r
+ }\r
+\r
+ @Override\r
+ public Set<Module> parseYangModels(final List<File> yangFiles, final SchemaContext context) {\r
+ if (yangFiles != null) {\r
+ final Map<InputStream, File> inputStreams = Maps.newHashMap();\r
+\r
+ for (final File yangFile : yangFiles) {\r
+ try {\r
+ inputStreams.put(new FileInputStream(yangFile), yangFile);\r
+ } catch (FileNotFoundException e) {\r
+ LOG.warn("Exception while reading yang file: " + yangFile.getName(), e);\r
+ }\r
+ }\r
+\r
+ Map<ModuleBuilder, InputStream> builderToStreamMap = Maps.newHashMap();\r
+\r
+ final Map<String, TreeMap<Date, ModuleBuilder>> modules = resolveModuleBuilders(\r
+ Lists.newArrayList(inputStreams.keySet()), builderToStreamMap);\r
+\r
+ for (InputStream is : inputStreams.keySet()) {\r
+ try {\r
+ is.close();\r
+ } catch (IOException e) {\r
+ LOG.debug("Failed to close stream.");\r
+ }\r
+ }\r
+\r
+ return new LinkedHashSet<Module>(buildWithContext(modules, context).values());\r
+ }\r
+ return Collections.emptySet();\r
+ }\r
+\r
+ @Override\r
+ public Set<Module> parseYangModelsFromStreams(final List<InputStream> yangModelStreams) {\r
+ return Sets.newHashSet(parseYangModelsFromStreamsMapped(yangModelStreams).values());\r
+ }\r
+\r
+ @Override\r
+ public Set<Module> parseYangModelsFromStreams(final List<InputStream> yangModelStreams, SchemaContext context) {\r
+ if (yangModelStreams != null) {\r
+ Map<ModuleBuilder, InputStream> builderToStreamMap = Maps.newHashMap();\r
+ final Map<String, TreeMap<Date, ModuleBuilder>> modules = resolveModuleBuildersWithContext(\r
+ yangModelStreams, builderToStreamMap, context);\r
+ return new LinkedHashSet<Module>(buildWithContext(modules, context).values());\r
+ }\r
+ return Collections.emptySet();\r
+ }\r
+\r
+ @Override\r
+ public Map<File, Module> parseYangModelsMapped(List<File> yangFiles) {\r
+ if (yangFiles != null) {\r
+ final Map<InputStream, File> inputStreams = Maps.newHashMap();\r
+\r
+ for (final File yangFile : yangFiles) {\r
+ try {\r
+ inputStreams.put(new FileInputStream(yangFile), yangFile);\r
+ } catch (FileNotFoundException e) {\r
+ LOG.warn("Exception while reading yang file: " + yangFile.getName(), e);\r
+ }\r
+ }\r
+\r
+ Map<ModuleBuilder, InputStream> builderToStreamMap = Maps.newHashMap();\r
+ final Map<String, TreeMap<Date, ModuleBuilder>> modules = resolveModuleBuilders(\r
+ Lists.newArrayList(inputStreams.keySet()), builderToStreamMap);\r
+\r
+ for (InputStream is : inputStreams.keySet()) {\r
+ try {\r
+ is.close();\r
+ } catch (IOException e) {\r
+ LOG.debug("Failed to close stream.");\r
+ }\r
+ }\r
+\r
+ Map<File, Module> retVal = Maps.newLinkedHashMap();\r
+ Map<ModuleBuilder, Module> builderToModuleMap = build(modules);\r
+\r
+ for (Entry<ModuleBuilder, Module> builderToModule : builderToModuleMap.entrySet()) {\r
+ retVal.put(inputStreams.get(builderToStreamMap.get(builderToModule.getKey())),\r
+ builderToModule.getValue());\r
+ }\r
+\r
+ return retVal;\r
+ }\r
+ return Collections.emptyMap();\r
+ }\r
+\r
+ @Override\r
+ public Map<InputStream, Module> parseYangModelsFromStreamsMapped(final List<InputStream> yangModelStreams) {\r
+ Map<ModuleBuilder, InputStream> builderToStreamMap = Maps.newHashMap();\r
+\r
+ final Map<String, TreeMap<Date, ModuleBuilder>> modules = resolveModuleBuilders(yangModelStreams,\r
+ builderToStreamMap);\r
+ Map<InputStream, Module> retVal = Maps.newLinkedHashMap();\r
+ Map<ModuleBuilder, Module> builderToModuleMap = build(modules);\r
+\r
+ for (Entry<ModuleBuilder, Module> builderToModule : builderToModuleMap.entrySet()) {\r
+ retVal.put(builderToStreamMap.get(builderToModule.getKey()), builderToModule.getValue());\r
+ }\r
+ return retVal;\r
+ }\r
+\r
+ @Override\r
+ public SchemaContext resolveSchemaContext(final Set<Module> modules) {\r
+ return new SchemaContextImpl(modules);\r
+ }\r
+\r
+ private ModuleBuilder[] parseModuleBuilders(List<InputStream> inputStreams,\r
+ Map<ModuleBuilder, InputStream> streamToBuilderMap) {\r
+\r
+ final ParseTreeWalker walker = new ParseTreeWalker();\r
+ final List<ParseTree> trees = parseStreams(inputStreams);\r
+ final ModuleBuilder[] builders = new ModuleBuilder[trees.size()];\r
+\r
+ // validate yang\r
+ new YangModelBasicValidator(walker).validate(trees);\r
+\r
+ YangParserListenerImpl yangModelParser = null;\r
+ for (int i = 0; i < trees.size(); i++) {\r
+ yangModelParser = new YangParserListenerImpl();\r
+ walker.walk(yangModelParser, trees.get(i));\r
+ ModuleBuilder moduleBuilder = yangModelParser.getModuleBuilder();\r
+\r
+ // We expect the order of trees and streams has to be the same\r
+ streamToBuilderMap.put(moduleBuilder, inputStreams.get(i));\r
+ builders[i] = moduleBuilder;\r
+ }\r
+ return builders;\r
+ }\r
+\r
+ private Map<String, TreeMap<Date, ModuleBuilder>> resolveModuleBuilders(final List<InputStream> yangFileStreams,\r
+ Map<ModuleBuilder, InputStream> streamToBuilderMap) {\r
+ return resolveModuleBuildersWithContext(yangFileStreams, streamToBuilderMap, null);\r
+ }\r
+\r
+ private Map<String, TreeMap<Date, ModuleBuilder>> resolveModuleBuildersWithContext(\r
+ final List<InputStream> yangFileStreams, final Map<ModuleBuilder, InputStream> streamToBuilderMap,\r
+ final SchemaContext context) {\r
+ final ModuleBuilder[] builders = parseModuleBuilders(yangFileStreams, streamToBuilderMap);\r
+\r
+ // LinkedHashMap must be used to preserve order\r
+ final LinkedHashMap<String, TreeMap<Date, ModuleBuilder>> modules = new LinkedHashMap<String, TreeMap<Date, ModuleBuilder>>();\r
+\r
+ // module dependency graph sorted\r
+ List<ModuleBuilder> sorted = null;\r
+ if (context == null) {\r
+ sorted = ModuleDependencySort.sort(builders);\r
+ } else {\r
+ sorted = ModuleDependencySort.sortWithContext(context, builders);\r
+ }\r
+\r
+ for (final ModuleBuilder builder : sorted) {\r
+ if (builder == null) {\r
+ continue;\r
+ }\r
+ final String builderName = builder.getName();\r
+ Date builderRevision = builder.getRevision();\r
+ if (builderRevision == null) {\r
+ builderRevision = new Date(0L);\r
+ }\r
+ TreeMap<Date, ModuleBuilder> builderByRevision = modules.get(builderName);\r
+ if (builderByRevision == null) {\r
+ builderByRevision = new TreeMap<Date, ModuleBuilder>();\r
+ }\r
+ builderByRevision.put(builderRevision, builder);\r
+ modules.put(builderName, builderByRevision);\r
+ }\r
+ return modules;\r
+ }\r
+\r
+ private List<ParseTree> parseStreams(final List<InputStream> yangStreams) {\r
+ final List<ParseTree> trees = new ArrayList<ParseTree>();\r
+ for (InputStream yangStream : yangStreams) {\r
+ trees.add(parseStream(yangStream));\r
+ }\r
+ return trees;\r
+ }\r
+\r
+ private ParseTree parseStream(final InputStream yangStream) {\r
+ ParseTree result = null;\r
+ try {\r
+ final ANTLRInputStream input = new ANTLRInputStream(yangStream);\r
+ final YangLexer lexer = new YangLexer(input);\r
+ final CommonTokenStream tokens = new CommonTokenStream(lexer);\r
+ final YangParser parser = new YangParser(tokens);\r
+ parser.removeErrorListeners();\r
+ parser.addErrorListener(new YangErrorListener());\r
+\r
+ result = parser.yang();\r
+ } catch (IOException e) {\r
+ LOG.warn("Exception while reading yang file: " + yangStream, e);\r
+ }\r
+ return result;\r
+ }\r
+\r
+ private Map<ModuleBuilder, Module> build(final Map<String, TreeMap<Date, ModuleBuilder>> modules) {\r
+ // fix unresolved nodes\r
+ findUsesTargets(modules, null);\r
+ resolveDirtyNodes(modules);\r
+ resolveAugments(modules);\r
+ resolveUses(modules);\r
+ resolveDeviations(modules);\r
+\r
+ // build\r
+ final Map<ModuleBuilder, Module> result = new LinkedHashMap<ModuleBuilder, Module>();\r
+ for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {\r
+ final Map<Date, Module> modulesByRevision = new HashMap<Date, Module>();\r
+ for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue().entrySet()) {\r
+ final ModuleBuilder moduleBuilder = childEntry.getValue();\r
+ final Module module = moduleBuilder.build();\r
+ modulesByRevision.put(childEntry.getKey(), module);\r
+ result.put(moduleBuilder, module);\r
+ }\r
+ }\r
+ return result;\r
+ }\r
+\r
+ private Map<ModuleBuilder, Module> buildWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,\r
+ final SchemaContext context) {\r
+ // fix unresolved nodes\r
+ findUsesTargets(modules, context);\r
+ resolvedDirtyNodesWithContext(modules, context);\r
+ resolveAugmentsWithContext(modules, context);\r
+ resolveUsesWithContext(modules, context);\r
+ resolveDeviationsWithContext(modules, context);\r
+\r
+ // build\r
+ final Map<ModuleBuilder, Module> result = new LinkedHashMap<ModuleBuilder, Module>();\r
+ for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {\r
+ final Map<Date, Module> modulesByRevision = new HashMap<Date, Module>();\r
+ for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue().entrySet()) {\r
+ final ModuleBuilder moduleBuilder = childEntry.getValue();\r
+ final Module module = moduleBuilder.build();\r
+ modulesByRevision.put(childEntry.getKey(), module);\r
+ result.put(moduleBuilder, module);\r
+ }\r
+ }\r
+ return result;\r
+ }\r
+\r
+ private void resolveDirtyNodes(final Map<String, TreeMap<Date, ModuleBuilder>> modules) {\r
+ for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {\r
+ for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue().entrySet()) {\r
+ final ModuleBuilder module = childEntry.getValue();\r
+ resolveDirtyNodes(modules, module);\r
+ resolveIdentities(modules, module);\r
+ resolveUnknownNodes(modules, module);\r
+ }\r
+ }\r
+ }\r
+\r
+ private void resolvedDirtyNodesWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,\r
+ final SchemaContext context) {\r
+ for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {\r
+ for (Map.Entry<Date, ModuleBuilder> childEntry : entry.getValue().entrySet()) {\r
+ final ModuleBuilder module = childEntry.getValue();\r
+ resolveDirtyNodesWithContext(modules, module, context);\r
+ resolveIdentitiesWithContext(modules, module, context);\r
+ resolveUnknownNodesWithContext(modules, module, context);\r
+ }\r
+ }\r
+ }\r
+\r
+ /**\r
+ * Search for dirty nodes (node which contains UnknownType) and resolve\r
+ * unknown types.\r
+ *\r
+ * @param modules\r
+ * all available modules\r
+ * @param module\r
+ * current module\r
+ */\r
+ private void resolveDirtyNodes(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {\r
+ final Set<TypeAwareBuilder> dirtyNodes = module.getDirtyNodes();\r
+ if (!dirtyNodes.isEmpty()) {\r
+ for (TypeAwareBuilder nodeToResolve : dirtyNodes) {\r
+ if (nodeToResolve instanceof UnionTypeBuilder) {\r
+ // special handling for union types\r
+ resolveTypeUnion((UnionTypeBuilder) nodeToResolve, modules, module);\r
+ } else if (nodeToResolve.getTypedef() instanceof IdentityrefTypeBuilder) {\r
+ // special handling for identityref types\r
+ IdentityrefTypeBuilder idref = (IdentityrefTypeBuilder) nodeToResolve.getTypedef();\r
+ nodeToResolve.setType(new IdentityrefType(findFullQName(modules, module, idref), idref.getPath()));\r
+ } else {\r
+ resolveType(nodeToResolve, modules, module);\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ private void resolveDirtyNodesWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,\r
+ final ModuleBuilder module, SchemaContext context) {\r
+ final Set<TypeAwareBuilder> dirtyNodes = module.getDirtyNodes();\r
+ if (!dirtyNodes.isEmpty()) {\r
+ for (TypeAwareBuilder nodeToResolve : dirtyNodes) {\r
+ if (nodeToResolve instanceof UnionTypeBuilder) {\r
+ // special handling for union types\r
+ resolveTypeUnionWithContext((UnionTypeBuilder) nodeToResolve, modules, module, context);\r
+ } else if (nodeToResolve.getTypedef() instanceof IdentityrefTypeBuilder) {\r
+ // special handling for identityref types\r
+ IdentityrefTypeBuilder idref = (IdentityrefTypeBuilder) nodeToResolve.getTypedef();\r
+ nodeToResolve.setType(new IdentityrefType(findFullQName(modules, module, idref), idref.getPath()));\r
+ } else {\r
+ resolveTypeWithContext(nodeToResolve, modules, module, context);\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ /**\r
+ * Go through all augment definitions and perform augmentation. It is\r
+ * expected that modules are already sorted by their dependencies.\r
+ *\r
+ * @param modules\r
+ * all loaded modules\r
+ */\r
+ private void resolveAugments(final Map<String, TreeMap<Date, ModuleBuilder>> modules) {\r
+ // collect augments from all loaded modules\r
+ final List<AugmentationSchemaBuilder> allAugments = new ArrayList<>();\r
+ for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {\r
+ for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {\r
+ allAugments.addAll(inner.getValue().getAllAugments());\r
+ }\r
+ }\r
+\r
+ for (int i = 0; i < allAugments.size(); i++) {\r
+ // pick one augment\r
+ final AugmentationSchemaBuilder augment = allAugments.get(i);\r
+ // create collection of others\r
+ List<AugmentationSchemaBuilder> others = new ArrayList<>(allAugments);\r
+ others.remove(augment);\r
+\r
+ // try to resolve it\r
+ boolean resolved = resolveAugment(modules, augment);\r
+ // while not resolved\r
+ int j = 0;\r
+ while (!(resolved) && j < others.size()) {\r
+ // try to resolve next augment\r
+ resolveAugment(modules, others.get(j));\r
+ // then try to resolve first again\r
+ resolved = resolveAugment(modules, augment);\r
+ j++;\r
+\r
+ }\r
+\r
+ if (!resolved) {\r
+ throw new YangParseException(augment.getModuleName(), augment.getLine(),\r
+ "Error in augment parsing: failed to find augment target");\r
+ }\r
+ }\r
+ }\r
+\r
+ /**\r
+ * Search for augment target and perform augmentation.\r
+ *\r
+ * @param modules\r
+ * all loaded modules\r
+ * @param augmentBuilder\r
+ * augment to resolve\r
+ * @return true if target node found, false otherwise\r
+ */\r
+ private boolean resolveAugment(final Map<String, TreeMap<Date, ModuleBuilder>> modules,\r
+ final AugmentationSchemaBuilder augmentBuilder) {\r
+ if (augmentBuilder.isResolved()) {\r
+ return true;\r
+ }\r
+\r
+ int line = augmentBuilder.getLine();\r
+ ModuleBuilder module = getParentModule(augmentBuilder);\r
+ List<QName> path = augmentBuilder.getTargetPath().getPath();\r
+ Builder augmentParent = augmentBuilder.getParent();\r
+\r
+ Builder firstNodeParent = null;\r
+ if (augmentParent instanceof ModuleBuilder) {\r
+ // if augment is defined under module, parent of first node is\r
+ // target module\r
+ final QName firstNameInPath = path.get(0);\r
+ String prefix = firstNameInPath.getPrefix();\r
+ if (prefix == null) {\r
+ prefix = module.getPrefix();\r
+ }\r
+ firstNodeParent = findDependentModuleBuilder(modules, module, prefix, line);\r
+ } else if (augmentParent instanceof UsesNodeBuilder) {\r
+ firstNodeParent = augmentParent.getParent();\r
+ } else {\r
+ // augment can be defined only under module or uses\r
+ throw new YangParseException(augmentBuilder.getModuleName(), line,\r
+ "Failed to parse augment: Unresolved parent of augment: " + augmentParent);\r
+ }\r
+\r
+ return processAugmentation(augmentBuilder, firstNodeParent, path);\r
+ }\r
+\r
+ /**\r
+ * Go through all augment definitions and resolve them. This method works in\r
+ * same way as {@link #resolveAugments(Map)} except that if target node is\r
+ * not found in loaded modules, it search for target node in given context.\r
+ *\r
+ * @param modules\r
+ * all loaded modules\r
+ * @param context\r
+ * SchemaContext containing already resolved modules\r
+ */\r
+ private void resolveAugmentsWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,\r
+ final SchemaContext context) {\r
+ // collect augments from all loaded modules\r
+ final List<AugmentationSchemaBuilder> allAugments = new ArrayList<>();\r
+ for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {\r
+ for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {\r
+ allAugments.addAll(inner.getValue().getAllAugments());\r
+ }\r
+ }\r
+\r
+ for (int i = 0; i < allAugments.size(); i++) {\r
+ // pick augment from list\r
+ final AugmentationSchemaBuilder augment = allAugments.get(i);\r
+ // try to resolve it\r
+ boolean resolved = resolveAugmentWithContext(modules, augment, context);\r
+ // while not resolved\r
+ int j = i + 1;\r
+ while (!(resolved) && j < allAugments.size()) {\r
+ // try to resolve next augment\r
+ resolveAugmentWithContext(modules, allAugments.get(j), context);\r
+ // then try to resolve first again\r
+ resolved = resolveAugmentWithContext(modules, augment, context);\r
+ j++;\r
+ }\r
+\r
+ if (!resolved) {\r
+ throw new YangParseException(augment.getModuleName(), augment.getLine(),\r
+ "Error in augment parsing: failed to find augment target");\r
+ }\r
+ }\r
+ }\r
+\r
+ /**\r
+ * Search for augment target and perform augmentation.\r
+ *\r
+ * @param modules\r
+ * all loaded modules\r
+ * @param augment\r
+ * augment to resolve\r
+ * @param context\r
+ * SchemaContext containing already resolved modules\r
+ * @return true if target node found, false otherwise\r
+ */\r
+ private boolean resolveAugmentWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,\r
+ final AugmentationSchemaBuilder augment, final SchemaContext context) {\r
+ if (augment.isResolved()) {\r
+ return true;\r
+ }\r
+ int line = augment.getLine();\r
+ ModuleBuilder module = getParentModule(augment);\r
+ List<QName> path = augment.getTargetPath().getPath();\r
+ final QName firstNameInPath = path.get(0);\r
+ String prefix = firstNameInPath.getPrefix();\r
+ if (prefix == null) {\r
+ prefix = module.getPrefix();\r
+ }\r
+ Builder augmentParent = augment.getParent();\r
+ Builder currentParent = null;\r
+\r
+ if (augmentParent instanceof ModuleBuilder) {\r
+ // if augment is defined under module, first parent is target module\r
+ currentParent = findDependentModuleBuilder(modules, module, prefix, line);\r
+ } else if (augmentParent instanceof UsesNodeBuilder) {\r
+ currentParent = augmentParent.getParent();\r
+ } else {\r
+ // augment can be defined only under module or uses\r
+ throw new YangParseException(augment.getModuleName(), augment.getLine(),\r
+ "Error in augment parsing: Unresolved parent of augment: " + augmentParent);\r
+ }\r
+\r
+ if (currentParent == null) {\r
+ return processAugmentationOnContext(augment, path, module, prefix, context);\r
+ } else {\r
+ return processAugmentation(augment, currentParent, path);\r
+ }\r
+ }\r
+\r
+ /**\r
+ * Go through identity statements defined in current module and resolve\r
+ * their 'base' statement if present.\r
+ *\r
+ * @param modules\r
+ * all modules\r
+ * @param module\r
+ * module being resolved\r
+ */\r
+ private void resolveIdentities(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {\r
+ final Set<IdentitySchemaNodeBuilder> identities = module.getIdentities();\r
+ for (IdentitySchemaNodeBuilder identity : identities) {\r
+ final String baseIdentityName = identity.getBaseIdentityName();\r
+ if (baseIdentityName != null) {\r
+ String baseIdentityPrefix = null;\r
+ String baseIdentityLocalName = null;\r
+ if (baseIdentityName.contains(":")) {\r
+ final String[] splitted = baseIdentityName.split(":");\r
+ baseIdentityPrefix = splitted[0];\r
+ baseIdentityLocalName = splitted[1];\r
+ } else {\r
+ baseIdentityPrefix = module.getPrefix();\r
+ baseIdentityLocalName = baseIdentityName;\r
+ }\r
+ final ModuleBuilder dependentModule = findDependentModuleBuilder(modules, module, baseIdentityPrefix,\r
+ identity.getLine());\r
+\r
+ final Set<IdentitySchemaNodeBuilder> dependentModuleIdentities = dependentModule.getIdentities();\r
+ for (IdentitySchemaNodeBuilder idBuilder : dependentModuleIdentities) {\r
+ if (idBuilder.getQName().getLocalName().equals(baseIdentityLocalName)) {\r
+ identity.setBaseIdentity(idBuilder);\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ /**\r
+ * Go through identity statements defined in current module and resolve\r
+ * their 'base' statement. Method tries to find base identity in given\r
+ * modules. If base identity is not found, method will search it in context.\r
+ *\r
+ * @param modules\r
+ * all loaded modules\r
+ * @param module\r
+ * current module\r
+ * @param context\r
+ * SchemaContext containing already resolved modules\r
+ */\r
+ private void resolveIdentitiesWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,\r
+ final ModuleBuilder module, final SchemaContext context) {\r
+ final Set<IdentitySchemaNodeBuilder> identities = module.getIdentities();\r
+ for (IdentitySchemaNodeBuilder identity : identities) {\r
+ final String baseIdentityName = identity.getBaseIdentityName();\r
+ if (baseIdentityName != null) {\r
+ String baseIdentityPrefix = null;\r
+ String baseIdentityLocalName = null;\r
+ if (baseIdentityName.contains(":")) {\r
+ final String[] splitted = baseIdentityName.split(":");\r
+ baseIdentityPrefix = splitted[0];\r
+ baseIdentityLocalName = splitted[1];\r
+ } else {\r
+ baseIdentityPrefix = module.getPrefix();\r
+ baseIdentityLocalName = baseIdentityName;\r
+ }\r
+ final ModuleBuilder dependentModuleBuilder = findDependentModuleBuilder(modules, module,\r
+ baseIdentityPrefix, identity.getLine());\r
+\r
+ if (dependentModuleBuilder == null) {\r
+ final Module dependentModule = findModuleFromContext(context, module, baseIdentityPrefix,\r
+ identity.getLine());\r
+ final Set<IdentitySchemaNode> dependentModuleIdentities = dependentModule.getIdentities();\r
+ for (IdentitySchemaNode idNode : dependentModuleIdentities) {\r
+ if (idNode.getQName().getLocalName().equals(baseIdentityLocalName)) {\r
+ identity.setBaseIdentity(idNode);\r
+ }\r
+ }\r
+ } else {\r
+ final Set<IdentitySchemaNodeBuilder> dependentModuleIdentities = dependentModuleBuilder\r
+ .getIdentities();\r
+ for (IdentitySchemaNodeBuilder idBuilder : dependentModuleIdentities) {\r
+ if (idBuilder.getQName().getLocalName().equals(baseIdentityLocalName)) {\r
+ identity.setBaseIdentity(idBuilder);\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ /**\r
+ * Find and add reference of uses target grouping.\r
+ *\r
+ * @param modules\r
+ * all loaded modules\r
+ * @param context\r
+ * SchemaContext containing already resolved modules or null if\r
+ * context is not available\r
+ */\r
+ private void findUsesTargets(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final SchemaContext context) {\r
+ final List<UsesNodeBuilder> allUses = new ArrayList<>();\r
+ for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {\r
+ for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {\r
+ allUses.addAll(inner.getValue().getAllUsesNodes());\r
+ }\r
+ }\r
+ for (UsesNodeBuilder usesNode : allUses) {\r
+ ModuleBuilder module = ParserUtils.getParentModule(usesNode);\r
+ final GroupingBuilder targetGroupingBuilder = GroupingUtils.getTargetGroupingFromModules(usesNode, modules,\r
+ module);\r
+ if (targetGroupingBuilder == null) {\r
+ if (context == null) {\r
+ throw new YangParseException(module.getName(), usesNode.getLine(), "Referenced grouping '"\r
+ + usesNode.getGroupingPathAsString() + "' not found.");\r
+ } else {\r
+ GroupingDefinition targetGroupingDefinition = GroupingUtils.getTargetGroupingFromContext(usesNode,\r
+ module, context);\r
+ usesNode.setGroupingDefinition(targetGroupingDefinition);\r
+ }\r
+ } else {\r
+ usesNode.setGrouping(targetGroupingBuilder);\r
+ }\r
+ }\r
+ }\r
+\r
+ /**\r
+ * Copy data from uses target, update uses parent and perform refinement.\r
+ * Augmentations have to be resolved already.\r
+ *\r
+ * @param modules\r
+ * all loaded modules\r
+ */\r
+ private void resolveUses(final Map<String, TreeMap<Date, ModuleBuilder>> modules) {\r
+ for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {\r
+ for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {\r
+ ModuleBuilder module = inner.getValue();\r
+ List<UsesNodeBuilder> usesNodes = null;\r
+ boolean dataCollected = module.isAllUsesDataCollected();\r
+\r
+ while (!dataCollected) {\r
+ usesNodes = new ArrayList<>(module.getAllUsesNodes());\r
+ for (UsesNodeBuilder usesNode : usesNodes) {\r
+ if (!usesNode.isDataCollected()) {\r
+ GroupingUtils.collectUsesData(usesNode);\r
+ }\r
+ }\r
+ dataCollected = module.isAllUsesDataCollected();\r
+ }\r
+ }\r
+ }\r
+\r
+ // new loop is must because in collecting data process new uses could\r
+ // be created\r
+ final List<UsesNodeBuilder> allModulesUses = new ArrayList<>();\r
+ for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {\r
+ for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {\r
+ allModulesUses.addAll(inner.getValue().getAllUsesNodes());\r
+ }\r
+ }\r
+\r
+ for (UsesNodeBuilder usesNode : allModulesUses) {\r
+ GroupingUtils.updateUsesParent(usesNode);\r
+ GroupingUtils.performRefine(usesNode);\r
+ }\r
+ for (UsesNodeBuilder usesNode : allModulesUses) {\r
+ GroupingUtils.fixUsesNodesPath(usesNode);\r
+ }\r
+\r
+ for (UsesNodeBuilder usesNode : allModulesUses) {\r
+ if (usesNode.isCopy()) {\r
+ usesNode.getParent().getUsesNodes().remove(usesNode);\r
+ }\r
+ }\r
+ }\r
+\r
+ /**\r
+ * Copy data from uses target, update uses parent and perform refinement.\r
+ * Augmentations have to be resolved already.\r
+ *\r
+ * @param modules\r
+ * all loaded modules\r
+ * @param context\r
+ * SchemaContext containing already resolved modules\r
+ */\r
+ private void resolveUsesWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,\r
+ final SchemaContext context) {\r
+ for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {\r
+ for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {\r
+ ModuleBuilder module = inner.getValue();\r
+ List<UsesNodeBuilder> usesNodes = null;\r
+ boolean dataCollected = module.isAllUsesDataCollected();\r
+\r
+ while (!dataCollected) {\r
+ usesNodes = new ArrayList<>(module.getAllUsesNodes());\r
+ for (UsesNodeBuilder usesNode : usesNodes) {\r
+ if (!usesNode.isDataCollected()) {\r
+ if (usesNode.getGroupingBuilder() == null) {\r
+ GroupingUtils.collectUsesDataFromContext(usesNode);\r
+ } else {\r
+ GroupingUtils.collectUsesData(usesNode);\r
+ }\r
+ }\r
+ }\r
+ dataCollected = module.isAllUsesDataCollected();\r
+ }\r
+ }\r
+ }\r
+\r
+ // new loop is must because in collecting data process new uses could\r
+ // be created\r
+ final List<UsesNodeBuilder> allModulesUses = new ArrayList<>();\r
+ for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {\r
+ for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {\r
+ allModulesUses.addAll(inner.getValue().getAllUsesNodes());\r
+ }\r
+ }\r
+\r
+ for (UsesNodeBuilder usesNode : allModulesUses) {\r
+ GroupingUtils.updateUsesParent(usesNode);\r
+ GroupingUtils.performRefine(usesNode);\r
+ }\r
+ for (UsesNodeBuilder usesNode : allModulesUses) {\r
+ GroupingUtils.fixUsesNodesPath(usesNode);\r
+ }\r
+ }\r
+\r
+ private void resolveUnknownNodes(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {\r
+ for (UnknownSchemaNodeBuilder usnb : module.getAllUnknownNodes()) {\r
+ QName nodeType = usnb.getNodeType();\r
+ try {\r
+ ModuleBuilder dependentModule = findDependentModuleBuilder(modules, module, nodeType.getPrefix(),\r
+ usnb.getLine());\r
+ for (ExtensionBuilder extension : dependentModule.getExtensions()) {\r
+ if (extension.getQName().getLocalName().equals(nodeType.getLocalName())) {\r
+ usnb.setNodeType(extension.getQName());\r
+ usnb.setExtensionBuilder(extension);\r
+ break;\r
+ }\r
+ }\r
+ } catch (YangParseException e) {\r
+ throw new YangParseException(module.getName(), usnb.getLine(), "Failed to resolve node " + usnb\r
+ + ": no such extension definition found.");\r
+ }\r
+ }\r
+ }\r
+\r
+ private void resolveUnknownNodesWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,\r
+ final ModuleBuilder module, final SchemaContext context) {\r
+ for (UnknownSchemaNodeBuilder usnb : module.getAllUnknownNodes()) {\r
+ QName nodeType = usnb.getNodeType();\r
+ try {\r
+ ModuleBuilder dependentModuleBuilder = findDependentModuleBuilder(modules, module,\r
+ nodeType.getPrefix(), usnb.getLine());\r
+\r
+ if (dependentModuleBuilder == null) {\r
+ Module dependentModule = findModuleFromContext(context, module, nodeType.getPrefix(),\r
+ usnb.getLine());\r
+ for (ExtensionDefinition e : dependentModule.getExtensionSchemaNodes()) {\r
+ if (e.getQName().getLocalName().equals(nodeType.getLocalName())) {\r
+ usnb.setNodeType(new QName(e.getQName().getNamespace(), e.getQName().getRevision(),\r
+ nodeType.getPrefix(), e.getQName().getLocalName()));\r
+ usnb.setExtensionDefinition(e);\r
+ break;\r
+ }\r
+ }\r
+ } else {\r
+ for (ExtensionBuilder extension : dependentModuleBuilder.getExtensions()) {\r
+ if (extension.getQName().getLocalName().equals(nodeType.getLocalName())) {\r
+ usnb.setExtensionBuilder(extension);\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+ } catch (YangParseException e) {\r
+ throw new YangParseException(module.getName(), usnb.getLine(), "Failed to resolve node " + usnb\r
+ + ": no such extension definition found.");\r
+ }\r
+\r
+ }\r
+ }\r
+\r
+ /**\r
+ * Traverse through modules and resolve their deviation statements.\r
+ *\r
+ * @param modules\r
+ * all loaded modules\r
+ */\r
+ private void resolveDeviations(final Map<String, TreeMap<Date, ModuleBuilder>> modules) {\r
+ for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {\r
+ for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {\r
+ ModuleBuilder b = inner.getValue();\r
+ resolveDeviation(modules, b);\r
+ }\r
+ }\r
+ }\r
+\r
+ /**\r
+ * Traverse through module and resolve its deviation statements.\r
+ *\r
+ * @param modules\r
+ * all loaded modules\r
+ * @param module\r
+ * module in which resolve deviations\r
+ */\r
+ private void resolveDeviation(final Map<String, TreeMap<Date, ModuleBuilder>> modules, final ModuleBuilder module) {\r
+ for (DeviationBuilder dev : module.getDeviations()) {\r
+ int line = dev.getLine();\r
+ SchemaPath targetPath = dev.getTargetPath();\r
+ List<QName> path = targetPath.getPath();\r
+ QName q0 = path.get(0);\r
+ String prefix = q0.getPrefix();\r
+ if (prefix == null) {\r
+ prefix = module.getPrefix();\r
+ }\r
+\r
+ ModuleBuilder dependentModuleBuilder = findDependentModuleBuilder(modules, module, prefix, line);\r
+ processDeviation(dev, dependentModuleBuilder, path, module);\r
+ }\r
+ }\r
+\r
+ /**\r
+ * Traverse through modules and resolve their deviation statements with\r
+ * given context.\r
+ *\r
+ * @param modules\r
+ * all loaded modules\r
+ * @param context\r
+ * already resolved context\r
+ */\r
+ private void resolveDeviationsWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,\r
+ final SchemaContext context) {\r
+ for (Map.Entry<String, TreeMap<Date, ModuleBuilder>> entry : modules.entrySet()) {\r
+ for (Map.Entry<Date, ModuleBuilder> inner : entry.getValue().entrySet()) {\r
+ ModuleBuilder b = inner.getValue();\r
+ resolveDeviationWithContext(modules, b, context);\r
+ }\r
+ }\r
+ }\r
+\r
+ /**\r
+ * Traverse through module and resolve its deviation statements with given\r
+ * context.\r
+ *\r
+ * @param modules\r
+ * all loaded modules\r
+ * @param module\r
+ * module in which resolve deviations\r
+ * @param context\r
+ * already resolved context\r
+ */\r
+ private void resolveDeviationWithContext(final Map<String, TreeMap<Date, ModuleBuilder>> modules,\r
+ final ModuleBuilder module, final SchemaContext context) {\r
+ for (DeviationBuilder dev : module.getDeviations()) {\r
+ int line = dev.getLine();\r
+ SchemaPath targetPath = dev.getTargetPath();\r
+ List<QName> path = targetPath.getPath();\r
+ QName q0 = path.get(0);\r
+ String prefix = q0.getPrefix();\r
+ if (prefix == null) {\r
+ prefix = module.getPrefix();\r
+ }\r
+ String name = null;\r
+\r
+ ModuleBuilder dependentModuleBuilder = findDependentModuleBuilder(modules, module, prefix, line);\r
+ if (dependentModuleBuilder == null) {\r
+ Module dependentModule = findModuleFromContext(context, module, prefix, line);\r
+ Object currentParent = dependentModule;\r
+\r
+ for (int i = 0; i < path.size(); i++) {\r
+ if (currentParent == null) {\r
+ throw new YangParseException(module.getName(), line, "Failed to find deviation target.");\r
+ }\r
+ QName q = path.get(i);\r
+ name = q.getLocalName();\r
+ if (currentParent instanceof DataNodeContainer) {\r
+ currentParent = ((DataNodeContainer) currentParent).getDataChildByName(name);\r
+ }\r
+ }\r
+\r
+ if (currentParent == null) {\r
+ throw new YangParseException(module.getName(), line, "Failed to find deviation target.");\r
+ }\r
+ if (currentParent instanceof SchemaNode) {\r
+ dev.setTargetPath(((SchemaNode) currentParent).getPath());\r
+ }\r
+\r
+ } else {\r
+ processDeviation(dev, dependentModuleBuilder, path, module);\r
+ }\r
+ }\r
+ }\r
+\r
+ /**\r
+ * Correct deviation target path in deviation builder.\r
+ *\r
+ * @param dev\r
+ * deviation\r
+ * @param dependentModuleBuilder\r
+ * module containing deviation target\r
+ * @param path\r
+ * current deviation target path\r
+ * @param module\r
+ * current module\r
+ */\r
+ private void processDeviation(final DeviationBuilder dev, final ModuleBuilder dependentModuleBuilder,\r
+ final List<QName> path, final ModuleBuilder module) {\r
+ final int line = dev.getLine();\r
+ Builder currentParent = dependentModuleBuilder;\r
+\r
+ for (int i = 0; i < path.size(); i++) {\r
+ if (currentParent == null) {\r
+ throw new YangParseException(module.getName(), line, "Failed to find deviation target.");\r
+ }\r
+ QName q = path.get(i);\r
+ String name = q.getLocalName();\r
+ if (currentParent instanceof DataNodeContainerBuilder) {\r
+ currentParent = ((DataNodeContainerBuilder) currentParent).getDataChildByName(name);\r
+ }\r
+ }\r
+\r
+ if (currentParent == null || !(currentParent instanceof SchemaNodeBuilder)) {\r
+ throw new YangParseException(module.getName(), line, "Failed to find deviation target.");\r
+ }\r
+ dev.setTargetPath(((SchemaNodeBuilder) currentParent).getPath());\r
+ }\r
+\r
+}\r
+++ /dev/null
-/*
- * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.yangtools.yang.parser.util;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Date;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeMap;
-
-import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
-import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
-import org.opendaylight.yangtools.yang.model.api.Module;
-import org.opendaylight.yangtools.yang.model.api.ModuleImport;
-import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
-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.parser.builder.api.AugmentationSchemaBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationTargetBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
-import org.opendaylight.yangtools.yang.parser.builder.api.DataNodeContainerBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.GroupingBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder.ChoiceNodeImpl;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceCaseBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceCaseBuilder.ChoiceCaseNodeImpl;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ContainerSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ContainerSchemaNodeBuilder.ContainerSchemaNodeImpl;
-import org.opendaylight.yangtools.yang.parser.builder.impl.IdentityrefTypeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ListSchemaNodeBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ListSchemaNodeBuilder.ListSchemaNodeImpl;
-import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.NotificationBuilder;
-import org.opendaylight.yangtools.yang.parser.builder.impl.NotificationBuilder.NotificationDefinitionImpl;
-
-public final class ParserUtils {
-
- private ParserUtils() {
- }
-
- /**
- * Create new SchemaPath from given path and qname.
- *
- * @param schemaPath
- * @param qname
- * @return
- */
- public static SchemaPath createSchemaPath(SchemaPath schemaPath, QName... qname) {
- List<QName> path = new ArrayList<>(schemaPath.getPath());
- path.addAll(Arrays.asList(qname));
- return new SchemaPath(path, schemaPath.isAbsolute());
- }
-
- /**
- * Get module import referenced by given prefix.
- *
- * @param builder
- * module to search
- * @param prefix
- * prefix associated with import
- * @return ModuleImport based on given prefix
- */
- public static ModuleImport getModuleImport(final ModuleBuilder builder, final String prefix) {
- ModuleImport moduleImport = null;
- for (ModuleImport mi : builder.getModuleImports()) {
- if (mi.getPrefix().equals(prefix)) {
- moduleImport = mi;
- break;
- }
- }
- return moduleImport;
- }
-
- /**
- * Find dependent module based on given prefix
- *
- * @param modules
- * all available modules
- * @param module
- * current module
- * @param prefix
- * target module prefix
- * @param line
- * current line in yang model
- * @return module builder if found, null otherwise
- */
- public static ModuleBuilder findDependentModuleBuilder(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final ModuleBuilder module, final String prefix, final int line) {
- ModuleBuilder dependentModule = null;
- Date dependentModuleRevision = null;
-
- if (prefix.equals(module.getPrefix())) {
- dependentModule = module;
- } else {
- final ModuleImport dependentModuleImport = getModuleImport(module, prefix);
- if (dependentModuleImport == null) {
- throw new YangParseException(module.getName(), line, "No import found with prefix '" + prefix + "'.");
- }
- final String dependentModuleName = dependentModuleImport.getModuleName();
- dependentModuleRevision = dependentModuleImport.getRevision();
-
- final TreeMap<Date, ModuleBuilder> moduleBuildersByRevision = modules.get(dependentModuleName);
- if (moduleBuildersByRevision == null) {
- return null;
- }
- if (dependentModuleRevision == null) {
- dependentModule = moduleBuildersByRevision.lastEntry().getValue();
- } else {
- dependentModule = moduleBuildersByRevision.get(dependentModuleRevision);
- }
- }
- return dependentModule;
- }
-
- /**
- * Find module from context based on prefix.
- *
- * @param context
- * schema context
- * @param currentModule
- * current module
- * @param prefix
- * current prefix used to reference dependent module
- * @param line
- * current line in yang model
- * @return module based on given prefix if found in context, null otherwise
- */
- public static Module findModuleFromContext(final SchemaContext context, final ModuleBuilder currentModule,
- final String prefix, final int line) {
- TreeMap<Date, Module> modulesByRevision = new TreeMap<Date, Module>();
-
- final ModuleImport dependentModuleImport = ParserUtils.getModuleImport(currentModule, prefix);
- if (dependentModuleImport == null) {
- throw new YangParseException(currentModule.getName(), line, "No import found with prefix '" + prefix + "'.");
- }
- final String dependentModuleName = dependentModuleImport.getModuleName();
- final Date dependentModuleRevision = dependentModuleImport.getRevision();
-
- for (Module contextModule : context.getModules()) {
- if (contextModule.getName().equals(dependentModuleName)) {
- Date revision = contextModule.getRevision();
- if (revision == null) {
- revision = new Date(0L);
- }
- modulesByRevision.put(revision, contextModule);
- break;
- }
- }
-
- Module result = null;
- if (dependentModuleRevision == null) {
- result = modulesByRevision.get(modulesByRevision.firstKey());
- } else {
- result = modulesByRevision.get(dependentModuleRevision);
- }
-
- return result;
- }
-
- /**
- * Parse XPath string.
- *
- * @param xpathString
- * as String
- * @return SchemaPath from given String
- */
- public static SchemaPath parseXPathString(final String xpathString) {
- final boolean absolute = xpathString.startsWith("/");
- final String[] splittedPath = xpathString.split("/");
- final List<QName> path = new ArrayList<QName>();
- QName name;
- for (String pathElement : splittedPath) {
- if (pathElement.length() > 0) {
- final String[] splittedElement = pathElement.split(":");
- if (splittedElement.length == 1) {
- name = new QName(null, null, null, splittedElement[0]);
- } else {
- name = new QName(null, null, splittedElement[0], splittedElement[1]);
- }
- path.add(name);
- }
- }
- return new SchemaPath(path, absolute);
- }
-
- /**
- * Add all augment's child nodes to given target.
- *
- * @param augment
- * builder of augment statement
- * @param target
- * augmentation target node
- */
- public static void fillAugmentTarget(final AugmentationSchemaBuilder augment, final DataNodeContainerBuilder target) {
- for (DataSchemaNodeBuilder child : augment.getChildNodeBuilders()) {
- DataSchemaNodeBuilder childCopy = CopyUtils.copy(child, target, false);
- childCopy.setAugmenting(true);
- correctNodePath(child, target.getPath());
- correctNodePath(childCopy, target.getPath());
- try {
- target.addChildNode(childCopy);
- } catch (YangParseException e) {
- // more descriptive message
- throw new YangParseException(augment.getModuleName(), augment.getLine(),
- "Failed to perform augmentation: " + e.getMessage());
- }
-
- }
- for (UsesNodeBuilder usesNode : augment.getUsesNodes()) {
- UsesNodeBuilder copy = CopyUtils.copyUses(usesNode, target);
- target.addUsesNode(copy);
- }
- }
-
- /**
- * Add all augment's child nodes to given target.
- *
- * @param augment
- * builder of augment statement
- * @param target
- * augmentation target choice node
- */
- public static void fillAugmentTarget(final AugmentationSchemaBuilder augment, final ChoiceBuilder target) {
- for (DataSchemaNodeBuilder builder : augment.getChildNodeBuilders()) {
- DataSchemaNodeBuilder childCopy = CopyUtils.copy(builder, target, false);
- childCopy.setAugmenting(true);
- correctNodePath(builder, target.getPath());
- correctNodePath(childCopy, target.getPath());
- target.addCase(childCopy);
- }
- for (UsesNodeBuilder usesNode : augment.getUsesNodes()) {
- if (usesNode != null) {
- throw new YangParseException(augment.getModuleName(), augment.getLine(),
- "Error in augment parsing: cannot augment uses to choice");
- }
- }
- }
-
- /**
- * Create new schema path of node based on parent node schema path.
- *
- * @param node
- * node to correct
- * @param parentSchemaPath
- * schema path of node parent
- */
- static void correctNodePath(final SchemaNodeBuilder node, final SchemaPath parentSchemaPath) {
- // set correct path
- List<QName> targetNodePath = new ArrayList<QName>(parentSchemaPath.getPath());
- targetNodePath.add(node.getQName());
- node.setPath(new SchemaPath(targetNodePath, true));
-
- // set correct path for all child nodes
- if (node instanceof DataNodeContainerBuilder) {
- DataNodeContainerBuilder dataNodeContainer = (DataNodeContainerBuilder) node;
- for (DataSchemaNodeBuilder child : dataNodeContainer.getChildNodeBuilders()) {
- correctNodePath(child, node.getPath());
- }
- }
-
- // set correct path for all cases
- if (node instanceof ChoiceBuilder) {
- ChoiceBuilder choiceBuilder = (ChoiceBuilder) node;
- for (ChoiceCaseBuilder choiceCaseBuilder : choiceBuilder.getCases()) {
- correctNodePath(choiceCaseBuilder, node.getPath());
- }
- }
- }
-
- /**
- * Find augment target node and perform augmentation.
- *
- * @param augment
- * @param firstNodeParent
- * parent of first node in path
- * @param path
- * path to augment target
- * @return true if augmentation process succeed, false otherwise
- */
- public static boolean processAugmentation(final AugmentationSchemaBuilder augment, final Builder firstNodeParent,
- final List<QName> path) {
- // traverse augment target path and try to reach target node
- String currentName = null;
- Builder currentParent = firstNodeParent;
-
- for (int i = 0; i < path.size(); i++) {
- QName qname = path.get(i);
-
- currentName = qname.getLocalName();
- if (currentParent instanceof DataNodeContainerBuilder) {
- DataSchemaNodeBuilder nodeFound = ((DataNodeContainerBuilder) currentParent)
- .getDataChildByName(currentName);
- // if not found as regular child, search in uses
- if (nodeFound == null) {
- boolean found = false;
- for (UsesNodeBuilder unb : ((DataNodeContainerBuilder) currentParent).getUsesNodes()) {
- DataSchemaNodeBuilder result = findNodeInUses(currentName, unb);
- if (result != null) {
- currentParent = result;
- found = true;
- break;
- }
- }
- // if not found even in uses nodes, return false
- if (!found) {
- return false;
- }
- } else {
- currentParent = nodeFound;
- }
- } else if (currentParent instanceof ChoiceBuilder) {
- currentParent = ((ChoiceBuilder) currentParent).getCaseNodeByName(currentName);
- } else {
- throw new YangParseException(augment.getModuleName(), augment.getLine(),
- "Error in augment parsing: failed to find node " + currentName);
- }
-
- // if node in path not found, return false
- if (currentParent == null) {
- return false;
- }
- }
- if (!(currentParent instanceof DataSchemaNodeBuilder)) {
- throw new YangParseException(
- augment.getModuleName(),
- augment.getLine(),
- "Error in augment parsing: The target node MUST be either a container, list, choice, case, input, output, or notification node.");
- }
-
- if (currentParent instanceof ChoiceBuilder) {
- fillAugmentTarget(augment, (ChoiceBuilder) currentParent);
- } else {
- fillAugmentTarget(augment, (DataNodeContainerBuilder) currentParent);
- }
- ((AugmentationTargetBuilder) currentParent).addAugmentation(augment);
- SchemaPath oldPath = ((DataSchemaNodeBuilder) currentParent).getPath();
- augment.setTargetPath(new SchemaPath(oldPath.getPath(), oldPath.isAbsolute()));
- augment.setResolved(true);
-
- return true;
- }
-
- /**
- * Find node with given name in uses target.
- *
- * @param localName
- * name of node to find
- * @param uses
- * uses node which target grouping should be searched
- * @return node with given name if found, null otherwise
- */
- private static DataSchemaNodeBuilder findNodeInUses(String localName, UsesNodeBuilder uses) {
- GroupingBuilder target = uses.getGroupingBuilder();
- for (DataSchemaNodeBuilder child : target.getChildNodeBuilders()) {
- if (child.getQName().getLocalName().equals(localName)) {
- return child;
- }
- }
- for (UsesNodeBuilder usesNode : target.getUsesNodes()) {
- DataSchemaNodeBuilder result = findNodeInUses(localName, usesNode);
- if (result != null) {
- return result;
- }
- }
- return null;
- }
-
- /**
- * Find augment target node in given context and perform augmentation.
- *
- * @param augment
- * @param path
- * path to augment target
- * @param module
- * current module
- * @param prefix
- * current prefix of target module
- * @param context
- * SchemaContext containing already resolved modules
- * @return true if augment process succeed, false otherwise
- */
- public static boolean processAugmentationOnContext(final AugmentationSchemaBuilder augment, final List<QName> path,
- final ModuleBuilder module, final String prefix, final SchemaContext context) {
- final int line = augment.getLine();
- final Module dependentModule = findModuleFromContext(context, module, prefix, line);
- if (dependentModule == null) {
- throw new YangParseException(module.getName(), line,
- "Error in augment parsing: failed to find module with prefix " + prefix + ".");
- }
-
- String currentName = path.get(0).getLocalName();
- SchemaNode currentParent = dependentModule.getDataChildByName(currentName);
- if (currentParent == null) {
- Set<NotificationDefinition> notifications = dependentModule.getNotifications();
- for (NotificationDefinition ntf : notifications) {
- if (ntf.getQName().getLocalName().equals(currentName)) {
- currentParent = ntf;
- break;
- }
- }
- }
- if (currentParent == null) {
- throw new YangParseException(module.getName(), line, "Error in augment parsing: failed to find node "
- + currentName + ".");
- }
-
- for (int i = 1; i < path.size(); i++) {
- currentName = path.get(i).getLocalName();
- if (currentParent instanceof DataNodeContainer) {
- currentParent = ((DataNodeContainer) currentParent).getDataChildByName(currentName);
- } else if (currentParent instanceof ChoiceNode) {
- currentParent = ((ChoiceNode) currentParent).getCaseNodeByName(currentName);
- } else {
- throw new YangParseException(augment.getModuleName(), line,
- "Error in augment parsing: failed to find node " + currentName);
- }
- // if node in path not found, return false
- if (currentParent == null) {
- throw new YangParseException(module.getName(), line, "Error in augment parsing: failed to find node "
- + currentName + ".");
- }
- }
-
- if (currentParent instanceof ContainerSchemaNodeImpl) {
- // includes container, input and output statement
- ContainerSchemaNodeImpl c = (ContainerSchemaNodeImpl) currentParent;
- ContainerSchemaNodeBuilder cb = c.toBuilder();
- fillAugmentTarget(augment, cb);
- ((AugmentationTargetBuilder) cb).addAugmentation(augment);
- SchemaPath oldPath = cb.getPath();
- cb.rebuild();
- augment.setTargetPath(new SchemaPath(oldPath.getPath(), oldPath.isAbsolute()));
- augment.setResolved(true);
- } else if (currentParent instanceof ListSchemaNodeImpl) {
- ListSchemaNodeImpl l = (ListSchemaNodeImpl) currentParent;
- ListSchemaNodeBuilder lb = l.toBuilder();
- fillAugmentTarget(augment, lb);
- ((AugmentationTargetBuilder) lb).addAugmentation(augment);
- SchemaPath oldPath = lb.getPath();
- lb.rebuild();
- augment.setTargetPath(new SchemaPath(oldPath.getPath(), oldPath.isAbsolute()));
- augment.setResolved(true);
- } else if (currentParent instanceof ChoiceNodeImpl) {
- ChoiceNodeImpl ch = (ChoiceNodeImpl) currentParent;
- ChoiceBuilder chb = ch.toBuilder();
- fillAugmentTarget(augment, chb);
- ((AugmentationTargetBuilder) chb).addAugmentation(augment);
- SchemaPath oldPath = chb.getPath();
- chb.rebuild();
- augment.setTargetPath(new SchemaPath(oldPath.getPath(), oldPath.isAbsolute()));
- augment.setResolved(true);
- } else if (currentParent instanceof ChoiceCaseNodeImpl) {
- ChoiceCaseNodeImpl chc = (ChoiceCaseNodeImpl) currentParent;
- ChoiceCaseBuilder chcb = chc.toBuilder();
- fillAugmentTarget(augment, chcb);
- ((AugmentationTargetBuilder) chcb).addAugmentation(augment);
- SchemaPath oldPath = chcb.getPath();
- chcb.rebuild();
- augment.setTargetPath(new SchemaPath(oldPath.getPath(), oldPath.isAbsolute()));
- augment.setResolved(true);
- } else if (currentParent instanceof NotificationDefinitionImpl) {
- NotificationDefinitionImpl nd = (NotificationDefinitionImpl) currentParent;
- NotificationBuilder nb = nd.toBuilder();
- fillAugmentTarget(augment, nb);
- ((AugmentationTargetBuilder) nb).addAugmentation(augment);
- SchemaPath oldPath = nb.getPath();
- nb.rebuild();
- augment.setTargetPath(new SchemaPath(oldPath.getPath(), oldPath.isAbsolute()));
- augment.setResolved(true);
- } else {
- throw new YangParseException(module.getName(), line, "Target of type " + currentParent.getClass()
- + " cannot be augmented.");
- }
-
- return true;
- }
-
- public static QName findFullQName(final Map<String, TreeMap<Date, ModuleBuilder>> modules,
- final ModuleBuilder module, final IdentityrefTypeBuilder idref) {
- QName result = null;
- String baseString = idref.getBaseString();
- if (baseString.contains(":")) {
- String[] splittedBase = baseString.split(":");
- if (splittedBase.length > 2) {
- throw new YangParseException(module.getName(), idref.getLine(), "Failed to parse identityref base: "
- + baseString);
- }
- String prefix = splittedBase[0];
- String name = splittedBase[1];
- ModuleBuilder dependentModule = findDependentModuleBuilder(modules, module, prefix, idref.getLine());
- result = new QName(dependentModule.getNamespace(), dependentModule.getRevision(), prefix, name);
- } else {
- result = new QName(module.getNamespace(), module.getRevision(), module.getPrefix(), baseString);
- }
- return result;
- }
-
- /**
- * Get module in which this node is defined.
- *
- * @param node
- * @return builder of module where this node is defined
- */
- public static ModuleBuilder getParentModule(Builder node) {
- if (node instanceof ModuleBuilder) {
- return (ModuleBuilder) node;
- }
-
- Builder parent = node.getParent();
- while (!(parent instanceof ModuleBuilder)) {
- parent = parent.getParent();
- }
- return (ModuleBuilder) parent;
- }
-
-}
--- /dev/null
+/*
+ * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.util;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
+import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
+import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.ModuleImport;
+import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
+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.parser.builder.api.AugmentationSchemaBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.AugmentationTargetBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.Builder;
+import org.opendaylight.yangtools.yang.parser.builder.api.DataNodeContainerBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.DataSchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.SchemaNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.api.UsesNodeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceBuilder.ChoiceNodeImpl;
+import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceCaseBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.impl.ChoiceCaseBuilder.ChoiceCaseNodeImpl;
+import org.opendaylight.yangtools.yang.parser.builder.impl.ContainerSchemaNodeBuilder.ContainerSchemaNodeImpl;
+import org.opendaylight.yangtools.yang.parser.builder.impl.IdentityrefTypeBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.impl.ListSchemaNodeBuilder.ListSchemaNodeImpl;
+import org.opendaylight.yangtools.yang.parser.builder.impl.ModuleBuilder;
+import org.opendaylight.yangtools.yang.parser.builder.impl.NotificationBuilder.NotificationDefinitionImpl;
+import org.opendaylight.yangtools.yang.model.api.AugmentationTarget
+import org.opendaylight.yangtools.yang.parser.builder.impl.RpcDefinitionBuilder
+
+
+public final class ParserUtils {
+
+ private new() {
+ }
+
+ /**
+ * Create new SchemaPath from given path and qname.
+ *
+ * @param schemaPath
+ * @param qname
+ * @return
+ */
+ public static def SchemaPath createSchemaPath(SchemaPath schemaPath, QName... qname) {
+ val path = new ArrayList<QName>(schemaPath.getPath());
+ path.addAll(Arrays.asList(qname));
+ return new SchemaPath(path, schemaPath.isAbsolute());
+ }
+
+ /**
+ * Get module import referenced by given prefix.
+ *
+ * @param builder
+ * module to search
+ * @param prefix
+ * prefix associated with import
+ * @return ModuleImport based on given prefix
+ */
+ public static def ModuleImport getModuleImport(ModuleBuilder builder, String prefix) {
+ for (ModuleImport mi : builder.getModuleImports()) {
+ if (mi.getPrefix().equals(prefix)) {
+ return mi;
+
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Find dependent module based on given prefix
+ *
+ * @param modules
+ * all available modules
+ * @param module
+ * current module
+ * @param prefix
+ * target module prefix
+ * @param line
+ * current line in yang model
+ * @return module builder if found, null otherwise
+ */
+ public static def ModuleBuilder findDependentModuleBuilder(Map<String, TreeMap<Date, ModuleBuilder>> modules,
+ ModuleBuilder module, String prefix, int line) {
+ var ModuleBuilder dependentModule = null;
+ var Date dependentModuleRevision = null;
+
+ if (prefix.equals(module.getPrefix())) {
+ dependentModule = module;
+ } else {
+ val ModuleImport dependentModuleImport = getModuleImport(module, prefix);
+ if (dependentModuleImport === null) {
+ throw new YangParseException(module.getName(), line, "No import found with prefix '" + prefix + "'.");
+ }
+ val String dependentModuleName = dependentModuleImport.getModuleName();
+ dependentModuleRevision = dependentModuleImport.getRevision();
+
+ val TreeMap<Date, ModuleBuilder> moduleBuildersByRevision = modules.get(dependentModuleName);
+ if (moduleBuildersByRevision === null) {
+ return null;
+ }
+ if (dependentModuleRevision === null) {
+ dependentModule = moduleBuildersByRevision.lastEntry().getValue();
+ } else {
+ dependentModule = moduleBuildersByRevision.get(dependentModuleRevision);
+ }
+ }
+ return dependentModule;
+ }
+
+ /**
+ * Find module from context based on prefix.
+ *
+ * @param context
+ * schema context
+ * @param currentModule
+ * current module
+ * @param prefix
+ * current prefix used to reference dependent module
+ * @param line
+ * current line in yang model
+ * @return module based on given prefix if found in context, null otherwise
+ */
+ public static def Module findModuleFromContext(SchemaContext context, ModuleBuilder currentModule,
+ String prefix, int line) {
+ val modulesByRevision = new TreeMap<Date, Module>();
+
+ val dependentModuleImport = ParserUtils.getModuleImport(currentModule, prefix);
+ if (dependentModuleImport === null) {
+ throw new YangParseException(currentModule.getName(), line, "No import found with prefix '" + prefix + "'.");
+ }
+ val dependentModuleName = dependentModuleImport.getModuleName();
+ val dependentModuleRevision = dependentModuleImport.getRevision();
+
+ for (Module contextModule : context.getModules()) {
+ if (contextModule.getName().equals(dependentModuleName)) {
+ var revision = contextModule.getRevision();
+ if (revision === null) {
+ revision = new Date(0L);
+ }
+ modulesByRevision.put(revision, contextModule);
+ }
+ }
+
+ var Module result = null;
+ if (dependentModuleRevision === null) {
+ result = modulesByRevision.get(modulesByRevision.firstKey());
+ } else {
+ result = modulesByRevision.get(dependentModuleRevision);
+ }
+ return result;
+ }
+
+ /**
+ * Parse XPath string.
+ *
+ * @param xpathString
+ * as String
+ * @return SchemaPath from given String
+ */
+ public static def SchemaPath parseXPathString(String xpathString) {
+ val absolute = xpathString.startsWith("/");
+ val String[] splittedPath = xpathString.split("/");
+ val path = new ArrayList<QName>();
+ var QName name;
+ for (String pathElement : splittedPath) {
+ if (pathElement.length() > 0) {
+ val String[] splittedElement = pathElement.split(":");
+ if (splittedElement.length == 1) {
+ name = new QName(null, null, null, splittedElement.get(0));
+ } else {
+ name = new QName(null, null, splittedElement.get(0), splittedElement.get(1));
+ }
+ path.add(name);
+ }
+ }
+ return new SchemaPath(path, absolute);
+ }
+
+ /**
+ * Add all augment's child nodes to given target.
+ *
+ * @param augment
+ * builder of augment statement
+ * @param target
+ * augmentation target node
+ */
+ public static def void fillAugmentTarget(AugmentationSchemaBuilder augment, DataNodeContainerBuilder target) {
+ for (DataSchemaNodeBuilder child : augment.getChildNodeBuilders()) {
+ val childCopy = CopyUtils.copy(child, target, false);
+ childCopy.setAugmenting(true);
+ correctNodePath(child, target.getPath());
+ correctNodePath(childCopy, target.getPath());
+ try {
+ target.addChildNode(childCopy);
+ } catch (YangParseException e) {
+
+ // more descriptive message
+ throw new YangParseException(augment.getModuleName(), augment.getLine(),
+ "Failed to perform augmentation: " + e.getMessage());
+ }
+
+ }
+ for (UsesNodeBuilder usesNode : augment.getUsesNodes()) {
+ val copy = CopyUtils.copyUses(usesNode, target);
+ target.addUsesNode(copy);
+ }
+ }
+
+ /**
+ * Add all augment's child nodes to given target.
+ *
+ * @param augment
+ * builder of augment statement
+ * @param target
+ * augmentation target choice node
+ */
+ public static def void fillAugmentTarget(AugmentationSchemaBuilder augment, ChoiceBuilder target) {
+ for (DataSchemaNodeBuilder builder : augment.getChildNodeBuilders()) {
+ val childCopy = CopyUtils.copy(builder, target, false);
+ childCopy.setAugmenting(true);
+ correctNodePath(builder, target.getPath());
+ correctNodePath(childCopy, target.getPath());
+ target.addCase(childCopy);
+ }
+ for (UsesNodeBuilder usesNode : augment.getUsesNodes()) {
+ if (usesNode !== null) {
+ throw new YangParseException(augment.getModuleName(), augment.getLine(),
+ "Error in augment parsing: cannot augment uses to choice");
+ }
+ }
+ }
+
+ /**
+ * Create new schema path of node based on parent node schema path.
+ *
+ * @param node
+ * node to correct
+ * @param parentSchemaPath
+ * schema path of node parent
+ */
+ static def void correctNodePath(SchemaNodeBuilder node, SchemaPath parentSchemaPath) {
+
+ // set correct path
+ val targetNodePath = new ArrayList<QName>(parentSchemaPath.getPath());
+ targetNodePath.add(node.getQName());
+ node.setPath(new SchemaPath(targetNodePath, true));
+
+ // set correct path for all child nodes
+ if (node instanceof DataNodeContainerBuilder) {
+ val dataNodeContainer = node as DataNodeContainerBuilder;
+ for (DataSchemaNodeBuilder child : dataNodeContainer.getChildNodeBuilders()) {
+ correctNodePath(child, node.getPath());
+ }
+ }
+
+ // set correct path for all cases
+ if (node instanceof ChoiceBuilder) {
+ val choiceBuilder = node as ChoiceBuilder;
+ for (ChoiceCaseBuilder choiceCaseBuilder : choiceBuilder.getCases()) {
+ correctNodePath(choiceCaseBuilder, node.getPath());
+ }
+ }
+ }
+
+
+
+ public static dispatch def SchemaNodeBuilder findNode(ModuleBuilder parent,List<QName> path) {
+ var node = _findNode(parent as DataNodeContainerBuilder,path);
+ if(node !== null) return node;
+
+ val current = path.get(0);
+ node = parent.getRpc(current.localName);
+ if(node !== null) return _findNode(node as RpcDefinitionBuilder,path.nextLevel);
+ node = parent.getNotification(current.localName);
+ return node;
+ }
+
+ public static dispatch def SchemaNodeBuilder findNode(DataNodeContainerBuilder parent,List<QName> path) {
+ if(path.empty) return parent as SchemaNodeBuilder;
+
+ var current = path.get(0);
+ var node = parent.getDataChildByName(current.localName)
+ if(node !== null) return findNode(node,path.nextLevel);
+ for (UsesNodeBuilder unb : parent.usesNodes) {
+ node = findNodeInUses(current.localName, unb);
+ if (node !== null) {
+ return findNode(node,path.nextLevel);
+ }
+ }
+ }
+
+ public static dispatch def SchemaNodeBuilder findNode(RpcDefinitionBuilder parent,List<QName> path) {
+ val current = path.get(0);
+ switch(current.localName) {
+ case "input": return findNode(parent.input,path.nextLevel)
+ case "output": return findNode(parent.output,path.nextLevel)
+ }
+ return null;
+ }
+
+ public static dispatch def SchemaNodeBuilder findNode(ChoiceBuilder parent,List<QName> path) {
+ if(path.empty) return parent as SchemaNodeBuilder;
+ var current = path.get(0);
+ val node = parent.getCaseNodeByName(current.localName);
+ if(node === null) return null;
+ return findNode(node,path.nextLevel);
+ }
+
+ public static def getRpc(ModuleBuilder module,String name) {
+ for(rpc : module.rpcs) {
+ if(name == rpc.QName.localName) {
+ return rpc;
+ }
+ }
+ return null;
+ }
+
+ public static def getNotification(ModuleBuilder module,String name) {
+ for(notification : module.notifications) {
+ if(name == notification.QName.localName) {
+ return notification;
+ }
+ }
+ }
+
+ private static def nextLevel(List<QName> path){
+ return path.subList(1,path.size)
+ }
+
+ /**
+ * Find augment target node and perform augmentation.
+ *
+ * @param augment
+ * @param firstNodeParent
+ * parent of first node in path
+ * @param path
+ * path to augment target
+ * @return true if augmentation process succeed, false otherwise
+ */
+ public static def boolean processAugmentation(AugmentationSchemaBuilder augment, Builder firstNodeParent,
+ List<QName> path) {
+
+ // traverse augment target path and try to reach target node
+ val currentParent = findNode(firstNodeParent,path);
+ if (currentParent === null) return false;
+
+ if ((currentParent instanceof DataNodeContainerBuilder)) {
+ fillAugmentTarget(augment, currentParent as DataNodeContainerBuilder);
+ } else if (currentParent instanceof ChoiceBuilder) {
+ fillAugmentTarget(augment, currentParent as ChoiceBuilder);
+ } else {
+ throw new YangParseException(augment.getModuleName(), augment.getLine(),
+ "Error in augment parsing: The target node MUST be either a container, list, choice, case, input, output, or notification node.");
+ }
+ (currentParent as AugmentationTargetBuilder).addAugmentation(augment);
+ val oldPath = (currentParent as SchemaNodeBuilder).getPath();
+ augment.setTargetPath(new SchemaPath(oldPath.getPath(), oldPath.isAbsolute()));
+ augment.setResolved(true);
+ return true;
+ }
+
+ /**
+ * Find node with given name in uses target.
+ *
+ * @param localName
+ * name of node to find
+ * @param uses
+ * uses node which target grouping should be searched
+ * @return node with given name if found, null otherwise
+ */
+ private static def DataSchemaNodeBuilder findNodeInUses(String localName, UsesNodeBuilder uses) {
+ val target = uses.getGroupingBuilder();
+ for (DataSchemaNodeBuilder child : target.getChildNodeBuilders()) {
+ if (child.getQName().getLocalName().equals(localName)) {
+ return child;
+ }
+ }
+ for (UsesNodeBuilder usesNode : target.getUsesNodes()) {
+ val result = findNodeInUses(localName, usesNode);
+ if (result !== null) {
+ return result;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Find augment target node in given context and perform augmentation.
+ *
+ * @param augment
+ * @param path
+ * path to augment target
+ * @param module
+ * current module
+ * @param prefix
+ * current prefix of target module
+ * @param context
+ * SchemaContext containing already resolved modules
+ * @return true if augment process succeed, false otherwise
+ */
+ public static def boolean processAugmentationOnContext(AugmentationSchemaBuilder augment, List<QName> path,
+ ModuleBuilder module, String prefix, SchemaContext context) {
+ val int line = augment.getLine();
+ val Module dependentModule = findModuleFromContext(context, module, prefix, line);
+ if (dependentModule === null) {
+ throw new YangParseException(module.getName(), line,
+ "Error in augment parsing: failed to find module with prefix " + prefix + ".");
+ }
+
+ var currentName = path.get(0).getLocalName();
+ var SchemaNode currentParent = dependentModule.getDataChildByName(currentName);
+ if (currentParent === null) {
+ val notifications = dependentModule.getNotifications();
+ for (NotificationDefinition ntf : notifications) {
+ if (ntf.getQName().getLocalName().equals(currentName)) {
+ currentParent = ntf;
+ }
+ }
+ }
+ if (currentParent === null) {
+ throw new YangParseException(module.getName(), line,
+ "Error in augment parsing: failed to find node " + currentName + ".");
+ }
+
+ for (qname : path.nextLevel) {
+ currentName = qname.getLocalName();
+ if (currentParent instanceof DataNodeContainer) {
+ currentParent = (currentParent as DataNodeContainer).getDataChildByName(currentName);
+ } else if (currentParent instanceof ChoiceNode) {
+ currentParent = (currentParent as ChoiceNode).getCaseNodeByName(currentName);
+ } else {
+ throw new YangParseException(augment.getModuleName(), line,
+ "Error in augment parsing: failed to find node " + currentName);
+ }
+
+ // if node in path not found, return false
+ if (currentParent === null) {
+ throw new YangParseException(module.getName(), line,
+ "Error in augment parsing: failed to find node " + currentName + ".");
+ }
+ }
+
+ val oldPath = currentParent.path;
+
+ if (!(currentParent instanceof AugmentationTarget)) {
+ throw new YangParseException(module.getName(), line,
+ "Target of type " + currentParent.class + " cannot be augmented.");
+ }
+
+ switch (currentParent) {
+ case (currentParent instanceof ContainerSchemaNodeImpl): {
+
+ // includes container, input and output statement
+ val c = currentParent as ContainerSchemaNodeImpl;
+ val cb = c.toBuilder();
+ fillAugmentTarget(augment, cb);
+ (cb as AugmentationTargetBuilder ).addAugmentation(augment);
+ cb.rebuild();
+ }
+ case (currentParent instanceof ListSchemaNodeImpl): {
+ val l = currentParent as ListSchemaNodeImpl;
+ val lb = l.toBuilder();
+ fillAugmentTarget(augment, lb);
+ (lb as AugmentationTargetBuilder ).addAugmentation(augment);
+ lb.rebuild();
+ augment.setTargetPath(new SchemaPath(oldPath.getPath(), oldPath.isAbsolute()));
+ augment.setResolved(true);
+ }
+ case (currentParent instanceof ChoiceNodeImpl): {
+ val ch = currentParent as ChoiceNodeImpl;
+ val chb = ch.toBuilder();
+ fillAugmentTarget(augment, chb);
+ (chb as AugmentationTargetBuilder ).addAugmentation(augment);
+ chb.rebuild();
+ augment.setTargetPath(new SchemaPath(oldPath.getPath(), oldPath.isAbsolute()));
+ augment.setResolved(true);
+ }
+ case (currentParent instanceof ChoiceCaseNodeImpl): {
+ val chc = currentParent as ChoiceCaseNodeImpl;
+ val chcb = chc.toBuilder();
+ fillAugmentTarget(augment, chcb);
+ (chcb as AugmentationTargetBuilder ).addAugmentation(augment);
+ chcb.rebuild();
+ augment.setTargetPath(new SchemaPath(oldPath.getPath(), oldPath.isAbsolute()));
+ augment.setResolved(true);
+ }
+ case (currentParent instanceof NotificationDefinitionImpl): {
+ val nd = currentParent as NotificationDefinitionImpl;
+ val nb = nd.toBuilder();
+ fillAugmentTarget(augment, nb);
+ (nb as AugmentationTargetBuilder ).addAugmentation(augment);
+ nb.rebuild();
+ augment.setTargetPath(new SchemaPath(oldPath.getPath(), oldPath.isAbsolute()));
+ augment.setResolved(true);
+ }
+ }
+ augment.setTargetPath(new SchemaPath(oldPath.getPath(), oldPath.isAbsolute()));
+ augment.setResolved(true);
+ return true;
+ }
+
+ public static def QName findFullQName(Map<String, TreeMap<Date, ModuleBuilder>> modules,
+ ModuleBuilder module, IdentityrefTypeBuilder idref) {
+ var QName result = null;
+ val String baseString = idref.getBaseString();
+ if (baseString.contains(":")) {
+ val String[] splittedBase = baseString.split(":");
+ if (splittedBase.length > 2) {
+ throw new YangParseException(module.getName(), idref.getLine(),
+ "Failed to parse identityref base: " + baseString);
+ }
+ val prefix = splittedBase.get(0);
+ val name = splittedBase.get(1);
+ val dependentModule = findDependentModuleBuilder(modules, module, prefix, idref.getLine());
+ result = new QName(dependentModule.getNamespace(), dependentModule.getRevision(), prefix, name);
+ } else {
+ result = new QName(module.getNamespace(), module.getRevision(), module.getPrefix(), baseString);
+ }
+ return result;
+ }
+
+ /**
+ * Get module in which this node is defined.
+ *
+ * @param node
+ * @return builder of module where this node is defined
+ */
+ public static def ModuleBuilder getParentModule(Builder node) {
+ if (node instanceof ModuleBuilder) {
+ return node as ModuleBuilder;
+ }
+ var parent = node.getParent();
+ while (!(parent instanceof ModuleBuilder)) {
+ parent = parent.getParent();
+ }
+ return parent as ModuleBuilder;
+ }
+ }
+
\ No newline at end of file
Code Review / yangtools.git / commitdiff