*/
package org.opendaylight.mdsal.binding.api;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
*/
package org.opendaylight.mdsal.binding.api;
-import com.google.common.base.Optional;
import java.util.EventListener;
+import java.util.Optional;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
* <li>If the data at the supplied path exists, the Future returns an Optional object
* containing the data.</li>
* <li>If the data at the supplied path does not exist, the Future returns
- * Optional#absent().</li>
+ * Optional.empty().</li>
* <li>If the read of the data fails, the Future will fail with a
* {@link ReadFailedException} or an exception derived from ReadFailedException.</li>
* </ul>
*/
package org.opendaylight.mdsal.binding.dom.adapter;
-import com.google.common.base.Optional;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.dom.api.DOMDataBroker;
Preconditions.checkArgument(!path.isWildcarded(), "Invalid read of wildcarded path %s", path);
return readTx.read(store, codec.toYangInstanceIdentifierBlocking(path))
- .transform(codec.getCodecRegistry().deserializeFunction(path), MoreExecutors.directExecutor());
+ .transform(codec.getCodecRegistry().deserializeFunction(path)::apply, MoreExecutors.directExecutor());
}
}
*/
package org.opendaylight.mdsal.binding.dom.adapter;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.FluentFuture;
import java.util.Map.Entry;
+import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
*/
@Deprecated
protected static Optional<YangInstanceIdentifier> getParent(final YangInstanceIdentifier child) {
- return Optional.fromNullable(child.getParent());
+ return Optional.ofNullable(child.getParent());
}
/**
*/
package org.opendaylight.mdsal.binding.dom.adapter;
-import com.google.common.base.Optional;
import com.google.common.cache.CacheLoader;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
if (deleg != null) {
builder.addDelegate(reqDeleg, deleg);
} else {
- return Optional.absent();
+ return Optional.empty();
}
}
return Optional.of(builder.build());
*/
package org.opendaylight.mdsal.binding.dom.adapter;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.mdsal.binding.api.MountPointService.MountPointListener;
import org.opendaylight.mdsal.dom.api.DOMMountPointListener;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
*/
package org.opendaylight.mdsal.binding.dom.adapter;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.mdsal.binding.api.MountPoint;
import org.opendaylight.mdsal.binding.api.MountPointService;
import org.opendaylight.mdsal.dom.api.DOMMountPoint;
public Optional<MountPoint> getMountPoint(final InstanceIdentifier<?> mountPoint) {
YangInstanceIdentifier domPath = getCodec().toYangInstanceIdentifierBlocking(mountPoint);
Optional<DOMMountPoint> domMount = getDelegate().getMountPoint(domPath);
- return domMount.transform(this::getAdapter);
+ return domMount.map(this::getAdapter);
}
@Override
*/
package org.opendaylight.mdsal.binding.dom.adapter;
-import com.google.common.base.Optional;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.LoadingCache;
+import java.util.Optional;
import org.opendaylight.mdsal.binding.api.BindingService;
import org.opendaylight.mdsal.binding.api.MountPoint;
import org.opendaylight.mdsal.dom.api.DOMMountPoint;
@Override
protected DOMService getDelegate(final Class<? extends DOMService> reqDeleg) {
- return domMountPoint.getService(reqDeleg).orNull();
+ return domMountPoint.getService(reqDeleg).orElse(null);
}
});
}
@Override
public <T extends BindingService> Optional<T> getService(final Class<T> service) {
- return services.getUnchecked(service).transform(service::cast);
+ return services.getUnchecked(service).map(service::cast);
}
}
import static java.util.Objects.requireNonNull;
import com.google.common.base.Function;
-import com.google.common.base.Optional;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import java.util.Collection;
import java.util.HashSet;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
* instance-identifier if it is possible to create representation.
*
* <p>
- * Returns Optional.absent for cases where target is mixin node except
+ * Returns Optional.empty for cases where target is mixin node except
* augmentation.
*/
public final Optional<InstanceIdentifier<? extends DataObject>> toBinding(final YangInstanceIdentifier normalized)
throws DeserializationException {
try {
- return Optional.fromNullable(codecRegistry.fromYangInstanceIdentifier(normalized));
+ return Optional.ofNullable(codecRegistry.fromYangInstanceIdentifier(normalized));
} catch (final IllegalArgumentException e) {
- return Optional.absent();
+ return Optional.empty();
}
}
@SuppressWarnings("unchecked")
final Entry<InstanceIdentifier<? extends DataObject>, DataObject> binding = Entry.class.cast(
codecRegistry.fromNormalizedNode(normalized.getKey(), normalized.getValue()));
- return Optional.fromNullable(binding);
+ return Optional.ofNullable(binding);
} catch (final IllegalArgumentException e) {
- return Optional.absent();
+ return Optional.empty();
}
}
@Deprecated
public final <T extends DataObject> Function<Optional<NormalizedNode<?, ?>>, Optional<T>> deserializeFunction(
final InstanceIdentifier<T> path) {
- return input -> Optional.fromJavaUtil(codecRegistry.deserializeFunction(path).apply(
- Optional.toJavaUtil(input)));
+ return codecRegistry.deserializeFunction(path)::apply;
}
public final BindingNormalizedNodeCodecRegistry getCodecRegistry() {
*/
package org.opendaylight.mdsal.binding.dom.adapter;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import com.google.common.util.concurrent.Futures;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Map.Entry;
+import java.util.Optional;
import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.mdsal.dom.api.DOMRpcResult;
*/
package org.opendaylight.mdsal.binding.dom.adapter.invoke;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodHandles.Lookup;
import java.lang.reflect.Method;
+import java.util.Optional;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.yangtools.yang.binding.DataContainer;
import org.opendaylight.yangtools.yang.binding.DataObject;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.junit.Test;
import org.opendaylight.mdsal.binding.api.MountPointService.MountPointListener;
import org.opendaylight.mdsal.binding.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
final BindingDOMMountPointServiceAdapter adapter =
new BindingDOMMountPointServiceAdapter(mountPointService, codec);
- doReturn(Optional.absent()).when(mountPointService).getMountPoint(any());
+ doReturn(Optional.empty()).when(mountPointService).getMountPoint(any());
assertFalse(adapter.getMountPoint(InstanceIdentifier.create(DataObject.class)).isPresent());
doReturn(Optional.of(mock(DOMMountPoint.class))).when(mountPointService).getMountPoint(any());
package org.opendaylight.mdsal.binding.dom.codec.api;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableCollection;
import java.util.List;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yangtools.yang.binding.BindingStreamEventWriter;
* same data was supplied and does not represent augmentation of this node.
*
* @param childClass
- * @return Context of child or Optional absent is supplied class is not
+ * @return Context of child or Optional.empty is supplied class is not
* applicable in context.
*/
<E extends DataObject> Optional<? extends BindingCodecTreeNode<E>> possibleStreamChild(
*/
package org.opendaylight.mdsal.binding.dom.codec.impl;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableListMultimap;
import com.google.common.collect.ImmutableMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import javax.annotation.Nonnull;
if (child != null) {
return Optional.of((DataContainerCodecContext<C, ?>) child.get());
}
- return Optional.absent();
+ return Optional.empty();
}
Iterable<Class<?>> getCaseChildrenClasses() {
*/
package org.opendaylight.mdsal.binding.dom.codec.impl;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.ImmutableSet;
import java.io.IOException;
import java.util.List;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeCachingCodec;
* must issue getChild(ChoiceClass).getChild(CaseClass).
*
* @param childClass child class
- * @return Context of child or Optional absent is supplied class is not applicable in context.
+ * @return Context of child or Optional.empty is supplied class is not applicable in context.
*/
@Override
public abstract <C extends DataObject> Optional<DataContainerCodecContext<C,?>> possibleStreamChild(
}
}
-}
\ No newline at end of file
+}
*/
package org.opendaylight.mdsal.binding.dom.codec.impl;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Throwables;
import com.google.common.collect.ImmutableMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.concurrent.ConcurrentHashMap;
if (childProto != null) {
return Optional.of((DataContainerCodecContext<C, ?>) childProto.get());
}
- return Optional.absent();
+ return Optional.empty();
}
@Override
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import java.lang.reflect.InvocationHandler;
import java.util.Arrays;
import java.util.Map;
import java.util.Objects;
+import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import org.opendaylight.mdsal.binding.dom.codec.util.AugmentationReader;
import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
*/
package org.opendaylight.mdsal.binding.dom.codec.impl;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableCollection;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
+import java.util.Optional;
import java.util.Set;
import javax.annotation.Nullable;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingCodecTreeNode;
@Nullable Object defaultObject() {
return defaultObject;
}
-}
\ No newline at end of file
+}
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Verify.verify;
-import com.google.common.base.Optional;
import com.google.common.base.Throwables;
import com.google.common.base.Verify;
import com.google.common.cache.CacheBuilder;
import com.google.common.util.concurrent.UncheckedExecutionException;
import java.lang.reflect.Type;
import java.util.List;
+import java.util.Optional;
import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
import org.opendaylight.yangtools.util.ClassLoaderUtils;
package org.opendaylight.mdsal.binding.generator.impl;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.HashSet;
import java.util.Iterator;
+import java.util.Optional;
import java.util.Set;
import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
import org.opendaylight.mdsal.binding.spec.reflect.BindingReflections;
Preconditions.checkArgument(currentArg != null);
QName currentQName = BindingReflections.findQName(currentArg.getType());
- Optional<DataNodeContainer> currentContainer = Optional.absent();
+ Optional<DataNodeContainer> currentContainer = Optional.empty();
if (BindingReflections.isNotification(currentArg.getType())) {
currentContainer = findNotification(ctx, currentQName);
} else if (BindingReflections.isRpcType(currentArg.getType())) {
if (potential.isPresent()) {
currentContainer = potential;
} else {
- return Optional.absent();
+ return Optional.empty();
}
}
return currentContainer;
return Optional.<DataNodeContainer> of(notification);
}
}
- return Optional.absent();
+ return Optional.empty();
}
private static Optional<DataNodeContainer> findDataNodeContainer(final DataNodeContainer ctx,
}
}
- return Optional.absent();
+ return Optional.empty();
}
private static DataNodeContainer findInCases(final ChoiceSchemaNode choiceNode, final QName targetQName) {
}
}
}
- return Optional.absent();
+ return Optional.empty();
}
private static Optional<DataNodeContainer> findInputOutput(final RpcDefinition rpc, final String targetType) {
if (targetType.equals(rpcOutputName)) {
return Optional.of(rpc.getOutput());
}
- return Optional.absent();
+ return Optional.empty();
}
public static Set<AugmentationSchemaNode> collectAllAugmentationDefinitions(final SchemaContext currentSchema,
return Optional.of((ChoiceSchemaNode) potential);
}
- return Optional.absent();
+ return Optional.empty();
}
public static Optional<CaseSchemaNode> findInstantiatedCase(final ChoiceSchemaNode instantiatedChoice,
return Optional.of(caze);
}
}
- return Optional.absent();
+ return Optional.empty();
}
}
*/
package org.opendaylight.mdsal.binding.generator.impl;
-import com.google.common.base.Optional;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.lang.ref.WeakReference;
+import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import org.opendaylight.mdsal.binding.generator.api.ClassLoadingStrategy;
// Implement remove ModuleInfo to update SchemaContext
public Optional<SchemaContext> tryToCreateSchemaContext() {
- return Optional.fromJavaUtil(ctxResolver.getSchemaContext());
+ return ctxResolver.getSchemaContext();
}
private boolean resolveModuleInfo(final Class<?> cls) {
import static com.google.common.base.Preconditions.checkState;
import com.google.common.base.MoreObjects;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
import javax.annotation.Nullable;
import org.opendaylight.mdsal.binding.generator.api.BindingRuntimeTypes;
*
* @param schema Resolved parent choice schema
* @param childClass Class representing case.
- * @return Optionally a resolved case schema, absent if the choice is not legal in
+ * @return Optionally a resolved case schema,.empty if the choice is not legal in
* the given context.
* @throws IllegalArgumentException If supplied class does not represent case.
*/
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkState;
-import com.google.common.base.Optional;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.ServiceLoader;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
* have name. May return null if QName is not present.
*/
public static QName findQName(final Class<?> dataType) {
- return CLASS_TO_QNAME.getUnchecked(dataType).orNull();
+ return CLASS_TO_QNAME.getUnchecked(dataType).orElse(null);
}
/**
*
* @param targetMethod
* method to scan
- * @return Optional.absent() if result type could not be get, or return type is Void.
+ * @return Optional.empty() if result type could not be get, or return type is Void.
*/
@SuppressWarnings("rawtypes")
public static Optional<Class<?>> resolveRpcOutputClass(final Method targetMethod) {
if (rpcResultArgument instanceof Class && !Void.class.equals(rpcResultArgument)) {
return Optional.of((Class) rpcResultArgument);
}
- return Optional.absent();
+ return Optional.empty();
}
/**
*
* @param targetMethod
* method to scan
- * @return Optional.absent() if RPC has no input, RPC input type otherwise.
+ * @return Optional.empty() if RPC has no input, RPC input type otherwise.
*/
@SuppressWarnings("rawtypes")
public static Optional<Class<? extends DataContainer>> resolveRpcInputClass(final Method targetMethod) {
return Optional.of(clazz);
}
}
- return Optional.absent();
+ return Optional.empty();
}
public static QName getQName(final Class<? extends BaseIdentity> context) {
private static Optional<Class<? extends DataContainer>> getYangModeledReturnType(final Method method) {
if ("getClass".equals(method.getName()) || !method.getName().startsWith("get")
|| method.getParameterTypes().length > 0) {
- return Optional.absent();
+ return Optional.empty();
}
Class returnType = method.getReturnType();
&& DataContainer.class.isAssignableFrom((Class) listResult)) {
return Optional.of((Class) listResult);
}
- return Optional.absent();
+ return Optional.empty();
});
} catch (Exception e) {
/*
LOG.debug("Unable to find YANG modeled return type for {}", method, e);
}
}
- return Optional.absent();
+ return Optional.empty();
}
private static class ClassToQNameLoader extends CacheLoader<Class<?>, Optional<QName>> {
*/
LOG.debug("Unexpected exception during extracting QName for {}", key, e);
}
- return Optional.absent();
+ return Optional.empty();
}
/**
import static com.google.common.base.Preconditions.checkState;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMap.Builder;
import java.lang.reflect.InvocationTargetException;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.binding.Augmentable;
import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.binding.DataContainer;
@SuppressWarnings("unchecked")
T potential = (T) resolveReadStrategy(parentClass, child).read(source, child);
- return Optional.fromNullable(potential);
+ return Optional.ofNullable(potential);
}
@SuppressWarnings("rawtypes")
package org.opendaylight.mdsal.binding.javav2.api;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.mdsal.binding.javav2.spec.base.InstanceIdentifier;
import org.opendaylight.yangtools.concepts.Identifiable;
package org.opendaylight.mdsal.binding.javav2.api;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.mdsal.binding.javav2.spec.base.InstanceIdentifier;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
package org.opendaylight.mdsal.binding.javav2.dom.adapter.impl.mountpoint;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.mdsal.binding.javav2.api.MountPointListener;
import org.opendaylight.mdsal.binding.javav2.dom.codec.impl.BindingToNormalizedNodeCodec;
package org.opendaylight.mdsal.binding.javav2.dom.adapter.impl.mountpoint;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.mdsal.binding.javav2.api.MountPoint;
import org.opendaylight.mdsal.binding.javav2.api.MountPointListener;
final YangInstanceIdentifier domPath = codec.toYangInstanceIdentifierBlocking(mountPoint);
final Optional<DOMMountPoint> domMount = mountService.getMountPoint(domPath);
if (domMount.isPresent()) {
- return Optional.fromNullable(bindingMountpoints.getUnchecked(domMount.get()));
+ return Optional.ofNullable(bindingMountpoints.getUnchecked(domMount.get()));
}
- return Optional.absent();
+ return Optional.empty();
}
@Override
package org.opendaylight.mdsal.binding.javav2.dom.adapter.impl.mountpoint;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.LoadingCache;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.mdsal.binding.javav2.api.BindingService;
@Nullable
@Override
protected DOMService getDelegate(final Class<? extends DOMService> reqDeleg) {
- return domMountPoint.getService(reqDeleg).orNull();
+ return domMountPoint.getService(reqDeleg).orElse(null);
}
});
}
if (potential.isPresent()) {
return Optional.of(service.cast(potential.get()));
}
- return Optional.absent();
+ return Optional.empty();
}
-}
\ No newline at end of file
+}
import com.google.common.annotations.Beta;
import com.google.common.base.Function;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import com.google.common.util.concurrent.Futures;
import java.lang.reflect.Proxy;
import java.util.Collection;
import java.util.Map.Entry;
+import java.util.Optional;
import org.opendaylight.mdsal.binding.javav2.dom.adapter.extractor.ContextReferenceExtractor;
import org.opendaylight.mdsal.binding.javav2.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
import org.opendaylight.mdsal.binding.javav2.dom.codec.impl.BindingToNormalizedNodeCodec;
package org.opendaylight.mdsal.binding.javav2.dom.adapter.impl.operation.invoker;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import com.google.common.base.Throwables;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodHandles.Lookup;
import java.lang.reflect.Method;
+import java.util.Optional;
import java.util.concurrent.Future;
import org.opendaylight.mdsal.binding.javav2.runtime.reflection.BindingReflections;
import org.opendaylight.mdsal.binding.javav2.spec.base.Instantiable;
package org.opendaylight.mdsal.binding.javav2.dom.adapter.spi;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
import org.opendaylight.mdsal.binding.javav2.dom.codec.impl.BindingToNormalizedNodeCodec;
import org.opendaylight.mdsal.binding.javav2.spec.base.InstanceIdentifier;
@SuppressWarnings("unchecked")
protected Optional<TreeNode> toBindingData(final InstanceIdentifier<?> path, final NormalizedNode<?, ?> data) {
if (path.isWildcarded()) {
- return Optional.absent();
+ return Optional.empty();
}
return (Optional<TreeNode>) getCodec().deserializeFunction(path)
.apply(Optional.of(data));
package org.opendaylight.mdsal.binding.javav2.dom.adapter.spi;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.MoreExecutors;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.mdsal.binding.javav2.dom.codec.impl.BindingToNormalizedNodeCodec;
import org.opendaylight.mdsal.binding.javav2.spec.base.InstanceIdentifier;
Preconditions.checkArgument(!path.isWildcarded(), "Invalid read of wildcarded path %s", path);
return readTx.read(store, codec.toYangInstanceIdentifierBlocking(path))
- .transform(Optional::fromJavaUtil, MoreExecutors.directExecutor())
- .transform(codec.deserializeFunction(path), MoreExecutors.directExecutor());
+ .transform(codec.deserializeFunction(path)::apply, MoreExecutors.directExecutor());
}
}
package org.opendaylight.mdsal.binding.javav2.dom.adapter.spi.loader;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import com.google.common.cache.CacheLoader;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.mdsal.binding.javav2.dom.adapter.spi.builder.AdapterBuilder;
if (deleg != null) {
builder.addDelegate(reqDeleg, deleg);
} else {
- return Optional.absent();
+ return Optional.empty();
}
}
return Optional.of(builder.build());
}
-}
\ No newline at end of file
+}
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.junit.Test;
import org.opendaylight.mdsal.binding.javav2.api.MountPointListener;
import org.opendaylight.mdsal.binding.javav2.dom.codec.impl.BindingNormalizedNodeCodecRegistry;
final BindingDOMMountPointServiceAdapter adapter =
new BindingDOMMountPointServiceAdapter(mountPointService, codec);
- doReturn(Optional.absent()).when(mountPointService).getMountPoint(any());
+ doReturn(Optional.empty()).when(mountPointService).getMountPoint(any());
assertFalse(adapter.getMountPoint(InstanceIdentifier.create(TreeNode.class)).isPresent());
doReturn(Optional.of(mock(DOMMountPoint.class))).when(mountPointService).getMountPoint(any());
package org.opendaylight.mdsal.binding.javav2.dom.codec.api;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableCollection;
import java.util.List;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.mdsal.binding.javav2.spec.base.TreeArgument;
* @param childClass
* - child class by Binding Stream navigation
* @param <E> data type
- * @return context of child or Optional absent if supplied is not applicable
+ * @return context of child or Optional.empty if supplied is not applicable
* in context
*/
<E extends TreeNode> Optional<? extends BindingTreeNodeCodec<E>> possibleStreamChild(@Nonnull Class<E> childClass);
import com.google.common.annotations.Beta;
import com.google.common.base.Function;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import java.util.ArrayList;
import java.util.List;
import java.util.Map.Entry;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.mdsal.binding.javav2.dom.codec.api.BindingTreeCodec;
if (input.isPresent()) {
return Optional.of((T) ctx.deserialize(input.get()));
}
- return Optional.absent();
+ return Optional.empty();
}
}
import com.google.common.annotations.Beta;
import com.google.common.base.Function;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import java.util.HashSet;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import javax.annotation.Nonnull;
* create representation.
*
* <p>
- * Returns Optional.absent for cases where target is mixin node except augmentation.
+ * Returns Optional.empty for cases where target is mixin node except augmentation.
*
*/
public Optional<InstanceIdentifier<? extends TreeNode>> toBinding(final YangInstanceIdentifier normalized)
throws DeserializationException {
try {
- return Optional.fromNullable(codecRegistry.fromYangInstanceIdentifier(normalized));
+ return Optional.ofNullable(codecRegistry.fromYangInstanceIdentifier(normalized));
} catch (final IllegalArgumentException e) {
- return Optional.absent();
+ return Optional.empty();
}
}
try {
final Entry<InstanceIdentifier<? extends TreeNode>, TreeNode> binding =
Entry.class.cast(codecRegistry.fromNormalizedNode(normalized.getKey(), normalized.getValue()));
- return Optional.fromNullable(binding);
+ return Optional.ofNullable(binding);
} catch (final IllegalArgumentException e) {
- return Optional.absent();
+ return Optional.empty();
}
}
package org.opendaylight.mdsal.binding.javav2.dom.codec.impl.context;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Iterables;
import java.util.HashSet;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
import javax.annotation.Nonnull;
import org.opendaylight.mdsal.binding.javav2.dom.codec.impl.context.base.DataContainerCodecContext;
if (child != null) {
return Optional.of((DataContainerCodecContext<C, ?>) child.get());
}
- return Optional.absent();
+ return Optional.empty();
}
Iterable<Class<?>> getCaseChildrenClasses() {
package org.opendaylight.mdsal.binding.javav2.dom.codec.impl.context;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Throwables;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.LoadingCache;
import com.google.common.util.concurrent.UncheckedExecutionException;
import java.util.Iterator;
+import java.util.Optional;
import java.util.Set;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
throw e;
}
}
-}
\ No newline at end of file
+}
package org.opendaylight.mdsal.binding.javav2.dom.codec.impl.context.base;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableCollection;
import java.lang.reflect.Method;
import java.util.List;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.mdsal.binding.javav2.dom.codec.api.BindingNormalizedNodeCachingCodec;
import org.opendaylight.mdsal.binding.javav2.dom.codec.api.BindingTreeNodeCodec;
* 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.mdsal.binding.javav2.dom.codec.impl.context.base;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.ImmutableSet;
import java.io.IOException;
import java.util.List;
+import java.util.Optional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.mdsal.binding.javav2.dom.codec.api.BindingNormalizedNodeCachingCodec;
* case, one must issue getChild(ChoiceClass).getChild(CaseClass).
*
* @param childClass input child class
- * @return Context of child or Optional absent is supplied class is not applicable in context.
+ * @return Context of child or Optional.empty is supplied class is not applicable in context.
*/
@Override
public abstract <C extends TreeNode> Optional<DataContainerCodecContext<C, ?>> possibleStreamChild(@Nonnull
}
}
-}
\ No newline at end of file
+}
Preconditions.checkNotNull(cls,"Supplied augmentation must not be null.");
@SuppressWarnings({"unchecked","rawtypes"})
- final Optional<DataContainerCodecContext<?,?>> augCtx = context.possibleStreamChild((Class) cls).toJavaUtil();
+ final Optional<DataContainerCodecContext<?,?>> augCtx = context.possibleStreamChild((Class) cls);
if (augCtx.isPresent()) {
final Optional<NormalizedNode<?, ?>> augData = data.getChild(augCtx.get().getDomPathArgument());
if (augData.isPresent()) {
* 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.mdsal.binding.javav2.dom.codec.impl.context.base;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableCollection;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
+import java.util.Optional;
import java.util.Set;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
Object defaultObject() {
return defaultObject;
}
-}
\ No newline at end of file
+}
package org.opendaylight.mdsal.binding.javav2.dom.codec.impl.context.base;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.base.Throwables;
import com.google.common.collect.ImmutableMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.concurrent.ConcurrentHashMap;
if (childProto != null) {
return Optional.of((DataContainerCodecContext<C,?>) childProto.get());
}
- return Optional.absent();
+ return Optional.empty();
}
@Nonnull
return getDomPathArgument();
}
-}
\ No newline at end of file
+}
import com.google.common.annotations.Beta;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.Collection;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import org.opendaylight.mdsal.binding.javav2.generator.context.ModuleContext;
import org.opendaylight.mdsal.binding.javav2.generator.spi.TypeProvider;
static Optional<QName> getRoutingContext(final DataSchemaNode schemaNode) {
for (UnknownSchemaNode extension : schemaNode.getUnknownSchemaNodes()) {
if (CONTEXT_REFERENCE.equals(extension.getNodeType())) {
- return Optional.fromNullable(extension.getQName());
+ return Optional.ofNullable(extension.getQName());
}
}
- return Optional.absent();
+ return Optional.empty();
}
private static void resolveActions(final DataNodeContainer parent, final Module module,
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import org.junit.Ignore;
import org.junit.Test;
import static org.opendaylight.mdsal.binding.javav2.util.BindingMapping.MODEL_BINDING_PROVIDER_CLASS_NAME;
import static org.opendaylight.mdsal.binding.javav2.util.BindingMapping.getRootPackageName;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableSet;
import java.io.IOException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import java.util.TreeMap;
import java.util.function.Function;
public String getModelBindingProviderName() {
return modelBindingProviderName;
}
-}
\ No newline at end of file
+}
package org.opendaylight.mdsal.binding.javav2.runtime.context;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import java.util.HashSet;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import java.util.Set;
import javax.annotation.Nullable;
import org.opendaylight.mdsal.binding.javav2.generator.api.ClassLoadingStrategy;
* - resolved parent choice schema
* @param childClass
* - class representing case.
- * @return Optionally a resolved case schema, absent if the choice is not
+ * @return Optionally a resolved case schema,.empty if the choice is not
* legal in the given context.
* @throws IllegalArgumentException
* - if supplied class does not represent case
import com.google.common.annotations.Beta;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Optional;
import com.google.common.io.ByteSource;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.io.IOException;
import java.io.InputStream;
import java.lang.ref.WeakReference;
+import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import org.opendaylight.mdsal.binding.javav2.generator.api.ClassLoadingStrategy;
* @return optional of schema context
*/
public Optional<SchemaContext> tryToCreateSchemaContext() {
- return Optional.fromJavaUtil(ctxResolver.getSchemaContext());
+ return ctxResolver.getSchemaContext();
}
private boolean resolveModuleInfo(final Class<?> cls) {
package org.opendaylight.mdsal.binding.javav2.runtime.context.util;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import java.util.Iterator;
+import java.util.Optional;
import java.util.Set;
import org.opendaylight.mdsal.binding.javav2.generator.util.JavaIdentifier;
import org.opendaylight.mdsal.binding.javav2.generator.util.JavaIdentifierNormalizer;
* - schema context
* @param path
* - binding path
- * @return node container by binding path if exists, absent otherwise
+ * @return node container by binding path if exists,.empty otherwise
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
public static Optional<DataNodeContainer> findDataNodeContainer(final SchemaContext ctx,
if (potential.isPresent()) {
currentContainer = potential;
} else {
- return Optional.absent();
+ return Optional.empty();
}
}
return currentContainer;
return Optional.of(notification);
}
}
- return Optional.absent();
+ return Optional.empty();
}
private static Optional<DataNodeContainer> findDataNodeContainer(final DataNodeContainer ctx,
}
}
- return Optional.absent();
+ return Optional.empty();
}
private static DataNodeContainer findInCases(final ChoiceSchemaNode choiceNode, final QName targetQName) {
}
}
}
- return Optional.absent();
+ return Optional.empty();
}
private static Optional<DataNodeContainer> findInputOutput(final OperationDefinition operation,
} else if (targetType.equals(actionOutputName)) {
return Optional.of(operation.getOutput());
}
- return Optional.absent();
+ return Optional.empty();
}
/**
* - choice parent
* @param choiceClass
* - choice binding class
- * @return choice schema node if exists, absent() otherwise
+ * @return choice schema node if exists,.empty() otherwise
*/
public static Optional<ChoiceSchemaNode> findInstantiatedChoice(final DataNodeContainer parent, final Class<?> choiceClass) {
return findInstantiatedChoice(parent, BindingReflections.findQName(choiceClass));
* - parent node
* @param choiceName
* - qname of choice
- * @return choice schema node if exists, absent() otherwise
+ * @return choice schema node if exists,.empty() otherwise
*/
public static Optional<ChoiceSchemaNode> findInstantiatedChoice(final DataNodeContainer ctxNode, final QName choiceName) {
final DataSchemaNode potential = ctxNode.getDataChildByName(choiceName);
return Optional.of((ChoiceSchemaNode) potential);
}
- return Optional.absent();
+ return Optional.empty();
}
/**
* - choice
* @param originalDefinition
* - choice case
- * @return choice case node if exists, absent() otherwise
+ * @return choice case node if exists,.empty() otherwise
*/
public static Optional<CaseSchemaNode> findInstantiatedCase(final ChoiceSchemaNode instantiatedChoice, final CaseSchemaNode originalDefinition) {
final QName qname = originalDefinition.getQName();
return Optional.of(found);
}
}
- return Optional.absent();
+ return Optional.empty();
}
}
import static com.google.common.base.Preconditions.checkState;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.ServiceLoader;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
* May return null if QName is not present.
*/
public static QName findQName(final Class<?> dataType) {
- return CLASS_TO_QNAME.getUnchecked(dataType).orNull();
+ return CLASS_TO_QNAME.getUnchecked(dataType).orElse(null);
}
/**
*
* @param targetMethod
* method to scan
- * @return Optional.absent() if result type could not be get, or return type
+ * @return Optional.empty() if result type could not be get, or return type
* is Void.
*/
@SuppressWarnings("rawtypes")
if (operationResultArgument instanceof Class && !Void.class.equals(operationResultArgument)) {
return Optional.of((Class) operationResultArgument);
}
- return Optional.absent();
+ return Optional.empty();
}
/**
*
* @param targetMethod
* - method to scan
- * @return Optional.absent() if RPC or Action has no input, RPC input type
+ * @return Optional.empty() if RPC or Action has no input, RPC input type
* otherwise.
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
return Optional.of(clazz);
}
}
- return Optional.absent();
+ return Optional.empty();
}
/**
private static Optional<Class<? extends Instantiable<?>>> getYangModeledReturnType(final Method method) {
if ("getClass".equals(method.getName()) || !method.getName().startsWith("get")
|| method.getParameterTypes().length > 0) {
- return Optional.absent();
+ return Optional.empty();
}
final Class returnType = method.getReturnType();
&& Instantiable.class.isAssignableFrom((Class) listResult)) {
return Optional.of((Class) listResult);
}
- return Optional.absent();
+ return Optional.empty();
});
} catch (final Exception e) {
/*
LOG.debug("Unable to find YANG modeled return type for {}", method, e);
}
}
- return Optional.absent();
+ return Optional.empty();
}
private static class ClassToQNameLoader extends CacheLoader<Class<?>, Optional<QName>> {
*/
LOG.debug("Unexpected exception during extracting QName for {}", key, e);
}
- return Optional.absent();
+ return Optional.empty();
}
/**
package org.opendaylight.mdsal.binding.javav2.spec.runtime;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import java.io.InputStream;
+import java.util.Optional;
import java.util.Set;
import org.opendaylight.yangtools.concepts.SemVer;
import org.opendaylight.yangtools.yang.model.repo.api.SchemaSourceRepresentation;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkState;
-import com.google.common.base.Optional;
+
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.ServiceLoader;
import java.util.concurrent.Callable;
import java.util.concurrent.Future;
*
* @param targetMethod
* method to scan
- * @return Optional.absent() if result type could not be get, or return type
+ * @return Optional.empty() if result type could not be get, or return type
* is Void.
*/
@SuppressWarnings("rawtypes")
if (rpcResultArgument instanceof Class && !Void.class.equals(rpcResultArgument)) {
return Optional.<Class<?>> of((Class) rpcResultArgument);
}
- return Optional.absent();
+ return Optional.empty();
}
/**
*
* @param targetMethod
* method to scan
- * @return Optional.absent() if rpc has no input, Rpc input type otherwise.
+ * @return Optional.empty() if rpc has no input, Rpc input type otherwise.
*/
@SuppressWarnings("unchecked")
public static Optional<Class<? extends InterfaceTyped>> resolveRpcInputClass(final Method targetMethod) {
@SuppressWarnings("rawtypes")
Class[] types = targetMethod.getParameterTypes();
if (types.length == 0) {
- return Optional.absent();
+ return Optional.empty();
}
if (types.length == 1) {
return Optional.<Class<? extends InterfaceTyped>> of(types[0]);
private static Optional<Class<? extends InterfaceTyped>> getYangModeledReturnType(final Method method) {
if (method.getName().equals("getClass") || !method.getName().startsWith("get")
|| method.getParameterTypes().length > 0) {
- return Optional.absent();
+ return Optional.empty();
}
@SuppressWarnings("rawtypes")
&& InterfaceTyped.class.isAssignableFrom((Class) listResult)) {
return Optional.<Class<? extends InterfaceTyped>> of((Class) listResult);
}
- return Optional.absent();
+ return Optional.empty();
}
});
LOG.debug("Unable to find YANG modeled return type for {}", method, e);
}
}
- return Optional.absent();
+ return Optional.empty();
}
private static class ClassToQNameLoader extends CacheLoader<Class<?>, Optional<QName>> {
*/
LOG.debug("Unexpected exception during extracting QName for {}", key, e);
}
- return Optional.absent();
+ return Optional.empty();
}
/**
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkState;
-import com.google.common.base.Optional;
+
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMap.Builder;
import java.lang.reflect.InvocationTargetException;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.binding.Augmentable;
import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.opendaylight.yangtools.yang.binding.InterfaceTyped;
@SuppressWarnings("unchecked")
T potential = (T) resolveReadStrategy(parentClass, child).read(source, child);
- return Optional.fromNullable(potential);
+ return Optional.ofNullable(potential);
}
@SuppressWarnings("rawtypes")
import static com.sun.xml.internal.ws.policy.sourcemodel.wspolicy.XmlToken.Optional;
-import com.google.common.base.Optional;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodHandles.Lookup;
import java.lang.reflect.Method;
+import java.util.Optional;
import java.util.concurrent.Future;
import org.opendaylight.yangtools.yang.binding.InterfaceTyped;
import org.opendaylight.yangtools.yang.binding.TreeNode;
/**
* Returns the value result of the call.
*
- * @return Invocation result, absent if the operation has not produced a result. This might be the case if the
+ * @return Invocation result,.empty if the operation has not produced a result. This might be the case if the
* operation does not produce a result, or if it failed.
*/
Optional<ContainerNode> getOutput();
* <li>If the data at the supplied path exists, the Future returns an Optional object
* containing the data.</li>
* <li>If the data at the supplied path does not exist, the Future returns
- * Optional#absent().</li>
+ * Optional.empty().</li>
* <li>If the read of the data fails, the Future will fail with a
* {@link ReadFailedException} or an exception derived from ReadFailedException.</li>
* </ul>
*/
package org.opendaylight.mdsal.dom.api;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
package org.opendaylight.mdsal.dom.api;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import static java.util.Objects.requireNonNull;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
import com.google.common.collect.MutableClassToInstanceMap;
import java.util.HashMap;
import java.util.Map;
+import java.util.Optional;
import org.opendaylight.mdsal.dom.api.DOMMountPoint;
import org.opendaylight.mdsal.dom.api.DOMMountPointListener;
import org.opendaylight.mdsal.dom.api.DOMMountPointService;
@Override
public Optional<DOMMountPoint> getMountPoint(final YangInstanceIdentifier path) {
- return Optional.fromNullable(mountPoints.get(path));
+ return Optional.ofNullable(mountPoints.get(path));
}
@Override
* 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.mdsal.dom.store.inmemory;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ForwardingObject;
+import java.util.Optional;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteCursor;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
}
public Optional<NormalizedNode<?, ?>> readNode(final PathArgument child) {
- return Optional.fromJavaUtil(delegate.readNode(child));
+ return delegate.readNode(child);
}
@Override
*/
package org.opendaylight.mdsal.dom.spi;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
+import java.util.Optional;
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
public static Optional<QName> getRoutingContext(final DataSchemaNode schemaNode) {
for (UnknownSchemaNode extension : schemaNode.getUnknownSchemaNodes()) {
if (CONTEXT_REFERENCE.equals(extension.getNodeType())) {
- return Optional.fromNullable(extension.getQName());
+ return Optional.ofNullable(extension.getQName());
}
}
- return Optional.absent();
+ return Optional.empty();
}
private static final class RoutedRpcStrategy extends RpcRoutingStrategy {
* 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.mdsal.dom.spi;
-import com.google.common.base.Optional;
import com.google.common.collect.ClassToInstanceMap;
import com.google.common.collect.ImmutableClassToInstanceMap;
+import java.util.Optional;
import org.opendaylight.mdsal.dom.api.DOMMountPoint;
import org.opendaylight.mdsal.dom.api.DOMService;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
@Override
public <T extends DOMService> Optional<T> getService(final Class<T> cls) {
- return Optional.fromNullable(services.getInstance(cls));
+ return Optional.ofNullable(services.getInstance(cls));
}
}
*/
package org.opendaylight.mdsal.dom.spi.shard;
-import com.google.common.base.Optional;
import com.google.common.collect.ForwardingObject;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshotCursor;
@Override
public Optional<NormalizedNode<?, ?>> readNode(final PathArgument arg) {
- return Optional.fromJavaUtil(delegate().readNode(arg));
+ return delegate().readNode(arg);
}
@Override
delegate().enter(arg);
return this;
}
-}
\ No newline at end of file
+}
package org.opendaylight.mdsal.dom.spi.shard;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
* <li>If the data at the supplied path exists, the Future returns an Optional object
* containing the data.</li>
* <li>If the data at the supplied path does not exist, the Future returns
- * Optional#absent().</li>
+ * Optional.empty().</li>
* <li>If the read of the data fails, the Future will fail with a
* {@link ReadFailedException} or an exception derived from ReadFailedException.</li>
* </ul>
*/
package org.opendaylight.mdsal.eos.binding.dom.adapter;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.mdsal.eos.binding.api.Entity;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
-import com.google.common.base.Optional;
+import java.util.Optional;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
package org.opendaylight.mdsal.eos.binding.api;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
import org.opendaylight.mdsal.eos.common.api.EntityOwnershipState;
*/
package org.opendaylight.mdsal.eos.common.api;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.concepts.Path;
package org.opendaylight.mdsal.eos.dom.api;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
import org.opendaylight.mdsal.eos.common.api.EntityOwnershipState;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.HashBasedTable;
import com.google.common.collect.Multimap;
import com.google.common.collect.Table;
import java.util.Collection;
+import java.util.Optional;
import java.util.UUID;
import javax.annotation.concurrent.GuardedBy;
import org.kohsuke.MetaInfServices;
@Override
public Optional<EntityOwnershipState> getOwnershipState(final DOMEntity forEntity) {
- return isCandidateRegistered(forEntity) ? Optional.of(EntityOwnershipState.IS_OWNER) : Optional.absent();
+ return isCandidateRegistered(forEntity) ? Optional.of(EntityOwnershipState.IS_OWNER) : Optional.empty();
}
@Override
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyZeroInteractions;
-import com.google.common.base.Optional;
+import java.util.Optional;
import java.util.UUID;
import org.junit.Before;
import org.junit.Test;
Code Review / mdsal.git / commitdiff