final Map<YangInstanceIdentifier, ? extends NormalizedNode<?, ?>> normalized) {
final Map<InstanceIdentifier<?>, DataObject> newMap = new HashMap<>();
- for (final Map.Entry<YangInstanceIdentifier, ? extends NormalizedNode<?, ?>> entry : normalized.entrySet()) {
+ for (final Entry<YangInstanceIdentifier, ? extends NormalizedNode<?, ?>> entry : normalized.entrySet()) {
try {
- final Optional<Entry<InstanceIdentifier<? extends DataObject>, DataObject>> potential
- = getCodec().toBinding(entry);
+ final Optional<Entry<InstanceIdentifier<? extends DataObject>, DataObject>> potential = getCodec()
+ .toBinding(entry);
if (potential.isPresent()) {
final Entry<InstanceIdentifier<? extends DataObject>, DataObject> binding = potential.get();
newMap.put(binding.getKey(), binding.getValue());
}
@SuppressWarnings("unchecked")
- protected java.util.Optional<DataObject> toBindingData(final InstanceIdentifier<?> path,
- final NormalizedNode<?, ?> data) {
+ protected Optional<DataObject> toBindingData(final InstanceIdentifier<?> path, final NormalizedNode<?, ?> data) {
if (path.isWildcarded()) {
- return java.util.Optional.empty();
+ return Optional.empty();
}
- return (java.util.Optional<DataObject>) getCodec().getCodecRegistry().deserializeFunction(path)
- .apply(java.util.Optional.of(data));
+ return (Optional<DataObject>) getCodec().getCodecRegistry().deserializeFunction(path).apply(Optional.of(data));
}
}
final ChoiceNodeCodecContext<?> choice = (ChoiceNodeCodecContext<?>) context;
choice.addYangPathArgument(arg, builder);
- final java.util.Optional<? extends Class<? extends DataObject>> caseType = arg.getCaseType();
+ final Optional<? extends Class<? extends DataObject>> caseType = arg.getCaseType();
final Class<? extends DataObject> type = arg.getType();
final DataContainerCodecContext<?, ?> caze;
if (caseType.isPresent()) {
Object getBindingChildValue(final Method method, final NormalizedNodeContainer domData) {
final NodeCodecContext<?> childContext = byMethod.get(method).get();
@SuppressWarnings("unchecked")
- final java.util.Optional<NormalizedNode<?, ?>> domChild = domData.getChild(childContext.getDomPathArgument());
+ final Optional<NormalizedNode<?, ?>> domChild = domData.getChild(childContext.getDomPathArgument());
if (domChild.isPresent()) {
return childContext.deserializeObject(domChild.get());
} else if (childContext instanceof LeafNodeCodecContext) {
}
}
for (final DataContainerCodecPrototype<?> value : byStreamAugmented.values()) {
- final java.util.Optional<NormalizedNode<?, ?>> augData = data.getChild(value.getYangArg());
+ final Optional<NormalizedNode<?, ?>> augData = data.getChild(value.getYangArg());
if (augData.isPresent()) {
map.put(value.getBindingClass(), value.get().deserializeObject(augData.get()));
}
// the augmentation the user is requesting -- otherwise a strict receiver would end up with a cryptic
// ClassCastException.
if (cls.isAssignableFrom(augCtx.getBindingClass())) {
- final java.util.Optional<NormalizedNode<?, ?>> augData = data.getChild(augCtx.getDomPathArgument());
+ final Optional<NormalizedNode<?, ?>> augData = data.getChild(augCtx.getDomPathArgument());
if (augData.isPresent()) {
return augCtx.deserialize(augData.get());
}
private static Object createDefaultObject(final DataSchemaNode schema, final Codec<Object, Object> codec,
final SchemaContext schemaContext) {
if (schema instanceof LeafSchemaNode) {
- java.util.Optional<? extends Object> defaultValue = ((LeafSchemaNode) schema).getType().getDefaultValue();
+ Optional<? extends Object> defaultValue = ((LeafSchemaNode) schema).getType().getDefaultValue();
TypeDefinition<?> type = ((LeafSchemaNode) schema).getType();
if (defaultValue.isPresent()) {
if (type instanceof IdentityrefTypeDefinition) {
new CacheLoader<QName, Class<?>>() {
@Override
public Class<?> load(final QName key) {
- final java.util.Optional<Type> identityType = runtimeTypes.findIdentity(key);
+ final Optional<Type> identityType = runtimeTypes.findIdentity(key);
checkArgument(identityType.isPresent(), "Supplied QName %s is not a valid identity", key);
try {
return strategy.loadClass(identityType.get());
for (final ChoiceSchemaNode choice : Iterables.filter(schema.getChildNodes(), ChoiceSchemaNode.class)) {
final ChoiceSchemaNode originalChoice = getOriginalSchema(choice);
- final java.util.Optional<Type> optType = runtimeTypes.findType(originalChoice);
+ final Optional<Type> optType = runtimeTypes.findType(originalChoice);
checkState(optType.isPresent(), "Failed to find generated type for choice %s", originalChoice);
final Type choiceType = optType.get();
}
final Type type = new ReferencedTypeImpl(name);
- final java.util.Optional<WithStatus> optSchema = runtimeTypes.findSchema(type);
+ final Optional<WithStatus> optSchema = runtimeTypes.findSchema(type);
if (!optSchema.isPresent()) {
continue;
}
final WithStatus schema = optSchema.get();
- final java.util.Optional<Type> optDefinedType = runtimeTypes.findType(schema);
+ final Optional<Type> optDefinedType = runtimeTypes.findType(schema);
if (!optDefinedType.isPresent()) {
continue;
}
public Class<?> getClassForSchema(final SchemaNode childSchema) {
final SchemaNode origSchema = getOriginalSchema(childSchema);
- final java.util.Optional<Type> clazzType = runtimeTypes.findType(origSchema);
+ final Optional<Type> clazzType = runtimeTypes.findType(origSchema);
checkArgument(clazzType.isPresent(), "Failed to find binding type for %s (original %s)",
childSchema, origSchema);
}
if (!augment.getChildNodes().isEmpty()) {
- final java.util.Optional<Type> augType = runtimeTypes.findType(augOrig);
+ final Optional<Type> augType = runtimeTypes.findType(augOrig);
if (augType.isPresent()) {
identifierToType.put(getAugmentationIdentifier(augment), augType.get());
}
final SchemaContext schemaContext) {
if (schema instanceof LeafSchemaNode) {
TypeDefinition<?> type = ((LeafSchemaNode) schema).getType();
- java.util.Optional<? extends Object> defaultValue = type.getDefaultValue();
+ Optional<? extends Object> defaultValue = type.getDefaultValue();
if (defaultValue.isPresent()) {
if (type instanceof IdentityrefTypeDefinition) {
return qnameDomValueFromString(codec, schema, (String) defaultValue.get(), schemaContext);
public Object getBindingChildValue(final Method method, final NormalizedNodeContainer domData) {
final NodeCodecContext<?> childContext = byMethod.get(method).get();
@SuppressWarnings("unchecked")
- final java.util.Optional<NormalizedNode<?, ?>> domChild = domData.getChild(childContext.getDomPathArgument());
+ final Optional<NormalizedNode<?, ?>> domChild = domData.getChild(childContext.getDomPathArgument());
if (domChild.isPresent()) {
return childContext.deserializeObject(domChild.get());
} else if (childContext instanceof LeafNodeCodecContext) {
}
}
for (final DataContainerCodecPrototype<?> value : byStreamAugmented.values()) {
- final java.util.Optional<NormalizedNode<?, ?>> augData = data.getChild(value.getYangArg());
+ final Optional<NormalizedNode<?, ?>> augData = data.getChild(value.getYangArg());
if (augData.isPresent()) {
map.put(value.getBindingClass(), value.get().deserializeObject(augData.get()));
}
when(module.getName()).thenReturn("module-name");
when(module.getRevision()).thenReturn(rpcQName.getRevision());
when(module.getNamespace()).thenReturn(rpcQName.getNamespace());
- when(module.getDescription()).thenReturn(java.util.Optional.empty());
- when(module.getReference()).thenReturn(java.util.Optional.empty());
+ when(module.getDescription()).thenReturn(Optional.empty());
+ when(module.getReference()).thenReturn(Optional.empty());
final Set<RpcDefinition> rpcs = new HashSet<>();
final RpcDefinition rpcDefinition = mock(RpcDefinition.class);
- when(rpcDefinition.getDescription()).thenReturn(java.util.Optional.empty());
- when(rpcDefinition.getReference()).thenReturn(java.util.Optional.empty());
+ when(rpcDefinition.getDescription()).thenReturn(Optional.empty());
+ when(rpcDefinition.getReference()).thenReturn(Optional.empty());
final SchemaPath rpcPath = SchemaPath.create(true, rpcParentQName, rpcQName);
when(rpcDefinition.getPath()).thenReturn(rpcPath);
when(rpcDefinition.getQName()).thenReturn(rpcQName);
final SchemaPath inputSchemaPath = SchemaPath.create(true, rpcQName, qnameInput);
when(input.getQName()).thenReturn(qnameInput);
when(input.getPath()).thenReturn(inputSchemaPath);
- when(input.getDescription()).thenReturn(java.util.Optional.empty());
- when(input.getReference()).thenReturn(java.util.Optional.empty());
+ when(input.getDescription()).thenReturn(Optional.empty());
+ when(input.getReference()).thenReturn(Optional.empty());
when(rpcDefinition.getInput()).thenReturn(input);
final SchemaPath outputSchemaPath = SchemaPath.create(true, rpcQName, qnameOutput);
when(output.getQName()).thenReturn(qnameOutput);
when(output.getPath()).thenReturn(outputSchemaPath);
- when(output.getDescription()).thenReturn(java.util.Optional.empty());
- when(output.getReference()).thenReturn(java.util.Optional.empty());
+ when(output.getDescription()).thenReturn(Optional.empty());
+ when(output.getReference()).thenReturn(Optional.empty());
when(rpcDefinition.getOutput()).thenReturn(output);
final Map<Module, ModuleContext> genCtx = new HashMap<>();
genCtx.put(module, moduleContext);
final SchemaContext schemaContext = mock(SchemaContext.class);
- when(schemaContext.findModule(rpcQName.getModule())).thenReturn(java.util.Optional.of(module));
+ when(schemaContext.findModule(rpcQName.getModule())).thenReturn(Optional.of(module));
final boolean verboseClassComments = false;
final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders = new HashMap<>();
when(module.getName()).thenReturn("module-name");
when(module.getRevision()).thenReturn(actionQName.getRevision());
when(module.getNamespace()).thenReturn(actionQName.getNamespace());
- when(module.getDescription()).thenReturn(java.util.Optional.empty());
- when(module.getReference()).thenReturn(java.util.Optional.empty());
+ when(module.getDescription()).thenReturn(Optional.empty());
+ when(module.getReference()).thenReturn(Optional.empty());
final Collection<DataSchemaNode> childNodes = new ArrayList<>();
final T actionNodeContainer = mock(clazz);
when(actionDefinition.getQName()).thenReturn(actionQName);
final SchemaPath actionPath = SchemaPath.create(true, actionQName);
when(actionDefinition.getPath()).thenReturn(actionPath);
- when(actionDefinition.getDescription()).thenReturn(java.util.Optional.empty());
- when(actionDefinition.getReference()).thenReturn(java.util.Optional.empty());
+ when(actionDefinition.getDescription()).thenReturn(Optional.empty());
+ when(actionDefinition.getReference()).thenReturn(Optional.empty());
final ContainerSchemaNode input = mock(ContainerSchemaNode.class);
final QName qnameInput = QName.create(actionQName, "action-input");
final SchemaPath inputSchemaPath = SchemaPath.create(true, actionQName, qnameInput);
when(input.getQName()).thenReturn(qnameInput);
when(input.getPath()).thenReturn(inputSchemaPath);
- when(input.getDescription()).thenReturn(java.util.Optional.empty());
- when(input.getReference()).thenReturn(java.util.Optional.empty());
+ when(input.getDescription()).thenReturn(Optional.empty());
+ when(input.getReference()).thenReturn(Optional.empty());
when(actionDefinition.getInput()).thenReturn(input);
final ContainerSchemaNode output = mock(ContainerSchemaNode.class);
final SchemaPath outputSchemaPath = SchemaPath.create(true, actionQName, qnameOutput);
when(output.getQName()).thenReturn(qnameOutput);
when(output.getPath()).thenReturn(outputSchemaPath);
- when(output.getDescription()).thenReturn(java.util.Optional.empty());
- when(output.getReference()).thenReturn(java.util.Optional.empty());
+ when(output.getDescription()).thenReturn(Optional.empty());
+ when(output.getReference()).thenReturn(Optional.empty());
when(actionDefinition.getOutput()).thenReturn(output);
actions.add(actionDefinition);
genCtx.put(module, moduleContext);
final SchemaContext schemaContext = mock(SchemaContext.class);
- when(schemaContext.findModule(actionQName.getModule())).thenReturn(java.util.Optional.of(module));
+ when(schemaContext.findModule(actionQName.getModule())).thenReturn(Optional.of(module));
final boolean verboseClassComments = false;
final Map<String, Map<String, GeneratedTypeBuilder>> genTypeBuilders = new HashMap<>();
final RpcDefinition rpcDef = mock(RpcDefinition.class);
when(rpcDef.getPath()).thenReturn(outputSchemaPath);
when(rpcDef.getQName()).thenReturn(qnameOutput);
- when(rpcDef.getDescription()).thenReturn(java.util.Optional.empty());
- when(rpcDef.getReference()).thenReturn(java.util.Optional.empty());
+ when(rpcDef.getDescription()).thenReturn(Optional.empty());
+ when(rpcDef.getReference()).thenReturn(Optional.empty());
when(module.getDataChildByName(actionQName)).thenReturn((ContainerSchemaNode) actionNodeContainer);
final List<UnknownSchemaNode> unknownSchemaNodes = new ArrayList<>();
private final Map<String, String> importMap = new HashMap<>();
private final String packageName;
private final String modelBindingProviderName;
- private final Function<Module, java.util.Optional<String>> moduleFilePathResolver;
+ private final Function<Module, Optional<String>> moduleFilePathResolver;
- public YangModuleInfoTemplateRenderer(final Module module, final SchemaContext ctx, final Function<Module,
- java.util.Optional<String>> moduleFilePathResolver) {
+ public YangModuleInfoTemplateRenderer(final Module module, final SchemaContext ctx,
+ final Function<Module, Optional<String>> moduleFilePathResolver) {
Preconditions.checkArgument(module != null, "Module must not be null.");
this.module = module;
}
public static Module getSortedQName(final Set<Module> modules, final String name) {
- final TreeMap<java.util.Optional<Revision>, Module> sorted = new TreeMap<>(Revision::compare);
+ final TreeMap<Optional<Revision>, Module> sorted = new TreeMap<>(Revision::compare);
for (Module module : modules) {
if (name.equals(module.getName())) {
sorted.put(module.getRevision(), module);
*/
public static String getSourcePath(final Module module, final Function<Module, Optional<String>>
moduleFilePathResolver) {
- final java.util.Optional<String> moduleFilePath = moduleFilePathResolver.apply(module);
+ final Optional<String> moduleFilePath = moduleFilePathResolver.apply(module);
Preconditions.checkArgument(moduleFilePath.isPresent(), "Module file path for %s is not present", module);
return moduleFilePath.get();
return Strings.isNullOrEmpty(description) ? description
: AMP_MATCHER.replaceFrom(TAIL_COMMENT_PATTERN.matcher(description).replaceAll("*/"), "&");
}
-}
\ No newline at end of file
+}
final QName root = ((SchemaNode) container).getPath().getPathFromRoot().iterator().next();
// findFirst makes no sense but just pick up one child to judge whether the target node is
// in the same module.
- final java.util.Optional<DataSchemaNode> child = augment.getChildNodes().stream().findFirst();
+ final Optional<DataSchemaNode> child = augment.getChildNodes().stream().findFirst();
if (child.isPresent()) {
return root.getModule().equals(child.get().getQName().getModule());
}
}
@Override
- public java.util.Optional<DataTreeSnapshot> getSnapshot() {
- return java.util.Optional.ofNullable(stableSnapshot);
+ public Optional<DataTreeSnapshot> getSnapshot() {
+ return Optional.ofNullable(stableSnapshot);
}
}
final NormalizedNode<?, ?> testNode = mock(NormalizedNode.class);
final Optional<NormalizedNode<?, ?>> optional = Optional.of(testNode);
doReturn("testNode").when(testNode).toString();
- doReturn(java.util.Optional.of(testNode)).when(DATA_TREE_SNAPSHOT).readNode(YangInstanceIdentifier.EMPTY);
+ doReturn(Optional.of(testNode)).when(DATA_TREE_SNAPSHOT).readNode(YangInstanceIdentifier.EMPTY);
assertTrue(snapshotBackedReadTransaction.exists(YangInstanceIdentifier.EMPTY).get());
assertEquals(optional, snapshotBackedReadTransaction.read(YangInstanceIdentifier.EMPTY).get());
throw e.getCause();
}
}
-}
\ No newline at end of file
+}
final NormalizedNode<?, ?> testNode = mock(NormalizedNode.class);
final Optional<NormalizedNode<?, ?>> optional = Optional.of(testNode);
doReturn("testNode").when(testNode).toString();
- doReturn(java.util.Optional.of(testNode)).when(DATA_TREE_MODIFICATION).readNode(YangInstanceIdentifier.EMPTY);
+ doReturn(Optional.of(testNode)).when(DATA_TREE_MODIFICATION).readNode(YangInstanceIdentifier.EMPTY);
assertTrue(snapshotBackedReadWriteTransaction.exists(YangInstanceIdentifier.EMPTY).get());
assertEquals(optional, snapshotBackedReadWriteTransaction.read(YangInstanceIdentifier.EMPTY).get());
}