summary |
shortlog |
log |
commit | commitdiff |
review |
tree
raw |
patch |
inline | side by side (from parent 1:
093728d)
Updated checkstyle does not like some our docs, fix them up.
Change-Id: I2d4f608fe9c44a56cdcac511cc1e2ae75c03b413
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
- protected RaftActorBehavior handleRequestVoteReply(final ActorRef sender,
- final RequestVoteReply requestVoteReply) {
+ protected RaftActorBehavior handleRequestVoteReply(final ActorRef sender, final RequestVoteReply requestVoteReply) {
- protected void beforeSendHeartbeat(){}
+ protected void beforeSendHeartbeat() {
+ // No-op
+ }
@Override
public RaftActorBehavior handleMessage(final ActorRef sender, final Object message) {
@Override
public RaftActorBehavior handleMessage(final ActorRef sender, final Object message) {
*/
@Deprecated
public interface ReadTransaction extends AsyncReadTransaction<InstanceIdentifier<?>, DataObject> {
*/
@Deprecated
public interface ReadTransaction extends AsyncReadTransaction<InstanceIdentifier<?>, DataObject> {
/**
* Reads data from the provided logical data store located at the provided path.
/**
* Reads data from the provided logical data store located at the provided path.
- *<p>
- * If the target is a subtree, then the whole subtree is read (and will be
- * accessible from the returned data object).
- * @param store
- * Logical data store from which read should occur.
- * @param path
- * Path which uniquely identifies subtree which client want to
- * read
+ * <p>
+ * If the target is a subtree, then the whole subtree is read (and will be accessible from the returned data
+ * object).
+ *
+ * @param store Logical data store from which read should occur.
+ * @param path Path which uniquely identifies subtree which client want to read
* @return a CheckFuture containing the result of the read. The Future blocks until the
* commit operation is complete. Once complete:
* <ul>
* @return a CheckFuture containing the result of the read. The Future blocks until the
* commit operation is complete. Once complete:
* <ul>
* Default implementation delegates to {@link #read(LogicalDatastoreType, InstanceIdentifier)}, implementations
* are advised to provide a more efficient override.
*
* Default implementation delegates to {@link #read(LogicalDatastoreType, InstanceIdentifier)}, implementations
* are advised to provide a more efficient override.
*
- * @param store
- * Logical data store from which read should occur.
- * @param path
- * Path which uniquely identifies subtree which client want to
- * check existence of
+ * @param store Logical data store from which read should occur.
+ * @param path Path which uniquely identifies subtree which client want to check existence of
* @return a CheckFuture containing the result of the check.
* <ul>
* <li>If the data at the supplied path exists, the Future returns a Boolean
* @return a CheckFuture containing the result of the check.
* <ul>
* <li>If the data at the supplied path exists, the Future returns a Boolean
*/
@Deprecated
public interface WriteTransaction extends AsyncWriteTransaction<InstanceIdentifier<?>, DataObject> {
*/
@Deprecated
public interface WriteTransaction extends AsyncWriteTransaction<InstanceIdentifier<?>, DataObject> {
- * Stores a piece of data at the specified path. This acts as an add / replace
- * operation, which is to say that whole subtree will be replaced by the specified data.
- * * <p>
+ * Stores a piece of data at the specified path. This acts as an add / replace operation, which is to say that whole
+ * subtree will be replaced by the specified data.
+ *
+ * <p>
* This method does not automatically create missing parent nodes. It is equivalent to invoking
* This method does not automatically create missing parent nodes. It is equivalent to invoking
- * {@link #put(LogicalDatastoreType, InstanceIdentifier, DataObject, boolean)}
- * with <code>createMissingParents</code> set to false.
+ * {@link #put(LogicalDatastoreType, InstanceIdentifier, DataObject, boolean)} with {@code createMissingParents} set
+ * to false.
+ *
* <p>
* For more information on usage and examples, please see the documentation in {@link AsyncWriteTransaction}.
* <p>
* For more information on usage and examples, please see the documentation in {@link AsyncWriteTransaction}.
- * If you need to make sure that a parent object exists but you do not want modify
- * its pre-existing state by using put, consider using {@link #merge} instead.
+ * If you need to make sure that a parent object exists but you do not want modify its pre-existing state by using
+ * put, consider using {@link #merge} instead.
- * @param store
- * the logical data store which should be modified
- * @param path
- * the data object path
- * @param data
- * the data object to be written to the specified path
- * @throws IllegalStateException
- * if the transaction has already been submitted
+ * @param store the logical data store which should be modified
+ * @param path the data object path
+ * @param data the data object to be written to the specified path
+ * @throws IllegalStateException if the transaction has already been submitted
*/
<T extends DataObject> void put(LogicalDatastoreType store, InstanceIdentifier<T> path, T data);
*/
<T extends DataObject> void put(LogicalDatastoreType store, InstanceIdentifier<T> path, T data);
- * Stores a piece of data at the specified path. This acts as an add /
- * replace operation, which is to say that whole subtree will be replaced by
- * the specified data.
+ * Stores a piece of data at the specified path. This acts as an add / replace operation, which is to say that whole
+ * subtree will be replaced by the specified data.
+ *
- * For more information on usage and examples, please see the documentation
- * in {@link AsyncWriteTransaction}.
+ * For more information on usage and examples, please see the documentation in {@link AsyncWriteTransaction}.
+ *
- * If you need to make sure that a parent object exists but you do not want
- * modify its pre-existing state by using put, consider using {@link #merge}
- * instead.
+ * If you need to make sure that a parent object exists but you do not want modify its pre-existing state by using
+ * put, consider using {@link #merge} instead.
- * Note: Using <code>createMissingParents</code> with value true, may
- * introduce garbage in data store, or recreate nodes, which were deleted by
- * previous transaction.
+ * <p>
+ * Note: Using <code>createMissingParents</code> with value true, may introduce garbage in data store, or recreate
+ * nodes, which were deleted by previous transaction.
- * @param store
- * the logical data store which should be modified
- * @param path
- * the data object path
- * @param data
- * the data object to be written to the specified path
- * @param createMissingParents
- * if {@link #CREATE_MISSING_PARENTS} ({@code true}), any missing
- * parent nodes will be automatically created using a merge
- * operation.
- * @throws IllegalStateException
- * if the transaction has already been submitted
+ * @param store the logical data store which should be modified
+ * @param path the data object path
+ * @param data the data object to be written to the specified path
+ * @param createMissingParents if {@link #CREATE_MISSING_PARENTS} ({@code true}), any missing parent nodes will be
+ * automatically created using a merge operation.
+ * @throws IllegalStateException if the transaction has already been submitted
*/
<T extends DataObject> void put(LogicalDatastoreType store, InstanceIdentifier<T> path, T data,
boolean createMissingParents);
/**
*/
<T extends DataObject> void put(LogicalDatastoreType store, InstanceIdentifier<T> path, T data,
boolean createMissingParents);
/**
- * Merges a piece of data with the existing data at a specified path. Any pre-existing data
- * which is not explicitly overwritten will be preserved. This means that if you store a container,
- * its child lists will be merged.
+ * Merges a piece of data with the existing data at a specified path. Any pre-existing data which is not explicitly
+ * overwritten will be preserved. This means that if you store a container, its child lists will be merged.
+ *
* <p>
* This method does not automatically create missing parent nodes. It is equivalent to invoking
* <p>
* This method does not automatically create missing parent nodes. It is equivalent to invoking
- * {@link #merge(LogicalDatastoreType, InstanceIdentifier, DataObject, boolean)}
- * with <code>createMissingParents</code> set to false.
+ * {@link #merge(LogicalDatastoreType, InstanceIdentifier, DataObject, boolean)} with {@code createMissingParents}
+ * set to false.
+ *
* <p>
* For more information on usage and examples, please see the documentation in {@link AsyncWriteTransaction}.
* <p>
* For more information on usage and examples, please see the documentation in {@link AsyncWriteTransaction}.
* If you require an explicit replace operation, use {@link #put} instead.
* If you require an explicit replace operation, use {@link #put} instead.
- * @param store
- * the logical data store which should be modified
- * @param path
- * the data object path
- * @param data
- * the data object to be merged to the specified path
- * @throws IllegalStateException
- * if the transaction has already been submitted
+ *
+ * @param store the logical data store which should be modified
+ * @param path the data object path
+ * @param data the data object to be merged to the specified path
+ * @throws IllegalStateException if the transaction has already been submitted
*/
<T extends DataObject> void merge(LogicalDatastoreType store, InstanceIdentifier<T> path, T data);
/**
*/
<T extends DataObject> void merge(LogicalDatastoreType store, InstanceIdentifier<T> path, T data);
/**
- * Merges a piece of data with the existing data at a specified path. Any
- * pre-existing data which is not explicitly overwritten will be preserved.
- * This means that if you store a container, its child lists will be merged.
+ * Merges a piece of data with the existing data at a specified path. Any pre-existing data which is not explicitly
+ * overwritten will be preserved. This means that if you store a container, its child lists will be merged.
+ *
- * For more information on usage and examples, please see the documentation
- * in {@link AsyncWriteTransaction}.
+ * For more information on usage and examples, please see the documentation in {@link AsyncWriteTransaction}.
+ *
* <p>
* If you require an explicit replace operation, use {@link #put} instead.
*
* <p>
* If you require an explicit replace operation, use {@link #put} instead.
*
- * @param store
- * the logical data store which should be modified
- * @param path
- * the data object path
- * @param data
- * the data object to be merged to the specified path
- * @param createMissingParents
- * if {@link #CREATE_MISSING_PARENTS} ({@code true}), any missing
- * parent nodes will be automatically created using a merge
- * operation.
- * @throws IllegalStateException
- * if the transaction has already been submitted
+ * @param store the logical data store which should be modified
+ * @param path the data object path
+ * @param data the data object to be merged to the specified path
+ * @param createMissingParents if {@link #CREATE_MISSING_PARENTS} ({@code true}), any missing parent nodes will be
+ * automatically created using a merge operation.
+ * @throws IllegalStateException if the transaction has already been submitted
*/
<T extends DataObject> void merge(LogicalDatastoreType store, InstanceIdentifier<T> path, T data,
boolean createMissingParents);
*/
<T extends DataObject> void merge(LogicalDatastoreType store, InstanceIdentifier<T> path, T data,
boolean createMissingParents);
* Returns an implementation of a requested RPC service.
*
* <p>
* Returns an implementation of a requested RPC service.
*
* <p>
- * The returned instance is not an actual implementation of the RPC service
- * interface, but a proxy implementation of the interface that forwards to
- * an actual implementation, if any.
- * <p>
+ * The returned instance is not an actual implementation of the RPC service interface, but a proxy implementation
+ * of the interface that forwards to an actual implementation, if any.
* The following describes the behavior of the proxy when invoking RPC methods:
* <ul>
* <li>If an actual implementation is registered with the MD-SAL, all invocations are
* The following describes the behavior of the proxy when invoking RPC methods:
* <ul>
* <li>If an actual implementation is registered with the MD-SAL, all invocations are
* If any are invalid, an {@link IllegalArgumentException} is thrown.
* </ul>
*
* If any are invalid, an {@link IllegalArgumentException} is thrown.
* </ul>
*
- * The returned proxy is automatically updated with the most recent
- * registered implementation.
- *
+ * <p>
+ * The returned proxy is automatically updated with the most recent registered implementation.
* {@code
* final Future<RpcResult<SomeRpcOutput>> future = someRpcService.someRpc( ... );
* Futures.addCallback(future,
* {@code
* final Future<RpcResult<SomeRpcOutput>> future = someRpcService.someRpc( ... );
* Futures.addCallback(future,
* @deprecated Use {@link org.opendaylight.mdsal.binding.api.RpcProviderService} instead
*/
@Deprecated
* @deprecated Use {@link org.opendaylight.mdsal.binding.api.RpcProviderService} instead
*/
@Deprecated
-public interface RpcProviderRegistry extends //
- RpcConsumerRegistry, //
+public interface RpcProviderRegistry extends RpcConsumerRegistry,
RouteChangePublisher<RpcContextIdentifier, InstanceIdentifier<?>> {
/**
* Registers a global implementation of the provided RPC service interface.
RouteChangePublisher<RpcContextIdentifier, InstanceIdentifier<?>> {
/**
* Registers a global implementation of the provided RPC service interface.
/**
* Registers an implementation of the given routed RPC service interface.
/**
* Registers an implementation of the given routed RPC service interface.
- * See the {@link RpcProviderRegistry class} documentation for information and example on
- * how to use routed RPCs.
+ * See the {@link RpcProviderRegistry class} documentation for information and example on how to use routed RPCs.
*
* @param serviceInterface the YANG-generated interface of the RPC Service for which to register.
* @param implementation the implementation instance to register.
*
* @param serviceInterface the YANG-generated interface of the RPC Service for which to register.
* @param implementation the implementation instance to register.
* implementation via invoking RoutedRpcRegistration#registerPath(Class, InstanceIdentifer).
* {@link RoutedRpcRegistration#close()} should be called to unregister the implementation
* and all previously registered paths when no longer needed.
* implementation via invoking RoutedRpcRegistration#registerPath(Class, InstanceIdentifer).
* {@link RoutedRpcRegistration#close()} should be called to unregister the implementation
* and all previously registered paths when no longer needed.
- *
- * @throws IllegalStateException
- * if the supplied RPC interface is not a routed RPC type.
+ * @throws IllegalStateException if the supplied RPC interface is not a routed RPC type.
*/
<T extends RpcService> RoutedRpcRegistration<T> addRoutedRpcImplementation(Class<T> serviceInterface,
*/
<T extends RpcService> RoutedRpcRegistration<T> addRoutedRpcImplementation(Class<T> serviceInterface,
- T implementation)
- throws IllegalStateException;
+ T implementation) throws IllegalStateException;
* Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
return staticSchemaContext;
}
return staticSchemaContext;
}
- private SchemaContextSingleton() { }
+ private SchemaContextSingleton() {
+
+ }
@FunctionalInterface
public interface Supplier<T> {
@FunctionalInterface
public interface Supplier<T> {
*/
@Deprecated
public interface AsyncConfigurationCommitCoordinator<P extends Path<P>, D> {
*/
@Deprecated
public interface AsyncConfigurationCommitCoordinator<P extends Path<P>, D> {
- * Register configuration commit handler for particular subtree.
- *
- * Configuration commit handler is invoked for all write transactions
- * which modifies <code>subtree</code>
+ * Register configuration commit handler for particular subtree. Configuration commit handler is invoked for all
+ * write transactions which modifies <code>subtree</code>
*
* @param subtree Subtree which configuration commit handler is interested it
* @param commitHandler Instance of user-provided commit handler
* @return Registration object representing this registration. Invoking {@link ObjectRegistration#close()}
*
* @param subtree Subtree which configuration commit handler is interested it
* @param commitHandler Instance of user-provided commit handler
* @return Registration object representing this registration. Invoking {@link ObjectRegistration#close()}
- * will unregister configuration commit handler.
+ * will unregister configuration commit handler.
*/
<C extends AsyncConfigurationCommitCohort<P, D>> ObjectRegistration<C> registerConfigurationCommitHandler(
P subtree, C commitHandler);
*/
<C extends AsyncConfigurationCommitCohort<P, D>> ObjectRegistration<C> registerConfigurationCommitHandler(
P subtree, C commitHandler);
Code Review / controller.git / commitdiff