<!-- Sonar properties using jacoco to retrieve integration test results -->
<sonar.java.coveragePlugin>jacoco</sonar.java.coveragePlugin>
<sonar.language>java</sonar.language>
- <sonar.skippedModules>org.openflow.openflowj,net.sf.jung2</sonar.skippedModules>
+ <sonar.skippedModules>org.openflow.openflowj,net.sf.jung2,org.opendaylight.controller.protobuff.messages</sonar.skippedModules>
+ <spifly.version>1.0.0</spifly.version>
+ <spring-osgi.version>1.2.1</spring-osgi.version>
+ <spring-security-karaf.version>3.1.4.RELEASE</spring-security-karaf.version>
+ <spring-security.version>3.1.3.RELEASE</spring-security.version>
+ <spring.version>3.1.3.RELEASE</spring.version>
<statistics.northbound.version>0.4.2-SNAPSHOT</statistics.northbound.version>
<statisticsmanager.implementation.version>0.4.2-SNAPSHOT</statisticsmanager.implementation.version>
<statisticsmanager.version>0.5.1-SNAPSHOT</statisticsmanager.version>
ovsdb.listenPort=6640
# ovsdb creates Openflow nodes/bridges. This configuration configures the bridge's Openflow version.
-# default Openflow version = 1.0, we also support 1.3.
-# ovsdb.of.version=1.3
+# default Openflow version = 1.3, we also support 1.0.
+ovsdb.of.version=1.3
# TLS configuration
# To enable TLS, set secureChannelEnabled=true and specify the location of controller Java KeyStore and TrustStore files.
uses tr:transaction-metadata;
uses flow:base-node-error-notification;
uses flow:node-error-reference;
- uses flow:node-error-reference;
}
notification group-mod-error-notification {
<!--sal-protocolbuffer-encoding-->
<module>sal-protocolbuffer-encoding</module>
- <!-- Karaf feature -->
- <module>feature</module>
+ <!-- Karaf feature -->
+ <module>feature</module>
+ <!-- Yang Test Models for MD-SAL -->
+ <module>sal-test-model</module>
</modules>
<build>
import org.opendaylight.yangtools.yang.binding.Notification;
/**
- * Interface implemented by objects interested in some sort of Notification. This
- * class acts as a base interface for specific listeners which usually are a type
+ * Interface for a generic listener that is interested in receiving YANG modeled notifications.
+ * This interface acts as a base interface for specific listeners which usually are a type
* capture of this interface.
*
- * @param <T> Notification type
+ * @param <T> the interested notification type
*/
public interface NotificationListener<T extends Notification> extends EventListener {
/**
- * Invoked to deliver the notification. Note that this method may be invoked
- * from a shared thread pool, so implementations SHOULD NOT perform CPU-intensive
- * operations and they definitely MUST NOT invoke any potentially blocking
- * operations.
+ * Invoked to deliver a notification.
+ * <p>
+ * Note that this method may be invoked from a shared thread pool, so implementations SHOULD NOT
+ * perform CPU-intensive operations and MUST NOT invoke any potentially blocking operations.
*
- * @param notification Notification being delivered.
+ * @param notification the notification.
*/
void onNotification(T notification);
}
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.Notification;
+/**
+ * Interface for a notification service that provides publish/subscribe capabilities for YANG
+ * modeled notifications. This interface is a combination of the {@link NotificationService} and
+ * {@link NotificationPublishService} interfaces.
+ */
public interface NotificationProviderService extends NotificationService, NotificationPublishService<Notification> {
+
/**
- * Publishes a notification.
- *
- * @param Notification
- * notification to publish.
- *
+ * {@inheritDoc}
*/
@Override
- void publish(Notification notification);
+ public void publish(Notification notification);
/**
- * Publishes a notification, listener calls are done in provided executor.
- *
+ * {@inheritDoc}
*/
@Override
- void publish(Notification notification, ExecutorService service);
+ void publish(Notification notification, ExecutorService executor);
+ /**
+ * Registers a listener to be notified about notification subscriptions. This
+ * enables a component to know when there is a notification listener subscribed
+ * for a particular notification type.
+ * <p>
+ * On registration of this listener, the
+ * {@link NotificationInterestListener#onNotificationSubscribtion(Class)} method
+ * will be invoked for every notification type that currently has a notification listener
+ * subscribed.
+ *
+ * @param interestListener the listener that will be notified when subscriptions
+ * for new notification types occur.
+ * @return a {@link ListenerRegistration} instance that should be used to unregister the listener
+ * by invoking the {@link ListenerRegistration#close()} method when no longer needed.
+ */
ListenerRegistration<NotificationInterestListener> registerInterestListener(
NotificationInterestListener interestListener);
+ /**
+ * Interface for a listener interested in being notified about notification subscriptions.
+ */
public interface NotificationInterestListener extends EventListener {
+ /**
+ * Callback that is invoked when a notification listener subscribes for a
+ * particular notification type.
+ * <p>
+ * This method is only called for the first subscription that occurs for a
+ * particular notification type. Subsequent subscriptions for the same
+ * notification type do not trigger invocation of this method.
+ * <p>
+ * <b>Note:</b>This callback is delivered from thread not owned by this listener,
+ * all processing should be as fast as possible and implementations should
+ * not do any blocking calls or block this thread.
+ *
+ * @param notificationType the notification type for the subscription that occurred.
+ */
void onNotificationSubscribtion(Class<? extends Notification> notificationType);
}
}
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.Notification;
+/**
+ * Notification broker which allows clients to subscribe for and publish YANG-modeled notifications.
+ *
+ *<p>
+ * Two styles of listeners are supported:
+ * <ul>
+ * <li>Generic listener</li>
+ * <li>Dispatch listener - listener, which implements <code>{ModelName}Listener</code> interface,
+ * which has dispatch methods for each defined notification. Methods are invoked based on notification type (class).
+ * </li>
+ *
+ * <h3>Generic Listener</h3>
+ * <p>
+ * A generic listener implements the {@link NotificationListener} interface which has one callback method
+ * <code>onNotification</code> that is invoked for any notification type the listener is subscribed to.
+ * <p>
+ * A generic listener is subscribed using the {@link #registerNotificationListener(Class, NotificationListener)}
+ * method by which you specify the type of notification to receive. A generic listener may be registered for
+ * multiple notification types via multiple subscriptions.
+ * <p>
+ * Generic listeners allow for a more flexible approach, allowing you to subscribe for just
+ * one type of notification from a YANG model. You could also have a general subscription
+ * for all notification in the system via
+ * <pre>
+ * service.registerNotificationListener(Notification.class, listener);
+ * </pre>
+ *
+ * <h3>Dispatch Listener</h3>
+ * <p>
+ * A dispatch listener implements a YANG-generated module interface <code>{ModuleName}Listener</code>
+ * which handles all the notifications defined in the YANG model. Each notification type translates to
+ * a specific method of the form <code>on{NotificationType}</code> on the generated interface.
+ * The generated interface also extends the
+ * {@link org.opendaylight.yangtools.yang.binding.NotificationListener} interface and implementations
+ * are registered using {@link #registerNotificationListener(org.opendaylight.yangtools.yang.binding.NotificationListener)}
+ * method.
+ *
+ * <h5>Dispatch Listener Example</h5>
+ * <p>
+ * Lets assume we have following YANG model:
+ *
+ * <pre>
+ * module example {
+ * ...
+ *
+ * notification start {
+ * ...
+ * }
+ *
+ * notification stop {
+ * ...
+ * }
+ * }
+ * </pre>
+ *
+ * The generated interface will be:
+ * <pre>
+ * public interface ExampleListener extends NotificationListener {
+ * void onStart(Start notification);
+ * void onStop(Stop notification);
+ * }
+ * </pre>
+ * The following defines an implementation of the generated interface:
+ * <pre>
+ * public class MyExampleListener implements ExampleListener {
+ * public void onStart(Start notification) {
+ * // do something
+ * }
+ *
+ * public void onStop(Stop notification) {
+ * // do something
+ * }
+ * }
+ * </pre>
+ * The implementation is registered as follows:
+ * <pre>
+ * MyExampleListener listener = new MyExampleListener();
+ * ListenerRegistration<NotificationListener> reg = service.registerNotificationListener( listener );
+ * </pre>
+ * The <code>onStart</code> method will be invoked when someone publishes a <code>Start</code> notification and
+ * the <code>onStop</code> method will be invoked when someone publishes a <code>Stop</code> notification.
+ */
public interface NotificationService extends BindingAwareService {
/**
- * Register a generic listener for specified notification type only.
+ * Registers a generic listener implementation for a specified notification type.
*
- * @param notificationType
- * @param listener
- * @return Registration for listener. To unregister listener invoke {@link ListenerRegistration#close()} method.
+ * @param notificationType the YANG-generated interface of the notification type.
+ * @param listener the listener implementation that will receive notifications.
+ * @return a {@link ListenerRegistration} instance that should be used to unregister the listener
+ * by invoking the {@link ListenerRegistration#close()} method when no longer needed.
*/
<T extends Notification> ListenerRegistration<NotificationListener<T>> registerNotificationListener(
Class<T> notificationType, NotificationListener<T> listener);
/**
- * Register a listener which implements generated notification interfaces derived from
+ * Registers a listener which implements a YANG-generated notification interface derived from
* {@link org.opendaylight.yangtools.yang.binding.NotificationListener}.
- * Listener is registered for all notifications present in implemented interfaces.
+ * The listener is registered for all notifications present in the implemented interface.
*
- * @param listener
- * @return Registration for listener. To unregister listener invoke {@link ListenerRegistration#close()} method.
+ * @param listener the listener implementation that will receive notifications.
+ * @return a {@link ListenerRegistration} instance that should be used to unregister the listener
+ * by invoking the {@link ListenerRegistration#close()} method when no longer needed.
*/
ListenerRegistration<org.opendaylight.yangtools.yang.binding.NotificationListener> registerNotificationListener(
org.opendaylight.yangtools.yang.binding.NotificationListener listener);
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
- <version>${slf4j.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
private Map<InstanceIdentifier<?>, DataObject> createdCache;
private Map<InstanceIdentifier<?>, DataObject> updatedCache;
- private Map<InstanceIdentifier<?>, ? extends DataObject> originalCache;
+ private Map<InstanceIdentifier<?>, DataObject> originalCache;
private Set<InstanceIdentifier<?>> removedCache;
private Optional<DataObject> originalDataCache;
private Optional<DataObject> updatedDataCache;
}
@Override
- public Map<InstanceIdentifier<?>, ? extends DataObject> getOriginalData() {
+ public Map<InstanceIdentifier<?>, DataObject> getOriginalData() {
if (originalCache == null) {
originalCache = Collections.unmodifiableMap(toBinding(domEvent.getOriginalData()));
}
*/
package org.opendaylight.controller.md.sal.binding.impl;
+import java.util.Collections;
import java.util.Map.Entry;
import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.Identifiable;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import com.google.common.base.Optional;
+import com.google.common.collect.Iterables;
import com.google.common.util.concurrent.ListenableFuture;
/**
protected final void doPut(final LogicalDatastoreType store,
final InstanceIdentifier<?> path, final DataObject data) {
- final Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, NormalizedNode<?, ?>> normalized = getCodec()
+ final Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, NormalizedNode<?, ?>> normalized = getCodec()
.toNormalizedNode(path, data);
+ ensureListParentIfNeeded(store,path,normalized);
getDelegate().put(store, normalized.getKey(), normalized.getValue());
}
+
+ /**
+ *
+ * Ensures list parent if item is list, otherwise noop.
+ *
+ * <p>
+ * One of properties of binding specification is that it is imposible
+ * to represent list as a whole and thus it is impossible to write
+ * empty variation of MapNode without creating parent node, with
+ * empty list.
+ *
+ * <p>
+ * This actually makes writes such as
+ * <pre>
+ * put("Nodes", new NodesBuilder().build());
+ * put("Nodes/Node[key]", new NodeBuilder().setKey("key").build());
+ * </pre>
+ * To result in three DOM operations:
+ * <pre>
+ * put("/nodes",domNodes);
+ * merge("/nodes/node",domNodeList);
+ * put("/nodes/node/node[key]",domNode);
+ * </pre>
+ *
+ *
+ * In order to allow that to be inserted if necessary, if we know
+ * item is list item, we will try to merge empty MapNode or OrderedNodeMap
+ * to ensure list exists.
+ *
+ * @param store Data Store type
+ * @param path Path to data (Binding Aware)
+ * @param normalized Normalized version of data to be written
+ */
+ private void ensureListParentIfNeeded(final LogicalDatastoreType store, final InstanceIdentifier<?> path,
+ final Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, NormalizedNode<?, ?>> normalized) {
+ if(Identifiable.class.isAssignableFrom(path.getTargetType())) {
+ org.opendaylight.yangtools.yang.data.api.InstanceIdentifier parentMapPath = getParent(normalized.getKey()).get();
+ NormalizedNode<?, ?> emptyParent = getCodec().getDefaultNodeFor(parentMapPath);
+ getDelegate().merge(store, parentMapPath, emptyParent);
+ }
+
+ }
+
+ // FIXME (should be probaly part of InstanceIdentifier)
+ protected static Optional<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier> getParent(
+ final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier child) {
+
+ Iterable<PathArgument> mapEntryItemPath = child.getPathArguments();
+ int parentPathSize = Iterables.size(mapEntryItemPath) - 1;
+ if(parentPathSize > 1) {
+ return Optional.of(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.create(Iterables.limit(mapEntryItemPath, parentPathSize)));
+ } else if(parentPathSize == 0) {
+ return Optional.of(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.create(Collections.<PathArgument>emptyList()));
+ } else {
+ return Optional.absent();
+ }
+ }
+
protected final void doMerge(final LogicalDatastoreType store,
final InstanceIdentifier<?> path, final DataObject data) {
+
final Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, NormalizedNode<?, ?>> normalized = getCodec()
.toNormalizedNode(path, data);
+ ensureListParentIfNeeded(store,path,normalized);
getDelegate().merge(store, normalized.getKey(), normalized.getValue());
}
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.AbstractMap.SimpleEntry;
+import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map.Entry;
return Optional.absent();
}
}
+
+ /**
+ * Returns an default object according to YANG schema for supplied path.
+ *
+ * @param path DOM Path
+ * @return Node with defaults set on.
+ */
+ public NormalizedNode<?, ?> getDefaultNodeFor(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier path) {
+ Iterator<PathArgument> iterator = path.getPathArguments().iterator();
+ DataNormalizationOperation<?> currentOp = legacyToNormalized.getRootOperation();
+ while (iterator.hasNext()) {
+ PathArgument currentArg = iterator.next();
+ try {
+ currentOp = currentOp.getChild(currentArg);
+ } catch (DataNormalizationException e) {
+ throw new IllegalArgumentException(String.format("Invalid child encountered in path %s", path), e);
+ }
+ }
+ return currentOp.createDefault(path.getLastPathArgument());
+ }
}
+++ /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.controller.sal.binding.codegen.impl;
-
-public class BrokerImplClassLoader extends ClassLoader {
- private final ClassLoader spiClassLoader;
-
- public BrokerImplClassLoader(final ClassLoader model, final ClassLoader spi) {
- super(model);
- this.spiClassLoader = spi;
- }
-
- @Override
- public Class<? extends Object> loadClass(final String name) throws ClassNotFoundException {
- try {
- return super.loadClass(name);
- } catch (ClassNotFoundException e) {
- return this.spiClassLoader.loadClass(name);
- }
- }
-}
val rpcMeta = metadata.getRpcMethod(name);
val bodyTmp = '''
{
+ if($1 == null) {
+ throw new IllegalArgumentException("RPC input must not be null and must contain a value for field «rpcMeta.inputRouteGetter.name»");
+ }
+ if($1.«rpcMeta.inputRouteGetter.name»() == null) {
+ throw new IllegalArgumentException("Field «rpcMeta.inputRouteGetter.name» must not be null");
+ }
final «InstanceIdentifier.name» identifier = $1.«rpcMeta.inputRouteGetter.name»()«IF rpcMeta.
routeEncapsulated».getValue()«ENDIF»;
«supertype.name» instance = («supertype.name») «rpcMeta.context.routingTableField».get(identifier);
import org.opendaylight.controller.sal.core.api.Provider;
import org.opendaylight.controller.sal.core.api.RpcImplementation;
import org.opendaylight.controller.sal.core.api.RpcProvisionRegistry;
+import org.opendaylight.controller.sal.core.api.RpcRegistrationListener;
import org.opendaylight.controller.sal.core.api.data.DataModificationTransaction;
import org.opendaylight.controller.sal.core.api.notify.NotificationListener;
import org.opendaylight.controller.sal.core.api.notify.NotificationPublishService;
+import org.opendaylight.yangtools.concepts.CompositeObjectRegistration;
+import org.opendaylight.yangtools.concepts.CompositeObjectRegistration.CompositeObjectRegistrationBuilder;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.binding.Augmentable;
import org.opendaylight.yangtools.yang.binding.Augmentation;
import org.slf4j.LoggerFactory;
import com.google.common.base.Function;
+import com.google.common.base.Optional;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSet.Builder;
public void startRpcForwarding() {
if (biRpcRegistry != null && baRpcRegistry instanceof RouteChangePublisher<?, ?>) {
checkState(!rpcForwarding, "Connector is already forwarding RPCs");
- domToBindingRpcManager = baRpcRegistry.registerRouteChangeListener(new DomToBindingRpcForwardingManager());
+ final DomToBindingRpcForwardingManager biFwdManager = new DomToBindingRpcForwardingManager();
+
+ domToBindingRpcManager = baRpcRegistry.registerRouteChangeListener(biFwdManager);
+ biRpcRegistry.addRpcRegistrationListener(biFwdManager);
if (baRpcRegistry instanceof RpcProviderRegistryImpl) {
baRpcRegistryImpl = (RpcProviderRegistryImpl) baRpcRegistry;
baRpcRegistryImpl.registerRouterInstantiationListener(domToBindingRpcManager.getInstance());
public void onRegister(
final DataCommitHandlerRegistration<InstanceIdentifier<? extends DataObject>, DataObject> registration) {
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier domPath = mappingService.toDataDom(registration
+ mappingService.toDataDom(registration
.getPath());
}
*/
private class DomToBindingRpcForwardingManager implements
RouteChangeListener<RpcContextIdentifier, InstanceIdentifier<?>>, RouterInstantiationListener,
- GlobalRpcRegistrationListener {
+ GlobalRpcRegistrationListener, RpcRegistrationListener {
private final Map<Class<? extends RpcService>, DomToBindingRpcForwarder> forwarders = new WeakHashMap<>();
private RpcProviderRegistryImpl registryImpl;
@Override
public void onGlobalRpcRegistered(final Class<? extends RpcService> cls) {
- getRpcForwarder(cls, null);
+ getRpcForwarder(cls, null).registerToDOMBroker();
}
@Override
return potential;
}
+ @Override
+ public void onRpcImplementationAdded(final QName name) {
+
+ final Optional<Class<? extends RpcService>> rpcInterface = mappingService.getRpcServiceClassFor(
+ name.getNamespace().toString(), name.getFormattedRevision());
+ if (rpcInterface.isPresent()) {
+ getRpcForwarder(rpcInterface.get(), null).registerToBindingBroker();
+ }
+ }
+
+ @Override
+ public void onRpcImplementationRemoved(final QName name) {
+
+ }
}
private class DomToBindingRpcForwarder implements RpcImplementation, InvocationHandler {
private final Set<QName> supportedRpcs;
private final WeakReference<Class<? extends RpcService>> rpcServiceType;
- private final Set<org.opendaylight.controller.sal.core.api.Broker.RoutedRpcRegistration> registrations;
+ private Set<org.opendaylight.controller.sal.core.api.Broker.RoutedRpcRegistration> registrations;
private final Map<QName, RpcInvocationStrategy> strategiesByQName = new HashMap<>();
private final WeakHashMap<Method, RpcInvocationStrategy> strategiesByMethod = new WeakHashMap<>();
+ private final RpcService proxy;
+ private ObjectRegistration<?> forwarderRegistration;
+ private boolean registrationInProgress = false;
public DomToBindingRpcForwarder(final Class<? extends RpcService> service) {
this.rpcServiceType = new WeakReference<Class<? extends RpcService>>(service);
this.supportedRpcs = mappingService.getRpcQNamesFor(service);
- try {
- for (QName rpc : supportedRpcs) {
- RpcInvocationStrategy strategy = createInvocationStrategy(rpc, service);
- strategiesByMethod.put(strategy.targetMethod, strategy);
- strategiesByQName.put(rpc, strategy);
- biRpcRegistry.addRpcImplementation(rpc, this);
- }
- } catch (Exception e) {
- LOG.error("Could not forward Rpcs of type {}", service.getName(), e);
- }
- registrations = ImmutableSet.of();
+ Class<?> cls = rpcServiceType.get();
+ ClassLoader clsLoader = cls.getClassLoader();
+ proxy =(RpcService) Proxy.newProxyInstance(clsLoader, new Class<?>[] { cls }, this);
+ createStrategies();
}
/**
* @param context
*/
public DomToBindingRpcForwarder(final Class<? extends RpcService> service,
- final Class<? extends BaseIdentity> context) {
- this.rpcServiceType = new WeakReference<Class<? extends RpcService>>(service);
- this.supportedRpcs = mappingService.getRpcQNamesFor(service);
+ final Class<? extends BaseIdentity> context) {
+ this(service);
Builder<RoutedRpcRegistration> registrationsBuilder = ImmutableSet
.<org.opendaylight.controller.sal.core.api.Broker.RoutedRpcRegistration> builder();
try {
for (QName rpc : supportedRpcs) {
- RpcInvocationStrategy strategy = createInvocationStrategy(rpc, service);
- strategiesByMethod.put(strategy.targetMethod, strategy);
- strategiesByQName.put(rpc, strategy);
registrationsBuilder.add(biRpcRegistry.addRoutedRpcImplementation(rpc, this));
}
createDefaultDomForwarder();
registrations = registrationsBuilder.build();
}
+
+
+ private void createStrategies() {
+ try {
+ for (QName rpc : supportedRpcs) {
+ RpcInvocationStrategy strategy = createInvocationStrategy(rpc, rpcServiceType.get());
+ strategiesByMethod.put(strategy.targetMethod, strategy);
+ strategiesByQName.put(rpc, strategy);
+ }
+ } catch (Exception e) {
+ LOG.error("Could not forward Rpcs of type {}", rpcServiceType.get(), e);
+ }
+
+ }
+
+ /**
+ * Registers RPC Forwarder to DOM Broker,
+ * this means Binding Aware Broker has implementation of RPC
+ * which is registered to it.
+ *
+ * If RPC Forwarder was previously registered to DOM Broker
+ * or to Bidning Broker this method is noop to prevent
+ * creating forwarding loop.
+ *
+ */
+ public void registerToDOMBroker() {
+ if(!registrationInProgress && forwarderRegistration == null) {
+ registrationInProgress = true;
+ CompositeObjectRegistrationBuilder<DomToBindingRpcForwarder> builder = CompositeObjectRegistration.builderFor(this);
+ try {
+ for (QName rpc : supportedRpcs) {
+ builder.add(biRpcRegistry.addRpcImplementation(rpc, this));
+ }
+ } catch (Exception e) {
+ LOG.error("Could not forward Rpcs of type {}", rpcServiceType.get(), e);
+ }
+ this.forwarderRegistration = builder.toInstance();
+ registrationInProgress = false;
+ }
+ }
+
+
public void registerPaths(final Class<? extends BaseIdentity> context,
final Class<? extends RpcService> service, final Set<InstanceIdentifier<?>> set) {
QName ctx = BindingReflections.findQName(context);
});
}
+
+ /**
+ * Registers RPC Forwarder to Binding Broker,
+ * this means DOM Broekr has implementation of RPC
+ * which is registered to it.
+ *
+ * If RPC Forwarder was previously registered to DOM Broker
+ * or to Bidning Broker this method is noop to prevent
+ * creating forwarding loop.
+ *
+ */
+ public void registerToBindingBroker() {
+ if(!registrationInProgress && forwarderRegistration == null) {
+ try {
+ registrationInProgress = true;
+ this.forwarderRegistration = baRpcRegistry.addRpcImplementation((Class)rpcServiceType.get(), proxy);
+ } catch (Exception e) {
+ LOG.error("Unable to forward RPCs for {}",rpcServiceType.get(),e);
+ } finally {
+ registrationInProgress = false;
+ }
+ }
+ }
}
public boolean isRpcForwarding() {
+++ /dev/null
-/*
- * Copyright (c) 2014 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.controller.sal.binding.impl.connect.dom;
-
-public class Constants {
- public static final Class<byte[]> BYTES_CLASS = byte[].class;
-}
+++ /dev/null
-/*
- * Copyright (c) 2014 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.controller.sal.binding.impl.connect.dom;
-
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-
-import org.opendaylight.controller.md.sal.common.api.data.DataModification;
-import org.opendaylight.yangtools.concepts.Path;
-
-public final class DataModificationTracker<P extends Path<P>,D> {
- ConcurrentMap<Object, DataModification<P,D>> trackedTransactions = new ConcurrentHashMap<>();
-
- public void startTrackingModification(DataModification<P,D> modification) {
- trackedTransactions.putIfAbsent(modification.getIdentifier(), modification);
- }
-
- public boolean containsIdentifier(Object identifier) {
- return trackedTransactions.containsKey(identifier);
- }
-}
+++ /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.controller.sal.binding.impl;
\ No newline at end of file
+++ /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.controller.sal.binding.spi;
-
-public interface DelegateProxy<T> {
-
- void setDelegate(T delegate);
- T getDelegate();
-}
+++ /dev/null
-/*
- * Copyright (c) 2014 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.controller.sal.binding.spi.remote;
-
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
-
-public interface RemoteRpcRouter {
-
-
-
-
-
-
- ListenerRegistration<RouteChangeListener> registerRouteChangeListener(RouteChangeListener listener);
-
-
-
-
-}
+++ /dev/null
-/*
- * Copyright (c) 2014 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.controller.sal.binding.spi.remote;
-
-import java.util.EventListener;
-
-import org.opendaylight.controller.md.sal.common.api.routing.RouteChange;
-import org.opendaylight.yangtools.yang.binding.BaseIdentity;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-
-public interface RouteChangeListener extends EventListener {
-
- void onRouteChange(RouteChange<Class<? extends BaseIdentity>, InstanceIdentifier<?>> change);
-
-}
--- /dev/null
+/*
+ * Copyright (c) 2014 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.controller.md.sal.binding.impl.test;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.concurrent.ExecutionException;
+
+import org.junit.Test;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.sal.binding.test.AbstractDataServiceTest;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+
+public class WriteTransactionTest extends AbstractDataServiceTest {
+
+ private DataBroker dataBroker;
+
+ private static final InstanceIdentifier<Nodes> NODES_PATH = InstanceIdentifier.create(Nodes.class);
+
+ private static final NodeKey NODE_KEY = new NodeKey(new NodeId("foo"));
+
+ private static final InstanceIdentifier<Node> NODE_PATH = NODES_PATH.child(Node.class, NODE_KEY);
+
+ @Override
+ public void setUp() {
+ super.setUp();
+
+ dataBroker = testContext.getDataBroker();
+ }
+
+ @Test
+ public void test() throws InterruptedException, ExecutionException {
+ WriteTransaction writeTx = dataBroker.newWriteOnlyTransaction();
+ writeTx.put(LogicalDatastoreType.OPERATIONAL, NODES_PATH, new NodesBuilder().build());
+ writeTx.put(LogicalDatastoreType.OPERATIONAL, NODE_PATH, new NodeBuilder().setKey(NODE_KEY).build());
+ assertEquals(TransactionStatus.COMMITED, writeTx.commit().get().getResult());
+ }
+
+}
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertSame;
+import static org.junit.Assert.fail;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
// We should have call to instance 1
verify(service[1]).simple(instance_1_input[0]);
+
+ /*
+ * Generated RPC service should throw illegalArgumentException
+ * with message if rpc input is null.
+ */
+ try {
+ product.getInvocationProxy().simple(null);
+ fail("Generated RPC router should throw IllegalArgumentException on null input");
+ } catch (IllegalArgumentException e){
+ assertNotNull(e.getMessage());
+ }
+
+
+ /*
+ * Generated RPC service should throw illegalArgumentException
+ * with message if rpc route is null.
+ */
+ try {
+ SimpleInput withoutValue = new SimpleInputImpl(null);
+ product.getInvocationProxy().simple(withoutValue);
+ fail("Generated RPC router should throw IllegalArgumentException on null value for route");
+ } catch (IllegalArgumentException e){
+ assertNotNull(e.getMessage());
+ }
+
}
private InstanceIdentifier<?>[][] identifiers(final int serviceSize, final int instancesPerService) {
* 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.controller.sal.binding.test.bugfix;
+package org.opendaylight.controller.sal.binding.test.compat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
* 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.controller.sal.binding.test.bugfix;
+package org.opendaylight.controller.sal.binding.test.compat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
* 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.controller.sal.binding.test.bugfix;
-
-public class RpcRegistrationNullPointer {
-
-
-
-
-}
+/**
+ *
+ * Test suite targeting legacy Data APIs
+ *
+ */
+package org.opendaylight.controller.sal.binding.test.compat;
\ No newline at end of file
import javassist.ClassPool;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.impl.ForwardedBackwardsCompatibleDataBroker;
+import org.opendaylight.controller.md.sal.binding.impl.ForwardedBindingDataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
import org.opendaylight.controller.md.sal.dom.broker.impl.DOMDataBrokerImpl;
private final MockSchemaService mockSchemaService = new MockSchemaService();
+ private DataBroker dataBroker;
+
public DOMDataBroker getDomAsyncDataBroker() {
biDataLegacyBroker = biDataImpl;
}
+ public void startNewDataBroker() {
+ checkState(executor != null, "Executor needs to be set");
+ checkState(newDOMDataBroker != null, "DOM Data Broker must be set");
+ dataBroker = new ForwardedBindingDataBroker(newDOMDataBroker, mappingServiceImpl, mockSchemaService);
+ }
+
public void startNewDomDataBroker() {
checkState(executor != null, "Executor needs to be set");
InMemoryDOMDataStore operStore = new InMemoryDOMDataStore("OPER", executor);
public void start() {
startNewDomDataBroker();
+
startDomBroker();
startDomMountPoint();
startBindingToDomMappingService();
+ startNewDataBroker();
startNewBindingDataBroker();
-
startBindingNotificationBroker();
startBindingBroker();
return biMountImpl;
}
+ public DataBroker getDataBroker() {
+ return dataBroker;
+ }
+
}
<artifactId>pax-exam-container-native</artifactId>
<scope>test</scope>
</dependency>
-
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-parser-impl</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal-test-model</artifactId>
+ <version>1.1-SNAPSHOT</version>
+ </dependency>
</dependencies>
<build>
<plugins>
</execution>
</executions>
</plugin>
- <plugin>
- <groupId>org.opendaylight.yangtools</groupId>
- <artifactId>yang-maven-plugin</artifactId>
- <executions>
- <execution>
- <goals>
- <goal>generate-sources</goal>
- </goals>
- <configuration>
- <codeGenerators>
- <generator>
- <codeGeneratorClass>org.opendaylight.yangtools.maven.sal.api.gen.plugin.CodeGeneratorImpl</codeGeneratorClass>
- <outputBaseDir>${salGeneratorPath}</outputBaseDir>
- </generator>
- </codeGenerators>
- <inspectDependencies>true</inspectDependencies>
- </configuration>
- </execution>
- </executions>
- </plugin>
</plugins>
</build>
<scm>
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
+/*
+ * FIXME: THis test should be moved to sal-binding-broker and rewriten
+ * to use new DataBroker API
+ */
+@SuppressWarnings("deprecation")
public class ConcurrentImplicitCreateTest extends AbstractDataServiceTest {
private static final NodeKey NODE_FOO_KEY = new NodeKey(new NodeId("foo"));
import com.google.common.util.concurrent.ListenableFuture;
/*
- * Copyright (c) 2014 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
+ * FIXME: THis test should be moved to sal-binding-broker and rewriten
+ * to use new DataBroker API
*/
+@SuppressWarnings("deprecation")
public class ListProcessingAndOrderingTest extends AbstractDataServiceTest {
private static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier DOM_UNORDERED_LIST_PATH = org.opendaylight.yangtools.yang.data.api.InstanceIdentifier
assertEquals(TransactionStatus.COMMITED,result.getResult());
}
- @SuppressWarnings("deprecation")
private void assertXmlRepresentation(final InstanceIdentifier<?> containerPath, final String... childNameValues) {
org.opendaylight.yangtools.yang.data.api.InstanceIdentifier domPath = testContext.getBindingToDomMappingService().toDataDom(containerPath);
import com.google.common.util.concurrent.SettableFuture;
/*
- * Copyright (c) 2014 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
+ * FIXME: THis test should be moved to compat test-suite and rewriten
+ * to use sal-test-model
*/
+@SuppressWarnings("deprecation")
public class WildcardedDataChangeListenerTest extends AbstractDataServiceTest {
private static final NodeKey NODE_0_KEY = new NodeKey(new NodeId("test:0"));
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
-import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.vlan.match.fields.VlanIdBuilder;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import com.google.common.collect.ImmutableMap;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
+@SuppressWarnings("deprecation")
public class DOMCodecBug01Test extends AbstractDataServiceTest {
- private static final QName NODE_ID_QNAME = QName.create(Node.QNAME, "id");
- private static final QName FLOW_ID_QNAME = QName.create(Flow.QNAME, "id");
- private static final QName FLOW_NODE_QNAME = QName.create(Flow.QNAME, "node");
private static final long FLOW_ID = 1234;
private static final String NODE_ID = "node:1";
private static final NodeKey NODE_KEY = new NodeKey(new NodeId(NODE_ID));
- private static final Map<QName, Object> NODE_KEY_BI = Collections.<QName, Object> singletonMap(NODE_ID_QNAME,
- NODE_ID);
-
private static final InstanceIdentifier<Node> NODE_INSTANCE_ID_BA = InstanceIdentifier.builder(Nodes.class) //
.child(Node.class, NODE_KEY).toInstance();
- private static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier NODE_INSTANCE_ID_BI = //
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.builder() //
- .node(Nodes.QNAME) //
- .nodeWithKey(Node.QNAME, NODE_KEY_BI) //
- .toInstance();
private static final NodeRef NODE_REF = new NodeRef(NODE_INSTANCE_ID_BA);
private static final FlowKey FLOW_KEY = new FlowKey(FLOW_ID, NODE_REF);
- private static final Map<QName, Object> FLOW_KEY_BI = //
- ImmutableMap.<QName, Object> of(FLOW_ID_QNAME, FLOW_ID, FLOW_NODE_QNAME, NODE_INSTANCE_ID_BI);
-
- private static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier FLOW_INSTANCE_ID_BI = //
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.builder() //
- .node(Flows.QNAME) //
- .nodeWithKey(Flow.QNAME, FLOW_KEY_BI) //
- .toInstance();
private static final InstanceIdentifier<? extends DataObject> FLOW_INSTANCE_ID_BA = //
InstanceIdentifier.builder(Flows.class) //
.child(Flow.class, FLOW_KEY) //
import static org.junit.Assert.assertNotNull;
import java.util.Collections;
-import java.util.Map;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction;
import org.opendaylight.controller.sal.binding.test.AbstractDataServiceTest;
import org.opendaylight.controller.sal.binding.test.util.BindingBrokerTestFactory;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.RpcResult;
import com.google.common.util.concurrent.ListeningExecutorService;
import com.google.common.util.concurrent.MoreExecutors;
+@SuppressWarnings("deprecation")
public class DOMCodecBug02Test extends AbstractDataServiceTest {
- private static final QName NODE_ID_QNAME = QName.create(Node.QNAME, "id");
- private static final String NODE_ID = "node:1";
-
- private static final NodeKey NODE_KEY = new NodeKey(new NodeId(NODE_ID));
-
- private static final Map<QName, Object> NODE_KEY_BI = Collections.<QName, Object> singletonMap(NODE_ID_QNAME,
- NODE_ID);
-
private static final InstanceIdentifier<Nodes> NODES_INSTANCE_ID_BA = InstanceIdentifier.builder(Nodes.class) //
.toInstance();
- private static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier NODES_INSTANCE_ID_BI = //
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.builder() //
- .node(Nodes.QNAME) //
- .toInstance();
-
- private static final InstanceIdentifier<Node> NODE_INSTANCE_ID_BA = InstanceIdentifier.builder(Nodes.class) //
- .child(Node.class, NODE_KEY).toInstance();
-
- private static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier NODE_INSTANCE_ID_BI = //
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.builder() //
- .node(Nodes.QNAME) //
- .nodeWithKey(Node.QNAME, NODE_KEY_BI) //
- .toInstance();
- private static final NodeRef NODE_REF = new NodeRef(NODE_INSTANCE_ID_BA);
-
/**
* This test is ignored, till found out better way to test generation of
* classes without leaking of instances from previous run
import com.google.common.util.concurrent.SettableFuture;
+@SuppressWarnings("deprecation")
public class DOMCodecBug03Test extends AbstractDataServiceTest implements DataChangeListener {
private static final QName NODE_ID_QNAME = QName.create(Node.QNAME, "id");
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
-import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import com.google.common.util.concurrent.SettableFuture;
+@SuppressWarnings("deprecation")
public class DeleteNestedAugmentationListenParentTest extends AbstractDataServiceTest {
private static final NodeKey NODE_KEY = new NodeKey(new NodeId("foo"));
private static final FlowKey FLOW_KEY = new FlowKey(new FlowId("100"));
- private static final InstanceIdentifier<FlowCapableNode> LISTENER_PATH = InstanceIdentifier.builder(Nodes.class) //
- .child(Node.class)
- .augmentation(FlowCapableNode.class).build();
-
-
private static final InstanceIdentifier<FlowCapableNode> NODE_AUGMENT_PATH = InstanceIdentifier.builder(Nodes.class)
.child(Node.class,NODE_KEY)
.augmentation(FlowCapableNode.class)
final SettableFuture<DataChangeEvent<InstanceIdentifier<?>, DataObject>> event = SettableFuture.create();
- ListenerRegistration<DataChangeListener> listenerReg = baDataService.registerDataChangeListener(FLOW_PATH, new DataChangeListener() {
+ baDataService.registerDataChangeListener(FLOW_PATH, new DataChangeListener() {
@Override
public void onDataChanged(final DataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
-import java.util.Map;
import org.junit.Test;
import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
import com.google.common.collect.ImmutableSet;
+@SuppressWarnings("deprecation")
public class FlagsSerializationTest extends AbstractDataServiceTest {
- private static final QName NODE_ID_QNAME = QName.create(Node.QNAME, "id");
- private static final QName FLOW_ID_QNAME = QName.create(Flow.QNAME, "id");
- private static final QName FLOW_NODE_QNAME = QName.create(Flow.QNAME, "node");
private static final String FLOW_ID = "1234";
private static final short TABLE_ID = (short)0;
private static final String NODE_ID = "node:1";
private static final FlowKey FLOW_KEY = new FlowKey(new FlowId(FLOW_ID));
private static final TableKey TABLE_KEY = new TableKey(TABLE_ID);
- private static final Map<QName, Object> NODE_KEY_BI = Collections.<QName, Object> singletonMap(NODE_ID_QNAME,
- NODE_ID);
-
private static final InstanceIdentifier<Node> NODE_INSTANCE_ID_BA = InstanceIdentifier.builder(Nodes.class) //
.child(Node.class, NODE_KEY).toInstance();
- private static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier NODE_INSTANCE_ID_BI = //
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.builder() //
- .node(Nodes.QNAME) //
- .nodeWithKey(Node.QNAME, NODE_KEY_BI) //
- .toInstance();
- private static final NodeRef NODE_REF = new NodeRef(NODE_INSTANCE_ID_BA);
-
-
-
-// private static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier FLOW_INSTANCE_ID_BI = //
-// org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.builder() //
-//
-// .node(Flows.QNAME) //
-// .nodeWithKey(Flow.QNAME, FLOW_KEY_BI) //
-// .toInstance();
private static final InstanceIdentifier<? extends DataObject> FLOW_INSTANCE_ID_BA = //
NODE_INSTANCE_ID_BA.builder() //
.augmentation(FlowCapableNode.class)
ImmutableSet<String> domAllTrueFlags = ImmutableSet.<String>of("CHECK_OVERLAP","NO_BYT_COUNTS", "NO_PKT_COUNTS", "RESET_COUNTS", "SEND_FLOW_REM");
testFlags(allTrueFlags,domAllTrueFlags);
- FlowModFlags nullFlags = null;
- ImmutableSet<String> domNullFlags = null;
testFlags(null,null);
}
- private void testFlags(FlowModFlags flagsToTest, ImmutableSet<String> domFlags) throws Exception {
+ private void testFlags(final FlowModFlags flagsToTest, final ImmutableSet<String> domFlags) throws Exception {
Flow flow = createFlow(flagsToTest);
assertNotNull(flow);
}
- private Flow createFlow(FlowModFlags flagsToTest) throws Exception {
+ private Flow createFlow(final FlowModFlags flagsToTest) throws Exception {
DataModificationTransaction modification = baDataService.beginTransaction();
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnectorBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.flow.node.SupportedActions;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import com.google.common.util.concurrent.SettableFuture;
+@SuppressWarnings("deprecation")
public class PutAugmentationTest extends AbstractDataServiceTest implements DataChangeListener {
private static final QName NODE_ID_QNAME = QName.create(Node.QNAME, "id");
NODES_INSTANCE_ID_BA.builder() //
.child(Node.class, NODE_KEY).toInstance();
- private static final InstanceIdentifier<SupportedActions> SUPPORTED_ACTIONS_INSTANCE_ID_BA = //
- NODES_INSTANCE_ID_BA.builder() //
- .child(Node.class, NODE_KEY) //
- .augmentation(FlowCapableNode.class) //
- .child(SupportedActions.class).toInstance();
-
private static final InstanceIdentifier<FlowCapableNode> ALL_FLOW_CAPABLE_NODES = //
NODES_INSTANCE_ID_BA.builder() //
.child(Node.class) //
.node(Nodes.QNAME) //
.nodeWithKey(Node.QNAME, NODE_KEY_BI) //
.toInstance();
- private static final QName SUPPORTED_ACTIONS_QNAME = QName.create(FlowCapableNode.QNAME,
- SupportedActions.QNAME.getLocalName());
-
- private static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier SUPPORTED_ACTIONS_INSTANCE_ID_BI = //
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.builder() //
- .node(Nodes.QNAME) //
- .nodeWithKey(Node.QNAME, NODE_KEY_BI) //
- .node(SUPPORTED_ACTIONS_QNAME) //
- .toInstance();
private static final InstanceIdentifier<FlowCapableNode> FLOW_AUGMENTATION_PATH =
NODE_INSTANCE_ID_BA.builder() //
.augmentation(FlowCapableNode.class) //
assertNull(node);
}
- private void verifyNodes(final Nodes nodes, final Node original) {
- assertNotNull(nodes);
- assertNotNull(nodes.getNode());
- assertEquals(1, nodes.getNode().size());
- Node readedNode = nodes.getNode().get(0);
- assertEquals(original.getId(), readedNode.getId());
- assertEquals(original.getKey(), readedNode.getKey());
-
- FlowCapableNode fnu = original.getAugmentation(FlowCapableNode.class);
- FlowCapableNode readedAugment = readedNode.getAugmentation(FlowCapableNode.class);
- assertNotNull(fnu);
- assertEquals(fnu.getDescription(), readedAugment.getDescription());
- assertEquals(fnu.getSerialNumber(), readedAugment.getSerialNumber());
-
- }
-
private void assertBindingIndependentVersion(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier nodeId) {
CompositeNode node = biDataService.readOperationalData(nodeId);
assertNotNull(node);
}
- private Nodes checkForNodes() {
- return (Nodes) baDataService.readOperationalData(NODES_INSTANCE_ID_BA);
- }
-
@Override
public void onDataChanged(final DataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
lastReceivedChangeEvent.set(change);
import com.google.common.util.concurrent.SettableFuture;
+@SuppressWarnings("deprecation")
public class WriteParentListenAugmentTest extends AbstractDataServiceTest {
private static final String NODE_ID = "node:1";
import com.google.common.collect.ImmutableList;
+@SuppressWarnings("deprecation")
public class WriteParentReadChildTest extends AbstractDataServiceTest {
private static final String FLOW_ID = "1234";
* 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.controller.sal.binding.impl.connect.dom;
-
-public class CompositeNodeUtils {
-
-}
+/**
+ * This testsuite test Hydrogen-level API and regression for most of it,
+ *
+ * FIXME: this testsuite needs to be refactored to use new DataBroker API,
+ * moved to sal-binding-broker-impl and uses models only from sal-test-model.
+ *
+ */
+package org.opendaylight.controller.sal.binding.test.bugfix;
\ No newline at end of file
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
-
import java.util.concurrent.Future;
-
import org.junit.Test;
import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction;
-
import org.opendaylight.controller.sal.binding.test.AbstractDataServiceTest;
-
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
+// FIXME: Migrate to use new Data Broker APIs
+@SuppressWarnings("deprecation")
public class BrokerIntegrationTest extends AbstractDataServiceTest {
@Test
assertNull(readedData2);
}
- private static NodeRef createNodeRef(String string) {
+ private static NodeRef createNodeRef(final String string) {
NodeKey key = new NodeKey(new NodeId(string));
InstanceIdentifier<Node> path = InstanceIdentifier.builder(Nodes.class).child(Node.class, key)
.toInstance();
return new NodeRef(path);
}
- private static Node createNode(String string) {
+ private static Node createNode(final String string) {
NodeBuilder ret = new NodeBuilder();
ret.setId(new NodeId(string));
ret.setKey(new NodeKey(ret.getId()));
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
import com.google.common.collect.ImmutableMap;
import com.google.common.util.concurrent.SettableFuture;
+// FIXME: Migrate to use new Data Broker APIs
+@SuppressWarnings("deprecation")
public class ChangeOriginatedInDomBrokerTest extends AbstractDataServiceTest {
private static final Logger LOG = LoggerFactory.getLogger(ChangeOriginatedInDomBrokerTest.class);
private static final QName NODE_ID_QNAME = QName.create(Node.QNAME, "id");
private static final QName FLOW_ID_QNAME = QName.create(Flow.QNAME, "id");
- private static final QName FLOW_NODE_QNAME = QName.create(Flow.QNAME, "node");
private static final QName TABLE_ID_QNAME = QName.create(Table.QNAME, "id");
private static final String NODE_ID = "node:1";
private static final InstanceIdentifier<Node> NODE_INSTANCE_ID_BA = InstanceIdentifier.builder(Nodes.class) //
.child(Node.class, NODE_KEY).toInstance();
- private static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier NODE_INSTANCE_ID_BI = //
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.builder() //
- .node(Nodes.QNAME) //
- .nodeWithKey(Node.QNAME, NODE_KEY_BI) //
- .toInstance();
- private static final NodeRef NODE_REF = new NodeRef(NODE_INSTANCE_ID_BA);
-
private static final Map<QName, Object> FLOW_KEY_BI = //
ImmutableMap.<QName, Object> of(FLOW_ID_QNAME, FLOW_ID.getValue());
import org.opendaylight.controller.sal.core.api.mount.MountProvisionInstance;
import org.opendaylight.controller.sal.core.api.mount.MountProvisionService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.NodeGroupStatistics;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.group.statistics.GroupStatistics;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.GroupKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
import com.google.common.util.concurrent.MoreExecutors;
+@SuppressWarnings("deprecation")
public class CrossBrokerMountPointTest {
private static final QName NODE_ID_QNAME = QName.create(Node.QNAME, "id");
- private static final QName FLOW_ID_QNAME = QName.create(Flow.QNAME, "id");
- private static final QName FLOW_NODE_QNAME = QName.create(Flow.QNAME, "node");
- private static final QName TABLE_ID_QNAME = QName.create(Table.QNAME, "id");
-
private static final String NODE_ID = "node:1";
private static final NodeKey NODE_KEY = new NodeKey(new NodeId(NODE_ID));
.nodeWithKey(QName.create(FlowCapableNode.QNAME, "group"), QName.create(FlowCapableNode.QNAME, "group-id"),
0L).node(AUGMENTED_GROUP_STATISTICS).toInstance();
- private static final NodeRef NODE_REF = new NodeRef(NODE_INSTANCE_ID_BA);
-
private BindingTestContext testContext;
private MountProviderService bindingMountPointService;
private MountProvisionService domMountPointService;
DataReader<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> simpleReader = new DataReader<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode>() {
@Override
- public CompositeNode readConfigurationData(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier arg0) {
+ public CompositeNode readConfigurationData(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier arg0) {
return null;
}
@Override
- public CompositeNode readOperationalData(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier arg0) {
+ public CompositeNode readOperationalData(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier arg0) {
if (arg0.equals(GROUP_STATISTICS_ID_BI)) {
ImmutableCompositeNode data = ImmutableCompositeNode
.builder()
--- /dev/null
+/*
+ * Copyright (c) 2014 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.controller.sal.binding.test.connect.dom;
+
+import static junit.framework.Assert.assertNotNull;
+import static junit.framework.Assert.assertTrue;
+import static junit.framework.Assert.fail;
+
+import java.io.InputStream;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.controller.sal.binding.api.mount.MountProviderInstance;
+import org.opendaylight.controller.sal.binding.api.mount.MountProviderService;
+import org.opendaylight.controller.sal.binding.test.util.BindingBrokerTestFactory;
+import org.opendaylight.controller.sal.binding.test.util.BindingTestContext;
+import org.opendaylight.controller.sal.common.util.Rpcs;
+import org.opendaylight.controller.sal.core.api.RpcImplementation;
+import org.opendaylight.controller.sal.core.api.mount.MountProvisionInstance;
+import org.opendaylight.controller.sal.core.api.mount.MountProvisionService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.bi.ba.rpcservice.rev140701.OpendaylightTestRpcServiceService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.bi.ba.rpcservice.rev140701.RockTheHouseInputBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.util.BindingReflections;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.data.api.CompositeNode;
+import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.parser.api.YangContextParser;
+import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+
+/**
+ * Test case for reported bug 560
+ *
+ * @author Lukas Sedlak
+ * @see <a
+ * href="https://bugs.opendaylight.org/show_bug.cgi?id=560">https://bugs.opendaylight.org/show_bug.cgi?id=560</a>
+ */
+public class DOMRpcServiceTestBugfix560 {
+
+ private final static String RPC_SERVICE_NAMESPACE = "urn:opendaylight:params:xml:ns:yang:controller:md:sal:test:bi:ba:rpcservice";
+ private final static String REVISION_DATE = "2014-07-01";
+ private final static QName RPC_NAME = QName.create(RPC_SERVICE_NAMESPACE,
+ REVISION_DATE, "rock-the-house");
+
+ private static final NodeId MOUNT_NODE = new NodeId("id");
+ private static final QName NODE_ID_QNAME = QName.create(Node.QNAME, "id");
+
+ private static final InstanceIdentifier<Node> BA_MOUNT_ID = createBANodeIdentifier(MOUNT_NODE);
+ private static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier BI_MOUNT_ID = createBINodeIdentifier(MOUNT_NODE);
+
+ private BindingTestContext testContext;
+ private MountProvisionService domMountPointService;
+ private MountProviderService bindingMountPointService;
+ private SchemaContext schemaContext;
+
+ /**
+ * @throws java.lang.Exception
+ */
+ @Before
+ public void setUp() throws Exception {
+ BindingBrokerTestFactory testFactory = new BindingBrokerTestFactory();
+ testFactory.setExecutor(MoreExecutors.sameThreadExecutor());
+ testFactory.setStartWithParsedSchema(true);
+ testContext = testFactory.getTestContext();
+
+ testContext.start();
+ domMountPointService = testContext.getDomMountProviderService();
+ bindingMountPointService = testContext.getBindingMountProviderService();
+ assertNotNull(domMountPointService);
+
+ final YangContextParser parser = new YangParserImpl();
+ final InputStream moduleStream = BindingReflections.getModuleInfo(
+ OpendaylightTestRpcServiceService.class)
+ .getModuleSourceStream();
+
+ assertNotNull(moduleStream);
+ List<InputStream> rpcModels = Collections.singletonList(moduleStream);
+ @SuppressWarnings("deprecation")
+ Set<Module> modules = parser.parseYangModelsFromStreams(rpcModels);
+ @SuppressWarnings("deprecation")
+ SchemaContext mountSchemaContext = parser.resolveSchemaContext(modules);
+ schemaContext = mountSchemaContext;
+ }
+
+ private static org.opendaylight.yangtools.yang.data.api.InstanceIdentifier createBINodeIdentifier(
+ final NodeId mountNode) {
+ return org.opendaylight.yangtools.yang.data.api.InstanceIdentifier
+ .builder().node(Nodes.QNAME)
+ .nodeWithKey(Node.QNAME, NODE_ID_QNAME, mountNode.getValue())
+ .toInstance();
+ }
+
+ private static InstanceIdentifier<Node> createBANodeIdentifier(
+ final NodeId mountNode) {
+ return InstanceIdentifier.builder(Nodes.class)
+ .child(Node.class, new NodeKey(mountNode)).toInstance();
+ }
+
+ @SuppressWarnings("deprecation")
+ @Test
+ public void test() throws ExecutionException, InterruptedException {
+ // FIXME: This is made to only make sure instance identifier codec
+ // for path is instantiated.
+ testContext.getBindingDataBroker().readOperationalData(BA_MOUNT_ID);
+ final MountProvisionInstance mountPoint = domMountPointService
+ .createMountPoint(BI_MOUNT_ID);
+ mountPoint.setSchemaContext(schemaContext);
+ assertNotNull(mountPoint);
+
+ mountPoint.addRpcImplementation(RPC_NAME, new RpcImplementation() {
+
+ @Override
+ public ListenableFuture<RpcResult<CompositeNode>> invokeRpc(
+ final QName rpc, final CompositeNode input) {
+
+ return Futures.immediateFuture(Rpcs
+ .<CompositeNode> getRpcResult(true));
+ }
+
+ @Override
+ public Set<QName> getSupportedRpcs() {
+ return ImmutableSet.of(RPC_NAME);
+ }
+ });
+
+ final Set<QName> biSupportedRpcs = mountPoint.getSupportedRpcs();
+ assertNotNull(biSupportedRpcs);
+ assertTrue(!biSupportedRpcs.isEmpty());
+
+ MountProviderInstance mountInstance = bindingMountPointService
+ .getMountPoint(BA_MOUNT_ID);
+ assertNotNull(mountInstance);
+ final OpendaylightTestRpcServiceService rpcService = mountInstance
+ .getRpcService(OpendaylightTestRpcServiceService.class);
+ assertNotNull(rpcService);
+
+ try {
+ Future<RpcResult<Void>> result = rpcService
+ .rockTheHouse(new RockTheHouseInputBuilder().build());
+ assertTrue(result.get().isSuccessful());
+ } catch (IllegalStateException ex) {
+ fail("OpendaylightTestRpcServiceService class doesn't contain rockTheHouse method!");
+ }
+ }
+
+ /**
+ * @throws java.lang.Exception
+ */
+ @After
+ public void teardown() throws Exception {
+ testContext.close();
+ }
+}
*
* @return map of paths and original state of updated and removed objects.
*/
- Map<P, ? extends D> getOriginalData();
+ Map<P, D> getOriginalData();
/**
* Returns an immutable stable view of data state, which captures the state of
import java.util.concurrent.ExecutorService;
+/**
+ * Interface for publishing YANG-modeled notifications.
+ * <p>
+ * Users of this interface can publish any YANG-modeled notification which will
+ * be delivered to all subscribed listeners.
+ * <p>
+ * Prefered way of publishing of notifications is done by invoking {@link #publish(Object)}.
+ *
+ * <p>You may consider using {@link #publish(Object, ExecutorService)} if and only if
+ * your use-case requires customized execution policy or run-to-completion
+ * inside process.
+ *
+ * <p>
+ * The metadata required to deliver a notification to the correct listeners is
+ * extracted from the published notification.
+ *
+ *
+ * FIXME: Consider clarification of execution/delivery policy, how it will be
+ * affected by Actor model and cluster-wide notifications.
+ *
+ * @param <N>
+ * the type of notifications
+ */
public interface NotificationPublishService<N> {
+ /**
+ * Publishes a notification and notifies subscribed listeners. All listener
+ * notifications are done via a default executor.
+ * <p>
+ * <b>Note:</b> This call will block when the default executor is saturated
+ * and the notification queue for this executor is full.
+ *
+ * @param notification
+ * the notification to publish.
+ */
void publish(N notification);
- void publish(N notification,ExecutorService executor);
+ /**
+ * Publishes a notification and notifies subscribed listeners. All listener
+ * notifications are done via the provided executor.
+ * <p>
+ * <b>Note:</b> Use only if ineccessary. Consider using
+ * {@link #publish(Object)} for most use-cases.
+ *
+ * <p>
+ * By using this method you could customize execution policy of listeners present
+ * inside process (e.g. using single-threaded executor or even same-thread executor
+ * delivery.
+ *
+ * <p>
+ * This executor is used only for inside-process notification deliveries.
+ *
+ * @param notification
+ * the notification to publish.
+ * @param executor
+ * the executor that will be used to deliver notifications to
+ * subscribed listeners.
+ */
+ void publish(N notification, ExecutorService executor);
}
+++ /dev/null
-/*
- * Copyright (c) 2014 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.controller.sal.compability;
-
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.PortFeatures;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
-
-public class ToSalPropertyClassUtils {
- public static Bandwidth salAdvertisedBandwidthFrom(NodeConnector nodeConnector) {
- FlowCapableNodeConnector flowCapNodeConn = nodeConnector.getAugmentation(FlowCapableNodeConnector.class);
- PortFeatures portFeatures = flowCapNodeConn.getAdvertisedFeatures();
- return new AdvertisedBandwidth(resolveBandwidth(portFeatures));
- }
-
- public static Bandwidth salPeerBandwidthFrom(NodeConnector nodeConnector) {
- FlowCapableNodeConnector flowCapNodeConn = nodeConnector.getAugmentation(FlowCapableNodeConnector.class);
- PortFeatures portFeatures = flowCapNodeConn.getPeerFeatures();
- return new PeerBandwidth(resolveBandwidth(portFeatures));
- }
-
- public static Bandwidth salSupportedBandwidthFrom(NodeConnector nodeConnector) {
- FlowCapableNodeConnector flowCapNodeConn = nodeConnector.getAugmentation(FlowCapableNodeConnector.class);
- PortFeatures portFeatures = flowCapNodeConn.getSupported();
- return new SupportedBandwidth(resolveBandwidth(portFeatures));
- }
-
- public static MacAddress salMacAddressFrom(NodeConnector nodeConnector) {
- FlowCapableNodeConnector flowCapNodeConn = nodeConnector.getAugmentation(FlowCapableNodeConnector.class);
- String hwAddress = flowCapNodeConn.getHardwareAddress().getValue();
- return new MacAddress(bytesFrom(hwAddress));
- }
-
-
- public static Name salNameFrom(NodeConnector nodeConnector) {
- FlowCapableNodeConnector flowCapNodeConn = nodeConnector.getAugmentation(FlowCapableNodeConnector.class);
- return new Name(flowCapNodeConn.getName());
- }
-
-
-
- private static byte[] bytesFrom(String hwAddress) {
- String[] mac = hwAddress.split(":");
- byte[] macAddress = new byte[6]; // mac.length == 6 bytes
- for (int i = 0; i < mac.length; i++) {
- macAddress[i] = Integer.decode("0x" + mac[i]).byteValue();
- }
- return macAddress;
- }
-
- private static long resolveBandwidth(PortFeatures portFeatures) {
- if (portFeatures.is_1tbFd()) {
- return Bandwidth.BW1Tbps;
- } else if (portFeatures.is_100gbFd()) {
- return Bandwidth.BW100Gbps;
- } else if (portFeatures.is_40gbFd()) {
- return Bandwidth.BW40Gbps;
- } else if (portFeatures.is_10gbFd()) {
- return Bandwidth.BW10Gbps;
- } else if (portFeatures.is_1gbHd() || portFeatures.is_1gbFd()) {
- return Bandwidth.BW1Gbps;
- } else if (portFeatures.is_100mbHd() || portFeatures.is_100mbFd()) {
- return Bandwidth.BW100Mbps;
- } else if (portFeatures.is_10mbHd() || portFeatures.is_10mbFd()) {
- return Bandwidth.BW10Mbps;
- } else {
- return Bandwidth.BWUNK;
- }
- }
-
-}
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
+import com.google.common.base.Preconditions;
import org.opendaylight.controller.md.sal.common.api.routing.RouteChange;
import org.opendaylight.controller.md.sal.common.api.routing.RouteChangeListener;
import org.opendaylight.controller.md.sal.common.impl.routing.RoutingUtils;
RpcDefinition definition = findRpcDefinition(rpcType);
checkArgument(!isRoutedRpc(definition), "RPC Type must not be routed.");
GlobalRpcRegistration reg = new GlobalRpcRegistration(rpcType, implementation, this);
- implementations.putIfAbsent(rpcType, implementation);
+ final RpcImplementation previous = implementations.putIfAbsent(rpcType, implementation);
+ Preconditions.checkState(previous == null, "Rpc %s is already registered.",rpcType);
+ notifyRpcAdded(rpcType);
return reg;
}
+ private void notifyRpcAdded(QName rpcType) {
+ for (ListenerRegistration<RpcRegistrationListener> listener : rpcRegistrationListeners) {
+ try {
+ listener.getInstance().onRpcImplementationAdded(rpcType);
+ } catch (Exception ex) {
+ LOG.error("Unhandled exception during invoking listener {}", listener.getInstance(), ex);
+ }
+
+ }
+ }
+
private boolean isRoutedRpc(RpcDefinition definition) {
return getRoutingStrategy(definition) instanceof RoutedRpcStrategy;
}
@Override
public ListenerRegistration<RpcRegistrationListener> addRpcRegistrationListener(RpcRegistrationListener listener) {
- return rpcRegistrationListeners.register(listener);
+ ListenerRegistration<RpcRegistrationListener> reg = rpcRegistrationListeners.register(listener);
+ for (QName impl : implementations.keySet()) {
+ listener.onRpcImplementationAdded(impl);
+ }
+ return reg;
}
@Override
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId>
- <version>${slf4j.version}</version>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>binding-generator-impl</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal-test-model</artifactId>
+ <scope>test</scope>
+ <version>${project.version}</version>
+ </dependency>
</dependencies>
<build>
private final NormalizedNode<?, ?> original;
private final NormalizedNode<?, ?> updated;
- private final Map<InstanceIdentifier, ? extends NormalizedNode<?, ?>> originalData;
+ private final Map<InstanceIdentifier, NormalizedNode<?, ?>> originalData;
private final Map<InstanceIdentifier, NormalizedNode<?, ?>> createdData;
private final Map<InstanceIdentifier, NormalizedNode<?, ?>> updatedData;
private final Set<InstanceIdentifier> removedPaths;
}
@Override
- public Map<InstanceIdentifier, ? extends NormalizedNode<?, ?>> getOriginalData() {
+ public Map<InstanceIdentifier, NormalizedNode<?, ?>> getOriginalData() {
return originalData;
}
*/
package org.opendaylight.controller.md.sal.dom.store.impl;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.Multimap;
+import static org.opendaylight.controller.md.sal.dom.store.impl.DOMImmutableDataChangeEvent.builder;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.concurrent.Callable;
+
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
import org.opendaylight.controller.md.sal.dom.store.impl.DOMImmutableDataChangeEvent.Builder;
import org.opendaylight.controller.md.sal.dom.store.impl.DOMImmutableDataChangeEvent.SimpleEventFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map.Entry;
-import java.util.Set;
-import java.util.concurrent.Callable;
-
-import static org.opendaylight.controller.md.sal.dom.store.impl.DOMImmutableDataChangeEvent.builder;
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Iterables;
+import com.google.common.collect.Multimap;
/**
* Resolve Data Change Events based on modifications and listeners
Builder subtree = builder(DataChangeScope.SUBTREE).
setBefore(modification.getDataBefore().get()).
setAfter(modification.getDataAfter().get());
-
+ boolean oneModified = false;
for (DataTreeCandidateNode childMod : modification.getChildNodes()) {
PathArgument childId = childMod.getIdentifier();
InstanceIdentifier childPath = path.node(childId);
Collection<ListenerTree.Node> childListeners = getListenerChildrenWildcarded(listeners, childId);
+
switch (childMod.getModificationType()) {
case WRITE:
case MERGE:
case DELETE:
one.merge(resolveAnyChangeEvent(childPath, childListeners, childMod));
+ oneModified = true;
break;
case SUBTREE_MODIFIED:
subtree.merge(resolveSubtreeChangeEvent(childPath, childListeners, childMod));
break;
}
}
- DOMImmutableDataChangeEvent oneChangeEvent = one.build();
- subtree.merge(oneChangeEvent);
+ final DOMImmutableDataChangeEvent oneChangeEvent;
+ if(oneModified) {
+ one.addUpdated(path, modification.getDataBefore().get(), modification.getDataAfter().get());
+ oneChangeEvent = one.build();
+ subtree.merge(oneChangeEvent);
+ } else {
+ oneChangeEvent = null;
+ subtree.addUpdated(path, modification.getDataBefore().get(), modification.getDataAfter().get());
+ }
DOMImmutableDataChangeEvent subtreeEvent = subtree.build();
if (!listeners.isEmpty()) {
- addPartialTask(listeners, oneChangeEvent);
+ if(oneChangeEvent != null) {
+ addPartialTask(listeners, oneChangeEvent);
+ }
addPartialTask(listeners, subtreeEvent);
}
return subtreeEvent;
--- /dev/null
+/*
+ * Copyright (c) 2014 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.controller.md.sal.dom.store.impl;
+
+import java.util.Collection;
+import java.util.Map;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.opendaylight.controller.md.sal.dom.store.impl.DatastoreTestTask.WriteTransactionCustomizer;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.Top;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.TwoLevelList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.two.level.list.TopLevelList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.two.level.list.top.level.list.NestedList;
+import org.opendaylight.yangtools.sal.binding.generator.impl.ModuleInfoBackedContext;
+import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
+import org.opendaylight.yangtools.yang.binding.util.BindingReflections;
+import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
+import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
+import org.opendaylight.yangtools.yang.data.api.schema.OrderedMapNode;
+import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
+import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.CollectionNodeBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeAttrBuilder;
+import org.opendaylight.yangtools.yang.data.impl.schema.builder.api.DataContainerNodeBuilder;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+
+import com.google.common.util.concurrent.MoreExecutors;
+
+public abstract class AbstractDataChangeListenerTest {
+
+ protected static final InstanceIdentifier TOP_LEVEL = InstanceIdentifier
+ .of(Top.QNAME);
+ private static final QName NAME_QNAME = QName.create(Top.QNAME, "name");
+ protected static final String FOO = "foo";
+ protected static final String BAR = "bar";
+ protected static final String BAZ = "baz";
+
+ private InMemoryDOMDataStore datastore;
+ private SchemaContext schemaContext;
+
+ @Before
+ public final void setup() throws Exception {
+ YangModuleInfo moduleInfo = BindingReflections
+ .getModuleInfo(TwoLevelList.class);
+ ModuleInfoBackedContext context = ModuleInfoBackedContext.create();
+ context.registerModuleInfo(moduleInfo);
+ schemaContext = context.tryToCreateSchemaContext().get();
+ datastore = new InMemoryDOMDataStore("TEST",
+ MoreExecutors.sameThreadExecutor());
+ datastore.onGlobalContextUpdated(schemaContext);
+ }
+
+ public final DatastoreTestTask newTestTask() {
+ return new DatastoreTestTask(datastore).cleanup(DatastoreTestTask
+ .simpleDelete(TOP_LEVEL));
+ }
+
+
+ public static final InstanceIdentifier path(final String topName,
+ final String nestedName) {
+ return path(topName).node(NestedList.QNAME).node(
+ new NodeIdentifierWithPredicates(NestedList.QNAME, NAME_QNAME,
+ nestedName));
+ }
+
+ public static final InstanceIdentifier path(final String topName) {
+ return TOP_LEVEL.node(TopLevelList.QNAME).node(
+ new NodeIdentifierWithPredicates(TopLevelList.QNAME,
+ NAME_QNAME, topName));
+ }
+
+ protected static DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> top() {
+ return Builders.containerBuilder().withNodeIdentifier(
+ new NodeIdentifier(Top.QNAME));
+ }
+
+
+
+ protected static void assertEmpty(final Collection<?> set) {
+ Assert.assertTrue(set.isEmpty());
+ }
+
+ protected static void assertEmpty(final Map<?,?> set) {
+ Assert.assertTrue(set.isEmpty());
+ }
+
+ protected static <K> void assertContains(final Collection<K> set, final K... values) {
+ for (K key : values) {
+ Assert.assertTrue(set.contains(key));
+ }
+
+ }
+
+ protected static <K> void assertNotContains(final Collection<K> set, final K... values) {
+ for (K key : values) {
+ Assert.assertFalse(set.contains(key));
+ }
+ }
+
+ protected static <K> void assertContains(final Map<K,?> map, final K... values) {
+ for (K key : values) {
+ Assert.assertTrue(map.containsKey(key));
+ }
+ }
+
+ protected static <K> void assertNotContains(final Map<K,?> map, final K... values) {
+ for (K key : values) {
+ Assert.assertFalse(map.containsKey(key));
+ }
+ }
+
+ protected static CollectionNodeBuilder<MapEntryNode, MapNode> topLevelMap() {
+ return ImmutableNodes.mapNodeBuilder(TopLevelList.QNAME);
+ }
+
+ protected static CollectionNodeBuilder<MapEntryNode, OrderedMapNode> nestedMap() {
+ return Builders.orderedMapBuilder().withNodeIdentifier(new NodeIdentifier(NestedList.QNAME));
+ }
+
+ public static DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> topLevelList(
+ final String key) {
+ return ImmutableNodes.mapEntryBuilder(TopLevelList.QNAME, NAME_QNAME,
+ key);
+ }
+
+ public static DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> nestedList(
+ final String key) {
+ return ImmutableNodes
+ .mapEntryBuilder(NestedList.QNAME, NAME_QNAME, key);
+ }
+
+ public static final WriteTransactionCustomizer writeOneTopMultipleNested(
+ final String topName, final String... nestedName) {
+ CollectionNodeBuilder<MapEntryNode, OrderedMapNode> nestedMapBuilder = nestedMap();
+ for (String nestedItem : nestedName) {
+ nestedMapBuilder.addChild(nestedList(nestedItem).build());
+ }
+
+ final ContainerNode data = top().addChild(
+ topLevelMap().addChild(
+ topLevelList(topName)
+ .addChild(nestedMapBuilder.build()).build())
+ .build()).build();
+
+ return DatastoreTestTask.simpleWrite(TOP_LEVEL, data);
+ }
+
+ public static final WriteTransactionCustomizer deleteNested(final String topName,
+ final String nestedName) {
+ return DatastoreTestTask.simpleDelete(path(topName, nestedName));
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 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.controller.md.sal.dom.store.impl;
+
+import static org.junit.Assert.assertTrue;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeListener;
+import org.opendaylight.controller.sal.core.spi.data.DOMStore;
+import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadTransaction;
+import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadWriteTransaction;
+import org.opendaylight.controller.sal.core.spi.data.DOMStoreThreePhaseCommitCohort;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+
+import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.SettableFuture;
+
+public class DatastoreTestTask {
+
+ private final DOMStore store;
+ private AsyncDataChangeListener<InstanceIdentifier, NormalizedNode<?, ?>> changeListener;
+
+ private WriteTransactionCustomizer setup;
+ private WriteTransactionCustomizer write;
+ private ReadTransactionVerifier read;
+ private WriteTransactionCustomizer cleanup;
+ private InstanceIdentifier changePath;
+ private DataChangeScope changeScope;
+ private boolean postSetup = false;
+ private final ChangeEventListener internalListener;
+
+ public DatastoreTestTask(final DOMStore datastore) {
+ this.store = datastore;
+ internalListener = new ChangeEventListener();
+ }
+
+ public DatastoreTestTask changeListener(final InstanceIdentifier path, final DataChangeScope scope,
+ final AsyncDataChangeListener<InstanceIdentifier, NormalizedNode<?, ?>> changeListener) {
+ this.changeListener = changeListener;
+ this.changePath = path;
+ this.changeScope = scope;
+ return this;
+ }
+
+ public DatastoreTestTask changeListener(final InstanceIdentifier path, final DataChangeScope scope) {
+ this.changePath = path;
+ this.changeScope = scope;
+ return this;
+ }
+
+ public DatastoreTestTask setup(final WriteTransactionCustomizer setup) {
+ this.setup = setup;
+ return this;
+ }
+
+ public DatastoreTestTask test(final WriteTransactionCustomizer write) {
+ this.write = write;
+ return this;
+ }
+
+ public DatastoreTestTask read(final ReadTransactionVerifier read) {
+ this.read = read;
+ return this;
+ }
+
+ public DatastoreTestTask cleanup(final WriteTransactionCustomizer cleanup) {
+ this.cleanup = cleanup;
+ return this;
+ }
+
+ public void run() throws InterruptedException, ExecutionException {
+ if (setup != null) {
+ execute(setup);
+ }
+ ListenerRegistration<ChangeEventListener> registration = null;
+ if (changePath != null) {
+ registration = store.registerChangeListener(changePath, internalListener, changeScope);
+ }
+
+ Preconditions.checkState(write != null, "Write Transaction must be set.");
+ postSetup = true;
+ execute(write);
+ if (registration != null) {
+ registration.close();
+ }
+ if (changeListener != null) {
+ changeListener.onDataChanged(internalListener.receivedChange.get());
+ }
+ if (read != null) {
+ read.verify(store.newReadOnlyTransaction());
+ }
+ if (cleanup != null) {
+ execute(cleanup);
+ }
+ }
+
+ public Future<AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>>> getChangeEvent() {
+ return internalListener.receivedChange;
+ }
+
+ private void execute(final WriteTransactionCustomizer writeCustomizer) throws InterruptedException,
+ ExecutionException {
+ DOMStoreReadWriteTransaction tx = store.newReadWriteTransaction();
+ writeCustomizer.customize(tx);
+ DOMStoreThreePhaseCommitCohort cohort = tx.ready();
+ assertTrue(cohort.canCommit().get());
+ cohort.preCommit().get();
+ cohort.commit().get();
+ }
+
+ public interface WriteTransactionCustomizer {
+ public void customize(DOMStoreReadWriteTransaction tx);
+ }
+
+ public interface ReadTransactionVerifier {
+ public void verify(DOMStoreReadTransaction tx);
+ }
+
+ private final class ChangeEventListener implements
+ AsyncDataChangeListener<InstanceIdentifier, NormalizedNode<?, ?>> {
+
+ protected final SettableFuture<AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>>> receivedChange = SettableFuture
+ .create();
+
+ @Override
+ public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change) {
+ if (postSetup) {
+ receivedChange.set(change);
+ }
+ }
+ }
+
+ public static final WriteTransactionCustomizer simpleWrite(final InstanceIdentifier path,
+ final NormalizedNode<?, ?> data) {
+ return new WriteTransactionCustomizer() {
+
+ @Override
+ public void customize(final DOMStoreReadWriteTransaction tx) {
+ tx.write(path, data);
+ }
+ };
+ }
+
+ public static final WriteTransactionCustomizer simpleMerge(final InstanceIdentifier path,
+ final NormalizedNode<?, ?> data) {
+ return new WriteTransactionCustomizer() {
+
+ @Override
+ public void customize(final DOMStoreReadWriteTransaction tx) {
+ tx.merge(path, data);
+ }
+ };
+ }
+
+ public static final WriteTransactionCustomizer simpleDelete(final InstanceIdentifier path) {
+ return new WriteTransactionCustomizer() {
+ @Override
+ public void customize(final DOMStoreReadWriteTransaction tx) {
+ tx.delete(path);
+ }
+ };
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 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.controller.md.sal.dom.store.impl;
+
+import java.util.concurrent.ExecutionException;
+
+import org.junit.Test;
+import org.opendaylight.controller.md.sal.dom.store.impl.DatastoreTestTask.WriteTransactionCustomizer;
+import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadWriteTransaction;
+
+public abstract class DefaultDataChangeListenerTestSuite extends AbstractDataChangeListenerTest {
+
+ protected static final String FOO_SIBLING = "foo-sibling";
+
+ abstract protected void customizeTask(DatastoreTestTask task);
+
+ @Test
+ public final void putTopLevelOneNested() throws InterruptedException, ExecutionException {
+
+ DatastoreTestTask task = newTestTask().test(writeOneTopMultipleNested(FOO, BAR));
+ customizeTask(task);
+ task.run();
+ putTopLevelOneNested(task);
+ }
+
+ @Test
+ public final void existingTopWriteSibling() throws InterruptedException, ExecutionException {
+ DatastoreTestTask task = newTestTask().setup(writeOneTopMultipleNested(FOO)).test(
+ new WriteTransactionCustomizer() {
+ @Override
+ public void customize(final DOMStoreReadWriteTransaction tx) {
+ tx.write(path(FOO_SIBLING), topLevelList(FOO_SIBLING).build());
+ }
+ });
+ customizeTask(task);
+ task.run();
+ existingTopWriteSibling(task);
+ }
+
+ protected abstract void existingTopWriteSibling(DatastoreTestTask task) throws InterruptedException, ExecutionException;
+
+
+ @Test
+ public final void existingTopWriteTwoNested() throws InterruptedException, ExecutionException {
+ DatastoreTestTask task = newTestTask().setup(writeOneTopMultipleNested(FOO)).test(
+ new WriteTransactionCustomizer() {
+ @Override
+ public void customize(final DOMStoreReadWriteTransaction tx) {
+ tx.write(path(FOO,BAR), nestedList(BAR).build());
+ tx.write(path(FOO,BAZ), nestedList(BAZ).build());
+ }
+ });
+ customizeTask(task);
+ task.run();
+ existingTopWriteTwoNested(task);
+ }
+
+ protected abstract void existingTopWriteTwoNested(DatastoreTestTask task) throws InterruptedException, ExecutionException;
+
+
+ @Test
+ public final void existingOneNestedWriteAdditionalNested() throws InterruptedException, ExecutionException {
+ DatastoreTestTask task = newTestTask().setup(writeOneTopMultipleNested(FOO, BAR)).test(
+ new WriteTransactionCustomizer() {
+ @Override
+ public void customize(final DOMStoreReadWriteTransaction tx) {
+ tx.write(path(FOO,BAZ), nestedList(BAZ).build());
+ }
+ });
+ customizeTask(task);
+ task.run();
+ existingOneNestedWriteAdditionalNested(task);
+ }
+
+ protected abstract void existingOneNestedWriteAdditionalNested(DatastoreTestTask task) throws InterruptedException, ExecutionException;
+
+ protected abstract void putTopLevelOneNested(DatastoreTestTask task) throws InterruptedException,
+ ExecutionException;
+
+ @Test
+ public final void replaceTopLevelNestedChanged() throws InterruptedException, ExecutionException {
+ DatastoreTestTask task = newTestTask().setup(writeOneTopMultipleNested(FOO, BAR)).test(
+ writeOneTopMultipleNested(FOO, BAZ));
+ customizeTask(task);
+ task.run();
+ replaceTopLevelNestedChanged(task);
+ }
+
+ protected abstract void replaceTopLevelNestedChanged(DatastoreTestTask task) throws InterruptedException,
+ ExecutionException;
+
+ @Test
+ public final void putTopLevelWithTwoNested() throws InterruptedException, ExecutionException {
+
+ DatastoreTestTask task = newTestTask().test(writeOneTopMultipleNested(FOO, BAR, BAZ));
+ customizeTask(task);
+ task.run();
+ putTopLevelWithTwoNested(task);
+ }
+
+ protected abstract void putTopLevelWithTwoNested(DatastoreTestTask task) throws InterruptedException,
+ ExecutionException;
+
+ @Test
+ public final void twoNestedExistsOneIsDeleted() throws InterruptedException, ExecutionException {
+
+ DatastoreTestTask task = newTestTask().setup(writeOneTopMultipleNested(FOO, BAR, BAZ)).test(
+ deleteNested(FOO, BAZ));
+ customizeTask(task);
+ task.run();
+ twoNestedExistsOneIsDeleted(task);
+ }
+
+ protected abstract void twoNestedExistsOneIsDeleted(DatastoreTestTask task) throws InterruptedException,
+ ExecutionException;
+
+ @Test
+ public final void nestedListExistsRootDeleted() throws InterruptedException, ExecutionException {
+
+ DatastoreTestTask task = newTestTask().cleanup(null).setup(writeOneTopMultipleNested(FOO, BAR, BAZ))
+ .test(DatastoreTestTask.simpleDelete(TOP_LEVEL));
+ customizeTask(task);
+ task.run();
+ nestedListExistsRootDeleted(task);
+ }
+
+ protected abstract void nestedListExistsRootDeleted(DatastoreTestTask task) throws InterruptedException,
+ ExecutionException;
+}
+/*
+ * Copyright (c) 2014 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.controller.md.sal.dom.store.impl;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.ListenableFuture;
-import com.google.common.util.concurrent.MoreExecutors;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.concurrent.ExecutionException;
+
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import java.util.concurrent.ExecutionException;
-
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
public class InMemoryDataStoreTest {
/**
* Reads /test from readTx Read should return container.
*/
- private static Optional<NormalizedNode<?, ?>> assertTestContainerExists(DOMStoreReadTransaction readTx)
+ private static Optional<NormalizedNode<?, ?>> assertTestContainerExists(final DOMStoreReadTransaction readTx)
throws InterruptedException, ExecutionException {
ListenableFuture<Optional<NormalizedNode<?, ?>>> writeTxContainer = readTx.read(TestModel.TEST_PATH);
--- /dev/null
+/*
+ * Copyright (c) 2014 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.controller.md.sal.dom.store.impl;
+
+import java.util.concurrent.ExecutionException;
+
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+
+public class RootScopeSubtreeTest extends DefaultDataChangeListenerTestSuite {
+
+ @Override
+ protected void customizeTask(final DatastoreTestTask task) {
+ task.changeListener(TOP_LEVEL, DataChangeScope.SUBTREE);
+ }
+
+ @Override
+ public void putTopLevelOneNested(final DatastoreTestTask task) throws InterruptedException, ExecutionException {
+ AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+
+ assertContains(change.getCreatedData(), TOP_LEVEL, path(FOO), path(FOO, BAR));
+ assertEmpty(change.getUpdatedData());
+ assertEmpty(change.getRemovedPaths());
+ }
+
+ @Override
+ public void replaceTopLevelNestedChanged(final DatastoreTestTask task) throws InterruptedException,
+ ExecutionException {
+
+ AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+
+ assertContains(change.getCreatedData(), path(FOO, BAZ));
+ assertContains(change.getUpdatedData(), TOP_LEVEL, path(FOO));
+ assertContains(change.getRemovedPaths(), path(FOO, BAR));
+ }
+
+ @Override
+ protected void putTopLevelWithTwoNested(final DatastoreTestTask task) throws InterruptedException,
+ ExecutionException {
+
+ AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+
+ assertContains(change.getCreatedData(), TOP_LEVEL, path(FOO), path(FOO, BAR), path(FOO, BAZ));
+ assertEmpty(change.getUpdatedData());
+ assertEmpty(change.getRemovedPaths());
+ }
+
+ @Override
+ protected void twoNestedExistsOneIsDeleted(final DatastoreTestTask task) throws InterruptedException,
+ ExecutionException {
+
+ AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+
+ assertEmpty(change.getCreatedData());
+ assertContains(change.getUpdatedData(), TOP_LEVEL, path(FOO));
+ assertContains(change.getRemovedPaths(), path(FOO, BAZ));
+ }
+
+ @Override
+ protected void nestedListExistsRootDeleted(final DatastoreTestTask task) throws InterruptedException,
+ ExecutionException {
+
+ AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+
+ assertEmpty(change.getCreatedData());
+ assertEmpty(change.getUpdatedData());
+ assertContains(change.getRemovedPaths(), TOP_LEVEL, path(FOO), path(FOO, BAR), path(FOO, BAZ));
+ }
+
+ @Override
+ protected void existingOneNestedWriteAdditionalNested(final DatastoreTestTask task) throws InterruptedException, ExecutionException {
+ AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+
+ assertContains(change.getCreatedData(), path(FOO,BAZ));
+ assertNotContains(change.getCreatedData(), path(FOO,BAR));
+ assertContains(change.getUpdatedData(), TOP_LEVEL, path(FOO));
+ assertEmpty(change.getRemovedPaths());
+ }
+
+ @Override
+ protected void existingTopWriteTwoNested(final DatastoreTestTask task) throws InterruptedException, ExecutionException {
+ AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+
+ assertContains(change.getCreatedData(), path(FOO,BAR),path(FOO,BAZ));
+ assertContains(change.getUpdatedData(), TOP_LEVEL, path(FOO));
+ assertNotContains(change.getUpdatedData(), path(FOO,BAR));
+ assertEmpty(change.getRemovedPaths());
+ }
+
+ @Override
+ protected void existingTopWriteSibling(final DatastoreTestTask task) throws InterruptedException, ExecutionException {
+ AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+
+ assertContains(change.getCreatedData(), path(FOO_SIBLING));
+ assertContains(change.getUpdatedData(), TOP_LEVEL);
+ assertNotContains(change.getUpdatedData(), path(FOO));
+ assertEmpty(change.getRemovedPaths());
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 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.controller.md.sal.dom.store.impl;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.two.level.list.TopLevelList;
+import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+
+public class WildcardedScopeBaseTest extends DefaultDataChangeListenerTestSuite {
+
+ private static final InstanceIdentifier TOP_LEVEL_LIST_ALL = TOP_LEVEL.node(TopLevelList.QNAME).node(
+ TopLevelList.QNAME);
+
+ @Override
+ protected void customizeTask(final DatastoreTestTask task) {
+ task.changeListener(TOP_LEVEL_LIST_ALL, DataChangeScope.BASE);
+ }
+
+ @Override
+ public void putTopLevelOneNested(final DatastoreTestTask task) throws InterruptedException, ExecutionException {
+
+ AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+
+ assertNotNull(change);
+
+ assertNotContains(change.getCreatedData(), TOP_LEVEL);
+ assertContains(change.getCreatedData(), path(FOO), path(FOO, BAR));
+
+ assertEmpty(change.getUpdatedData());
+ assertEmpty(change.getRemovedPaths());
+
+ }
+
+ @Override
+ public void replaceTopLevelNestedChanged(final DatastoreTestTask task) throws InterruptedException,
+ ExecutionException {
+
+ AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ assertNotNull(change);
+
+ assertContains(change.getCreatedData(), path(FOO, BAZ));
+ assertContains(change.getUpdatedData(), path(FOO));
+ assertNotContains(change.getUpdatedData(), TOP_LEVEL);
+ assertContains(change.getRemovedPaths(), path(FOO, BAR));
+
+ }
+
+ @Override
+ protected void putTopLevelWithTwoNested(final DatastoreTestTask task) throws InterruptedException,
+ ExecutionException {
+
+ AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ assertNotNull(change);
+ assertFalse(change.getCreatedData().isEmpty());
+
+ assertContains(change.getCreatedData(), path(FOO), path(FOO, BAR), path(FOO, BAZ));
+ assertNotContains(change.getCreatedData(), TOP_LEVEL);
+ assertEmpty(change.getUpdatedData());
+ assertEmpty(change.getRemovedPaths());
+
+ }
+
+ @Override
+ protected void twoNestedExistsOneIsDeleted(final DatastoreTestTask task) throws InterruptedException,
+ ExecutionException {
+
+ Future<?> future = task.getChangeEvent();
+ /*
+ * Base listener should be notified only and only if actual node changed its state,
+ * since deletion of child, did not result in change of node we are listening
+ * for, we should not be getting data change event
+ * and this means settable future containing receivedDataChangeEvent is not done.
+ *
+ */
+ assertFalse(future.isDone());
+ }
+
+ @Override
+ public void nestedListExistsRootDeleted(final DatastoreTestTask task) throws InterruptedException,
+ ExecutionException {
+
+ AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+
+ assertEmpty(change.getCreatedData());
+ assertEmpty(change.getUpdatedData());
+
+ assertNotContains(change.getUpdatedData(), TOP_LEVEL);
+ assertContains(change.getRemovedPaths(), path(FOO),path(FOO, BAZ),path(FOO,BAR));
+ }
+
+ @Override
+ protected void existingOneNestedWriteAdditionalNested(final DatastoreTestTask task) {
+ Future<?> future = task.getChangeEvent();
+ /*
+ * One listener should be notified only and only if actual node changed its state,
+ * since deletion of nested child (in this case /nested-list/nested-list[foo],
+ * did not result in change of node we are listening
+ * for, we should not be getting data change event
+ * and this means settable future containing receivedDataChangeEvent is not done.
+ *
+ */
+ assertFalse(future.isDone());
+ }
+
+ @Override
+ protected void existingTopWriteTwoNested(final DatastoreTestTask task) throws InterruptedException, ExecutionException {
+ Future<?> future = task.getChangeEvent();
+ /*
+ * One listener should be notified only and only if actual node changed its state,
+ * since deletion of nested child (in this case /nested-list/nested-list[foo],
+ * did not result in change of node we are listening
+ * for, we should not be getting data change event
+ * and this means settable future containing receivedDataChangeEvent is not done.
+ *
+ */
+ assertFalse(future.isDone());
+ }
+
+ @Override
+ protected void existingTopWriteSibling(final DatastoreTestTask task) throws InterruptedException, ExecutionException {
+ AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+
+ assertContains(change.getCreatedData(), path(FOO_SIBLING));
+ assertNotContains(change.getUpdatedData(), path(FOO), TOP_LEVEL);
+ assertEmpty(change.getRemovedPaths());
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 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.controller.md.sal.dom.store.impl;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.two.level.list.TopLevelList;
+import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+
+public class WildcardedScopeOneTest extends DefaultDataChangeListenerTestSuite {
+
+ private static final InstanceIdentifier TOP_LEVEL_LIST_ALL = TOP_LEVEL.node(TopLevelList.QNAME).node(
+ TopLevelList.QNAME);
+
+ @Override
+ protected void customizeTask(final DatastoreTestTask task) {
+ task.changeListener(TOP_LEVEL_LIST_ALL, DataChangeScope.ONE);
+ }
+
+ @Override
+ public void putTopLevelOneNested(final DatastoreTestTask task) throws InterruptedException, ExecutionException {
+
+ AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+
+ assertNotNull(change);
+
+ assertNotContains(change.getCreatedData(), TOP_LEVEL);
+ assertContains(change.getCreatedData(), path(FOO), path(FOO, BAR));
+
+ assertEmpty(change.getUpdatedData());
+ assertEmpty(change.getRemovedPaths());
+
+ }
+
+ @Override
+ public void replaceTopLevelNestedChanged(final DatastoreTestTask task) throws InterruptedException,
+ ExecutionException {
+
+ AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ assertNotNull(change);
+
+ assertContains(change.getCreatedData(), path(FOO, BAZ));
+ assertContains(change.getUpdatedData(), path(FOO));
+ assertNotContains(change.getUpdatedData(), TOP_LEVEL);
+ assertContains(change.getRemovedPaths(), path(FOO, BAR));
+
+ }
+
+ @Override
+ protected void putTopLevelWithTwoNested(final DatastoreTestTask task) throws InterruptedException,
+ ExecutionException {
+
+ AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ assertNotNull(change);
+ assertFalse(change.getCreatedData().isEmpty());
+
+ assertContains(change.getCreatedData(), path(FOO), path(FOO, BAR), path(FOO, BAZ));
+ assertNotContains(change.getCreatedData(), TOP_LEVEL);
+ assertEmpty(change.getUpdatedData());
+ assertEmpty(change.getRemovedPaths());
+
+ }
+
+ @Override
+ protected void twoNestedExistsOneIsDeleted(final DatastoreTestTask task) throws InterruptedException,
+ ExecutionException {
+
+ Future<?> future = task.getChangeEvent();
+ /*
+ * One listener should be notified only and only if actual node changed its state,
+ * since deletion of nested child (in this case /nested-list/nested-list[foo],
+ * did not result in change of node we are listening
+ * for, we should not be getting data change event
+ * and this means settable future containing receivedDataChangeEvent is not done.
+ *
+ */
+ assertFalse(future.isDone());
+ }
+
+ @Override
+ public void nestedListExistsRootDeleted(final DatastoreTestTask task) throws InterruptedException,
+ ExecutionException {
+
+ AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+
+ assertEmpty(change.getCreatedData());
+ assertEmpty(change.getUpdatedData());
+
+ assertNotContains(change.getUpdatedData(), TOP_LEVEL);
+ assertContains(change.getRemovedPaths(), path(FOO),path(FOO, BAZ),path(FOO,BAR));
+ }
+
+ @Override
+ protected void existingOneNestedWriteAdditionalNested(final DatastoreTestTask task) {
+ Future<?> future = task.getChangeEvent();
+ /*
+ * One listener should be notified only and only if actual node changed its state,
+ * since deletion of nested child (in this case /nested-list/nested-list[foo],
+ * did not result in change of node we are listening
+ * for, we should not be getting data change event
+ * and this means settable future containing receivedDataChangeEvent is not done.
+ *
+ */
+ assertFalse(future.isDone());
+ }
+
+ @Override
+ protected void existingTopWriteTwoNested(final DatastoreTestTask task) throws InterruptedException, ExecutionException {
+ Future<?> future = task.getChangeEvent();
+ /*
+ * One listener should be notified only and only if actual node changed its state,
+ * since deletion of nested child (in this case /nested-list/nested-list[foo],
+ * did not result in change of node we are listening
+ * for, we should not be getting data change event
+ * and this means settable future containing receivedDataChangeEvent is not done.
+ *
+ */
+ assertFalse(future.isDone());
+ }
+
+ @Override
+ protected void existingTopWriteSibling(final DatastoreTestTask task) throws InterruptedException, ExecutionException {
+ AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+
+ assertContains(change.getCreatedData(), path(FOO_SIBLING));
+ assertNotContains(change.getUpdatedData(),path(FOO), TOP_LEVEL);
+ assertEmpty(change.getRemovedPaths());
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 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.controller.md.sal.dom.store.impl;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.concurrent.ExecutionException;
+
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.two.level.list.TopLevelList;
+import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
+
+public class WildcardedScopeSubtreeTest extends DefaultDataChangeListenerTestSuite {
+
+ private static final InstanceIdentifier TOP_LEVEL_LIST_ALL = TOP_LEVEL.node(TopLevelList.QNAME).node(
+ TopLevelList.QNAME);
+
+ @Override
+ protected void customizeTask(final DatastoreTestTask task) {
+ task.changeListener(TOP_LEVEL_LIST_ALL, DataChangeScope.SUBTREE);
+ }
+
+ @Override
+ public void putTopLevelOneNested(final DatastoreTestTask task) throws InterruptedException, ExecutionException {
+
+ AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+
+ assertNotContains(change.getCreatedData(), TOP_LEVEL);
+ assertContains(change.getCreatedData(), path(FOO), path(FOO, BAR));
+ assertEmpty(change.getUpdatedData());
+ assertEmpty(change.getRemovedPaths());
+
+ }
+
+ @Override
+ public void replaceTopLevelNestedChanged(final DatastoreTestTask task) throws InterruptedException,
+ ExecutionException {
+
+ AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ assertNotNull(change);
+
+ assertContains(change.getCreatedData(), path(FOO, BAZ));
+ assertContains(change.getUpdatedData(), path(FOO));
+ assertNotContains(change.getUpdatedData(), TOP_LEVEL);
+ assertContains(change.getRemovedPaths(), path(FOO, BAR));
+
+ }
+
+ @Override
+ protected void putTopLevelWithTwoNested(final DatastoreTestTask task) throws InterruptedException,
+ ExecutionException {
+
+ AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ assertNotNull(change);
+ assertFalse(change.getCreatedData().isEmpty());
+
+ assertContains(change.getCreatedData(), path(FOO), path(FOO, BAR), path(FOO, BAZ));
+ assertNotContains(change.getCreatedData(), TOP_LEVEL);
+ assertEmpty(change.getUpdatedData());
+ assertEmpty(change.getRemovedPaths());
+
+ }
+
+ @Override
+ protected void twoNestedExistsOneIsDeleted(final DatastoreTestTask task) throws InterruptedException,
+ ExecutionException {
+
+ AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ assertNotNull(change);
+ assertTrue(change.getCreatedData().isEmpty());
+ assertContains(change.getUpdatedData(), path(FOO));
+ assertNotContains(change.getUpdatedData(), TOP_LEVEL);
+ assertContains(change.getRemovedPaths(),path(FOO, BAZ));
+ }
+
+ @Override
+ public void nestedListExistsRootDeleted(final DatastoreTestTask task) throws InterruptedException,
+ ExecutionException {
+
+ AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+
+ assertEmpty(change.getCreatedData());
+ assertEmpty(change.getUpdatedData());
+
+ assertNotContains(change.getUpdatedData(), TOP_LEVEL);
+ assertContains(change.getRemovedPaths(), path(FOO),path(FOO, BAZ),path(FOO,BAR));
+ }
+
+ @Override
+ protected void existingOneNestedWriteAdditionalNested(final DatastoreTestTask task) throws InterruptedException, ExecutionException {
+ AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+
+ assertContains(change.getCreatedData(), path(FOO,BAZ));
+ assertNotContains(change.getCreatedData(), path(FOO,BAR));
+ assertContains(change.getUpdatedData(), path(FOO));
+ assertNotContains(change.getUpdatedData(), TOP_LEVEL);
+ assertEmpty(change.getRemovedPaths());
+ }
+
+ @Override
+ protected void existingTopWriteTwoNested(final DatastoreTestTask task) throws InterruptedException, ExecutionException {
+ AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+
+ assertContains(change.getCreatedData(), path(FOO,BAR),path(FOO,BAZ));
+ assertContains(change.getUpdatedData(), path(FOO));
+ assertNotContains(change.getUpdatedData(), TOP_LEVEL, path(FOO,BAR));
+ assertEmpty(change.getRemovedPaths());
+ }
+
+ @Override
+ protected void existingTopWriteSibling(final DatastoreTestTask task) throws InterruptedException, ExecutionException {
+ AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+
+ assertContains(change.getCreatedData(), path(FOO_SIBLING));
+ assertNotContains(change.getUpdatedData(), path(FOO), TOP_LEVEL);
+ assertEmpty(change.getRemovedPaths());
+ }
+}
private static CompositeNode toNotification(final NetconfMessage message, final SchemaContext ctx) {
final Set<NotificationDefinition> notifications = ctx.getNotifications();
final Document document = message.getDocument();
- return XmlDocumentUtils.notificationToDomNodes(document, Optional.fromNullable(notifications));
+ return XmlDocumentUtils.notificationToDomNodes(document, Optional.fromNullable(notifications), ctx);
}
@Override
--- /dev/null
+package org.opendaylight.controller.sal.connect.netconf;
+
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertNotNull;
+import static junit.framework.Assert.assertTrue;
+
+import java.io.InputStream;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+import javax.xml.parsers.DocumentBuilderFactory;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.controller.netconf.api.NetconfMessage;
+import org.opendaylight.controller.netconf.util.xml.XmlUtil;
+import org.opendaylight.controller.sal.connect.netconf.schema.mapping.NetconfMessageTransformer;
+import org.opendaylight.yangtools.yang.data.api.CompositeNode;
+import org.opendaylight.yangtools.yang.model.api.Module;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
+import org.opendaylight.yangtools.yang.model.parser.api.YangContextParser;
+import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
+import org.w3c.dom.Document;
+
+/**
+ * @author Lukas Sedlak <lsedlak@cisco.com>
+ */
+public class NetconfToNotificationTest {
+
+ NetconfMessageTransformer messageTransformer;
+
+ NetconfMessage userNotification;
+
+ @Before
+ public void setup() throws Exception {
+ final List<InputStream> modelsToParse = Collections.singletonList(getClass().getResourceAsStream("/schemas/user-notification.yang"));
+ final YangContextParser parser = new YangParserImpl();
+ final Set<Module> modules = parser.parseYangModelsFromStreams(modelsToParse);
+ assertTrue(!modules.isEmpty());
+ final SchemaContext schemaContext = parser.resolveSchemaContext(modules);
+ assertNotNull(schemaContext);
+
+ messageTransformer = new NetconfMessageTransformer();
+ messageTransformer.onGlobalContextUpdated(schemaContext);
+
+ final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+ factory.setNamespaceAware(true);
+ InputStream notifyPayloadStream = getClass().getResourceAsStream("/notification-payload.xml");
+ assertNotNull(notifyPayloadStream);
+
+ final Document doc = XmlUtil.readXmlToDocument(notifyPayloadStream);
+ assertNotNull(doc);
+ userNotification = new NetconfMessage(doc);
+ }
+
+ @Test
+ public void test() throws Exception {
+ final CompositeNode root = messageTransformer.toNotification(userNotification);
+
+ assertNotNull(root);
+ assertEquals(6, root.size());
+ assertEquals("user-visited-page", root.getKey().getLocalName());
+ }
+}
--- /dev/null
+<notification xmlns="urn:ietf:params:xml:ns:netconf:notification:1.0">
+<eventTime>2014-07-08T11:20:48UTC</eventTime>
+<user-visited-page xmlns="org:opendaylight:notification:test:ns:yang:user-notification">
+ <ui:incoming-user xmlns:ui="org:opendaylight:notification:test:ns:yang:user-notification">ui:public-user</ui:incoming-user>
+ <ip-address>172.23.29.104</ip-address>
+ <mac>00:11:00:ff:dd:02</mac>
+ <browser-id>Chrome 35.0.1916.153 m</browser-id>
+ <region>
+ <name>Slovakia</name>
+ <time-zone>UTC/GMT+2</time-zone>
+ </region>
+ <visiting-date>2014-07-08 11:20:48</visiting-date>
+</user-visited-page>
+</notification>
\ No newline at end of file
--- /dev/null
+module user-notification {
+ yang-version 1;
+ namespace "org:opendaylight:notification:test:ns:yang:user-notification";
+ prefix "user";
+
+ organization "Cisco Systems";
+ contact "Lukas Sedlak";
+ description "Test model for testing notifications";
+
+ revision "2014-07-08" {
+ description "Initial revision";
+ }
+
+ identity user-identity {
+ description "Identity of user incoming to Web Page";
+ }
+
+ identity public-user {
+ base user-identity;
+ description "Identity of random public non-registered user";
+ }
+
+ notification user-visited-page {
+ leaf incoming-user {
+ type identityref {
+ base "user-identity";
+ }
+ }
+
+ leaf ip-address {
+ type string;
+ }
+
+ leaf mac {
+ type string;
+ }
+
+ leaf browser-id {
+ type string;
+ }
+
+ container region {
+ leaf name {
+ type string;
+ }
+
+ leaf time-zone {
+ type string;
+ }
+ }
+
+ leaf visiting-date {
+ type string;
+ }
+ }
+}
\ No newline at end of file
protoc --proto_path=src/main/resources --java_out=src/main/java src/main/resources/*.proto
-5. Run mvn clean install and resolve any trailing spaces issues & build the .jar
+5. Run mvn clean install & build the .jar
+
+6. !!!WARNING!!! - never edit the generated sources files of protocol buffer
+
+7. !!!NOTE!!! if you are planning to add new .proto file option java_package should begin with
+ org.opendaylight.controller.protobuff.messages to properly exclude from sonar.
# or run command
# protoc --proto_path=src/main/resources --java_out=src/main/java src/main/resources/*.proto
#
-#5. Run mvn clean install and resolve any trailing spaces issues & build the .jar
+#5. Run mvn clean install & build the .jar
+#
+#6 !!!WARNING!!!! never edit the source files generated
+#
+#7. !!!NOTE!!! if you are planning to add new .proto file option java_package should begin with
+# org.opendaylight.controller.protobuff.messages to properly exclude from sonar.
########################################################################################################
protoc --proto_path=src/main/resources --java_out=src/main/java src/main/resources/*.proto
echo "Done generating Java source files."
+#to remove trailing spaces in the code files
find src/main/java -type f -name '*.java' -exec sed --in-place 's/[[:space:]]\+$//' {} \+
+++ /dev/null
-// Generated by the protocol buffer compiler. DO NOT EDIT!
-// source: ListenerRegistration.proto
-
-package org.opendaylight.controller.cluster.datastore.registration;
-
-public final class ListenerRegistrationMessages {
- private ListenerRegistrationMessages() {}
-
- public static void registerAllExtensions(
- com.google.protobuf.ExtensionRegistry registry) {}
-
- public interface CloseOrBuilder extends com.google.protobuf.MessageOrBuilder {
- }
- /**
- * Protobuf type {@code org.opendaylight.controller.mdsal.Close}
- */
- public static final class Close extends com.google.protobuf.GeneratedMessage
- implements CloseOrBuilder {
- // Use Close.newBuilder() to construct.
- private Close(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
- super(builder);
- this.unknownFields = builder.getUnknownFields();
- }
-
- private Close(boolean noInit) {
- this.unknownFields =
- com.google.protobuf.UnknownFieldSet.getDefaultInstance();
- }
-
- private static final Close defaultInstance;
-
- public static Close getDefaultInstance() {
- return defaultInstance;
- }
-
- public Close getDefaultInstanceForType() {
- return defaultInstance;
- }
-
- private final com.google.protobuf.UnknownFieldSet unknownFields;
-
- @java.lang.Override
- public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
- return this.unknownFields;
- }
-
- private Close(com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- initFields();
- com.google.protobuf.UnknownFieldSet.Builder unknownFields =
- com.google.protobuf.UnknownFieldSet.newBuilder();
- try {
- boolean done = false;
- while (!done) {
- int tag = input.readTag();
- switch (tag) {
- case 0:
- done = true;
- break;
- default: {
- if (!parseUnknownField(input, unknownFields, extensionRegistry,
- tag)) {
- done = true;
- }
- break;
- }
- }
- }
- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
- throw e.setUnfinishedMessage(this);
- } catch (java.io.IOException e) {
- throw new com.google.protobuf.InvalidProtocolBufferException(
- e.getMessage()).setUnfinishedMessage(this);
- } finally {
- this.unknownFields = unknownFields.build();
- makeExtensionsImmutable();
- }
- }
-
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_Close_descriptor;
- }
-
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_Close_fieldAccessorTable
- .ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close.class,
- org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close.Builder.class);
- }
-
- public static com.google.protobuf.Parser<Close> PARSER =
- new com.google.protobuf.AbstractParser<Close>() {
- public Close parsePartialFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return new Close(input, extensionRegistry);
- }
- };
-
- @java.lang.Override
- public com.google.protobuf.Parser<Close> getParserForType() {
- return PARSER;
- }
-
- private void initFields() {}
-
- private byte memoizedIsInitialized = -1;
-
- public final boolean isInitialized() {
- byte isInitialized = memoizedIsInitialized;
- if (isInitialized != -1)
- return isInitialized == 1;
-
- memoizedIsInitialized = 1;
- return true;
- }
-
- public void writeTo(com.google.protobuf.CodedOutputStream output)
- throws java.io.IOException {
- getSerializedSize();
- getUnknownFields().writeTo(output);
- }
-
- private int memoizedSerializedSize = -1;
-
- public int getSerializedSize() {
- int size = memoizedSerializedSize;
- if (size != -1)
- return size;
-
- size = 0;
- size += getUnknownFields().getSerializedSize();
- memoizedSerializedSize = size;
- return size;
- }
-
- private static final long serialVersionUID = 0L;
-
- @java.lang.Override
- protected java.lang.Object writeReplace()
- throws java.io.ObjectStreamException {
- return super.writeReplace();
- }
-
- public static org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close parseFrom(
- com.google.protobuf.ByteString data)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return PARSER.parseFrom(data);
- }
-
- public static org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close parseFrom(
- com.google.protobuf.ByteString data,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return PARSER.parseFrom(data, extensionRegistry);
- }
-
- public static org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close parseFrom(
- byte[] data) throws com.google.protobuf.InvalidProtocolBufferException {
- return PARSER.parseFrom(data);
- }
-
- public static org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close parseFrom(
- byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return PARSER.parseFrom(data, extensionRegistry);
- }
-
- public static org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close parseFrom(
- java.io.InputStream input) throws java.io.IOException {
- return PARSER.parseFrom(input);
- }
-
- public static org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close parseFrom(
- java.io.InputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws java.io.IOException {
- return PARSER.parseFrom(input, extensionRegistry);
- }
-
- public static org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close parseDelimitedFrom(
- java.io.InputStream input) throws java.io.IOException {
- return PARSER.parseDelimitedFrom(input);
- }
-
- public static org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close parseDelimitedFrom(
- java.io.InputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws java.io.IOException {
- return PARSER.parseDelimitedFrom(input, extensionRegistry);
- }
-
- public static org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close parseFrom(
- com.google.protobuf.CodedInputStream input) throws java.io.IOException {
- return PARSER.parseFrom(input);
- }
-
- public static org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close parseFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws java.io.IOException {
- return PARSER.parseFrom(input, extensionRegistry);
- }
-
- public static Builder newBuilder() {
- return Builder.create();
- }
-
- public Builder newBuilderForType() {
- return newBuilder();
- }
-
- public static Builder newBuilder(
- org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close prototype) {
- return newBuilder().mergeFrom(prototype);
- }
-
- public Builder toBuilder() {
- return newBuilder(this);
- }
-
- @java.lang.Override
- protected Builder newBuilderForType(
- com.google.protobuf.GeneratedMessage.BuilderParent parent) {
- Builder builder = new Builder(parent);
- return builder;
- }
-
- /**
- * Protobuf type {@code org.opendaylight.controller.mdsal.Close}
- */
- public static final class Builder extends
- com.google.protobuf.GeneratedMessage.Builder<Builder>
- implements
- org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseOrBuilder {
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_Close_descriptor;
- }
-
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_Close_fieldAccessorTable
- .ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close.class,
- org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close.Builder.class);
- }
-
- // Construct using
- // org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close.newBuilder()
- private Builder() {
- maybeForceBuilderInitialization();
- }
-
- private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
- super(parent);
- maybeForceBuilderInitialization();
- }
-
- private void maybeForceBuilderInitialization() {
- if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
- }
- }
-
- private static Builder create() {
- return new Builder();
- }
-
- public Builder clear() {
- super.clear();
- return this;
- }
-
- public Builder clone() {
- return create().mergeFrom(buildPartial());
- }
-
- public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
- return org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_Close_descriptor;
- }
-
- public org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close getDefaultInstanceForType() {
- return org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close
- .getDefaultInstance();
- }
-
- public org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close build() {
- org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close result =
- buildPartial();
- if (!result.isInitialized()) {
- throw newUninitializedMessageException(result);
- }
- return result;
- }
-
- public org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close buildPartial() {
- org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close result =
- new org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close(
- this);
- onBuilt();
- return result;
- }
-
- public Builder mergeFrom(com.google.protobuf.Message other) {
- if (other instanceof org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close) {
- return mergeFrom((org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close) other);
- } else {
- super.mergeFrom(other);
- return this;
- }
- }
-
- public Builder mergeFrom(
- org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close other) {
- if (other == org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close
- .getDefaultInstance())
- return this;
- this.mergeUnknownFields(other.getUnknownFields());
- return this;
- }
-
- public final boolean isInitialized() {
- return true;
- }
-
- public Builder mergeFrom(com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws java.io.IOException {
- org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close parsedMessage =
- null;
- try {
- parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
- parsedMessage =
- (org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.Close) e
- .getUnfinishedMessage();
- throw e;
- } finally {
- if (parsedMessage != null) {
- mergeFrom(parsedMessage);
- }
- }
- return this;
- }
-
- // @@protoc_insertion_point(builder_scope:org.opendaylight.controller.mdsal.Close)
- }
-
- static {
- defaultInstance = new Close(true);
- defaultInstance.initFields();
- }
-
- // @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.Close)
- }
-
- public interface CloseReplyOrBuilder extends
- com.google.protobuf.MessageOrBuilder {
- }
- /**
- * Protobuf type {@code org.opendaylight.controller.mdsal.CloseReply}
- */
- public static final class CloseReply extends
- com.google.protobuf.GeneratedMessage implements CloseReplyOrBuilder {
- // Use CloseReply.newBuilder() to construct.
- private CloseReply(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
- super(builder);
- this.unknownFields = builder.getUnknownFields();
- }
-
- private CloseReply(boolean noInit) {
- this.unknownFields =
- com.google.protobuf.UnknownFieldSet.getDefaultInstance();
- }
-
- private static final CloseReply defaultInstance;
-
- public static CloseReply getDefaultInstance() {
- return defaultInstance;
- }
-
- public CloseReply getDefaultInstanceForType() {
- return defaultInstance;
- }
-
- private final com.google.protobuf.UnknownFieldSet unknownFields;
-
- @java.lang.Override
- public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
- return this.unknownFields;
- }
-
- private CloseReply(com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- initFields();
- com.google.protobuf.UnknownFieldSet.Builder unknownFields =
- com.google.protobuf.UnknownFieldSet.newBuilder();
- try {
- boolean done = false;
- while (!done) {
- int tag = input.readTag();
- switch (tag) {
- case 0:
- done = true;
- break;
- default: {
- if (!parseUnknownField(input, unknownFields, extensionRegistry,
- tag)) {
- done = true;
- }
- break;
- }
- }
- }
- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
- throw e.setUnfinishedMessage(this);
- } catch (java.io.IOException e) {
- throw new com.google.protobuf.InvalidProtocolBufferException(
- e.getMessage()).setUnfinishedMessage(this);
- } finally {
- this.unknownFields = unknownFields.build();
- makeExtensionsImmutable();
- }
- }
-
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_CloseReply_descriptor;
- }
-
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_CloseReply_fieldAccessorTable
- .ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply.class,
- org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply.Builder.class);
- }
-
- public static com.google.protobuf.Parser<CloseReply> PARSER =
- new com.google.protobuf.AbstractParser<CloseReply>() {
- public CloseReply parsePartialFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return new CloseReply(input, extensionRegistry);
- }
- };
-
- @java.lang.Override
- public com.google.protobuf.Parser<CloseReply> getParserForType() {
- return PARSER;
- }
-
- private void initFields() {}
-
- private byte memoizedIsInitialized = -1;
-
- public final boolean isInitialized() {
- byte isInitialized = memoizedIsInitialized;
- if (isInitialized != -1)
- return isInitialized == 1;
-
- memoizedIsInitialized = 1;
- return true;
- }
-
- public void writeTo(com.google.protobuf.CodedOutputStream output)
- throws java.io.IOException {
- getSerializedSize();
- getUnknownFields().writeTo(output);
- }
-
- private int memoizedSerializedSize = -1;
-
- public int getSerializedSize() {
- int size = memoizedSerializedSize;
- if (size != -1)
- return size;
-
- size = 0;
- size += getUnknownFields().getSerializedSize();
- memoizedSerializedSize = size;
- return size;
- }
-
- private static final long serialVersionUID = 0L;
-
- @java.lang.Override
- protected java.lang.Object writeReplace()
- throws java.io.ObjectStreamException {
- return super.writeReplace();
- }
-
- public static org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply parseFrom(
- com.google.protobuf.ByteString data)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return PARSER.parseFrom(data);
- }
-
- public static org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply parseFrom(
- com.google.protobuf.ByteString data,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return PARSER.parseFrom(data, extensionRegistry);
- }
-
- public static org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply parseFrom(
- byte[] data) throws com.google.protobuf.InvalidProtocolBufferException {
- return PARSER.parseFrom(data);
- }
-
- public static org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply parseFrom(
- byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return PARSER.parseFrom(data, extensionRegistry);
- }
-
- public static org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply parseFrom(
- java.io.InputStream input) throws java.io.IOException {
- return PARSER.parseFrom(input);
- }
-
- public static org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply parseFrom(
- java.io.InputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws java.io.IOException {
- return PARSER.parseFrom(input, extensionRegistry);
- }
-
- public static org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply parseDelimitedFrom(
- java.io.InputStream input) throws java.io.IOException {
- return PARSER.parseDelimitedFrom(input);
- }
-
- public static org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply parseDelimitedFrom(
- java.io.InputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws java.io.IOException {
- return PARSER.parseDelimitedFrom(input, extensionRegistry);
- }
-
- public static org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply parseFrom(
- com.google.protobuf.CodedInputStream input) throws java.io.IOException {
- return PARSER.parseFrom(input);
- }
-
- public static org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply parseFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws java.io.IOException {
- return PARSER.parseFrom(input, extensionRegistry);
- }
-
- public static Builder newBuilder() {
- return Builder.create();
- }
-
- public Builder newBuilderForType() {
- return newBuilder();
- }
-
- public static Builder newBuilder(
- org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply prototype) {
- return newBuilder().mergeFrom(prototype);
- }
-
- public Builder toBuilder() {
- return newBuilder(this);
- }
-
- @java.lang.Override
- protected Builder newBuilderForType(
- com.google.protobuf.GeneratedMessage.BuilderParent parent) {
- Builder builder = new Builder(parent);
- return builder;
- }
-
- /**
- * Protobuf type {@code org.opendaylight.controller.mdsal.CloseReply}
- */
- public static final class Builder extends
- com.google.protobuf.GeneratedMessage.Builder<Builder>
- implements
- org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReplyOrBuilder {
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_CloseReply_descriptor;
- }
-
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_CloseReply_fieldAccessorTable
- .ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply.class,
- org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply.Builder.class);
- }
-
- // Construct using
- // org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply.newBuilder()
- private Builder() {
- maybeForceBuilderInitialization();
- }
-
- private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
- super(parent);
- maybeForceBuilderInitialization();
- }
-
- private void maybeForceBuilderInitialization() {
- if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
- }
- }
-
- private static Builder create() {
- return new Builder();
- }
-
- public Builder clear() {
- super.clear();
- return this;
- }
-
- public Builder clone() {
- return create().mergeFrom(buildPartial());
- }
-
- public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
- return org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_CloseReply_descriptor;
- }
-
- public org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply getDefaultInstanceForType() {
- return org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply
- .getDefaultInstance();
- }
-
- public org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply build() {
- org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply result =
- buildPartial();
- if (!result.isInitialized()) {
- throw newUninitializedMessageException(result);
- }
- return result;
- }
-
- public org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply buildPartial() {
- org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply result =
- new org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply(
- this);
- onBuilt();
- return result;
- }
-
- public Builder mergeFrom(com.google.protobuf.Message other) {
- if (other instanceof org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply) {
- return mergeFrom((org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply) other);
- } else {
- super.mergeFrom(other);
- return this;
- }
- }
-
- public Builder mergeFrom(
- org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply other) {
- if (other == org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply
- .getDefaultInstance())
- return this;
- this.mergeUnknownFields(other.getUnknownFields());
- return this;
- }
-
- public final boolean isInitialized() {
- return true;
- }
-
- public Builder mergeFrom(com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws java.io.IOException {
- org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply parsedMessage =
- null;
- try {
- parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
- parsedMessage =
- (org.opendaylight.controller.cluster.datastore.registration.ListenerRegistrationMessages.CloseReply) e
- .getUnfinishedMessage();
- throw e;
- } finally {
- if (parsedMessage != null) {
- mergeFrom(parsedMessage);
- }
- }
- return this;
- }
-
- // @@protoc_insertion_point(builder_scope:org.opendaylight.controller.mdsal.CloseReply)
- }
-
- static {
- defaultInstance = new CloseReply(true);
- defaultInstance.initFields();
- }
-
- // @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.CloseReply)
- }
-
- private static com.google.protobuf.Descriptors.Descriptor internal_static_org_opendaylight_controller_mdsal_Close_descriptor;
- private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_org_opendaylight_controller_mdsal_Close_fieldAccessorTable;
- private static com.google.protobuf.Descriptors.Descriptor internal_static_org_opendaylight_controller_mdsal_CloseReply_descriptor;
- private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_org_opendaylight_controller_mdsal_CloseReply_fieldAccessorTable;
-
- public static com.google.protobuf.Descriptors.FileDescriptor getDescriptor() {
- return descriptor;
- }
-
- private static com.google.protobuf.Descriptors.FileDescriptor descriptor;
- static {
- java.lang.String[] descriptorData =
- {"\n\032ListenerRegistration.proto\022!org.openda"
- + "ylight.controller.mdsal\"\007\n\005Close\"\014\n\nClos"
- + "eReplyBZ\n:org.opendaylight.controller.cl"
- + "uster.datastore.registrationB\034ListenerRe"
- + "gistrationMessages"};
- com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
- new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
- public com.google.protobuf.ExtensionRegistry assignDescriptors(
- com.google.protobuf.Descriptors.FileDescriptor root) {
- descriptor = root;
- internal_static_org_opendaylight_controller_mdsal_Close_descriptor =
- getDescriptor().getMessageTypes().get(0);
- internal_static_org_opendaylight_controller_mdsal_Close_fieldAccessorTable =
- new com.google.protobuf.GeneratedMessage.FieldAccessorTable(
- internal_static_org_opendaylight_controller_mdsal_Close_descriptor,
- new java.lang.String[] {});
- internal_static_org_opendaylight_controller_mdsal_CloseReply_descriptor =
- getDescriptor().getMessageTypes().get(1);
- internal_static_org_opendaylight_controller_mdsal_CloseReply_fieldAccessorTable =
- new com.google.protobuf.GeneratedMessage.FieldAccessorTable(
- internal_static_org_opendaylight_controller_mdsal_CloseReply_descriptor,
- new java.lang.String[] {});
- return null;
- }
- };
- com.google.protobuf.Descriptors.FileDescriptor
- .internalBuildGeneratedFileFrom(descriptorData,
- new com.google.protobuf.Descriptors.FileDescriptor[]{}, assigner);
- }
-
- // @@protoc_insertion_point(outer_class_scope)
-}
+++ /dev/null
-// Generated by the protocol buffer compiler. DO NOT EDIT!
-// source: ShardTransactionChain.proto
-
-package org.opendaylight.controller.cluster.datastore.transaction;
-
-public final class ShardTransactionChainMessages {
- private ShardTransactionChainMessages() {}
-
- public static void registerAllExtensions(
- com.google.protobuf.ExtensionRegistry registry) {}
-
- public interface CloseTransactionChainOrBuilder extends
- com.google.protobuf.MessageOrBuilder {
- }
- /**
- * Protobuf type {@code org.opendaylight.controller.mdsal.CloseTransactionChain}
- */
- public static final class CloseTransactionChain extends
- com.google.protobuf.GeneratedMessage implements
- CloseTransactionChainOrBuilder {
- // Use CloseTransactionChain.newBuilder() to construct.
- private CloseTransactionChain(
- com.google.protobuf.GeneratedMessage.Builder<?> builder) {
- super(builder);
- this.unknownFields = builder.getUnknownFields();
- }
-
- private CloseTransactionChain(boolean noInit) {
- this.unknownFields =
- com.google.protobuf.UnknownFieldSet.getDefaultInstance();
- }
-
- private static final CloseTransactionChain defaultInstance;
-
- public static CloseTransactionChain getDefaultInstance() {
- return defaultInstance;
- }
-
- public CloseTransactionChain getDefaultInstanceForType() {
- return defaultInstance;
- }
-
- private final com.google.protobuf.UnknownFieldSet unknownFields;
-
- @java.lang.Override
- public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
- return this.unknownFields;
- }
-
- private CloseTransactionChain(com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- initFields();
- com.google.protobuf.UnknownFieldSet.Builder unknownFields =
- com.google.protobuf.UnknownFieldSet.newBuilder();
- try {
- boolean done = false;
- while (!done) {
- int tag = input.readTag();
- switch (tag) {
- case 0:
- done = true;
- break;
- default: {
- if (!parseUnknownField(input, unknownFields, extensionRegistry,
- tag)) {
- done = true;
- }
- break;
- }
- }
- }
- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
- throw e.setUnfinishedMessage(this);
- } catch (java.io.IOException e) {
- throw new com.google.protobuf.InvalidProtocolBufferException(
- e.getMessage()).setUnfinishedMessage(this);
- } finally {
- this.unknownFields = unknownFields.build();
- makeExtensionsImmutable();
- }
- }
-
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionChain_descriptor;
- }
-
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionChain_fieldAccessorTable
- .ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain.Builder.class);
- }
-
- public static com.google.protobuf.Parser<CloseTransactionChain> PARSER =
- new com.google.protobuf.AbstractParser<CloseTransactionChain>() {
- public CloseTransactionChain parsePartialFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return new CloseTransactionChain(input, extensionRegistry);
- }
- };
-
- @java.lang.Override
- public com.google.protobuf.Parser<CloseTransactionChain> getParserForType() {
- return PARSER;
- }
-
- private void initFields() {}
-
- private byte memoizedIsInitialized = -1;
-
- public final boolean isInitialized() {
- byte isInitialized = memoizedIsInitialized;
- if (isInitialized != -1)
- return isInitialized == 1;
-
- memoizedIsInitialized = 1;
- return true;
- }
-
- public void writeTo(com.google.protobuf.CodedOutputStream output)
- throws java.io.IOException {
- getSerializedSize();
- getUnknownFields().writeTo(output);
- }
-
- private int memoizedSerializedSize = -1;
-
- public int getSerializedSize() {
- int size = memoizedSerializedSize;
- if (size != -1)
- return size;
-
- size = 0;
- size += getUnknownFields().getSerializedSize();
- memoizedSerializedSize = size;
- return size;
- }
-
- private static final long serialVersionUID = 0L;
-
- @java.lang.Override
- protected java.lang.Object writeReplace()
- throws java.io.ObjectStreamException {
- return super.writeReplace();
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain parseFrom(
- com.google.protobuf.ByteString data)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return PARSER.parseFrom(data);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain parseFrom(
- com.google.protobuf.ByteString data,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return PARSER.parseFrom(data, extensionRegistry);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain parseFrom(
- byte[] data) throws com.google.protobuf.InvalidProtocolBufferException {
- return PARSER.parseFrom(data);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain parseFrom(
- byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return PARSER.parseFrom(data, extensionRegistry);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain parseFrom(
- java.io.InputStream input) throws java.io.IOException {
- return PARSER.parseFrom(input);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain parseFrom(
- java.io.InputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws java.io.IOException {
- return PARSER.parseFrom(input, extensionRegistry);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain parseDelimitedFrom(
- java.io.InputStream input) throws java.io.IOException {
- return PARSER.parseDelimitedFrom(input);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain parseDelimitedFrom(
- java.io.InputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws java.io.IOException {
- return PARSER.parseDelimitedFrom(input, extensionRegistry);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain parseFrom(
- com.google.protobuf.CodedInputStream input) throws java.io.IOException {
- return PARSER.parseFrom(input);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain parseFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws java.io.IOException {
- return PARSER.parseFrom(input, extensionRegistry);
- }
-
- public static Builder newBuilder() {
- return Builder.create();
- }
-
- public Builder newBuilderForType() {
- return newBuilder();
- }
-
- public static Builder newBuilder(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain prototype) {
- return newBuilder().mergeFrom(prototype);
- }
-
- public Builder toBuilder() {
- return newBuilder(this);
- }
-
- @java.lang.Override
- protected Builder newBuilderForType(
- com.google.protobuf.GeneratedMessage.BuilderParent parent) {
- Builder builder = new Builder(parent);
- return builder;
- }
-
- /**
- * Protobuf type {@code org.opendaylight.controller.mdsal.CloseTransactionChain}
- */
- public static final class Builder extends
- com.google.protobuf.GeneratedMessage.Builder<Builder>
- implements
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainOrBuilder {
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionChain_descriptor;
- }
-
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionChain_fieldAccessorTable
- .ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain.Builder.class);
- }
-
- // Construct using
- // org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain.newBuilder()
- private Builder() {
- maybeForceBuilderInitialization();
- }
-
- private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
- super(parent);
- maybeForceBuilderInitialization();
- }
-
- private void maybeForceBuilderInitialization() {
- if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
- }
- }
-
- private static Builder create() {
- return new Builder();
- }
-
- public Builder clear() {
- super.clear();
- return this;
- }
-
- public Builder clone() {
- return create().mergeFrom(buildPartial());
- }
-
- public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionChain_descriptor;
- }
-
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain getDefaultInstanceForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain
- .getDefaultInstance();
- }
-
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain build() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain result =
- buildPartial();
- if (!result.isInitialized()) {
- throw newUninitializedMessageException(result);
- }
- return result;
- }
-
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain buildPartial() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain result =
- new org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain(
- this);
- onBuilt();
- return result;
- }
-
- public Builder mergeFrom(com.google.protobuf.Message other) {
- if (other instanceof org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain) {
- return mergeFrom((org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain) other);
- } else {
- super.mergeFrom(other);
- return this;
- }
- }
-
- public Builder mergeFrom(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain other) {
- if (other == org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain
- .getDefaultInstance())
- return this;
- this.mergeUnknownFields(other.getUnknownFields());
- return this;
- }
-
- public final boolean isInitialized() {
- return true;
- }
-
- public Builder mergeFrom(com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws java.io.IOException {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain parsedMessage =
- null;
- try {
- parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
- parsedMessage =
- (org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChain) e
- .getUnfinishedMessage();
- throw e;
- } finally {
- if (parsedMessage != null) {
- mergeFrom(parsedMessage);
- }
- }
- return this;
- }
-
- // @@protoc_insertion_point(builder_scope:org.opendaylight.controller.mdsal.CloseTransactionChain)
- }
-
- static {
- defaultInstance = new CloseTransactionChain(true);
- defaultInstance.initFields();
- }
-
- // @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.CloseTransactionChain)
- }
-
- public interface CloseTransactionChainReplyOrBuilder extends
- com.google.protobuf.MessageOrBuilder {
- }
- /**
- * Protobuf type {@code org.opendaylight.controller.mdsal.CloseTransactionChainReply}
- */
- public static final class CloseTransactionChainReply extends
- com.google.protobuf.GeneratedMessage implements
- CloseTransactionChainReplyOrBuilder {
- // Use CloseTransactionChainReply.newBuilder() to construct.
- private CloseTransactionChainReply(
- com.google.protobuf.GeneratedMessage.Builder<?> builder) {
- super(builder);
- this.unknownFields = builder.getUnknownFields();
- }
-
- private CloseTransactionChainReply(boolean noInit) {
- this.unknownFields =
- com.google.protobuf.UnknownFieldSet.getDefaultInstance();
- }
-
- private static final CloseTransactionChainReply defaultInstance;
-
- public static CloseTransactionChainReply getDefaultInstance() {
- return defaultInstance;
- }
-
- public CloseTransactionChainReply getDefaultInstanceForType() {
- return defaultInstance;
- }
-
- private final com.google.protobuf.UnknownFieldSet unknownFields;
-
- @java.lang.Override
- public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
- return this.unknownFields;
- }
-
- private CloseTransactionChainReply(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- initFields();
- com.google.protobuf.UnknownFieldSet.Builder unknownFields =
- com.google.protobuf.UnknownFieldSet.newBuilder();
- try {
- boolean done = false;
- while (!done) {
- int tag = input.readTag();
- switch (tag) {
- case 0:
- done = true;
- break;
- default: {
- if (!parseUnknownField(input, unknownFields, extensionRegistry,
- tag)) {
- done = true;
- }
- break;
- }
- }
- }
- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
- throw e.setUnfinishedMessage(this);
- } catch (java.io.IOException e) {
- throw new com.google.protobuf.InvalidProtocolBufferException(
- e.getMessage()).setUnfinishedMessage(this);
- } finally {
- this.unknownFields = unknownFields.build();
- makeExtensionsImmutable();
- }
- }
-
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionChainReply_descriptor;
- }
-
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionChainReply_fieldAccessorTable
- .ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply.Builder.class);
- }
-
- public static com.google.protobuf.Parser<CloseTransactionChainReply> PARSER =
- new com.google.protobuf.AbstractParser<CloseTransactionChainReply>() {
- public CloseTransactionChainReply parsePartialFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return new CloseTransactionChainReply(input, extensionRegistry);
- }
- };
-
- @java.lang.Override
- public com.google.protobuf.Parser<CloseTransactionChainReply> getParserForType() {
- return PARSER;
- }
-
- private void initFields() {}
-
- private byte memoizedIsInitialized = -1;
-
- public final boolean isInitialized() {
- byte isInitialized = memoizedIsInitialized;
- if (isInitialized != -1)
- return isInitialized == 1;
-
- memoizedIsInitialized = 1;
- return true;
- }
-
- public void writeTo(com.google.protobuf.CodedOutputStream output)
- throws java.io.IOException {
- getSerializedSize();
- getUnknownFields().writeTo(output);
- }
-
- private int memoizedSerializedSize = -1;
-
- public int getSerializedSize() {
- int size = memoizedSerializedSize;
- if (size != -1)
- return size;
-
- size = 0;
- size += getUnknownFields().getSerializedSize();
- memoizedSerializedSize = size;
- return size;
- }
-
- private static final long serialVersionUID = 0L;
-
- @java.lang.Override
- protected java.lang.Object writeReplace()
- throws java.io.ObjectStreamException {
- return super.writeReplace();
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply parseFrom(
- com.google.protobuf.ByteString data)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return PARSER.parseFrom(data);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply parseFrom(
- com.google.protobuf.ByteString data,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return PARSER.parseFrom(data, extensionRegistry);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply parseFrom(
- byte[] data) throws com.google.protobuf.InvalidProtocolBufferException {
- return PARSER.parseFrom(data);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply parseFrom(
- byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return PARSER.parseFrom(data, extensionRegistry);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply parseFrom(
- java.io.InputStream input) throws java.io.IOException {
- return PARSER.parseFrom(input);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply parseFrom(
- java.io.InputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws java.io.IOException {
- return PARSER.parseFrom(input, extensionRegistry);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply parseDelimitedFrom(
- java.io.InputStream input) throws java.io.IOException {
- return PARSER.parseDelimitedFrom(input);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply parseDelimitedFrom(
- java.io.InputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws java.io.IOException {
- return PARSER.parseDelimitedFrom(input, extensionRegistry);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply parseFrom(
- com.google.protobuf.CodedInputStream input) throws java.io.IOException {
- return PARSER.parseFrom(input);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply parseFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws java.io.IOException {
- return PARSER.parseFrom(input, extensionRegistry);
- }
-
- public static Builder newBuilder() {
- return Builder.create();
- }
-
- public Builder newBuilderForType() {
- return newBuilder();
- }
-
- public static Builder newBuilder(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply prototype) {
- return newBuilder().mergeFrom(prototype);
- }
-
- public Builder toBuilder() {
- return newBuilder(this);
- }
-
- @java.lang.Override
- protected Builder newBuilderForType(
- com.google.protobuf.GeneratedMessage.BuilderParent parent) {
- Builder builder = new Builder(parent);
- return builder;
- }
-
- /**
- * Protobuf type {@code org.opendaylight.controller.mdsal.CloseTransactionChainReply}
- */
- public static final class Builder extends
- com.google.protobuf.GeneratedMessage.Builder<Builder>
- implements
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReplyOrBuilder {
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionChainReply_descriptor;
- }
-
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionChainReply_fieldAccessorTable
- .ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply.Builder.class);
- }
-
- // Construct using
- // org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply.newBuilder()
- private Builder() {
- maybeForceBuilderInitialization();
- }
-
- private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
- super(parent);
- maybeForceBuilderInitialization();
- }
-
- private void maybeForceBuilderInitialization() {
- if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
- }
- }
-
- private static Builder create() {
- return new Builder();
- }
-
- public Builder clear() {
- super.clear();
- return this;
- }
-
- public Builder clone() {
- return create().mergeFrom(buildPartial());
- }
-
- public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionChainReply_descriptor;
- }
-
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply getDefaultInstanceForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply
- .getDefaultInstance();
- }
-
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply build() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply result =
- buildPartial();
- if (!result.isInitialized()) {
- throw newUninitializedMessageException(result);
- }
- return result;
- }
-
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply buildPartial() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply result =
- new org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply(
- this);
- onBuilt();
- return result;
- }
-
- public Builder mergeFrom(com.google.protobuf.Message other) {
- if (other instanceof org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply) {
- return mergeFrom((org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply) other);
- } else {
- super.mergeFrom(other);
- return this;
- }
- }
-
- public Builder mergeFrom(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply other) {
- if (other == org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply
- .getDefaultInstance())
- return this;
- this.mergeUnknownFields(other.getUnknownFields());
- return this;
- }
-
- public final boolean isInitialized() {
- return true;
- }
-
- public Builder mergeFrom(com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws java.io.IOException {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply parsedMessage =
- null;
- try {
- parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
- parsedMessage =
- (org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CloseTransactionChainReply) e
- .getUnfinishedMessage();
- throw e;
- } finally {
- if (parsedMessage != null) {
- mergeFrom(parsedMessage);
- }
- }
- return this;
- }
-
- // @@protoc_insertion_point(builder_scope:org.opendaylight.controller.mdsal.CloseTransactionChainReply)
- }
-
- static {
- defaultInstance = new CloseTransactionChainReply(true);
- defaultInstance.initFields();
- }
-
- // @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.CloseTransactionChainReply)
- }
-
- public interface CreateTransactionChainOrBuilder extends
- com.google.protobuf.MessageOrBuilder {
- }
- /**
- * Protobuf type {@code org.opendaylight.controller.mdsal.CreateTransactionChain}
- */
- public static final class CreateTransactionChain extends
- com.google.protobuf.GeneratedMessage implements
- CreateTransactionChainOrBuilder {
- // Use CreateTransactionChain.newBuilder() to construct.
- private CreateTransactionChain(
- com.google.protobuf.GeneratedMessage.Builder<?> builder) {
- super(builder);
- this.unknownFields = builder.getUnknownFields();
- }
-
- private CreateTransactionChain(boolean noInit) {
- this.unknownFields =
- com.google.protobuf.UnknownFieldSet.getDefaultInstance();
- }
-
- private static final CreateTransactionChain defaultInstance;
-
- public static CreateTransactionChain getDefaultInstance() {
- return defaultInstance;
- }
-
- public CreateTransactionChain getDefaultInstanceForType() {
- return defaultInstance;
- }
-
- private final com.google.protobuf.UnknownFieldSet unknownFields;
-
- @java.lang.Override
- public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
- return this.unknownFields;
- }
-
- private CreateTransactionChain(com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- initFields();
- com.google.protobuf.UnknownFieldSet.Builder unknownFields =
- com.google.protobuf.UnknownFieldSet.newBuilder();
- try {
- boolean done = false;
- while (!done) {
- int tag = input.readTag();
- switch (tag) {
- case 0:
- done = true;
- break;
- default: {
- if (!parseUnknownField(input, unknownFields, extensionRegistry,
- tag)) {
- done = true;
- }
- break;
- }
- }
- }
- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
- throw e.setUnfinishedMessage(this);
- } catch (java.io.IOException e) {
- throw new com.google.protobuf.InvalidProtocolBufferException(
- e.getMessage()).setUnfinishedMessage(this);
- } finally {
- this.unknownFields = unknownFields.build();
- makeExtensionsImmutable();
- }
- }
-
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionChain_descriptor;
- }
-
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionChain_fieldAccessorTable
- .ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain.Builder.class);
- }
-
- public static com.google.protobuf.Parser<CreateTransactionChain> PARSER =
- new com.google.protobuf.AbstractParser<CreateTransactionChain>() {
- public CreateTransactionChain parsePartialFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return new CreateTransactionChain(input, extensionRegistry);
- }
- };
-
- @java.lang.Override
- public com.google.protobuf.Parser<CreateTransactionChain> getParserForType() {
- return PARSER;
- }
-
- private void initFields() {}
-
- private byte memoizedIsInitialized = -1;
-
- public final boolean isInitialized() {
- byte isInitialized = memoizedIsInitialized;
- if (isInitialized != -1)
- return isInitialized == 1;
-
- memoizedIsInitialized = 1;
- return true;
- }
-
- public void writeTo(com.google.protobuf.CodedOutputStream output)
- throws java.io.IOException {
- getSerializedSize();
- getUnknownFields().writeTo(output);
- }
-
- private int memoizedSerializedSize = -1;
-
- public int getSerializedSize() {
- int size = memoizedSerializedSize;
- if (size != -1)
- return size;
-
- size = 0;
- size += getUnknownFields().getSerializedSize();
- memoizedSerializedSize = size;
- return size;
- }
-
- private static final long serialVersionUID = 0L;
-
- @java.lang.Override
- protected java.lang.Object writeReplace()
- throws java.io.ObjectStreamException {
- return super.writeReplace();
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain parseFrom(
- com.google.protobuf.ByteString data)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return PARSER.parseFrom(data);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain parseFrom(
- com.google.protobuf.ByteString data,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return PARSER.parseFrom(data, extensionRegistry);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain parseFrom(
- byte[] data) throws com.google.protobuf.InvalidProtocolBufferException {
- return PARSER.parseFrom(data);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain parseFrom(
- byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return PARSER.parseFrom(data, extensionRegistry);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain parseFrom(
- java.io.InputStream input) throws java.io.IOException {
- return PARSER.parseFrom(input);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain parseFrom(
- java.io.InputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws java.io.IOException {
- return PARSER.parseFrom(input, extensionRegistry);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain parseDelimitedFrom(
- java.io.InputStream input) throws java.io.IOException {
- return PARSER.parseDelimitedFrom(input);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain parseDelimitedFrom(
- java.io.InputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws java.io.IOException {
- return PARSER.parseDelimitedFrom(input, extensionRegistry);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain parseFrom(
- com.google.protobuf.CodedInputStream input) throws java.io.IOException {
- return PARSER.parseFrom(input);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain parseFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws java.io.IOException {
- return PARSER.parseFrom(input, extensionRegistry);
- }
-
- public static Builder newBuilder() {
- return Builder.create();
- }
-
- public Builder newBuilderForType() {
- return newBuilder();
- }
-
- public static Builder newBuilder(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain prototype) {
- return newBuilder().mergeFrom(prototype);
- }
-
- public Builder toBuilder() {
- return newBuilder(this);
- }
-
- @java.lang.Override
- protected Builder newBuilderForType(
- com.google.protobuf.GeneratedMessage.BuilderParent parent) {
- Builder builder = new Builder(parent);
- return builder;
- }
-
- /**
- * Protobuf type {@code org.opendaylight.controller.mdsal.CreateTransactionChain}
- */
- public static final class Builder extends
- com.google.protobuf.GeneratedMessage.Builder<Builder>
- implements
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainOrBuilder {
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionChain_descriptor;
- }
-
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionChain_fieldAccessorTable
- .ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain.Builder.class);
- }
-
- // Construct using
- // org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain.newBuilder()
- private Builder() {
- maybeForceBuilderInitialization();
- }
-
- private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
- super(parent);
- maybeForceBuilderInitialization();
- }
-
- private void maybeForceBuilderInitialization() {
- if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
- }
- }
-
- private static Builder create() {
- return new Builder();
- }
-
- public Builder clear() {
- super.clear();
- return this;
- }
-
- public Builder clone() {
- return create().mergeFrom(buildPartial());
- }
-
- public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionChain_descriptor;
- }
-
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain getDefaultInstanceForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain
- .getDefaultInstance();
- }
-
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain build() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain result =
- buildPartial();
- if (!result.isInitialized()) {
- throw newUninitializedMessageException(result);
- }
- return result;
- }
-
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain buildPartial() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain result =
- new org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain(
- this);
- onBuilt();
- return result;
- }
-
- public Builder mergeFrom(com.google.protobuf.Message other) {
- if (other instanceof org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain) {
- return mergeFrom((org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain) other);
- } else {
- super.mergeFrom(other);
- return this;
- }
- }
-
- public Builder mergeFrom(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain other) {
- if (other == org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain
- .getDefaultInstance())
- return this;
- this.mergeUnknownFields(other.getUnknownFields());
- return this;
- }
-
- public final boolean isInitialized() {
- return true;
- }
-
- public Builder mergeFrom(com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws java.io.IOException {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain parsedMessage =
- null;
- try {
- parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
- parsedMessage =
- (org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChain) e
- .getUnfinishedMessage();
- throw e;
- } finally {
- if (parsedMessage != null) {
- mergeFrom(parsedMessage);
- }
- }
- return this;
- }
-
- // @@protoc_insertion_point(builder_scope:org.opendaylight.controller.mdsal.CreateTransactionChain)
- }
-
- static {
- defaultInstance = new CreateTransactionChain(true);
- defaultInstance.initFields();
- }
-
- // @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.CreateTransactionChain)
- }
-
- public interface CreateTransactionChainReplyOrBuilder extends
- com.google.protobuf.MessageOrBuilder {
-
- // required string transactionChainPath = 1;
- /**
- * <code>required string transactionChainPath = 1;</code>
- */
- boolean hasTransactionChainPath();
-
- /**
- * <code>required string transactionChainPath = 1;</code>
- */
- java.lang.String getTransactionChainPath();
-
- /**
- * <code>required string transactionChainPath = 1;</code>
- */
- com.google.protobuf.ByteString getTransactionChainPathBytes();
- }
- /**
- * Protobuf type {@code org.opendaylight.controller.mdsal.CreateTransactionChainReply}
- */
- public static final class CreateTransactionChainReply extends
- com.google.protobuf.GeneratedMessage implements
- CreateTransactionChainReplyOrBuilder {
- // Use CreateTransactionChainReply.newBuilder() to construct.
- private CreateTransactionChainReply(
- com.google.protobuf.GeneratedMessage.Builder<?> builder) {
- super(builder);
- this.unknownFields = builder.getUnknownFields();
- }
-
- private CreateTransactionChainReply(boolean noInit) {
- this.unknownFields =
- com.google.protobuf.UnknownFieldSet.getDefaultInstance();
- }
-
- private static final CreateTransactionChainReply defaultInstance;
-
- public static CreateTransactionChainReply getDefaultInstance() {
- return defaultInstance;
- }
-
- public CreateTransactionChainReply getDefaultInstanceForType() {
- return defaultInstance;
- }
-
- private final com.google.protobuf.UnknownFieldSet unknownFields;
-
- @java.lang.Override
- public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
- return this.unknownFields;
- }
-
- private CreateTransactionChainReply(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- initFields();
- int mutable_bitField0_ = 0;
- com.google.protobuf.UnknownFieldSet.Builder unknownFields =
- com.google.protobuf.UnknownFieldSet.newBuilder();
- try {
- boolean done = false;
- while (!done) {
- int tag = input.readTag();
- switch (tag) {
- case 0:
- done = true;
- break;
- default: {
- if (!parseUnknownField(input, unknownFields, extensionRegistry,
- tag)) {
- done = true;
- }
- break;
- }
- case 10: {
- bitField0_ |= 0x00000001;
- transactionChainPath_ = input.readBytes();
- break;
- }
- }
- }
- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
- throw e.setUnfinishedMessage(this);
- } catch (java.io.IOException e) {
- throw new com.google.protobuf.InvalidProtocolBufferException(
- e.getMessage()).setUnfinishedMessage(this);
- } finally {
- this.unknownFields = unknownFields.build();
- makeExtensionsImmutable();
- }
- }
-
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionChainReply_descriptor;
- }
-
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionChainReply_fieldAccessorTable
- .ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply.Builder.class);
- }
-
- public static com.google.protobuf.Parser<CreateTransactionChainReply> PARSER =
- new com.google.protobuf.AbstractParser<CreateTransactionChainReply>() {
- public CreateTransactionChainReply parsePartialFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return new CreateTransactionChainReply(input, extensionRegistry);
- }
- };
-
- @java.lang.Override
- public com.google.protobuf.Parser<CreateTransactionChainReply> getParserForType() {
- return PARSER;
- }
-
- private int bitField0_;
- // required string transactionChainPath = 1;
- public static final int TRANSACTIONCHAINPATH_FIELD_NUMBER = 1;
- private java.lang.Object transactionChainPath_;
-
- /**
- * <code>required string transactionChainPath = 1;</code>
- */
- public boolean hasTransactionChainPath() {
- return ((bitField0_ & 0x00000001) == 0x00000001);
- }
-
- /**
- * <code>required string transactionChainPath = 1;</code>
- */
- public java.lang.String getTransactionChainPath() {
- java.lang.Object ref = transactionChainPath_;
- if (ref instanceof java.lang.String) {
- return (java.lang.String) ref;
- } else {
- com.google.protobuf.ByteString bs =
- (com.google.protobuf.ByteString) ref;
- java.lang.String s = bs.toStringUtf8();
- if (bs.isValidUtf8()) {
- transactionChainPath_ = s;
- }
- return s;
- }
- }
-
- /**
- * <code>required string transactionChainPath = 1;</code>
- */
- public com.google.protobuf.ByteString getTransactionChainPathBytes() {
- java.lang.Object ref = transactionChainPath_;
- if (ref instanceof java.lang.String) {
- com.google.protobuf.ByteString b =
- com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
- transactionChainPath_ = b;
- return b;
- } else {
- return (com.google.protobuf.ByteString) ref;
- }
- }
-
- private void initFields() {
- transactionChainPath_ = "";
- }
-
- private byte memoizedIsInitialized = -1;
-
- public final boolean isInitialized() {
- byte isInitialized = memoizedIsInitialized;
- if (isInitialized != -1)
- return isInitialized == 1;
-
- if (!hasTransactionChainPath()) {
- memoizedIsInitialized = 0;
- return false;
- }
- memoizedIsInitialized = 1;
- return true;
- }
-
- public void writeTo(com.google.protobuf.CodedOutputStream output)
- throws java.io.IOException {
- getSerializedSize();
- if (((bitField0_ & 0x00000001) == 0x00000001)) {
- output.writeBytes(1, getTransactionChainPathBytes());
- }
- getUnknownFields().writeTo(output);
- }
-
- private int memoizedSerializedSize = -1;
-
- public int getSerializedSize() {
- int size = memoizedSerializedSize;
- if (size != -1)
- return size;
-
- size = 0;
- if (((bitField0_ & 0x00000001) == 0x00000001)) {
- size +=
- com.google.protobuf.CodedOutputStream.computeBytesSize(1,
- getTransactionChainPathBytes());
- }
- size += getUnknownFields().getSerializedSize();
- memoizedSerializedSize = size;
- return size;
- }
-
- private static final long serialVersionUID = 0L;
-
- @java.lang.Override
- protected java.lang.Object writeReplace()
- throws java.io.ObjectStreamException {
- return super.writeReplace();
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply parseFrom(
- com.google.protobuf.ByteString data)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return PARSER.parseFrom(data);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply parseFrom(
- com.google.protobuf.ByteString data,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return PARSER.parseFrom(data, extensionRegistry);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply parseFrom(
- byte[] data) throws com.google.protobuf.InvalidProtocolBufferException {
- return PARSER.parseFrom(data);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply parseFrom(
- byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return PARSER.parseFrom(data, extensionRegistry);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply parseFrom(
- java.io.InputStream input) throws java.io.IOException {
- return PARSER.parseFrom(input);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply parseFrom(
- java.io.InputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws java.io.IOException {
- return PARSER.parseFrom(input, extensionRegistry);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply parseDelimitedFrom(
- java.io.InputStream input) throws java.io.IOException {
- return PARSER.parseDelimitedFrom(input);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply parseDelimitedFrom(
- java.io.InputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws java.io.IOException {
- return PARSER.parseDelimitedFrom(input, extensionRegistry);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply parseFrom(
- com.google.protobuf.CodedInputStream input) throws java.io.IOException {
- return PARSER.parseFrom(input);
- }
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply parseFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws java.io.IOException {
- return PARSER.parseFrom(input, extensionRegistry);
- }
-
- public static Builder newBuilder() {
- return Builder.create();
- }
-
- public Builder newBuilderForType() {
- return newBuilder();
- }
-
- public static Builder newBuilder(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply prototype) {
- return newBuilder().mergeFrom(prototype);
- }
-
- public Builder toBuilder() {
- return newBuilder(this);
- }
-
- @java.lang.Override
- protected Builder newBuilderForType(
- com.google.protobuf.GeneratedMessage.BuilderParent parent) {
- Builder builder = new Builder(parent);
- return builder;
- }
-
- /**
- * Protobuf type {@code org.opendaylight.controller.mdsal.CreateTransactionChainReply}
- */
- public static final class Builder extends
- com.google.protobuf.GeneratedMessage.Builder<Builder>
- implements
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReplyOrBuilder {
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionChainReply_descriptor;
- }
-
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionChainReply_fieldAccessorTable
- .ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply.Builder.class);
- }
-
- // Construct using
- // org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply.newBuilder()
- private Builder() {
- maybeForceBuilderInitialization();
- }
-
- private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
- super(parent);
- maybeForceBuilderInitialization();
- }
-
- private void maybeForceBuilderInitialization() {
- if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
- }
- }
-
- private static Builder create() {
- return new Builder();
- }
-
- public Builder clear() {
- super.clear();
- transactionChainPath_ = "";
- bitField0_ = (bitField0_ & ~0x00000001);
- return this;
- }
-
- public Builder clone() {
- return create().mergeFrom(buildPartial());
- }
-
- public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionChainReply_descriptor;
- }
-
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply getDefaultInstanceForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply
- .getDefaultInstance();
- }
-
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply build() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply result =
- buildPartial();
- if (!result.isInitialized()) {
- throw newUninitializedMessageException(result);
- }
- return result;
- }
-
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply buildPartial() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply result =
- new org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply(
- this);
- int from_bitField0_ = bitField0_;
- int to_bitField0_ = 0;
- if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
- to_bitField0_ |= 0x00000001;
- }
- result.transactionChainPath_ = transactionChainPath_;
- result.bitField0_ = to_bitField0_;
- onBuilt();
- return result;
- }
-
- public Builder mergeFrom(com.google.protobuf.Message other) {
- if (other instanceof org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply) {
- return mergeFrom((org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply) other);
- } else {
- super.mergeFrom(other);
- return this;
- }
- }
-
- public Builder mergeFrom(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply other) {
- if (other == org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply
- .getDefaultInstance())
- return this;
- if (other.hasTransactionChainPath()) {
- bitField0_ |= 0x00000001;
- transactionChainPath_ = other.transactionChainPath_;
- onChanged();
- }
- this.mergeUnknownFields(other.getUnknownFields());
- return this;
- }
-
- public final boolean isInitialized() {
- if (!hasTransactionChainPath()) {
-
- return false;
- }
- return true;
- }
-
- public Builder mergeFrom(com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws java.io.IOException {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply parsedMessage =
- null;
- try {
- parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
- } catch (com.google.protobuf.InvalidProtocolBufferException e) {
- parsedMessage =
- (org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionChainMessages.CreateTransactionChainReply) e
- .getUnfinishedMessage();
- throw e;
- } finally {
- if (parsedMessage != null) {
- mergeFrom(parsedMessage);
- }
- }
- return this;
- }
-
- private int bitField0_;
-
- // required string transactionChainPath = 1;
- private java.lang.Object transactionChainPath_ = "";
-
- /**
- * <code>required string transactionChainPath = 1;</code>
- */
- public boolean hasTransactionChainPath() {
- return ((bitField0_ & 0x00000001) == 0x00000001);
- }
-
- /**
- * <code>required string transactionChainPath = 1;</code>
- */
- public java.lang.String getTransactionChainPath() {
- java.lang.Object ref = transactionChainPath_;
- if (!(ref instanceof java.lang.String)) {
- java.lang.String s =
- ((com.google.protobuf.ByteString) ref).toStringUtf8();
- transactionChainPath_ = s;
- return s;
- } else {
- return (java.lang.String) ref;
- }
- }
-
- /**
- * <code>required string transactionChainPath = 1;</code>
- */
- public com.google.protobuf.ByteString getTransactionChainPathBytes() {
- java.lang.Object ref = transactionChainPath_;
- if (ref instanceof String) {
- com.google.protobuf.ByteString b =
- com.google.protobuf.ByteString
- .copyFromUtf8((java.lang.String) ref);
- transactionChainPath_ = b;
- return b;
- } else {
- return (com.google.protobuf.ByteString) ref;
- }
- }
-
- /**
- * <code>required string transactionChainPath = 1;</code>
- */
- public Builder setTransactionChainPath(java.lang.String value) {
- if (value == null) {
- throw new NullPointerException();
- }
- bitField0_ |= 0x00000001;
- transactionChainPath_ = value;
- onChanged();
- return this;
- }
-
- /**
- * <code>required string transactionChainPath = 1;</code>
- */
- public Builder clearTransactionChainPath() {
- bitField0_ = (bitField0_ & ~0x00000001);
- transactionChainPath_ = getDefaultInstance().getTransactionChainPath();
- onChanged();
- return this;
- }
-
- /**
- * <code>required string transactionChainPath = 1;</code>
- */
- public Builder setTransactionChainPathBytes(
- com.google.protobuf.ByteString value) {
- if (value == null) {
- throw new NullPointerException();
- }
- bitField0_ |= 0x00000001;
- transactionChainPath_ = value;
- onChanged();
- return this;
- }
-
- // @@protoc_insertion_point(builder_scope:org.opendaylight.controller.mdsal.CreateTransactionChainReply)
- }
-
- static {
- defaultInstance = new CreateTransactionChainReply(true);
- defaultInstance.initFields();
- }
-
- // @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.CreateTransactionChainReply)
- }
-
- private static com.google.protobuf.Descriptors.Descriptor internal_static_org_opendaylight_controller_mdsal_CloseTransactionChain_descriptor;
- private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_org_opendaylight_controller_mdsal_CloseTransactionChain_fieldAccessorTable;
- private static com.google.protobuf.Descriptors.Descriptor internal_static_org_opendaylight_controller_mdsal_CloseTransactionChainReply_descriptor;
- private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_org_opendaylight_controller_mdsal_CloseTransactionChainReply_fieldAccessorTable;
- private static com.google.protobuf.Descriptors.Descriptor internal_static_org_opendaylight_controller_mdsal_CreateTransactionChain_descriptor;
- private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_org_opendaylight_controller_mdsal_CreateTransactionChain_fieldAccessorTable;
- private static com.google.protobuf.Descriptors.Descriptor internal_static_org_opendaylight_controller_mdsal_CreateTransactionChainReply_descriptor;
- private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_org_opendaylight_controller_mdsal_CreateTransactionChainReply_fieldAccessorTable;
-
- public static com.google.protobuf.Descriptors.FileDescriptor getDescriptor() {
- return descriptor;
- }
-
- private static com.google.protobuf.Descriptors.FileDescriptor descriptor;
- static {
- java.lang.String[] descriptorData =
- {"\n\033ShardTransactionChain.proto\022!org.opend"
- + "aylight.controller.mdsal\"\027\n\025CloseTransac"
- + "tionChain\"\034\n\032CloseTransactionChainReply\""
- + "\030\n\026CreateTransactionChain\";\n\033CreateTrans"
- + "actionChainReply\022\034\n\024transactionChainPath"
- + "\030\001 \002(\tBZ\n9org.opendaylight.controller.cl"
- + "uster.datastore.transactionB\035ShardTransa"
- + "ctionChainMessages"};
- com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
- new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
- public com.google.protobuf.ExtensionRegistry assignDescriptors(
- com.google.protobuf.Descriptors.FileDescriptor root) {
- descriptor = root;
- internal_static_org_opendaylight_controller_mdsal_CloseTransactionChain_descriptor =
- getDescriptor().getMessageTypes().get(0);
- internal_static_org_opendaylight_controller_mdsal_CloseTransactionChain_fieldAccessorTable =
- new com.google.protobuf.GeneratedMessage.FieldAccessorTable(
- internal_static_org_opendaylight_controller_mdsal_CloseTransactionChain_descriptor,
- new java.lang.String[] {});
- internal_static_org_opendaylight_controller_mdsal_CloseTransactionChainReply_descriptor =
- getDescriptor().getMessageTypes().get(1);
- internal_static_org_opendaylight_controller_mdsal_CloseTransactionChainReply_fieldAccessorTable =
- new com.google.protobuf.GeneratedMessage.FieldAccessorTable(
- internal_static_org_opendaylight_controller_mdsal_CloseTransactionChainReply_descriptor,
- new java.lang.String[] {});
- internal_static_org_opendaylight_controller_mdsal_CreateTransactionChain_descriptor =
- getDescriptor().getMessageTypes().get(2);
- internal_static_org_opendaylight_controller_mdsal_CreateTransactionChain_fieldAccessorTable =
- new com.google.protobuf.GeneratedMessage.FieldAccessorTable(
- internal_static_org_opendaylight_controller_mdsal_CreateTransactionChain_descriptor,
- new java.lang.String[] {});
- internal_static_org_opendaylight_controller_mdsal_CreateTransactionChainReply_descriptor =
- getDescriptor().getMessageTypes().get(3);
- internal_static_org_opendaylight_controller_mdsal_CreateTransactionChainReply_fieldAccessorTable =
- new com.google.protobuf.GeneratedMessage.FieldAccessorTable(
- internal_static_org_opendaylight_controller_mdsal_CreateTransactionChainReply_descriptor,
- new java.lang.String[] {"TransactionChainPath",});
- return null;
- }
- };
- com.google.protobuf.Descriptors.FileDescriptor
- .internalBuildGeneratedFileFrom(descriptorData,
- new com.google.protobuf.Descriptors.FileDescriptor[]{}, assigner);
- }
-
- // @@protoc_insertion_point(outer_class_scope)
-}
import com.google.common.base.Preconditions;
import com.google.common.collect.Lists;
-import org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage;
+import org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-// Generated by the protocol buffer compiler. DO NOT EDIT!
+// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: SimpleNormalizedNode.proto
-package org.opendaylight.controller.cluster.datastore.common;
+package org.opendaylight.controller.protobuff.messages.common;
public final class SimpleNormalizedNodeMessage {
private SimpleNormalizedNodeMessage() {}
-
public static void registerAllExtensions(
- com.google.protobuf.ExtensionRegistry registry) {}
-
- public interface NormalizedNodeXmlOrBuilder extends
- com.google.protobuf.MessageOrBuilder {
+ com.google.protobuf.ExtensionRegistry registry) {
+ }
+ public interface NormalizedNodeXmlOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
// required string nodeIdentifier = 1;
/**
* <code>required string nodeIdentifier = 1;</code>
*/
boolean hasNodeIdentifier();
-
/**
* <code>required string nodeIdentifier = 1;</code>
*/
java.lang.String getNodeIdentifier();
-
/**
* <code>required string nodeIdentifier = 1;</code>
*/
- com.google.protobuf.ByteString getNodeIdentifierBytes();
+ com.google.protobuf.ByteString
+ getNodeIdentifierBytes();
// required string xmlString = 2;
/**
* <code>required string xmlString = 2;</code>
*/
boolean hasXmlString();
-
/**
* <code>required string xmlString = 2;</code>
*/
java.lang.String getXmlString();
-
/**
* <code>required string xmlString = 2;</code>
*/
- com.google.protobuf.ByteString getXmlStringBytes();
+ com.google.protobuf.ByteString
+ getXmlStringBytes();
}
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.NormalizedNodeXml}
*/
public static final class NormalizedNodeXml extends
- com.google.protobuf.GeneratedMessage implements
- NormalizedNodeXmlOrBuilder {
+ com.google.protobuf.GeneratedMessage
+ implements NormalizedNodeXmlOrBuilder {
// Use NormalizedNodeXml.newBuilder() to construct.
- private NormalizedNodeXml(
- com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ private NormalizedNodeXml(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
super(builder);
this.unknownFields = builder.getUnknownFields();
}
-
- private NormalizedNodeXml(boolean noInit) {
- this.unknownFields =
- com.google.protobuf.UnknownFieldSet.getDefaultInstance();
- }
+ private NormalizedNodeXml(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
private static final NormalizedNodeXml defaultInstance;
-
public static NormalizedNodeXml getDefaultInstance() {
return defaultInstance;
}
}
private final com.google.protobuf.UnknownFieldSet unknownFields;
-
@java.lang.Override
- public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
return this.unknownFields;
}
-
- private NormalizedNodeXml(com.google.protobuf.CodedInputStream input,
+ private NormalizedNodeXml(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
initFields();
done = true;
break;
default: {
- if (!parseUnknownField(input, unknownFields, extensionRegistry,
- tag)) {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
done = true;
}
break;
makeExtensionsImmutable();
}
}
-
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.internal_static_org_opendaylight_controller_mdsal_NormalizedNodeXml_descriptor;
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.internal_static_org_opendaylight_controller_mdsal_NormalizedNodeXml_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.internal_static_org_opendaylight_controller_mdsal_NormalizedNodeXml_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.internal_static_org_opendaylight_controller_mdsal_NormalizedNodeXml_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.class,
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder.class);
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.class, org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder.class);
}
public static com.google.protobuf.Parser<NormalizedNodeXml> PARSER =
new com.google.protobuf.AbstractParser<NormalizedNodeXml>() {
- public NormalizedNodeXml parsePartialFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return new NormalizedNodeXml(input, extensionRegistry);
- }
- };
+ public NormalizedNodeXml parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new NormalizedNodeXml(input, extensionRegistry);
+ }
+ };
@java.lang.Override
public com.google.protobuf.Parser<NormalizedNodeXml> getParserForType() {
// required string nodeIdentifier = 1;
public static final int NODEIDENTIFIER_FIELD_NUMBER = 1;
private java.lang.Object nodeIdentifier_;
-
/**
* <code>required string nodeIdentifier = 1;</code>
*/
public boolean hasNodeIdentifier() {
return ((bitField0_ & 0x00000001) == 0x00000001);
}
-
/**
* <code>required string nodeIdentifier = 1;</code>
*/
return s;
}
}
-
/**
* <code>required string nodeIdentifier = 1;</code>
*/
- public com.google.protobuf.ByteString getNodeIdentifierBytes() {
+ public com.google.protobuf.ByteString
+ getNodeIdentifierBytes() {
java.lang.Object ref = nodeIdentifier_;
if (ref instanceof java.lang.String) {
com.google.protobuf.ByteString b =
- com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
+ com.google.protobuf.ByteString.copyFromUtf8(
+ (java.lang.String) ref);
nodeIdentifier_ = b;
return b;
} else {
// required string xmlString = 2;
public static final int XMLSTRING_FIELD_NUMBER = 2;
private java.lang.Object xmlString_;
-
/**
* <code>required string xmlString = 2;</code>
*/
public boolean hasXmlString() {
return ((bitField0_ & 0x00000002) == 0x00000002);
}
-
/**
* <code>required string xmlString = 2;</code>
*/
return s;
}
}
-
/**
* <code>required string xmlString = 2;</code>
*/
- public com.google.protobuf.ByteString getXmlStringBytes() {
+ public com.google.protobuf.ByteString
+ getXmlStringBytes() {
java.lang.Object ref = xmlString_;
if (ref instanceof java.lang.String) {
com.google.protobuf.ByteString b =
- com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
+ com.google.protobuf.ByteString.copyFromUtf8(
+ (java.lang.String) ref);
xmlString_ = b;
return b;
} else {
nodeIdentifier_ = "";
xmlString_ = "";
}
-
private byte memoizedIsInitialized = -1;
-
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
- if (isInitialized != -1)
- return isInitialized == 1;
+ if (isInitialized != -1) return isInitialized == 1;
if (!hasNodeIdentifier()) {
memoizedIsInitialized = 0;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
- throws java.io.IOException {
+ throws java.io.IOException {
getSerializedSize();
if (((bitField0_ & 0x00000001) == 0x00000001)) {
output.writeBytes(1, getNodeIdentifierBytes());
}
private int memoizedSerializedSize = -1;
-
public int getSerializedSize() {
int size = memoizedSerializedSize;
- if (size != -1)
- return size;
+ if (size != -1) return size;
size = 0;
if (((bitField0_ & 0x00000001) == 0x00000001)) {
- size +=
- com.google.protobuf.CodedOutputStream.computeBytesSize(1,
- getNodeIdentifierBytes());
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(1, getNodeIdentifierBytes());
}
if (((bitField0_ & 0x00000002) == 0x00000002)) {
- size +=
- com.google.protobuf.CodedOutputStream.computeBytesSize(2,
- getXmlStringBytes());
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(2, getXmlStringBytes());
}
size += getUnknownFields().getSerializedSize();
memoizedSerializedSize = size;
}
private static final long serialVersionUID = 0L;
-
@java.lang.Override
protected java.lang.Object writeReplace()
throws java.io.ObjectStreamException {
return super.writeReplace();
}
- public static org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml parseFrom(
- byte[] data) throws com.google.protobuf.InvalidProtocolBufferException {
+ public static org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml parseFrom(
- byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ public static org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml parseFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml parseDelimitedFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseDelimitedFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml parseDelimitedFrom(
+ public static org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseDelimitedFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml parseFrom(
- com.google.protobuf.CodedInputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
- public static Builder newBuilder() {
- return Builder.create();
- }
-
- public Builder newBuilderForType() {
- return newBuilder();
- }
-
- public static Builder newBuilder(
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml prototype) {
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml prototype) {
return newBuilder().mergeFrom(prototype);
}
-
- public Builder toBuilder() {
- return newBuilder(this);
- }
+ public Builder toBuilder() { return newBuilder(this); }
@java.lang.Override
protected Builder newBuilderForType(
Builder builder = new Builder(parent);
return builder;
}
-
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.NormalizedNodeXml}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessage.Builder<Builder>
- implements
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder {
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.internal_static_org_opendaylight_controller_mdsal_NormalizedNodeXml_descriptor;
+ implements org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.internal_static_org_opendaylight_controller_mdsal_NormalizedNodeXml_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.internal_static_org_opendaylight_controller_mdsal_NormalizedNodeXml_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.internal_static_org_opendaylight_controller_mdsal_NormalizedNodeXml_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.class,
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder.class);
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.class, org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder.class);
}
- // Construct using
- // org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.newBuilder()
+ // Construct using org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
- private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
-
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
}
}
-
private static Builder create() {
return new Builder();
}
return create().mergeFrom(buildPartial());
}
- public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
- return org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.internal_static_org_opendaylight_controller_mdsal_NormalizedNodeXml_descriptor;
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.internal_static_org_opendaylight_controller_mdsal_NormalizedNodeXml_descriptor;
}
- public org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml getDefaultInstanceForType() {
- return org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml
- .getDefaultInstance();
+ public org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml getDefaultInstanceForType() {
+ return org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.getDefaultInstance();
}
- public org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml build() {
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml result =
- buildPartial();
+ public org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml build() {
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
- public org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml buildPartial() {
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml result =
- new org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml(
- this);
+ public org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml buildPartial() {
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml result = new org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml(this);
int from_bitField0_ = bitField0_;
int to_bitField0_ = 0;
if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
}
public Builder mergeFrom(com.google.protobuf.Message other) {
- if (other instanceof org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml) {
- return mergeFrom((org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml) other);
+ if (other instanceof org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml) {
+ return mergeFrom((org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml)other);
} else {
super.mergeFrom(other);
return this;
}
}
- public Builder mergeFrom(
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml other) {
- if (other == org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml
- .getDefaultInstance())
- return this;
+ public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml other) {
+ if (other == org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.getDefaultInstance()) return this;
if (other.hasNodeIdentifier()) {
bitField0_ |= 0x00000001;
nodeIdentifier_ = other.nodeIdentifier_;
return true;
}
- public Builder mergeFrom(com.google.protobuf.CodedInputStream input,
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml parsedMessage =
- null;
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
- parsedMessage =
- (org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml) e
- .getUnfinishedMessage();
+ parsedMessage = (org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml) e.getUnfinishedMessage();
throw e;
} finally {
if (parsedMessage != null) {
}
return this;
}
-
private int bitField0_;
// required string nodeIdentifier = 1;
private java.lang.Object nodeIdentifier_ = "";
-
/**
* <code>required string nodeIdentifier = 1;</code>
*/
public boolean hasNodeIdentifier() {
return ((bitField0_ & 0x00000001) == 0x00000001);
}
-
/**
* <code>required string nodeIdentifier = 1;</code>
*/
public java.lang.String getNodeIdentifier() {
java.lang.Object ref = nodeIdentifier_;
if (!(ref instanceof java.lang.String)) {
- java.lang.String s =
- ((com.google.protobuf.ByteString) ref).toStringUtf8();
+ java.lang.String s = ((com.google.protobuf.ByteString) ref)
+ .toStringUtf8();
nodeIdentifier_ = s;
return s;
} else {
return (java.lang.String) ref;
}
}
-
/**
* <code>required string nodeIdentifier = 1;</code>
*/
- public com.google.protobuf.ByteString getNodeIdentifierBytes() {
+ public com.google.protobuf.ByteString
+ getNodeIdentifierBytes() {
java.lang.Object ref = nodeIdentifier_;
if (ref instanceof String) {
com.google.protobuf.ByteString b =
- com.google.protobuf.ByteString
- .copyFromUtf8((java.lang.String) ref);
+ com.google.protobuf.ByteString.copyFromUtf8(
+ (java.lang.String) ref);
nodeIdentifier_ = b;
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
-
/**
* <code>required string nodeIdentifier = 1;</code>
*/
- public Builder setNodeIdentifier(java.lang.String value) {
+ public Builder setNodeIdentifier(
+ java.lang.String value) {
if (value == null) {
- throw new NullPointerException();
- }
- bitField0_ |= 0x00000001;
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000001;
nodeIdentifier_ = value;
onChanged();
return this;
}
-
/**
* <code>required string nodeIdentifier = 1;</code>
*/
onChanged();
return this;
}
-
/**
* <code>required string nodeIdentifier = 1;</code>
*/
- public Builder setNodeIdentifierBytes(com.google.protobuf.ByteString value) {
+ public Builder setNodeIdentifierBytes(
+ com.google.protobuf.ByteString value) {
if (value == null) {
- throw new NullPointerException();
- }
- bitField0_ |= 0x00000001;
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000001;
nodeIdentifier_ = value;
onChanged();
return this;
// required string xmlString = 2;
private java.lang.Object xmlString_ = "";
-
/**
* <code>required string xmlString = 2;</code>
*/
public boolean hasXmlString() {
return ((bitField0_ & 0x00000002) == 0x00000002);
}
-
/**
* <code>required string xmlString = 2;</code>
*/
public java.lang.String getXmlString() {
java.lang.Object ref = xmlString_;
if (!(ref instanceof java.lang.String)) {
- java.lang.String s =
- ((com.google.protobuf.ByteString) ref).toStringUtf8();
+ java.lang.String s = ((com.google.protobuf.ByteString) ref)
+ .toStringUtf8();
xmlString_ = s;
return s;
} else {
return (java.lang.String) ref;
}
}
-
/**
* <code>required string xmlString = 2;</code>
*/
- public com.google.protobuf.ByteString getXmlStringBytes() {
+ public com.google.protobuf.ByteString
+ getXmlStringBytes() {
java.lang.Object ref = xmlString_;
if (ref instanceof String) {
com.google.protobuf.ByteString b =
- com.google.protobuf.ByteString
- .copyFromUtf8((java.lang.String) ref);
+ com.google.protobuf.ByteString.copyFromUtf8(
+ (java.lang.String) ref);
xmlString_ = b;
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
-
/**
* <code>required string xmlString = 2;</code>
*/
- public Builder setXmlString(java.lang.String value) {
+ public Builder setXmlString(
+ java.lang.String value) {
if (value == null) {
- throw new NullPointerException();
- }
- bitField0_ |= 0x00000002;
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000002;
xmlString_ = value;
onChanged();
return this;
}
-
/**
* <code>required string xmlString = 2;</code>
*/
onChanged();
return this;
}
-
/**
* <code>required string xmlString = 2;</code>
*/
- public Builder setXmlStringBytes(com.google.protobuf.ByteString value) {
+ public Builder setXmlStringBytes(
+ com.google.protobuf.ByteString value) {
if (value == null) {
- throw new NullPointerException();
- }
- bitField0_ |= 0x00000002;
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000002;
xmlString_ = value;
onChanged();
return this;
// @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.NormalizedNodeXml)
}
- private static com.google.protobuf.Descriptors.Descriptor internal_static_org_opendaylight_controller_mdsal_NormalizedNodeXml_descriptor;
- private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_org_opendaylight_controller_mdsal_NormalizedNodeXml_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_org_opendaylight_controller_mdsal_NormalizedNodeXml_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_org_opendaylight_controller_mdsal_NormalizedNodeXml_fieldAccessorTable;
- public static com.google.protobuf.Descriptors.FileDescriptor getDescriptor() {
+ public static com.google.protobuf.Descriptors.FileDescriptor
+ getDescriptor() {
return descriptor;
}
-
- private static com.google.protobuf.Descriptors.FileDescriptor descriptor;
+ private static com.google.protobuf.Descriptors.FileDescriptor
+ descriptor;
static {
- java.lang.String[] descriptorData =
- {"\n\032SimpleNormalizedNode.proto\022!org.openda"
- + "ylight.controller.mdsal\">\n\021NormalizedNod"
- + "eXml\022\026\n\016nodeIdentifier\030\001 \002(\t\022\021\n\txmlStrin"
- + "g\030\002 \002(\tBS\n4org.opendaylight.controller.c"
- + "luster.datastore.commonB\033SimpleNormalize" + "dNodeMessage"};
+ java.lang.String[] descriptorData = {
+ "\n\032SimpleNormalizedNode.proto\022!org.openda" +
+ "ylight.controller.mdsal\">\n\021NormalizedNod" +
+ "eXml\022\026\n\016nodeIdentifier\030\001 \002(\t\022\021\n\txmlStrin" +
+ "g\030\002 \002(\tBT\n5org.opendaylight.controller.p" +
+ "rotobuff.messages.commonB\033SimpleNormaliz" +
+ "edNodeMessage"
+ };
com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
- new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
- public com.google.protobuf.ExtensionRegistry assignDescriptors(
- com.google.protobuf.Descriptors.FileDescriptor root) {
- descriptor = root;
- internal_static_org_opendaylight_controller_mdsal_NormalizedNodeXml_descriptor =
- getDescriptor().getMessageTypes().get(0);
- internal_static_org_opendaylight_controller_mdsal_NormalizedNodeXml_fieldAccessorTable =
- new com.google.protobuf.GeneratedMessage.FieldAccessorTable(
- internal_static_org_opendaylight_controller_mdsal_NormalizedNodeXml_descriptor,
- new java.lang.String[] {"NodeIdentifier", "XmlString",});
- return null;
- }
- };
+ new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
+ public com.google.protobuf.ExtensionRegistry assignDescriptors(
+ com.google.protobuf.Descriptors.FileDescriptor root) {
+ descriptor = root;
+ internal_static_org_opendaylight_controller_mdsal_NormalizedNodeXml_descriptor =
+ getDescriptor().getMessageTypes().get(0);
+ internal_static_org_opendaylight_controller_mdsal_NormalizedNodeXml_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_org_opendaylight_controller_mdsal_NormalizedNodeXml_descriptor,
+ new java.lang.String[] { "NodeIdentifier", "XmlString", });
+ return null;
+ }
+ };
com.google.protobuf.Descriptors.FileDescriptor
- .internalBuildGeneratedFileFrom(descriptorData,
- new com.google.protobuf.Descriptors.FileDescriptor[]{}, assigner);
+ .internalBuildGeneratedFileFrom(descriptorData,
+ new com.google.protobuf.Descriptors.FileDescriptor[] {
+ }, assigner);
}
// @@protoc_insertion_point(outer_class_scope)
-// Generated by the protocol buffer compiler. DO NOT EDIT!
+// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: DataChangeListener.proto
-package org.opendaylight.controller.cluster.datastore.datachange.notification;
+package org.opendaylight.controller.protobuff.messages.datachange.notification;
public final class DataChangeListenerMessages {
private DataChangeListenerMessages() {}
-
public static void registerAllExtensions(
- com.google.protobuf.ExtensionRegistry registry) {}
-
- public interface DataChangedOrBuilder extends
- com.google.protobuf.MessageOrBuilder {
+ com.google.protobuf.ExtensionRegistry registry) {
+ }
+ public interface DataChangedOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
// repeated string instanceIdentifierPathArguments = 1;
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
- java.util.List<java.lang.String> getInstanceIdentifierPathArgumentsList();
-
+ java.util.List<java.lang.String>
+ getInstanceIdentifierPathArgumentsList();
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
int getInstanceIdentifierPathArgumentsCount();
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
java.lang.String getInstanceIdentifierPathArguments(int index);
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
- com.google.protobuf.ByteString getInstanceIdentifierPathArgumentsBytes(
- int index);
+ com.google.protobuf.ByteString
+ getInstanceIdentifierPathArgumentsBytes(int index);
// required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
*/
boolean hasNormalizedNodeXml();
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
*/
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml getNormalizedNodeXml();
-
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml getNormalizedNodeXml();
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
*/
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder getNormalizedNodeXmlOrBuilder();
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder getNormalizedNodeXmlOrBuilder();
}
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.DataChanged}
*/
public static final class DataChanged extends
- com.google.protobuf.GeneratedMessage implements DataChangedOrBuilder {
+ com.google.protobuf.GeneratedMessage
+ implements DataChangedOrBuilder {
// Use DataChanged.newBuilder() to construct.
private DataChanged(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
super(builder);
this.unknownFields = builder.getUnknownFields();
}
-
- private DataChanged(boolean noInit) {
- this.unknownFields =
- com.google.protobuf.UnknownFieldSet.getDefaultInstance();
- }
+ private DataChanged(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
private static final DataChanged defaultInstance;
-
public static DataChanged getDefaultInstance() {
return defaultInstance;
}
}
private final com.google.protobuf.UnknownFieldSet unknownFields;
-
@java.lang.Override
- public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
return this.unknownFields;
}
-
- private DataChanged(com.google.protobuf.CodedInputStream input,
+ private DataChanged(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
initFields();
done = true;
break;
default: {
- if (!parseUnknownField(input, unknownFields, extensionRegistry,
- tag)) {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
done = true;
}
break;
}
case 10: {
if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
- instanceIdentifierPathArguments_ =
- new com.google.protobuf.LazyStringArrayList();
+ instanceIdentifierPathArguments_ = new com.google.protobuf.LazyStringArrayList();
mutable_bitField0_ |= 0x00000001;
}
instanceIdentifierPathArguments_.add(input.readBytes());
break;
}
case 18: {
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder subBuilder =
- null;
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder subBuilder = null;
if (((bitField0_ & 0x00000001) == 0x00000001)) {
subBuilder = normalizedNodeXml_.toBuilder();
}
- normalizedNodeXml_ =
- input
- .readMessage(
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.PARSER,
- extensionRegistry);
+ normalizedNodeXml_ = input.readMessage(org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.PARSER, extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom(normalizedNodeXml_);
normalizedNodeXml_ = subBuilder.buildPartial();
e.getMessage()).setUnfinishedMessage(this);
} finally {
if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
- instanceIdentifierPathArguments_ =
- new com.google.protobuf.UnmodifiableLazyStringList(
- instanceIdentifierPathArguments_);
+ instanceIdentifierPathArguments_ = new com.google.protobuf.UnmodifiableLazyStringList(instanceIdentifierPathArguments_);
}
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
-
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChanged_descriptor;
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChanged_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChanged_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChanged_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged.class,
- org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged.Builder.class);
+ org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged.class, org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged.Builder.class);
}
public static com.google.protobuf.Parser<DataChanged> PARSER =
new com.google.protobuf.AbstractParser<DataChanged>() {
- public DataChanged parsePartialFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return new DataChanged(input, extensionRegistry);
- }
- };
+ public DataChanged parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new DataChanged(input, extensionRegistry);
+ }
+ };
@java.lang.Override
public com.google.protobuf.Parser<DataChanged> getParserForType() {
// repeated string instanceIdentifierPathArguments = 1;
public static final int INSTANCEIDENTIFIERPATHARGUMENTS_FIELD_NUMBER = 1;
private com.google.protobuf.LazyStringList instanceIdentifierPathArguments_;
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
- public java.util.List<java.lang.String> getInstanceIdentifierPathArgumentsList() {
+ public java.util.List<java.lang.String>
+ getInstanceIdentifierPathArgumentsList() {
return instanceIdentifierPathArguments_;
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
public int getInstanceIdentifierPathArgumentsCount() {
return instanceIdentifierPathArguments_.size();
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
public java.lang.String getInstanceIdentifierPathArguments(int index) {
return instanceIdentifierPathArguments_.get(index);
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
- public com.google.protobuf.ByteString getInstanceIdentifierPathArgumentsBytes(
- int index) {
+ public com.google.protobuf.ByteString
+ getInstanceIdentifierPathArgumentsBytes(int index) {
return instanceIdentifierPathArguments_.getByteString(index);
}
// required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;
public static final int NORMALIZEDNODEXML_FIELD_NUMBER = 2;
- private org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml normalizedNodeXml_;
-
+ private org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml normalizedNodeXml_;
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
*/
public boolean hasNormalizedNodeXml() {
return ((bitField0_ & 0x00000001) == 0x00000001);
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
*/
- public org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml getNormalizedNodeXml() {
+ public org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml getNormalizedNodeXml() {
return normalizedNodeXml_;
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
*/
- public org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder getNormalizedNodeXmlOrBuilder() {
+ public org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder getNormalizedNodeXmlOrBuilder() {
return normalizedNodeXml_;
}
private void initFields() {
- instanceIdentifierPathArguments_ =
- com.google.protobuf.LazyStringArrayList.EMPTY;
- normalizedNodeXml_ =
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml
- .getDefaultInstance();
+ instanceIdentifierPathArguments_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+ normalizedNodeXml_ = org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.getDefaultInstance();
}
-
private byte memoizedIsInitialized = -1;
-
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
- if (isInitialized != -1)
- return isInitialized == 1;
+ if (isInitialized != -1) return isInitialized == 1;
if (!hasNormalizedNodeXml()) {
memoizedIsInitialized = 0;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
- throws java.io.IOException {
+ throws java.io.IOException {
getSerializedSize();
for (int i = 0; i < instanceIdentifierPathArguments_.size(); i++) {
output.writeBytes(1, instanceIdentifierPathArguments_.getByteString(i));
}
private int memoizedSerializedSize = -1;
-
public int getSerializedSize() {
int size = memoizedSerializedSize;
- if (size != -1)
- return size;
+ if (size != -1) return size;
size = 0;
{
int dataSize = 0;
for (int i = 0; i < instanceIdentifierPathArguments_.size(); i++) {
- dataSize +=
- com.google.protobuf.CodedOutputStream
- .computeBytesSizeNoTag(instanceIdentifierPathArguments_
- .getByteString(i));
+ dataSize += com.google.protobuf.CodedOutputStream
+ .computeBytesSizeNoTag(instanceIdentifierPathArguments_.getByteString(i));
}
size += dataSize;
size += 1 * getInstanceIdentifierPathArgumentsList().size();
}
if (((bitField0_ & 0x00000001) == 0x00000001)) {
- size +=
- com.google.protobuf.CodedOutputStream.computeMessageSize(2,
- normalizedNodeXml_);
+ size += com.google.protobuf.CodedOutputStream
+ .computeMessageSize(2, normalizedNodeXml_);
}
size += getUnknownFields().getSerializedSize();
memoizedSerializedSize = size;
}
private static final long serialVersionUID = 0L;
-
@java.lang.Override
protected java.lang.Object writeReplace()
throws java.io.ObjectStreamException {
return super.writeReplace();
}
- public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged parseFrom(
- byte[] data) throws com.google.protobuf.InvalidProtocolBufferException {
+ public static org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged parseFrom(
- byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ public static org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged parseFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged parseDelimitedFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseDelimitedFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged parseDelimitedFrom(
+ public static org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseDelimitedFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged parseFrom(
- com.google.protobuf.CodedInputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
- public static Builder newBuilder() {
- return Builder.create();
- }
-
- public Builder newBuilderForType() {
- return newBuilder();
- }
-
- public static Builder newBuilder(
- org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged prototype) {
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged prototype) {
return newBuilder().mergeFrom(prototype);
}
-
- public Builder toBuilder() {
- return newBuilder(this);
- }
+ public Builder toBuilder() { return newBuilder(this); }
@java.lang.Override
protected Builder newBuilderForType(
Builder builder = new Builder(parent);
return builder;
}
-
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.DataChanged}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessage.Builder<Builder>
- implements
- org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedOrBuilder {
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChanged_descriptor;
+ implements org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChanged_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChanged_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChanged_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged.class,
- org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged.Builder.class);
+ org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged.class, org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged.Builder.class);
}
- // Construct using
- // org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged.newBuilder()
+ // Construct using org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
- private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
-
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
getNormalizedNodeXmlFieldBuilder();
}
}
-
private static Builder create() {
return new Builder();
}
public Builder clear() {
super.clear();
- instanceIdentifierPathArguments_ =
- com.google.protobuf.LazyStringArrayList.EMPTY;
+ instanceIdentifierPathArguments_ = com.google.protobuf.LazyStringArrayList.EMPTY;
bitField0_ = (bitField0_ & ~0x00000001);
if (normalizedNodeXmlBuilder_ == null) {
- normalizedNodeXml_ =
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml
- .getDefaultInstance();
+ normalizedNodeXml_ = org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.getDefaultInstance();
} else {
normalizedNodeXmlBuilder_.clear();
}
return create().mergeFrom(buildPartial());
}
- public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
- return org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChanged_descriptor;
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChanged_descriptor;
}
- public org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged getDefaultInstanceForType() {
- return org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged
- .getDefaultInstance();
+ public org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged getDefaultInstanceForType() {
+ return org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged.getDefaultInstance();
}
- public org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged build() {
- org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged result =
- buildPartial();
+ public org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged build() {
+ org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
- public org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged buildPartial() {
- org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged result =
- new org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged(
- this);
+ public org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged buildPartial() {
+ org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged result = new org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged(this);
int from_bitField0_ = bitField0_;
int to_bitField0_ = 0;
if (((bitField0_ & 0x00000001) == 0x00000001)) {
- instanceIdentifierPathArguments_ =
- new com.google.protobuf.UnmodifiableLazyStringList(
- instanceIdentifierPathArguments_);
+ instanceIdentifierPathArguments_ = new com.google.protobuf.UnmodifiableLazyStringList(
+ instanceIdentifierPathArguments_);
bitField0_ = (bitField0_ & ~0x00000001);
}
- result.instanceIdentifierPathArguments_ =
- instanceIdentifierPathArguments_;
+ result.instanceIdentifierPathArguments_ = instanceIdentifierPathArguments_;
if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
to_bitField0_ |= 0x00000001;
}
}
public Builder mergeFrom(com.google.protobuf.Message other) {
- if (other instanceof org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged) {
- return mergeFrom((org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged) other);
+ if (other instanceof org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged) {
+ return mergeFrom((org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged)other);
} else {
super.mergeFrom(other);
return this;
}
}
- public Builder mergeFrom(
- org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged other) {
- if (other == org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged
- .getDefaultInstance())
- return this;
+ public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged other) {
+ if (other == org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged.getDefaultInstance()) return this;
if (!other.instanceIdentifierPathArguments_.isEmpty()) {
if (instanceIdentifierPathArguments_.isEmpty()) {
- instanceIdentifierPathArguments_ =
- other.instanceIdentifierPathArguments_;
+ instanceIdentifierPathArguments_ = other.instanceIdentifierPathArguments_;
bitField0_ = (bitField0_ & ~0x00000001);
} else {
ensureInstanceIdentifierPathArgumentsIsMutable();
- instanceIdentifierPathArguments_
- .addAll(other.instanceIdentifierPathArguments_);
+ instanceIdentifierPathArguments_.addAll(other.instanceIdentifierPathArguments_);
}
onChanged();
}
return true;
}
- public Builder mergeFrom(com.google.protobuf.CodedInputStream input,
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
- org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged parsedMessage =
- null;
+ org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
- parsedMessage =
- (org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChanged) e
- .getUnfinishedMessage();
+ parsedMessage = (org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChanged) e.getUnfinishedMessage();
throw e;
} finally {
if (parsedMessage != null) {
}
return this;
}
-
private int bitField0_;
// repeated string instanceIdentifierPathArguments = 1;
- private com.google.protobuf.LazyStringList instanceIdentifierPathArguments_ =
- com.google.protobuf.LazyStringArrayList.EMPTY;
-
+ private com.google.protobuf.LazyStringList instanceIdentifierPathArguments_ = com.google.protobuf.LazyStringArrayList.EMPTY;
private void ensureInstanceIdentifierPathArgumentsIsMutable() {
if (!((bitField0_ & 0x00000001) == 0x00000001)) {
- instanceIdentifierPathArguments_ =
- new com.google.protobuf.LazyStringArrayList(
- instanceIdentifierPathArguments_);
+ instanceIdentifierPathArguments_ = new com.google.protobuf.LazyStringArrayList(instanceIdentifierPathArguments_);
bitField0_ |= 0x00000001;
- }
+ }
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
- public java.util.List<java.lang.String> getInstanceIdentifierPathArgumentsList() {
- return java.util.Collections
- .unmodifiableList(instanceIdentifierPathArguments_);
+ public java.util.List<java.lang.String>
+ getInstanceIdentifierPathArgumentsList() {
+ return java.util.Collections.unmodifiableList(instanceIdentifierPathArguments_);
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
public int getInstanceIdentifierPathArgumentsCount() {
return instanceIdentifierPathArguments_.size();
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
public java.lang.String getInstanceIdentifierPathArguments(int index) {
return instanceIdentifierPathArguments_.get(index);
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
- public com.google.protobuf.ByteString getInstanceIdentifierPathArgumentsBytes(
- int index) {
+ public com.google.protobuf.ByteString
+ getInstanceIdentifierPathArgumentsBytes(int index) {
return instanceIdentifierPathArguments_.getByteString(index);
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
- public Builder setInstanceIdentifierPathArguments(int index,
- java.lang.String value) {
+ public Builder setInstanceIdentifierPathArguments(
+ int index, java.lang.String value) {
if (value == null) {
- throw new NullPointerException();
- }
- ensureInstanceIdentifierPathArgumentsIsMutable();
+ throw new NullPointerException();
+ }
+ ensureInstanceIdentifierPathArgumentsIsMutable();
instanceIdentifierPathArguments_.set(index, value);
onChanged();
return this;
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
- public Builder addInstanceIdentifierPathArguments(java.lang.String value) {
+ public Builder addInstanceIdentifierPathArguments(
+ java.lang.String value) {
if (value == null) {
- throw new NullPointerException();
- }
- ensureInstanceIdentifierPathArgumentsIsMutable();
+ throw new NullPointerException();
+ }
+ ensureInstanceIdentifierPathArgumentsIsMutable();
instanceIdentifierPathArguments_.add(value);
onChanged();
return this;
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
onChanged();
return this;
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
public Builder clearInstanceIdentifierPathArguments() {
- instanceIdentifierPathArguments_ =
- com.google.protobuf.LazyStringArrayList.EMPTY;
+ instanceIdentifierPathArguments_ = com.google.protobuf.LazyStringArrayList.EMPTY;
bitField0_ = (bitField0_ & ~0x00000001);
onChanged();
return this;
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
public Builder addInstanceIdentifierPathArgumentsBytes(
com.google.protobuf.ByteString value) {
if (value == null) {
- throw new NullPointerException();
- }
- ensureInstanceIdentifierPathArgumentsIsMutable();
+ throw new NullPointerException();
+ }
+ ensureInstanceIdentifierPathArgumentsIsMutable();
instanceIdentifierPathArguments_.add(value);
onChanged();
return this;
}
// required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;
- private org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml normalizedNodeXml_ =
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml
- .getDefaultInstance();
- private com.google.protobuf.SingleFieldBuilder<org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml, org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder, org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder> normalizedNodeXmlBuilder_;
-
+ private org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml normalizedNodeXml_ = org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.getDefaultInstance();
+ private com.google.protobuf.SingleFieldBuilder<
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml, org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder, org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder> normalizedNodeXmlBuilder_;
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
*/
public boolean hasNormalizedNodeXml() {
return ((bitField0_ & 0x00000002) == 0x00000002);
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
*/
- public org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml getNormalizedNodeXml() {
+ public org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml getNormalizedNodeXml() {
if (normalizedNodeXmlBuilder_ == null) {
return normalizedNodeXml_;
} else {
return normalizedNodeXmlBuilder_.getMessage();
}
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
*/
- public Builder setNormalizedNodeXml(
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml value) {
+ public Builder setNormalizedNodeXml(org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml value) {
if (normalizedNodeXmlBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
bitField0_ |= 0x00000002;
return this;
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
*/
public Builder setNormalizedNodeXml(
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder builderForValue) {
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder builderForValue) {
if (normalizedNodeXmlBuilder_ == null) {
normalizedNodeXml_ = builderForValue.build();
onChanged();
bitField0_ |= 0x00000002;
return this;
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
*/
- public Builder mergeNormalizedNodeXml(
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml value) {
+ public Builder mergeNormalizedNodeXml(org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml value) {
if (normalizedNodeXmlBuilder_ == null) {
- if (((bitField0_ & 0x00000002) == 0x00000002)
- && normalizedNodeXml_ != org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml
- .getDefaultInstance()) {
+ if (((bitField0_ & 0x00000002) == 0x00000002) &&
+ normalizedNodeXml_ != org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.getDefaultInstance()) {
normalizedNodeXml_ =
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml
- .newBuilder(normalizedNodeXml_).mergeFrom(value)
- .buildPartial();
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.newBuilder(normalizedNodeXml_).mergeFrom(value).buildPartial();
} else {
normalizedNodeXml_ = value;
}
bitField0_ |= 0x00000002;
return this;
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
*/
public Builder clearNormalizedNodeXml() {
if (normalizedNodeXmlBuilder_ == null) {
- normalizedNodeXml_ =
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml
- .getDefaultInstance();
+ normalizedNodeXml_ = org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.getDefaultInstance();
onChanged();
} else {
normalizedNodeXmlBuilder_.clear();
bitField0_ = (bitField0_ & ~0x00000002);
return this;
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
*/
- public org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder getNormalizedNodeXmlBuilder() {
+ public org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder getNormalizedNodeXmlBuilder() {
bitField0_ |= 0x00000002;
onChanged();
return getNormalizedNodeXmlFieldBuilder().getBuilder();
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
*/
- public org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder getNormalizedNodeXmlOrBuilder() {
+ public org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder getNormalizedNodeXmlOrBuilder() {
if (normalizedNodeXmlBuilder_ != null) {
return normalizedNodeXmlBuilder_.getMessageOrBuilder();
} else {
return normalizedNodeXml_;
}
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNodeXml = 2;</code>
*/
- private com.google.protobuf.SingleFieldBuilder<org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml, org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder, org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder> getNormalizedNodeXmlFieldBuilder() {
+ private com.google.protobuf.SingleFieldBuilder<
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml, org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder, org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder>
+ getNormalizedNodeXmlFieldBuilder() {
if (normalizedNodeXmlBuilder_ == null) {
- normalizedNodeXmlBuilder_ =
- new com.google.protobuf.SingleFieldBuilder<org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml, org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder, org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder>(
- normalizedNodeXml_, getParentForChildren(), isClean());
+ normalizedNodeXmlBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml, org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder, org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder>(
+ normalizedNodeXml_,
+ getParentForChildren(),
+ isClean());
normalizedNodeXml_ = null;
}
return normalizedNodeXmlBuilder_;
// @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.DataChanged)
}
- public interface DataChangedReplyOrBuilder extends
- com.google.protobuf.MessageOrBuilder {
+ public interface DataChangedReplyOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
}
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.DataChangedReply}
*/
public static final class DataChangedReply extends
- com.google.protobuf.GeneratedMessage implements DataChangedReplyOrBuilder {
+ com.google.protobuf.GeneratedMessage
+ implements DataChangedReplyOrBuilder {
// Use DataChangedReply.newBuilder() to construct.
- private DataChangedReply(
- com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ private DataChangedReply(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
super(builder);
this.unknownFields = builder.getUnknownFields();
}
-
- private DataChangedReply(boolean noInit) {
- this.unknownFields =
- com.google.protobuf.UnknownFieldSet.getDefaultInstance();
- }
+ private DataChangedReply(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
private static final DataChangedReply defaultInstance;
-
public static DataChangedReply getDefaultInstance() {
return defaultInstance;
}
}
private final com.google.protobuf.UnknownFieldSet unknownFields;
-
@java.lang.Override
- public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
return this.unknownFields;
}
-
- private DataChangedReply(com.google.protobuf.CodedInputStream input,
+ private DataChangedReply(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
initFields();
done = true;
break;
default: {
- if (!parseUnknownField(input, unknownFields, extensionRegistry,
- tag)) {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
done = true;
}
break;
makeExtensionsImmutable();
}
}
-
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChangedReply_descriptor;
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChangedReply_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChangedReply_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChangedReply_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply.class,
- org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply.Builder.class);
+ org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply.class, org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply.Builder.class);
}
public static com.google.protobuf.Parser<DataChangedReply> PARSER =
new com.google.protobuf.AbstractParser<DataChangedReply>() {
- public DataChangedReply parsePartialFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return new DataChangedReply(input, extensionRegistry);
- }
- };
+ public DataChangedReply parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new DataChangedReply(input, extensionRegistry);
+ }
+ };
@java.lang.Override
public com.google.protobuf.Parser<DataChangedReply> getParserForType() {
return PARSER;
}
- private void initFields() {}
-
+ private void initFields() {
+ }
private byte memoizedIsInitialized = -1;
-
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
- if (isInitialized != -1)
- return isInitialized == 1;
+ if (isInitialized != -1) return isInitialized == 1;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
- throws java.io.IOException {
+ throws java.io.IOException {
getSerializedSize();
getUnknownFields().writeTo(output);
}
private int memoizedSerializedSize = -1;
-
public int getSerializedSize() {
int size = memoizedSerializedSize;
- if (size != -1)
- return size;
+ if (size != -1) return size;
size = 0;
size += getUnknownFields().getSerializedSize();
}
private static final long serialVersionUID = 0L;
-
@java.lang.Override
protected java.lang.Object writeReplace()
throws java.io.ObjectStreamException {
return super.writeReplace();
}
- public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply parseFrom(
- byte[] data) throws com.google.protobuf.InvalidProtocolBufferException {
+ public static org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply parseFrom(
- byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ public static org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply parseFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply parseDelimitedFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseDelimitedFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply parseDelimitedFrom(
+ public static org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseDelimitedFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply parseFrom(
- com.google.protobuf.CodedInputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
- public static Builder newBuilder() {
- return Builder.create();
- }
-
- public Builder newBuilderForType() {
- return newBuilder();
- }
-
- public static Builder newBuilder(
- org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply prototype) {
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply prototype) {
return newBuilder().mergeFrom(prototype);
}
-
- public Builder toBuilder() {
- return newBuilder(this);
- }
+ public Builder toBuilder() { return newBuilder(this); }
@java.lang.Override
protected Builder newBuilderForType(
Builder builder = new Builder(parent);
return builder;
}
-
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.DataChangedReply}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessage.Builder<Builder>
- implements
- org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReplyOrBuilder {
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChangedReply_descriptor;
+ implements org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReplyOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChangedReply_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChangedReply_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChangedReply_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply.class,
- org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply.Builder.class);
+ org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply.class, org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply.Builder.class);
}
- // Construct using
- // org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply.newBuilder()
+ // Construct using org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
- private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
-
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
}
}
-
private static Builder create() {
return new Builder();
}
return create().mergeFrom(buildPartial());
}
- public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
- return org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChangedReply_descriptor;
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.internal_static_org_opendaylight_controller_mdsal_DataChangedReply_descriptor;
}
- public org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply getDefaultInstanceForType() {
- return org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply
- .getDefaultInstance();
+ public org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply getDefaultInstanceForType() {
+ return org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply.getDefaultInstance();
}
- public org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply build() {
- org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply result =
- buildPartial();
+ public org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply build() {
+ org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
- public org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply buildPartial() {
- org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply result =
- new org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply(
- this);
+ public org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply buildPartial() {
+ org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply result = new org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply(this);
onBuilt();
return result;
}
public Builder mergeFrom(com.google.protobuf.Message other) {
- if (other instanceof org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply) {
- return mergeFrom((org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply) other);
+ if (other instanceof org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply) {
+ return mergeFrom((org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply)other);
} else {
super.mergeFrom(other);
return this;
}
}
- public Builder mergeFrom(
- org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply other) {
- if (other == org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply
- .getDefaultInstance())
- return this;
+ public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply other) {
+ if (other == org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply.getDefaultInstance()) return this;
this.mergeUnknownFields(other.getUnknownFields());
return this;
}
return true;
}
- public Builder mergeFrom(com.google.protobuf.CodedInputStream input,
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
- org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply parsedMessage =
- null;
+ org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
- parsedMessage =
- (org.opendaylight.controller.cluster.datastore.datachange.notification.DataChangeListenerMessages.DataChangedReply) e
- .getUnfinishedMessage();
+ parsedMessage = (org.opendaylight.controller.protobuff.messages.datachange.notification.DataChangeListenerMessages.DataChangedReply) e.getUnfinishedMessage();
throw e;
} finally {
if (parsedMessage != null) {
// @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.DataChangedReply)
}
- private static com.google.protobuf.Descriptors.Descriptor internal_static_org_opendaylight_controller_mdsal_DataChanged_descriptor;
- private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_org_opendaylight_controller_mdsal_DataChanged_fieldAccessorTable;
- private static com.google.protobuf.Descriptors.Descriptor internal_static_org_opendaylight_controller_mdsal_DataChangedReply_descriptor;
- private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_org_opendaylight_controller_mdsal_DataChangedReply_fieldAccessorTable;
-
- public static com.google.protobuf.Descriptors.FileDescriptor getDescriptor() {
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_org_opendaylight_controller_mdsal_DataChanged_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_org_opendaylight_controller_mdsal_DataChanged_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_org_opendaylight_controller_mdsal_DataChangedReply_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_org_opendaylight_controller_mdsal_DataChangedReply_fieldAccessorTable;
+
+ public static com.google.protobuf.Descriptors.FileDescriptor
+ getDescriptor() {
return descriptor;
}
-
- private static com.google.protobuf.Descriptors.FileDescriptor descriptor;
+ private static com.google.protobuf.Descriptors.FileDescriptor
+ descriptor;
static {
- java.lang.String[] descriptorData =
- {"\n\030DataChangeListener.proto\022!org.opendayl"
- + "ight.controller.mdsal\032\032SimpleNormalizedN"
- + "ode.proto\"\207\001\n\013DataChanged\022\'\n\037instanceIde"
- + "ntifierPathArguments\030\001 \003(\t\022O\n\021normalized"
- + "NodeXml\030\002 \002(\01324.org.opendaylight.control"
- + "ler.mdsal.NormalizedNodeXml\"\022\n\020DataChang"
- + "edReplyBc\nEorg.opendaylight.controller.c"
- + "luster.datastore.datachange.notification"
- + "B\032DataChangeListenerMessages"};
+ java.lang.String[] descriptorData = {
+ "\n\030DataChangeListener.proto\022!org.opendayl" +
+ "ight.controller.mdsal\032\032SimpleNormalizedN" +
+ "ode.proto\"\207\001\n\013DataChanged\022\'\n\037instanceIde" +
+ "ntifierPathArguments\030\001 \003(\t\022O\n\021normalized" +
+ "NodeXml\030\002 \002(\01324.org.opendaylight.control" +
+ "ler.mdsal.NormalizedNodeXml\"\022\n\020DataChang" +
+ "edReplyBd\nForg.opendaylight.controller.p" +
+ "rotobuff.messages.datachange.notificatio" +
+ "nB\032DataChangeListenerMessages"
+ };
com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
- new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
- public com.google.protobuf.ExtensionRegistry assignDescriptors(
- com.google.protobuf.Descriptors.FileDescriptor root) {
- descriptor = root;
- internal_static_org_opendaylight_controller_mdsal_DataChanged_descriptor =
- getDescriptor().getMessageTypes().get(0);
- internal_static_org_opendaylight_controller_mdsal_DataChanged_fieldAccessorTable =
- new com.google.protobuf.GeneratedMessage.FieldAccessorTable(
- internal_static_org_opendaylight_controller_mdsal_DataChanged_descriptor,
- new java.lang.String[] {"InstanceIdentifierPathArguments",
- "NormalizedNodeXml",});
- internal_static_org_opendaylight_controller_mdsal_DataChangedReply_descriptor =
- getDescriptor().getMessageTypes().get(1);
- internal_static_org_opendaylight_controller_mdsal_DataChangedReply_fieldAccessorTable =
- new com.google.protobuf.GeneratedMessage.FieldAccessorTable(
- internal_static_org_opendaylight_controller_mdsal_DataChangedReply_descriptor,
- new java.lang.String[] {});
- return null;
- }
- };
+ new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
+ public com.google.protobuf.ExtensionRegistry assignDescriptors(
+ com.google.protobuf.Descriptors.FileDescriptor root) {
+ descriptor = root;
+ internal_static_org_opendaylight_controller_mdsal_DataChanged_descriptor =
+ getDescriptor().getMessageTypes().get(0);
+ internal_static_org_opendaylight_controller_mdsal_DataChanged_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_org_opendaylight_controller_mdsal_DataChanged_descriptor,
+ new java.lang.String[] { "InstanceIdentifierPathArguments", "NormalizedNodeXml", });
+ internal_static_org_opendaylight_controller_mdsal_DataChangedReply_descriptor =
+ getDescriptor().getMessageTypes().get(1);
+ internal_static_org_opendaylight_controller_mdsal_DataChangedReply_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_org_opendaylight_controller_mdsal_DataChangedReply_descriptor,
+ new java.lang.String[] { });
+ return null;
+ }
+ };
com.google.protobuf.Descriptors.FileDescriptor
- .internalBuildGeneratedFileFrom(
- descriptorData,
- new com.google.protobuf.Descriptors.FileDescriptor[]{org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage
- .getDescriptor(),}, assigner);
+ .internalBuildGeneratedFileFrom(descriptorData,
+ new com.google.protobuf.Descriptors.FileDescriptor[] {
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.getDescriptor(),
+ }, assigner);
}
// @@protoc_insertion_point(outer_class_scope)
--- /dev/null
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: ListenerRegistration.proto
+
+package org.opendaylight.controller.protobuff.messages.registration;
+
+public final class ListenerRegistrationMessages {
+ private ListenerRegistrationMessages() {}
+ public static void registerAllExtensions(
+ com.google.protobuf.ExtensionRegistry registry) {
+ }
+ public interface CloseOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+ }
+ /**
+ * Protobuf type {@code org.opendaylight.controller.mdsal.Close}
+ */
+ public static final class Close extends
+ com.google.protobuf.GeneratedMessage
+ implements CloseOrBuilder {
+ // Use Close.newBuilder() to construct.
+ private Close(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private Close(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final Close defaultInstance;
+ public static Close getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public Close getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private Close(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_Close_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_Close_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close.class, org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<Close> PARSER =
+ new com.google.protobuf.AbstractParser<Close>() {
+ public Close parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new Close(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<Close> getParserForType() {
+ return PARSER;
+ }
+
+ private void initFields() {
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code org.opendaylight.controller.mdsal.Close}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_Close_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_Close_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close.class, org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close.Builder.class);
+ }
+
+ // Construct using org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_Close_descriptor;
+ }
+
+ public org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close getDefaultInstanceForType() {
+ return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close.getDefaultInstance();
+ }
+
+ public org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close build() {
+ org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close buildPartial() {
+ org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close result = new org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close(this);
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close) {
+ return mergeFrom((org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close other) {
+ if (other == org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close.getDefaultInstance()) return this;
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.Close) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:org.opendaylight.controller.mdsal.Close)
+ }
+
+ static {
+ defaultInstance = new Close(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.Close)
+ }
+
+ public interface CloseReplyOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+ }
+ /**
+ * Protobuf type {@code org.opendaylight.controller.mdsal.CloseReply}
+ */
+ public static final class CloseReply extends
+ com.google.protobuf.GeneratedMessage
+ implements CloseReplyOrBuilder {
+ // Use CloseReply.newBuilder() to construct.
+ private CloseReply(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private CloseReply(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final CloseReply defaultInstance;
+ public static CloseReply getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public CloseReply getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private CloseReply(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_CloseReply_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_CloseReply_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply.class, org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<CloseReply> PARSER =
+ new com.google.protobuf.AbstractParser<CloseReply>() {
+ public CloseReply parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new CloseReply(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<CloseReply> getParserForType() {
+ return PARSER;
+ }
+
+ private void initFields() {
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code org.opendaylight.controller.mdsal.CloseReply}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReplyOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_CloseReply_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_CloseReply_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply.class, org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply.Builder.class);
+ }
+
+ // Construct using org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.internal_static_org_opendaylight_controller_mdsal_CloseReply_descriptor;
+ }
+
+ public org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply getDefaultInstanceForType() {
+ return org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply.getDefaultInstance();
+ }
+
+ public org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply build() {
+ org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply buildPartial() {
+ org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply result = new org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply(this);
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply) {
+ return mergeFrom((org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply other) {
+ if (other == org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply.getDefaultInstance()) return this;
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.opendaylight.controller.protobuff.messages.registration.ListenerRegistrationMessages.CloseReply) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:org.opendaylight.controller.mdsal.CloseReply)
+ }
+
+ static {
+ defaultInstance = new CloseReply(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.CloseReply)
+ }
+
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_org_opendaylight_controller_mdsal_Close_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_org_opendaylight_controller_mdsal_Close_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_org_opendaylight_controller_mdsal_CloseReply_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_org_opendaylight_controller_mdsal_CloseReply_fieldAccessorTable;
+
+ public static com.google.protobuf.Descriptors.FileDescriptor
+ getDescriptor() {
+ return descriptor;
+ }
+ private static com.google.protobuf.Descriptors.FileDescriptor
+ descriptor;
+ static {
+ java.lang.String[] descriptorData = {
+ "\n\032ListenerRegistration.proto\022!org.openda" +
+ "ylight.controller.mdsal\"\007\n\005Close\"\014\n\nClos" +
+ "eReplyB[\n;org.opendaylight.controller.pr" +
+ "otobuff.messages.registrationB\034ListenerR" +
+ "egistrationMessages"
+ };
+ com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
+ new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
+ public com.google.protobuf.ExtensionRegistry assignDescriptors(
+ com.google.protobuf.Descriptors.FileDescriptor root) {
+ descriptor = root;
+ internal_static_org_opendaylight_controller_mdsal_Close_descriptor =
+ getDescriptor().getMessageTypes().get(0);
+ internal_static_org_opendaylight_controller_mdsal_Close_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_org_opendaylight_controller_mdsal_Close_descriptor,
+ new java.lang.String[] { });
+ internal_static_org_opendaylight_controller_mdsal_CloseReply_descriptor =
+ getDescriptor().getMessageTypes().get(1);
+ internal_static_org_opendaylight_controller_mdsal_CloseReply_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_org_opendaylight_controller_mdsal_CloseReply_descriptor,
+ new java.lang.String[] { });
+ return null;
+ }
+ };
+ com.google.protobuf.Descriptors.FileDescriptor
+ .internalBuildGeneratedFileFrom(descriptorData,
+ new com.google.protobuf.Descriptors.FileDescriptor[] {
+ }, assigner);
+ }
+
+ // @@protoc_insertion_point(outer_class_scope)
+}
-// Generated by the protocol buffer compiler. DO NOT EDIT!
+// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: ShardManager.proto
-package org.opendaylight.controller.cluster.datastore.shard;
+package org.opendaylight.controller.protobuff.messages.shard;
public final class ShardManagerMessages {
private ShardManagerMessages() {}
-
public static void registerAllExtensions(
- com.google.protobuf.ExtensionRegistry registry) {}
-
- public interface FindPrimaryOrBuilder extends
- com.google.protobuf.MessageOrBuilder {
+ com.google.protobuf.ExtensionRegistry registry) {
+ }
+ public interface FindPrimaryOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
// required string shardName = 1;
/**
* <code>required string shardName = 1;</code>
*/
boolean hasShardName();
-
/**
* <code>required string shardName = 1;</code>
*/
java.lang.String getShardName();
-
/**
* <code>required string shardName = 1;</code>
*/
- com.google.protobuf.ByteString getShardNameBytes();
+ com.google.protobuf.ByteString
+ getShardNameBytes();
}
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.FindPrimary}
*/
public static final class FindPrimary extends
- com.google.protobuf.GeneratedMessage implements FindPrimaryOrBuilder {
+ com.google.protobuf.GeneratedMessage
+ implements FindPrimaryOrBuilder {
// Use FindPrimary.newBuilder() to construct.
private FindPrimary(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
super(builder);
this.unknownFields = builder.getUnknownFields();
}
-
- private FindPrimary(boolean noInit) {
- this.unknownFields =
- com.google.protobuf.UnknownFieldSet.getDefaultInstance();
- }
+ private FindPrimary(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
private static final FindPrimary defaultInstance;
-
public static FindPrimary getDefaultInstance() {
return defaultInstance;
}
}
private final com.google.protobuf.UnknownFieldSet unknownFields;
-
@java.lang.Override
- public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
return this.unknownFields;
}
-
- private FindPrimary(com.google.protobuf.CodedInputStream input,
+ private FindPrimary(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
initFields();
done = true;
break;
default: {
- if (!parseUnknownField(input, unknownFields, extensionRegistry,
- tag)) {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
done = true;
}
break;
makeExtensionsImmutable();
}
}
-
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_FindPrimary_descriptor;
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_FindPrimary_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_FindPrimary_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_FindPrimary_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary.class,
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary.Builder.class);
+ org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary.class, org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary.Builder.class);
}
public static com.google.protobuf.Parser<FindPrimary> PARSER =
new com.google.protobuf.AbstractParser<FindPrimary>() {
- public FindPrimary parsePartialFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return new FindPrimary(input, extensionRegistry);
- }
- };
+ public FindPrimary parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new FindPrimary(input, extensionRegistry);
+ }
+ };
@java.lang.Override
public com.google.protobuf.Parser<FindPrimary> getParserForType() {
// required string shardName = 1;
public static final int SHARDNAME_FIELD_NUMBER = 1;
private java.lang.Object shardName_;
-
/**
* <code>required string shardName = 1;</code>
*/
public boolean hasShardName() {
return ((bitField0_ & 0x00000001) == 0x00000001);
}
-
/**
* <code>required string shardName = 1;</code>
*/
return s;
}
}
-
/**
* <code>required string shardName = 1;</code>
*/
- public com.google.protobuf.ByteString getShardNameBytes() {
+ public com.google.protobuf.ByteString
+ getShardNameBytes() {
java.lang.Object ref = shardName_;
if (ref instanceof java.lang.String) {
com.google.protobuf.ByteString b =
- com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
+ com.google.protobuf.ByteString.copyFromUtf8(
+ (java.lang.String) ref);
shardName_ = b;
return b;
} else {
private void initFields() {
shardName_ = "";
}
-
private byte memoizedIsInitialized = -1;
-
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
- if (isInitialized != -1)
- return isInitialized == 1;
+ if (isInitialized != -1) return isInitialized == 1;
if (!hasShardName()) {
memoizedIsInitialized = 0;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
- throws java.io.IOException {
+ throws java.io.IOException {
getSerializedSize();
if (((bitField0_ & 0x00000001) == 0x00000001)) {
output.writeBytes(1, getShardNameBytes());
}
private int memoizedSerializedSize = -1;
-
public int getSerializedSize() {
int size = memoizedSerializedSize;
- if (size != -1)
- return size;
+ if (size != -1) return size;
size = 0;
if (((bitField0_ & 0x00000001) == 0x00000001)) {
- size +=
- com.google.protobuf.CodedOutputStream.computeBytesSize(1,
- getShardNameBytes());
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(1, getShardNameBytes());
}
size += getUnknownFields().getSerializedSize();
memoizedSerializedSize = size;
}
private static final long serialVersionUID = 0L;
-
@java.lang.Override
protected java.lang.Object writeReplace()
throws java.io.ObjectStreamException {
return super.writeReplace();
}
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary parseFrom(
- byte[] data) throws com.google.protobuf.InvalidProtocolBufferException {
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary parseFrom(
- byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary parseFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary parseDelimitedFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseDelimitedFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary parseDelimitedFrom(
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseDelimitedFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary parseFrom(
- com.google.protobuf.CodedInputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
- public static Builder newBuilder() {
- return Builder.create();
- }
-
- public Builder newBuilderForType() {
- return newBuilder();
- }
-
- public static Builder newBuilder(
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary prototype) {
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary prototype) {
return newBuilder().mergeFrom(prototype);
}
-
- public Builder toBuilder() {
- return newBuilder(this);
- }
+ public Builder toBuilder() { return newBuilder(this); }
@java.lang.Override
protected Builder newBuilderForType(
Builder builder = new Builder(parent);
return builder;
}
-
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.FindPrimary}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessage.Builder<Builder>
- implements
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimaryOrBuilder {
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_FindPrimary_descriptor;
+ implements org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimaryOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_FindPrimary_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_FindPrimary_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_FindPrimary_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary.class,
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary.Builder.class);
+ org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary.class, org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary.Builder.class);
}
- // Construct using
- // org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary.newBuilder()
+ // Construct using org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
- private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
-
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
}
}
-
private static Builder create() {
return new Builder();
}
return create().mergeFrom(buildPartial());
}
- public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
- return org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_FindPrimary_descriptor;
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_FindPrimary_descriptor;
}
- public org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary getDefaultInstanceForType() {
- return org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary
- .getDefaultInstance();
+ public org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary getDefaultInstanceForType() {
+ return org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary.getDefaultInstance();
}
- public org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary build() {
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary result =
- buildPartial();
+ public org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary build() {
+ org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
- public org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary buildPartial() {
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary result =
- new org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary(
- this);
+ public org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary buildPartial() {
+ org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary result = new org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary(this);
int from_bitField0_ = bitField0_;
int to_bitField0_ = 0;
if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
}
public Builder mergeFrom(com.google.protobuf.Message other) {
- if (other instanceof org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary) {
- return mergeFrom((org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary) other);
+ if (other instanceof org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary) {
+ return mergeFrom((org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary)other);
} else {
super.mergeFrom(other);
return this;
}
}
- public Builder mergeFrom(
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary other) {
- if (other == org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary
- .getDefaultInstance())
- return this;
+ public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary other) {
+ if (other == org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary.getDefaultInstance()) return this;
if (other.hasShardName()) {
bitField0_ |= 0x00000001;
shardName_ = other.shardName_;
return true;
}
- public Builder mergeFrom(com.google.protobuf.CodedInputStream input,
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary parsedMessage =
- null;
+ org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
- parsedMessage =
- (org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.FindPrimary) e
- .getUnfinishedMessage();
+ parsedMessage = (org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.FindPrimary) e.getUnfinishedMessage();
throw e;
} finally {
if (parsedMessage != null) {
}
return this;
}
-
private int bitField0_;
// required string shardName = 1;
private java.lang.Object shardName_ = "";
-
/**
* <code>required string shardName = 1;</code>
*/
public boolean hasShardName() {
return ((bitField0_ & 0x00000001) == 0x00000001);
}
-
/**
* <code>required string shardName = 1;</code>
*/
public java.lang.String getShardName() {
java.lang.Object ref = shardName_;
if (!(ref instanceof java.lang.String)) {
- java.lang.String s =
- ((com.google.protobuf.ByteString) ref).toStringUtf8();
+ java.lang.String s = ((com.google.protobuf.ByteString) ref)
+ .toStringUtf8();
shardName_ = s;
return s;
} else {
return (java.lang.String) ref;
}
}
-
/**
* <code>required string shardName = 1;</code>
*/
- public com.google.protobuf.ByteString getShardNameBytes() {
+ public com.google.protobuf.ByteString
+ getShardNameBytes() {
java.lang.Object ref = shardName_;
if (ref instanceof String) {
com.google.protobuf.ByteString b =
- com.google.protobuf.ByteString
- .copyFromUtf8((java.lang.String) ref);
+ com.google.protobuf.ByteString.copyFromUtf8(
+ (java.lang.String) ref);
shardName_ = b;
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
-
/**
* <code>required string shardName = 1;</code>
*/
- public Builder setShardName(java.lang.String value) {
+ public Builder setShardName(
+ java.lang.String value) {
if (value == null) {
- throw new NullPointerException();
- }
- bitField0_ |= 0x00000001;
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000001;
shardName_ = value;
onChanged();
return this;
}
-
/**
* <code>required string shardName = 1;</code>
*/
onChanged();
return this;
}
-
/**
* <code>required string shardName = 1;</code>
*/
- public Builder setShardNameBytes(com.google.protobuf.ByteString value) {
+ public Builder setShardNameBytes(
+ com.google.protobuf.ByteString value) {
if (value == null) {
- throw new NullPointerException();
- }
- bitField0_ |= 0x00000001;
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000001;
shardName_ = value;
onChanged();
return this;
// @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.FindPrimary)
}
- public interface PrimaryFoundOrBuilder extends
- com.google.protobuf.MessageOrBuilder {
+ public interface PrimaryFoundOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
}
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.PrimaryFound}
*/
public static final class PrimaryFound extends
- com.google.protobuf.GeneratedMessage implements PrimaryFoundOrBuilder {
+ com.google.protobuf.GeneratedMessage
+ implements PrimaryFoundOrBuilder {
// Use PrimaryFound.newBuilder() to construct.
private PrimaryFound(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
super(builder);
this.unknownFields = builder.getUnknownFields();
}
-
- private PrimaryFound(boolean noInit) {
- this.unknownFields =
- com.google.protobuf.UnknownFieldSet.getDefaultInstance();
- }
+ private PrimaryFound(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
private static final PrimaryFound defaultInstance;
-
public static PrimaryFound getDefaultInstance() {
return defaultInstance;
}
}
private final com.google.protobuf.UnknownFieldSet unknownFields;
-
@java.lang.Override
- public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
return this.unknownFields;
}
-
- private PrimaryFound(com.google.protobuf.CodedInputStream input,
+ private PrimaryFound(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
initFields();
done = true;
break;
default: {
- if (!parseUnknownField(input, unknownFields, extensionRegistry,
- tag)) {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
done = true;
}
break;
makeExtensionsImmutable();
}
}
-
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_PrimaryFound_descriptor;
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_PrimaryFound_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_PrimaryFound_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_PrimaryFound_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound.class,
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound.Builder.class);
+ org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound.class, org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound.Builder.class);
}
public static com.google.protobuf.Parser<PrimaryFound> PARSER =
new com.google.protobuf.AbstractParser<PrimaryFound>() {
- public PrimaryFound parsePartialFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return new PrimaryFound(input, extensionRegistry);
- }
- };
+ public PrimaryFound parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new PrimaryFound(input, extensionRegistry);
+ }
+ };
@java.lang.Override
public com.google.protobuf.Parser<PrimaryFound> getParserForType() {
return PARSER;
}
- private void initFields() {}
-
+ private void initFields() {
+ }
private byte memoizedIsInitialized = -1;
-
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
- if (isInitialized != -1)
- return isInitialized == 1;
+ if (isInitialized != -1) return isInitialized == 1;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
- throws java.io.IOException {
+ throws java.io.IOException {
getSerializedSize();
getUnknownFields().writeTo(output);
}
private int memoizedSerializedSize = -1;
-
public int getSerializedSize() {
int size = memoizedSerializedSize;
- if (size != -1)
- return size;
+ if (size != -1) return size;
size = 0;
size += getUnknownFields().getSerializedSize();
}
private static final long serialVersionUID = 0L;
-
@java.lang.Override
protected java.lang.Object writeReplace()
throws java.io.ObjectStreamException {
return super.writeReplace();
}
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound parseFrom(
- byte[] data) throws com.google.protobuf.InvalidProtocolBufferException {
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound parseFrom(
- byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound parseFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound parseDelimitedFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseDelimitedFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound parseDelimitedFrom(
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseDelimitedFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound parseFrom(
- com.google.protobuf.CodedInputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
- public static Builder newBuilder() {
- return Builder.create();
- }
-
- public Builder newBuilderForType() {
- return newBuilder();
- }
-
- public static Builder newBuilder(
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound prototype) {
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound prototype) {
return newBuilder().mergeFrom(prototype);
}
-
- public Builder toBuilder() {
- return newBuilder(this);
- }
+ public Builder toBuilder() { return newBuilder(this); }
@java.lang.Override
protected Builder newBuilderForType(
Builder builder = new Builder(parent);
return builder;
}
-
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.PrimaryFound}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessage.Builder<Builder>
- implements
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFoundOrBuilder {
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_PrimaryFound_descriptor;
+ implements org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFoundOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_PrimaryFound_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_PrimaryFound_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_PrimaryFound_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound.class,
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound.Builder.class);
+ org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound.class, org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound.Builder.class);
}
- // Construct using
- // org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound.newBuilder()
+ // Construct using org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
- private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
-
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
}
}
-
private static Builder create() {
return new Builder();
}
return create().mergeFrom(buildPartial());
}
- public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
- return org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_PrimaryFound_descriptor;
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_PrimaryFound_descriptor;
}
- public org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound getDefaultInstanceForType() {
- return org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound
- .getDefaultInstance();
+ public org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound getDefaultInstanceForType() {
+ return org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound.getDefaultInstance();
}
- public org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound build() {
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound result =
- buildPartial();
+ public org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound build() {
+ org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
- public org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound buildPartial() {
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound result =
- new org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound(
- this);
+ public org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound buildPartial() {
+ org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound result = new org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound(this);
onBuilt();
return result;
}
public Builder mergeFrom(com.google.protobuf.Message other) {
- if (other instanceof org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound) {
- return mergeFrom((org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound) other);
+ if (other instanceof org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound) {
+ return mergeFrom((org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound)other);
} else {
super.mergeFrom(other);
return this;
}
}
- public Builder mergeFrom(
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound other) {
- if (other == org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound
- .getDefaultInstance())
- return this;
+ public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound other) {
+ if (other == org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound.getDefaultInstance()) return this;
this.mergeUnknownFields(other.getUnknownFields());
return this;
}
return true;
}
- public Builder mergeFrom(com.google.protobuf.CodedInputStream input,
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound parsedMessage =
- null;
+ org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
- parsedMessage =
- (org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryFound) e
- .getUnfinishedMessage();
+ parsedMessage = (org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryFound) e.getUnfinishedMessage();
throw e;
} finally {
if (parsedMessage != null) {
// @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.PrimaryFound)
}
- public interface PrimaryNotFoundOrBuilder extends
- com.google.protobuf.MessageOrBuilder {
+ public interface PrimaryNotFoundOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
}
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.PrimaryNotFound}
*/
public static final class PrimaryNotFound extends
- com.google.protobuf.GeneratedMessage implements PrimaryNotFoundOrBuilder {
+ com.google.protobuf.GeneratedMessage
+ implements PrimaryNotFoundOrBuilder {
// Use PrimaryNotFound.newBuilder() to construct.
- private PrimaryNotFound(
- com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ private PrimaryNotFound(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
super(builder);
this.unknownFields = builder.getUnknownFields();
}
-
- private PrimaryNotFound(boolean noInit) {
- this.unknownFields =
- com.google.protobuf.UnknownFieldSet.getDefaultInstance();
- }
+ private PrimaryNotFound(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
private static final PrimaryNotFound defaultInstance;
-
public static PrimaryNotFound getDefaultInstance() {
return defaultInstance;
}
}
private final com.google.protobuf.UnknownFieldSet unknownFields;
-
@java.lang.Override
- public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
return this.unknownFields;
}
-
- private PrimaryNotFound(com.google.protobuf.CodedInputStream input,
+ private PrimaryNotFound(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
initFields();
done = true;
break;
default: {
- if (!parseUnknownField(input, unknownFields, extensionRegistry,
- tag)) {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
done = true;
}
break;
makeExtensionsImmutable();
}
}
-
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_PrimaryNotFound_descriptor;
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_PrimaryNotFound_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_PrimaryNotFound_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_PrimaryNotFound_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound.class,
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound.Builder.class);
+ org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound.class, org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound.Builder.class);
}
public static com.google.protobuf.Parser<PrimaryNotFound> PARSER =
new com.google.protobuf.AbstractParser<PrimaryNotFound>() {
- public PrimaryNotFound parsePartialFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return new PrimaryNotFound(input, extensionRegistry);
- }
- };
+ public PrimaryNotFound parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new PrimaryNotFound(input, extensionRegistry);
+ }
+ };
@java.lang.Override
public com.google.protobuf.Parser<PrimaryNotFound> getParserForType() {
return PARSER;
}
- private void initFields() {}
-
+ private void initFields() {
+ }
private byte memoizedIsInitialized = -1;
-
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
- if (isInitialized != -1)
- return isInitialized == 1;
+ if (isInitialized != -1) return isInitialized == 1;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
- throws java.io.IOException {
+ throws java.io.IOException {
getSerializedSize();
getUnknownFields().writeTo(output);
}
private int memoizedSerializedSize = -1;
-
public int getSerializedSize() {
int size = memoizedSerializedSize;
- if (size != -1)
- return size;
+ if (size != -1) return size;
size = 0;
size += getUnknownFields().getSerializedSize();
}
private static final long serialVersionUID = 0L;
-
@java.lang.Override
protected java.lang.Object writeReplace()
throws java.io.ObjectStreamException {
return super.writeReplace();
}
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound parseFrom(
- byte[] data) throws com.google.protobuf.InvalidProtocolBufferException {
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound parseFrom(
- byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound parseFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound parseDelimitedFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseDelimitedFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound parseDelimitedFrom(
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseDelimitedFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound parseFrom(
- com.google.protobuf.CodedInputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
- public static Builder newBuilder() {
- return Builder.create();
- }
-
- public Builder newBuilderForType() {
- return newBuilder();
- }
-
- public static Builder newBuilder(
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound prototype) {
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound prototype) {
return newBuilder().mergeFrom(prototype);
}
-
- public Builder toBuilder() {
- return newBuilder(this);
- }
+ public Builder toBuilder() { return newBuilder(this); }
@java.lang.Override
protected Builder newBuilderForType(
Builder builder = new Builder(parent);
return builder;
}
-
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.PrimaryNotFound}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessage.Builder<Builder>
- implements
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFoundOrBuilder {
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_PrimaryNotFound_descriptor;
+ implements org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFoundOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_PrimaryNotFound_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_PrimaryNotFound_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_PrimaryNotFound_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound.class,
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound.Builder.class);
+ org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound.class, org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound.Builder.class);
}
- // Construct using
- // org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound.newBuilder()
+ // Construct using org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
- private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
-
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
}
}
-
private static Builder create() {
return new Builder();
}
return create().mergeFrom(buildPartial());
}
- public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
- return org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_PrimaryNotFound_descriptor;
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.internal_static_org_opendaylight_controller_mdsal_PrimaryNotFound_descriptor;
}
- public org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound getDefaultInstanceForType() {
- return org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound
- .getDefaultInstance();
+ public org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound getDefaultInstanceForType() {
+ return org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound.getDefaultInstance();
}
- public org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound build() {
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound result =
- buildPartial();
+ public org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound build() {
+ org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
- public org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound buildPartial() {
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound result =
- new org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound(
- this);
+ public org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound buildPartial() {
+ org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound result = new org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound(this);
onBuilt();
return result;
}
public Builder mergeFrom(com.google.protobuf.Message other) {
- if (other instanceof org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound) {
- return mergeFrom((org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound) other);
+ if (other instanceof org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound) {
+ return mergeFrom((org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound)other);
} else {
super.mergeFrom(other);
return this;
}
}
- public Builder mergeFrom(
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound other) {
- if (other == org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound
- .getDefaultInstance())
- return this;
+ public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound other) {
+ if (other == org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound.getDefaultInstance()) return this;
this.mergeUnknownFields(other.getUnknownFields());
return this;
}
return true;
}
- public Builder mergeFrom(com.google.protobuf.CodedInputStream input,
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
- org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound parsedMessage =
- null;
+ org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
- parsedMessage =
- (org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages.PrimaryNotFound) e
- .getUnfinishedMessage();
+ parsedMessage = (org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages.PrimaryNotFound) e.getUnfinishedMessage();
throw e;
} finally {
if (parsedMessage != null) {
// @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.PrimaryNotFound)
}
- private static com.google.protobuf.Descriptors.Descriptor internal_static_org_opendaylight_controller_mdsal_FindPrimary_descriptor;
- private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_org_opendaylight_controller_mdsal_FindPrimary_fieldAccessorTable;
- private static com.google.protobuf.Descriptors.Descriptor internal_static_org_opendaylight_controller_mdsal_PrimaryFound_descriptor;
- private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_org_opendaylight_controller_mdsal_PrimaryFound_fieldAccessorTable;
- private static com.google.protobuf.Descriptors.Descriptor internal_static_org_opendaylight_controller_mdsal_PrimaryNotFound_descriptor;
- private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_org_opendaylight_controller_mdsal_PrimaryNotFound_fieldAccessorTable;
-
- public static com.google.protobuf.Descriptors.FileDescriptor getDescriptor() {
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_org_opendaylight_controller_mdsal_FindPrimary_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_org_opendaylight_controller_mdsal_FindPrimary_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_org_opendaylight_controller_mdsal_PrimaryFound_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_org_opendaylight_controller_mdsal_PrimaryFound_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_org_opendaylight_controller_mdsal_PrimaryNotFound_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_org_opendaylight_controller_mdsal_PrimaryNotFound_fieldAccessorTable;
+
+ public static com.google.protobuf.Descriptors.FileDescriptor
+ getDescriptor() {
return descriptor;
}
-
- private static com.google.protobuf.Descriptors.FileDescriptor descriptor;
+ private static com.google.protobuf.Descriptors.FileDescriptor
+ descriptor;
static {
- java.lang.String[] descriptorData =
- {"\n\022ShardManager.proto\022!org.opendaylight.c"
- + "ontroller.mdsal\" \n\013FindPrimary\022\021\n\tshardN"
- + "ame\030\001 \002(\t\"\016\n\014PrimaryFound\"\021\n\017PrimaryNotF"
- + "oundBK\n3org.opendaylight.controller.clus"
- + "ter.datastore.shardB\024ShardManagerMessage" + "s"};
+ java.lang.String[] descriptorData = {
+ "\n\022ShardManager.proto\022!org.opendaylight.c" +
+ "ontroller.mdsal\" \n\013FindPrimary\022\021\n\tshardN" +
+ "ame\030\001 \002(\t\"\016\n\014PrimaryFound\"\021\n\017PrimaryNotF" +
+ "oundBL\n4org.opendaylight.controller.prot" +
+ "obuff.messages.shardB\024ShardManagerMessag" +
+ "es"
+ };
com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
- new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
- public com.google.protobuf.ExtensionRegistry assignDescriptors(
- com.google.protobuf.Descriptors.FileDescriptor root) {
- descriptor = root;
- internal_static_org_opendaylight_controller_mdsal_FindPrimary_descriptor =
- getDescriptor().getMessageTypes().get(0);
- internal_static_org_opendaylight_controller_mdsal_FindPrimary_fieldAccessorTable =
- new com.google.protobuf.GeneratedMessage.FieldAccessorTable(
- internal_static_org_opendaylight_controller_mdsal_FindPrimary_descriptor,
- new java.lang.String[] {"ShardName",});
- internal_static_org_opendaylight_controller_mdsal_PrimaryFound_descriptor =
- getDescriptor().getMessageTypes().get(1);
- internal_static_org_opendaylight_controller_mdsal_PrimaryFound_fieldAccessorTable =
- new com.google.protobuf.GeneratedMessage.FieldAccessorTable(
- internal_static_org_opendaylight_controller_mdsal_PrimaryFound_descriptor,
- new java.lang.String[] {});
- internal_static_org_opendaylight_controller_mdsal_PrimaryNotFound_descriptor =
- getDescriptor().getMessageTypes().get(2);
- internal_static_org_opendaylight_controller_mdsal_PrimaryNotFound_fieldAccessorTable =
- new com.google.protobuf.GeneratedMessage.FieldAccessorTable(
- internal_static_org_opendaylight_controller_mdsal_PrimaryNotFound_descriptor,
- new java.lang.String[] {});
- return null;
- }
- };
+ new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
+ public com.google.protobuf.ExtensionRegistry assignDescriptors(
+ com.google.protobuf.Descriptors.FileDescriptor root) {
+ descriptor = root;
+ internal_static_org_opendaylight_controller_mdsal_FindPrimary_descriptor =
+ getDescriptor().getMessageTypes().get(0);
+ internal_static_org_opendaylight_controller_mdsal_FindPrimary_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_org_opendaylight_controller_mdsal_FindPrimary_descriptor,
+ new java.lang.String[] { "ShardName", });
+ internal_static_org_opendaylight_controller_mdsal_PrimaryFound_descriptor =
+ getDescriptor().getMessageTypes().get(1);
+ internal_static_org_opendaylight_controller_mdsal_PrimaryFound_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_org_opendaylight_controller_mdsal_PrimaryFound_descriptor,
+ new java.lang.String[] { });
+ internal_static_org_opendaylight_controller_mdsal_PrimaryNotFound_descriptor =
+ getDescriptor().getMessageTypes().get(2);
+ internal_static_org_opendaylight_controller_mdsal_PrimaryNotFound_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_org_opendaylight_controller_mdsal_PrimaryNotFound_descriptor,
+ new java.lang.String[] { });
+ return null;
+ }
+ };
com.google.protobuf.Descriptors.FileDescriptor
- .internalBuildGeneratedFileFrom(descriptorData,
- new com.google.protobuf.Descriptors.FileDescriptor[]{}, assigner);
+ .internalBuildGeneratedFileFrom(descriptorData,
+ new com.google.protobuf.Descriptors.FileDescriptor[] {
+ }, assigner);
}
// @@protoc_insertion_point(outer_class_scope)
--- /dev/null
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: ShardTransactionChain.proto
+
+package org.opendaylight.controller.protobuff.messages.transaction;
+
+public final class ShardTransactionChainMessages {
+ private ShardTransactionChainMessages() {}
+ public static void registerAllExtensions(
+ com.google.protobuf.ExtensionRegistry registry) {
+ }
+ public interface CloseTransactionChainOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+ }
+ /**
+ * Protobuf type {@code org.opendaylight.controller.mdsal.CloseTransactionChain}
+ */
+ public static final class CloseTransactionChain extends
+ com.google.protobuf.GeneratedMessage
+ implements CloseTransactionChainOrBuilder {
+ // Use CloseTransactionChain.newBuilder() to construct.
+ private CloseTransactionChain(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private CloseTransactionChain(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final CloseTransactionChain defaultInstance;
+ public static CloseTransactionChain getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public CloseTransactionChain getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private CloseTransactionChain(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionChain_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionChain_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<CloseTransactionChain> PARSER =
+ new com.google.protobuf.AbstractParser<CloseTransactionChain>() {
+ public CloseTransactionChain parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new CloseTransactionChain(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<CloseTransactionChain> getParserForType() {
+ return PARSER;
+ }
+
+ private void initFields() {
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code org.opendaylight.controller.mdsal.CloseTransactionChain}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionChain_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionChain_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain.Builder.class);
+ }
+
+ // Construct using org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionChain_descriptor;
+ }
+
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain getDefaultInstanceForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain.getDefaultInstance();
+ }
+
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain build() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain buildPartial() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain result = new org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain(this);
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain) {
+ return mergeFrom((org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain other) {
+ if (other == org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain.getDefaultInstance()) return this;
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChain) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:org.opendaylight.controller.mdsal.CloseTransactionChain)
+ }
+
+ static {
+ defaultInstance = new CloseTransactionChain(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.CloseTransactionChain)
+ }
+
+ public interface CloseTransactionChainReplyOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+ }
+ /**
+ * Protobuf type {@code org.opendaylight.controller.mdsal.CloseTransactionChainReply}
+ */
+ public static final class CloseTransactionChainReply extends
+ com.google.protobuf.GeneratedMessage
+ implements CloseTransactionChainReplyOrBuilder {
+ // Use CloseTransactionChainReply.newBuilder() to construct.
+ private CloseTransactionChainReply(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private CloseTransactionChainReply(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final CloseTransactionChainReply defaultInstance;
+ public static CloseTransactionChainReply getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public CloseTransactionChainReply getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private CloseTransactionChainReply(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionChainReply_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionChainReply_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<CloseTransactionChainReply> PARSER =
+ new com.google.protobuf.AbstractParser<CloseTransactionChainReply>() {
+ public CloseTransactionChainReply parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new CloseTransactionChainReply(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<CloseTransactionChainReply> getParserForType() {
+ return PARSER;
+ }
+
+ private void initFields() {
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code org.opendaylight.controller.mdsal.CloseTransactionChainReply}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReplyOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionChainReply_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionChainReply_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply.Builder.class);
+ }
+
+ // Construct using org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionChainReply_descriptor;
+ }
+
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply getDefaultInstanceForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply.getDefaultInstance();
+ }
+
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply build() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply buildPartial() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply result = new org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply(this);
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply) {
+ return mergeFrom((org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply other) {
+ if (other == org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply.getDefaultInstance()) return this;
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CloseTransactionChainReply) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:org.opendaylight.controller.mdsal.CloseTransactionChainReply)
+ }
+
+ static {
+ defaultInstance = new CloseTransactionChainReply(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.CloseTransactionChainReply)
+ }
+
+ public interface CreateTransactionChainOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+ }
+ /**
+ * Protobuf type {@code org.opendaylight.controller.mdsal.CreateTransactionChain}
+ */
+ public static final class CreateTransactionChain extends
+ com.google.protobuf.GeneratedMessage
+ implements CreateTransactionChainOrBuilder {
+ // Use CreateTransactionChain.newBuilder() to construct.
+ private CreateTransactionChain(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private CreateTransactionChain(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final CreateTransactionChain defaultInstance;
+ public static CreateTransactionChain getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public CreateTransactionChain getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private CreateTransactionChain(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionChain_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionChain_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<CreateTransactionChain> PARSER =
+ new com.google.protobuf.AbstractParser<CreateTransactionChain>() {
+ public CreateTransactionChain parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new CreateTransactionChain(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<CreateTransactionChain> getParserForType() {
+ return PARSER;
+ }
+
+ private void initFields() {
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code org.opendaylight.controller.mdsal.CreateTransactionChain}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionChain_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionChain_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain.Builder.class);
+ }
+
+ // Construct using org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionChain_descriptor;
+ }
+
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain getDefaultInstanceForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain.getDefaultInstance();
+ }
+
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain build() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain buildPartial() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain result = new org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain(this);
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain) {
+ return mergeFrom((org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain other) {
+ if (other == org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain.getDefaultInstance()) return this;
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChain) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:org.opendaylight.controller.mdsal.CreateTransactionChain)
+ }
+
+ static {
+ defaultInstance = new CreateTransactionChain(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.CreateTransactionChain)
+ }
+
+ public interface CreateTransactionChainReplyOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
+
+ // required string transactionChainPath = 1;
+ /**
+ * <code>required string transactionChainPath = 1;</code>
+ */
+ boolean hasTransactionChainPath();
+ /**
+ * <code>required string transactionChainPath = 1;</code>
+ */
+ java.lang.String getTransactionChainPath();
+ /**
+ * <code>required string transactionChainPath = 1;</code>
+ */
+ com.google.protobuf.ByteString
+ getTransactionChainPathBytes();
+ }
+ /**
+ * Protobuf type {@code org.opendaylight.controller.mdsal.CreateTransactionChainReply}
+ */
+ public static final class CreateTransactionChainReply extends
+ com.google.protobuf.GeneratedMessage
+ implements CreateTransactionChainReplyOrBuilder {
+ // Use CreateTransactionChainReply.newBuilder() to construct.
+ private CreateTransactionChainReply(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ super(builder);
+ this.unknownFields = builder.getUnknownFields();
+ }
+ private CreateTransactionChainReply(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
+
+ private static final CreateTransactionChainReply defaultInstance;
+ public static CreateTransactionChainReply getDefaultInstance() {
+ return defaultInstance;
+ }
+
+ public CreateTransactionChainReply getDefaultInstanceForType() {
+ return defaultInstance;
+ }
+
+ private final com.google.protobuf.UnknownFieldSet unknownFields;
+ @java.lang.Override
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
+ return this.unknownFields;
+ }
+ private CreateTransactionChainReply(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ initFields();
+ int mutable_bitField0_ = 0;
+ com.google.protobuf.UnknownFieldSet.Builder unknownFields =
+ com.google.protobuf.UnknownFieldSet.newBuilder();
+ try {
+ boolean done = false;
+ while (!done) {
+ int tag = input.readTag();
+ switch (tag) {
+ case 0:
+ done = true;
+ break;
+ default: {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
+ done = true;
+ }
+ break;
+ }
+ case 10: {
+ bitField0_ |= 0x00000001;
+ transactionChainPath_ = input.readBytes();
+ break;
+ }
+ }
+ }
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ throw e.setUnfinishedMessage(this);
+ } catch (java.io.IOException e) {
+ throw new com.google.protobuf.InvalidProtocolBufferException(
+ e.getMessage()).setUnfinishedMessage(this);
+ } finally {
+ this.unknownFields = unknownFields.build();
+ makeExtensionsImmutable();
+ }
+ }
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionChainReply_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionChainReply_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply.Builder.class);
+ }
+
+ public static com.google.protobuf.Parser<CreateTransactionChainReply> PARSER =
+ new com.google.protobuf.AbstractParser<CreateTransactionChainReply>() {
+ public CreateTransactionChainReply parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new CreateTransactionChainReply(input, extensionRegistry);
+ }
+ };
+
+ @java.lang.Override
+ public com.google.protobuf.Parser<CreateTransactionChainReply> getParserForType() {
+ return PARSER;
+ }
+
+ private int bitField0_;
+ // required string transactionChainPath = 1;
+ public static final int TRANSACTIONCHAINPATH_FIELD_NUMBER = 1;
+ private java.lang.Object transactionChainPath_;
+ /**
+ * <code>required string transactionChainPath = 1;</code>
+ */
+ public boolean hasTransactionChainPath() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>required string transactionChainPath = 1;</code>
+ */
+ public java.lang.String getTransactionChainPath() {
+ java.lang.Object ref = transactionChainPath_;
+ if (ref instanceof java.lang.String) {
+ return (java.lang.String) ref;
+ } else {
+ com.google.protobuf.ByteString bs =
+ (com.google.protobuf.ByteString) ref;
+ java.lang.String s = bs.toStringUtf8();
+ if (bs.isValidUtf8()) {
+ transactionChainPath_ = s;
+ }
+ return s;
+ }
+ }
+ /**
+ * <code>required string transactionChainPath = 1;</code>
+ */
+ public com.google.protobuf.ByteString
+ getTransactionChainPathBytes() {
+ java.lang.Object ref = transactionChainPath_;
+ if (ref instanceof java.lang.String) {
+ com.google.protobuf.ByteString b =
+ com.google.protobuf.ByteString.copyFromUtf8(
+ (java.lang.String) ref);
+ transactionChainPath_ = b;
+ return b;
+ } else {
+ return (com.google.protobuf.ByteString) ref;
+ }
+ }
+
+ private void initFields() {
+ transactionChainPath_ = "";
+ }
+ private byte memoizedIsInitialized = -1;
+ public final boolean isInitialized() {
+ byte isInitialized = memoizedIsInitialized;
+ if (isInitialized != -1) return isInitialized == 1;
+
+ if (!hasTransactionChainPath()) {
+ memoizedIsInitialized = 0;
+ return false;
+ }
+ memoizedIsInitialized = 1;
+ return true;
+ }
+
+ public void writeTo(com.google.protobuf.CodedOutputStream output)
+ throws java.io.IOException {
+ getSerializedSize();
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ output.writeBytes(1, getTransactionChainPathBytes());
+ }
+ getUnknownFields().writeTo(output);
+ }
+
+ private int memoizedSerializedSize = -1;
+ public int getSerializedSize() {
+ int size = memoizedSerializedSize;
+ if (size != -1) return size;
+
+ size = 0;
+ if (((bitField0_ & 0x00000001) == 0x00000001)) {
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(1, getTransactionChainPathBytes());
+ }
+ size += getUnknownFields().getSerializedSize();
+ memoizedSerializedSize = size;
+ return size;
+ }
+
+ private static final long serialVersionUID = 0L;
+ @java.lang.Override
+ protected java.lang.Object writeReplace()
+ throws java.io.ObjectStreamException {
+ return super.writeReplace();
+ }
+
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply parseFrom(
+ com.google.protobuf.ByteString data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply parseFrom(
+ com.google.protobuf.ByteString data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return PARSER.parseFrom(data, extensionRegistry);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply parseFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply parseDelimitedFrom(
+ java.io.InputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseDelimitedFrom(input, extensionRegistry);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input);
+ }
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply parseFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ return PARSER.parseFrom(input, extensionRegistry);
+ }
+
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply prototype) {
+ return newBuilder().mergeFrom(prototype);
+ }
+ public Builder toBuilder() { return newBuilder(this); }
+
+ @java.lang.Override
+ protected Builder newBuilderForType(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ Builder builder = new Builder(parent);
+ return builder;
+ }
+ /**
+ * Protobuf type {@code org.opendaylight.controller.mdsal.CreateTransactionChainReply}
+ */
+ public static final class Builder extends
+ com.google.protobuf.GeneratedMessage.Builder<Builder>
+ implements org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReplyOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionChainReply_descriptor;
+ }
+
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionChainReply_fieldAccessorTable
+ .ensureFieldAccessorsInitialized(
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply.Builder.class);
+ }
+
+ // Construct using org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply.newBuilder()
+ private Builder() {
+ maybeForceBuilderInitialization();
+ }
+
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ super(parent);
+ maybeForceBuilderInitialization();
+ }
+ private void maybeForceBuilderInitialization() {
+ if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
+ }
+ }
+ private static Builder create() {
+ return new Builder();
+ }
+
+ public Builder clear() {
+ super.clear();
+ transactionChainPath_ = "";
+ bitField0_ = (bitField0_ & ~0x00000001);
+ return this;
+ }
+
+ public Builder clone() {
+ return create().mergeFrom(buildPartial());
+ }
+
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionChainReply_descriptor;
+ }
+
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply getDefaultInstanceForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply.getDefaultInstance();
+ }
+
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply build() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply result = buildPartial();
+ if (!result.isInitialized()) {
+ throw newUninitializedMessageException(result);
+ }
+ return result;
+ }
+
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply buildPartial() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply result = new org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply(this);
+ int from_bitField0_ = bitField0_;
+ int to_bitField0_ = 0;
+ if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
+ to_bitField0_ |= 0x00000001;
+ }
+ result.transactionChainPath_ = transactionChainPath_;
+ result.bitField0_ = to_bitField0_;
+ onBuilt();
+ return result;
+ }
+
+ public Builder mergeFrom(com.google.protobuf.Message other) {
+ if (other instanceof org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply) {
+ return mergeFrom((org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply)other);
+ } else {
+ super.mergeFrom(other);
+ return this;
+ }
+ }
+
+ public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply other) {
+ if (other == org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply.getDefaultInstance()) return this;
+ if (other.hasTransactionChainPath()) {
+ bitField0_ |= 0x00000001;
+ transactionChainPath_ = other.transactionChainPath_;
+ onChanged();
+ }
+ this.mergeUnknownFields(other.getUnknownFields());
+ return this;
+ }
+
+ public final boolean isInitialized() {
+ if (!hasTransactionChainPath()) {
+
+ return false;
+ }
+ return true;
+ }
+
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws java.io.IOException {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply parsedMessage = null;
+ try {
+ parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
+ } catch (com.google.protobuf.InvalidProtocolBufferException e) {
+ parsedMessage = (org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionChainMessages.CreateTransactionChainReply) e.getUnfinishedMessage();
+ throw e;
+ } finally {
+ if (parsedMessage != null) {
+ mergeFrom(parsedMessage);
+ }
+ }
+ return this;
+ }
+ private int bitField0_;
+
+ // required string transactionChainPath = 1;
+ private java.lang.Object transactionChainPath_ = "";
+ /**
+ * <code>required string transactionChainPath = 1;</code>
+ */
+ public boolean hasTransactionChainPath() {
+ return ((bitField0_ & 0x00000001) == 0x00000001);
+ }
+ /**
+ * <code>required string transactionChainPath = 1;</code>
+ */
+ public java.lang.String getTransactionChainPath() {
+ java.lang.Object ref = transactionChainPath_;
+ if (!(ref instanceof java.lang.String)) {
+ java.lang.String s = ((com.google.protobuf.ByteString) ref)
+ .toStringUtf8();
+ transactionChainPath_ = s;
+ return s;
+ } else {
+ return (java.lang.String) ref;
+ }
+ }
+ /**
+ * <code>required string transactionChainPath = 1;</code>
+ */
+ public com.google.protobuf.ByteString
+ getTransactionChainPathBytes() {
+ java.lang.Object ref = transactionChainPath_;
+ if (ref instanceof String) {
+ com.google.protobuf.ByteString b =
+ com.google.protobuf.ByteString.copyFromUtf8(
+ (java.lang.String) ref);
+ transactionChainPath_ = b;
+ return b;
+ } else {
+ return (com.google.protobuf.ByteString) ref;
+ }
+ }
+ /**
+ * <code>required string transactionChainPath = 1;</code>
+ */
+ public Builder setTransactionChainPath(
+ java.lang.String value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000001;
+ transactionChainPath_ = value;
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>required string transactionChainPath = 1;</code>
+ */
+ public Builder clearTransactionChainPath() {
+ bitField0_ = (bitField0_ & ~0x00000001);
+ transactionChainPath_ = getDefaultInstance().getTransactionChainPath();
+ onChanged();
+ return this;
+ }
+ /**
+ * <code>required string transactionChainPath = 1;</code>
+ */
+ public Builder setTransactionChainPathBytes(
+ com.google.protobuf.ByteString value) {
+ if (value == null) {
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000001;
+ transactionChainPath_ = value;
+ onChanged();
+ return this;
+ }
+
+ // @@protoc_insertion_point(builder_scope:org.opendaylight.controller.mdsal.CreateTransactionChainReply)
+ }
+
+ static {
+ defaultInstance = new CreateTransactionChainReply(true);
+ defaultInstance.initFields();
+ }
+
+ // @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.CreateTransactionChainReply)
+ }
+
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_org_opendaylight_controller_mdsal_CloseTransactionChain_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_org_opendaylight_controller_mdsal_CloseTransactionChain_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_org_opendaylight_controller_mdsal_CloseTransactionChainReply_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_org_opendaylight_controller_mdsal_CloseTransactionChainReply_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_org_opendaylight_controller_mdsal_CreateTransactionChain_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_org_opendaylight_controller_mdsal_CreateTransactionChain_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_org_opendaylight_controller_mdsal_CreateTransactionChainReply_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_org_opendaylight_controller_mdsal_CreateTransactionChainReply_fieldAccessorTable;
+
+ public static com.google.protobuf.Descriptors.FileDescriptor
+ getDescriptor() {
+ return descriptor;
+ }
+ private static com.google.protobuf.Descriptors.FileDescriptor
+ descriptor;
+ static {
+ java.lang.String[] descriptorData = {
+ "\n\033ShardTransactionChain.proto\022!org.opend" +
+ "aylight.controller.mdsal\"\027\n\025CloseTransac" +
+ "tionChain\"\034\n\032CloseTransactionChainReply\"" +
+ "\030\n\026CreateTransactionChain\";\n\033CreateTrans" +
+ "actionChainReply\022\034\n\024transactionChainPath" +
+ "\030\001 \002(\tB[\n:org.opendaylight.controller.pr" +
+ "otobuff.messages.transactionB\035ShardTrans" +
+ "actionChainMessages"
+ };
+ com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
+ new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
+ public com.google.protobuf.ExtensionRegistry assignDescriptors(
+ com.google.protobuf.Descriptors.FileDescriptor root) {
+ descriptor = root;
+ internal_static_org_opendaylight_controller_mdsal_CloseTransactionChain_descriptor =
+ getDescriptor().getMessageTypes().get(0);
+ internal_static_org_opendaylight_controller_mdsal_CloseTransactionChain_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_org_opendaylight_controller_mdsal_CloseTransactionChain_descriptor,
+ new java.lang.String[] { });
+ internal_static_org_opendaylight_controller_mdsal_CloseTransactionChainReply_descriptor =
+ getDescriptor().getMessageTypes().get(1);
+ internal_static_org_opendaylight_controller_mdsal_CloseTransactionChainReply_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_org_opendaylight_controller_mdsal_CloseTransactionChainReply_descriptor,
+ new java.lang.String[] { });
+ internal_static_org_opendaylight_controller_mdsal_CreateTransactionChain_descriptor =
+ getDescriptor().getMessageTypes().get(2);
+ internal_static_org_opendaylight_controller_mdsal_CreateTransactionChain_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_org_opendaylight_controller_mdsal_CreateTransactionChain_descriptor,
+ new java.lang.String[] { });
+ internal_static_org_opendaylight_controller_mdsal_CreateTransactionChainReply_descriptor =
+ getDescriptor().getMessageTypes().get(3);
+ internal_static_org_opendaylight_controller_mdsal_CreateTransactionChainReply_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_org_opendaylight_controller_mdsal_CreateTransactionChainReply_descriptor,
+ new java.lang.String[] { "TransactionChainPath", });
+ return null;
+ }
+ };
+ com.google.protobuf.Descriptors.FileDescriptor
+ .internalBuildGeneratedFileFrom(descriptorData,
+ new com.google.protobuf.Descriptors.FileDescriptor[] {
+ }, assigner);
+ }
+
+ // @@protoc_insertion_point(outer_class_scope)
+}
-// Generated by the protocol buffer compiler. DO NOT EDIT!
+// Generated by the protocol buffer compiler. DO NOT EDIT!
// source: ShardTransaction.proto
-package org.opendaylight.controller.cluster.datastore.transaction;
+package org.opendaylight.controller.protobuff.messages.transaction;
public final class ShardTransactionMessages {
private ShardTransactionMessages() {}
-
public static void registerAllExtensions(
- com.google.protobuf.ExtensionRegistry registry) {}
-
- public interface CloseTransactionOrBuilder extends
- com.google.protobuf.MessageOrBuilder {
+ com.google.protobuf.ExtensionRegistry registry) {
+ }
+ public interface CloseTransactionOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
}
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.CloseTransaction}
*/
public static final class CloseTransaction extends
- com.google.protobuf.GeneratedMessage implements CloseTransactionOrBuilder {
+ com.google.protobuf.GeneratedMessage
+ implements CloseTransactionOrBuilder {
// Use CloseTransaction.newBuilder() to construct.
- private CloseTransaction(
- com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ private CloseTransaction(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
super(builder);
this.unknownFields = builder.getUnknownFields();
}
-
- private CloseTransaction(boolean noInit) {
- this.unknownFields =
- com.google.protobuf.UnknownFieldSet.getDefaultInstance();
- }
+ private CloseTransaction(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
private static final CloseTransaction defaultInstance;
-
public static CloseTransaction getDefaultInstance() {
return defaultInstance;
}
}
private final com.google.protobuf.UnknownFieldSet unknownFields;
-
@java.lang.Override
- public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
return this.unknownFields;
}
-
- private CloseTransaction(com.google.protobuf.CodedInputStream input,
+ private CloseTransaction(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
initFields();
done = true;
break;
default: {
- if (!parseUnknownField(input, unknownFields, extensionRegistry,
- tag)) {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
done = true;
}
break;
makeExtensionsImmutable();
}
}
-
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransaction_descriptor;
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransaction_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransaction_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransaction_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction.Builder.class);
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction.Builder.class);
}
public static com.google.protobuf.Parser<CloseTransaction> PARSER =
new com.google.protobuf.AbstractParser<CloseTransaction>() {
- public CloseTransaction parsePartialFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return new CloseTransaction(input, extensionRegistry);
- }
- };
+ public CloseTransaction parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new CloseTransaction(input, extensionRegistry);
+ }
+ };
@java.lang.Override
public com.google.protobuf.Parser<CloseTransaction> getParserForType() {
return PARSER;
}
- private void initFields() {}
-
+ private void initFields() {
+ }
private byte memoizedIsInitialized = -1;
-
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
- if (isInitialized != -1)
- return isInitialized == 1;
+ if (isInitialized != -1) return isInitialized == 1;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
- throws java.io.IOException {
+ throws java.io.IOException {
getSerializedSize();
getUnknownFields().writeTo(output);
}
private int memoizedSerializedSize = -1;
-
public int getSerializedSize() {
int size = memoizedSerializedSize;
- if (size != -1)
- return size;
+ if (size != -1) return size;
size = 0;
size += getUnknownFields().getSerializedSize();
}
private static final long serialVersionUID = 0L;
-
@java.lang.Override
protected java.lang.Object writeReplace()
throws java.io.ObjectStreamException {
return super.writeReplace();
}
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction parseFrom(
- byte[] data) throws com.google.protobuf.InvalidProtocolBufferException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction parseFrom(
- byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction parseFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction parseDelimitedFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseDelimitedFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction parseDelimitedFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseDelimitedFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction parseFrom(
- com.google.protobuf.CodedInputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
- public static Builder newBuilder() {
- return Builder.create();
- }
-
- public Builder newBuilderForType() {
- return newBuilder();
- }
-
- public static Builder newBuilder(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction prototype) {
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction prototype) {
return newBuilder().mergeFrom(prototype);
}
-
- public Builder toBuilder() {
- return newBuilder(this);
- }
+ public Builder toBuilder() { return newBuilder(this); }
@java.lang.Override
protected Builder newBuilderForType(
Builder builder = new Builder(parent);
return builder;
}
-
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.CloseTransaction}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessage.Builder<Builder>
- implements
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionOrBuilder {
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransaction_descriptor;
+ implements org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransaction_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransaction_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransaction_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction.Builder.class);
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction.Builder.class);
}
- // Construct using
- // org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction.newBuilder()
+ // Construct using org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
- private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
-
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
}
}
-
private static Builder create() {
return new Builder();
}
return create().mergeFrom(buildPartial());
}
- public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransaction_descriptor;
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransaction_descriptor;
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction getDefaultInstanceForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction
- .getDefaultInstance();
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction getDefaultInstanceForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction.getDefaultInstance();
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction build() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction result =
- buildPartial();
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction build() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction buildPartial() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction result =
- new org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction(
- this);
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction buildPartial() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction result = new org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction(this);
onBuilt();
return result;
}
public Builder mergeFrom(com.google.protobuf.Message other) {
- if (other instanceof org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction) {
- return mergeFrom((org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction) other);
+ if (other instanceof org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction) {
+ return mergeFrom((org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction)other);
} else {
super.mergeFrom(other);
return this;
}
}
- public Builder mergeFrom(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction other) {
- if (other == org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction
- .getDefaultInstance())
- return this;
+ public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction other) {
+ if (other == org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction.getDefaultInstance()) return this;
this.mergeUnknownFields(other.getUnknownFields());
return this;
}
return true;
}
- public Builder mergeFrom(com.google.protobuf.CodedInputStream input,
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction parsedMessage =
- null;
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
- parsedMessage =
- (org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransaction) e
- .getUnfinishedMessage();
+ parsedMessage = (org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransaction) e.getUnfinishedMessage();
throw e;
} finally {
if (parsedMessage != null) {
// @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.CloseTransaction)
}
- public interface CloseTransactionReplyOrBuilder extends
- com.google.protobuf.MessageOrBuilder {
+ public interface CloseTransactionReplyOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
}
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.CloseTransactionReply}
*/
public static final class CloseTransactionReply extends
- com.google.protobuf.GeneratedMessage implements
- CloseTransactionReplyOrBuilder {
+ com.google.protobuf.GeneratedMessage
+ implements CloseTransactionReplyOrBuilder {
// Use CloseTransactionReply.newBuilder() to construct.
- private CloseTransactionReply(
- com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ private CloseTransactionReply(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
super(builder);
this.unknownFields = builder.getUnknownFields();
}
-
- private CloseTransactionReply(boolean noInit) {
- this.unknownFields =
- com.google.protobuf.UnknownFieldSet.getDefaultInstance();
- }
+ private CloseTransactionReply(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
private static final CloseTransactionReply defaultInstance;
-
public static CloseTransactionReply getDefaultInstance() {
return defaultInstance;
}
}
private final com.google.protobuf.UnknownFieldSet unknownFields;
-
@java.lang.Override
- public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
return this.unknownFields;
}
-
- private CloseTransactionReply(com.google.protobuf.CodedInputStream input,
+ private CloseTransactionReply(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
initFields();
done = true;
break;
default: {
- if (!parseUnknownField(input, unknownFields, extensionRegistry,
- tag)) {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
done = true;
}
break;
makeExtensionsImmutable();
}
}
-
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionReply_descriptor;
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionReply_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionReply_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionReply_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply.Builder.class);
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply.Builder.class);
}
public static com.google.protobuf.Parser<CloseTransactionReply> PARSER =
new com.google.protobuf.AbstractParser<CloseTransactionReply>() {
- public CloseTransactionReply parsePartialFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return new CloseTransactionReply(input, extensionRegistry);
- }
- };
+ public CloseTransactionReply parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new CloseTransactionReply(input, extensionRegistry);
+ }
+ };
@java.lang.Override
public com.google.protobuf.Parser<CloseTransactionReply> getParserForType() {
return PARSER;
}
- private void initFields() {}
-
+ private void initFields() {
+ }
private byte memoizedIsInitialized = -1;
-
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
- if (isInitialized != -1)
- return isInitialized == 1;
+ if (isInitialized != -1) return isInitialized == 1;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
- throws java.io.IOException {
+ throws java.io.IOException {
getSerializedSize();
getUnknownFields().writeTo(output);
}
private int memoizedSerializedSize = -1;
-
public int getSerializedSize() {
int size = memoizedSerializedSize;
- if (size != -1)
- return size;
+ if (size != -1) return size;
size = 0;
size += getUnknownFields().getSerializedSize();
}
private static final long serialVersionUID = 0L;
-
@java.lang.Override
protected java.lang.Object writeReplace()
throws java.io.ObjectStreamException {
return super.writeReplace();
}
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply parseFrom(
- byte[] data) throws com.google.protobuf.InvalidProtocolBufferException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply parseFrom(
- byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply parseFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply parseDelimitedFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseDelimitedFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply parseDelimitedFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseDelimitedFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply parseFrom(
- com.google.protobuf.CodedInputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
- public static Builder newBuilder() {
- return Builder.create();
- }
-
- public Builder newBuilderForType() {
- return newBuilder();
- }
-
- public static Builder newBuilder(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply prototype) {
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply prototype) {
return newBuilder().mergeFrom(prototype);
}
-
- public Builder toBuilder() {
- return newBuilder(this);
- }
+ public Builder toBuilder() { return newBuilder(this); }
@java.lang.Override
protected Builder newBuilderForType(
Builder builder = new Builder(parent);
return builder;
}
-
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.CloseTransactionReply}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessage.Builder<Builder>
- implements
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReplyOrBuilder {
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionReply_descriptor;
+ implements org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReplyOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionReply_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionReply_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionReply_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply.Builder.class);
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply.Builder.class);
}
- // Construct using
- // org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply.newBuilder()
+ // Construct using org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
- private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
-
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
}
}
-
private static Builder create() {
return new Builder();
}
return create().mergeFrom(buildPartial());
}
- public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionReply_descriptor;
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CloseTransactionReply_descriptor;
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply getDefaultInstanceForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply
- .getDefaultInstance();
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply getDefaultInstanceForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply.getDefaultInstance();
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply build() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply result =
- buildPartial();
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply build() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply buildPartial() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply result =
- new org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply(
- this);
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply buildPartial() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply result = new org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply(this);
onBuilt();
return result;
}
public Builder mergeFrom(com.google.protobuf.Message other) {
- if (other instanceof org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply) {
- return mergeFrom((org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply) other);
+ if (other instanceof org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply) {
+ return mergeFrom((org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply)other);
} else {
super.mergeFrom(other);
return this;
}
}
- public Builder mergeFrom(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply other) {
- if (other == org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply
- .getDefaultInstance())
- return this;
+ public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply other) {
+ if (other == org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply.getDefaultInstance()) return this;
this.mergeUnknownFields(other.getUnknownFields());
return this;
}
return true;
}
- public Builder mergeFrom(com.google.protobuf.CodedInputStream input,
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply parsedMessage =
- null;
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
- parsedMessage =
- (org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CloseTransactionReply) e
- .getUnfinishedMessage();
+ parsedMessage = (org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CloseTransactionReply) e.getUnfinishedMessage();
throw e;
} finally {
if (parsedMessage != null) {
// @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.CloseTransactionReply)
}
- public interface CreateTransactionOrBuilder extends
- com.google.protobuf.MessageOrBuilder {
+ public interface CreateTransactionOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
}
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.CreateTransaction}
*/
public static final class CreateTransaction extends
- com.google.protobuf.GeneratedMessage implements
- CreateTransactionOrBuilder {
+ com.google.protobuf.GeneratedMessage
+ implements CreateTransactionOrBuilder {
// Use CreateTransaction.newBuilder() to construct.
- private CreateTransaction(
- com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ private CreateTransaction(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
super(builder);
this.unknownFields = builder.getUnknownFields();
}
-
- private CreateTransaction(boolean noInit) {
- this.unknownFields =
- com.google.protobuf.UnknownFieldSet.getDefaultInstance();
- }
+ private CreateTransaction(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
private static final CreateTransaction defaultInstance;
-
public static CreateTransaction getDefaultInstance() {
return defaultInstance;
}
}
private final com.google.protobuf.UnknownFieldSet unknownFields;
-
@java.lang.Override
- public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
return this.unknownFields;
}
-
- private CreateTransaction(com.google.protobuf.CodedInputStream input,
+ private CreateTransaction(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
initFields();
done = true;
break;
default: {
- if (!parseUnknownField(input, unknownFields, extensionRegistry,
- tag)) {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
done = true;
}
break;
makeExtensionsImmutable();
}
}
-
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransaction_descriptor;
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransaction_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransaction_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransaction_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction.Builder.class);
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction.Builder.class);
}
public static com.google.protobuf.Parser<CreateTransaction> PARSER =
new com.google.protobuf.AbstractParser<CreateTransaction>() {
- public CreateTransaction parsePartialFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return new CreateTransaction(input, extensionRegistry);
- }
- };
+ public CreateTransaction parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new CreateTransaction(input, extensionRegistry);
+ }
+ };
@java.lang.Override
public com.google.protobuf.Parser<CreateTransaction> getParserForType() {
return PARSER;
}
- private void initFields() {}
-
+ private void initFields() {
+ }
private byte memoizedIsInitialized = -1;
-
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
- if (isInitialized != -1)
- return isInitialized == 1;
+ if (isInitialized != -1) return isInitialized == 1;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
- throws java.io.IOException {
+ throws java.io.IOException {
getSerializedSize();
getUnknownFields().writeTo(output);
}
private int memoizedSerializedSize = -1;
-
public int getSerializedSize() {
int size = memoizedSerializedSize;
- if (size != -1)
- return size;
+ if (size != -1) return size;
size = 0;
size += getUnknownFields().getSerializedSize();
}
private static final long serialVersionUID = 0L;
-
@java.lang.Override
protected java.lang.Object writeReplace()
throws java.io.ObjectStreamException {
return super.writeReplace();
}
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction parseFrom(
- byte[] data) throws com.google.protobuf.InvalidProtocolBufferException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction parseFrom(
- byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction parseFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction parseDelimitedFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseDelimitedFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction parseDelimitedFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseDelimitedFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction parseFrom(
- com.google.protobuf.CodedInputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
- public static Builder newBuilder() {
- return Builder.create();
- }
-
- public Builder newBuilderForType() {
- return newBuilder();
- }
-
- public static Builder newBuilder(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction prototype) {
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction prototype) {
return newBuilder().mergeFrom(prototype);
}
-
- public Builder toBuilder() {
- return newBuilder(this);
- }
+ public Builder toBuilder() { return newBuilder(this); }
@java.lang.Override
protected Builder newBuilderForType(
Builder builder = new Builder(parent);
return builder;
}
-
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.CreateTransaction}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessage.Builder<Builder>
- implements
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionOrBuilder {
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransaction_descriptor;
+ implements org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransaction_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransaction_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransaction_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction.Builder.class);
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction.Builder.class);
}
- // Construct using
- // org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction.newBuilder()
+ // Construct using org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
- private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
-
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
}
}
-
private static Builder create() {
return new Builder();
}
return create().mergeFrom(buildPartial());
}
- public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransaction_descriptor;
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransaction_descriptor;
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction getDefaultInstanceForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction
- .getDefaultInstance();
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction getDefaultInstanceForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction.getDefaultInstance();
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction build() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction result =
- buildPartial();
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction build() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction buildPartial() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction result =
- new org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction(
- this);
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction buildPartial() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction result = new org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction(this);
onBuilt();
return result;
}
public Builder mergeFrom(com.google.protobuf.Message other) {
- if (other instanceof org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction) {
- return mergeFrom((org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction) other);
+ if (other instanceof org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction) {
+ return mergeFrom((org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction)other);
} else {
super.mergeFrom(other);
return this;
}
}
- public Builder mergeFrom(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction other) {
- if (other == org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction
- .getDefaultInstance())
- return this;
+ public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction other) {
+ if (other == org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction.getDefaultInstance()) return this;
this.mergeUnknownFields(other.getUnknownFields());
return this;
}
return true;
}
- public Builder mergeFrom(com.google.protobuf.CodedInputStream input,
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction parsedMessage =
- null;
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
- parsedMessage =
- (org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransaction) e
- .getUnfinishedMessage();
+ parsedMessage = (org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransaction) e.getUnfinishedMessage();
throw e;
} finally {
if (parsedMessage != null) {
// @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.CreateTransaction)
}
- public interface CreateTransactionReplyOrBuilder extends
- com.google.protobuf.MessageOrBuilder {
+ public interface CreateTransactionReplyOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
// required string transactionPath = 1;
/**
* <code>required string transactionPath = 1;</code>
*/
boolean hasTransactionPath();
-
/**
* <code>required string transactionPath = 1;</code>
*/
java.lang.String getTransactionPath();
-
/**
* <code>required string transactionPath = 1;</code>
*/
- com.google.protobuf.ByteString getTransactionPathBytes();
+ com.google.protobuf.ByteString
+ getTransactionPathBytes();
}
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.CreateTransactionReply}
*/
public static final class CreateTransactionReply extends
- com.google.protobuf.GeneratedMessage implements
- CreateTransactionReplyOrBuilder {
+ com.google.protobuf.GeneratedMessage
+ implements CreateTransactionReplyOrBuilder {
// Use CreateTransactionReply.newBuilder() to construct.
- private CreateTransactionReply(
- com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ private CreateTransactionReply(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
super(builder);
this.unknownFields = builder.getUnknownFields();
}
-
- private CreateTransactionReply(boolean noInit) {
- this.unknownFields =
- com.google.protobuf.UnknownFieldSet.getDefaultInstance();
- }
+ private CreateTransactionReply(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
private static final CreateTransactionReply defaultInstance;
-
public static CreateTransactionReply getDefaultInstance() {
return defaultInstance;
}
}
private final com.google.protobuf.UnknownFieldSet unknownFields;
-
@java.lang.Override
- public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
return this.unknownFields;
}
-
- private CreateTransactionReply(com.google.protobuf.CodedInputStream input,
+ private CreateTransactionReply(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
initFields();
done = true;
break;
default: {
- if (!parseUnknownField(input, unknownFields, extensionRegistry,
- tag)) {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
done = true;
}
break;
makeExtensionsImmutable();
}
}
-
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionReply_descriptor;
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionReply_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionReply_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionReply_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply.Builder.class);
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply.Builder.class);
}
public static com.google.protobuf.Parser<CreateTransactionReply> PARSER =
new com.google.protobuf.AbstractParser<CreateTransactionReply>() {
- public CreateTransactionReply parsePartialFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return new CreateTransactionReply(input, extensionRegistry);
- }
- };
+ public CreateTransactionReply parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new CreateTransactionReply(input, extensionRegistry);
+ }
+ };
@java.lang.Override
public com.google.protobuf.Parser<CreateTransactionReply> getParserForType() {
// required string transactionPath = 1;
public static final int TRANSACTIONPATH_FIELD_NUMBER = 1;
private java.lang.Object transactionPath_;
-
/**
* <code>required string transactionPath = 1;</code>
*/
public boolean hasTransactionPath() {
return ((bitField0_ & 0x00000001) == 0x00000001);
}
-
/**
* <code>required string transactionPath = 1;</code>
*/
return s;
}
}
-
/**
* <code>required string transactionPath = 1;</code>
*/
- public com.google.protobuf.ByteString getTransactionPathBytes() {
+ public com.google.protobuf.ByteString
+ getTransactionPathBytes() {
java.lang.Object ref = transactionPath_;
if (ref instanceof java.lang.String) {
com.google.protobuf.ByteString b =
- com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
+ com.google.protobuf.ByteString.copyFromUtf8(
+ (java.lang.String) ref);
transactionPath_ = b;
return b;
} else {
private void initFields() {
transactionPath_ = "";
}
-
private byte memoizedIsInitialized = -1;
-
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
- if (isInitialized != -1)
- return isInitialized == 1;
+ if (isInitialized != -1) return isInitialized == 1;
if (!hasTransactionPath()) {
memoizedIsInitialized = 0;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
- throws java.io.IOException {
+ throws java.io.IOException {
getSerializedSize();
if (((bitField0_ & 0x00000001) == 0x00000001)) {
output.writeBytes(1, getTransactionPathBytes());
}
private int memoizedSerializedSize = -1;
-
public int getSerializedSize() {
int size = memoizedSerializedSize;
- if (size != -1)
- return size;
+ if (size != -1) return size;
size = 0;
if (((bitField0_ & 0x00000001) == 0x00000001)) {
- size +=
- com.google.protobuf.CodedOutputStream.computeBytesSize(1,
- getTransactionPathBytes());
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(1, getTransactionPathBytes());
}
size += getUnknownFields().getSerializedSize();
memoizedSerializedSize = size;
}
private static final long serialVersionUID = 0L;
-
@java.lang.Override
protected java.lang.Object writeReplace()
throws java.io.ObjectStreamException {
return super.writeReplace();
}
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply parseFrom(
- byte[] data) throws com.google.protobuf.InvalidProtocolBufferException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply parseFrom(
- byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply parseFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply parseDelimitedFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseDelimitedFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply parseDelimitedFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseDelimitedFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply parseFrom(
- com.google.protobuf.CodedInputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
- public static Builder newBuilder() {
- return Builder.create();
- }
-
- public Builder newBuilderForType() {
- return newBuilder();
- }
-
- public static Builder newBuilder(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply prototype) {
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply prototype) {
return newBuilder().mergeFrom(prototype);
}
-
- public Builder toBuilder() {
- return newBuilder(this);
- }
+ public Builder toBuilder() { return newBuilder(this); }
@java.lang.Override
protected Builder newBuilderForType(
Builder builder = new Builder(parent);
return builder;
}
-
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.CreateTransactionReply}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessage.Builder<Builder>
- implements
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReplyOrBuilder {
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionReply_descriptor;
+ implements org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReplyOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionReply_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionReply_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionReply_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply.Builder.class);
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply.Builder.class);
}
- // Construct using
- // org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply.newBuilder()
+ // Construct using org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
- private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
-
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
}
}
-
private static Builder create() {
return new Builder();
}
return create().mergeFrom(buildPartial());
}
- public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionReply_descriptor;
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_CreateTransactionReply_descriptor;
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply getDefaultInstanceForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply
- .getDefaultInstance();
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply getDefaultInstanceForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply.getDefaultInstance();
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply build() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply result =
- buildPartial();
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply build() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply buildPartial() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply result =
- new org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply(
- this);
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply buildPartial() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply result = new org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply(this);
int from_bitField0_ = bitField0_;
int to_bitField0_ = 0;
if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
}
public Builder mergeFrom(com.google.protobuf.Message other) {
- if (other instanceof org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply) {
- return mergeFrom((org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply) other);
+ if (other instanceof org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply) {
+ return mergeFrom((org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply)other);
} else {
super.mergeFrom(other);
return this;
}
}
- public Builder mergeFrom(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply other) {
- if (other == org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply
- .getDefaultInstance())
- return this;
+ public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply other) {
+ if (other == org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply.getDefaultInstance()) return this;
if (other.hasTransactionPath()) {
bitField0_ |= 0x00000001;
transactionPath_ = other.transactionPath_;
return true;
}
- public Builder mergeFrom(com.google.protobuf.CodedInputStream input,
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply parsedMessage =
- null;
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
- parsedMessage =
- (org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.CreateTransactionReply) e
- .getUnfinishedMessage();
+ parsedMessage = (org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.CreateTransactionReply) e.getUnfinishedMessage();
throw e;
} finally {
if (parsedMessage != null) {
}
return this;
}
-
private int bitField0_;
// required string transactionPath = 1;
private java.lang.Object transactionPath_ = "";
-
/**
* <code>required string transactionPath = 1;</code>
*/
public boolean hasTransactionPath() {
return ((bitField0_ & 0x00000001) == 0x00000001);
}
-
/**
* <code>required string transactionPath = 1;</code>
*/
public java.lang.String getTransactionPath() {
java.lang.Object ref = transactionPath_;
if (!(ref instanceof java.lang.String)) {
- java.lang.String s =
- ((com.google.protobuf.ByteString) ref).toStringUtf8();
+ java.lang.String s = ((com.google.protobuf.ByteString) ref)
+ .toStringUtf8();
transactionPath_ = s;
return s;
} else {
return (java.lang.String) ref;
}
}
-
/**
* <code>required string transactionPath = 1;</code>
*/
- public com.google.protobuf.ByteString getTransactionPathBytes() {
+ public com.google.protobuf.ByteString
+ getTransactionPathBytes() {
java.lang.Object ref = transactionPath_;
if (ref instanceof String) {
com.google.protobuf.ByteString b =
- com.google.protobuf.ByteString
- .copyFromUtf8((java.lang.String) ref);
+ com.google.protobuf.ByteString.copyFromUtf8(
+ (java.lang.String) ref);
transactionPath_ = b;
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
-
/**
* <code>required string transactionPath = 1;</code>
*/
- public Builder setTransactionPath(java.lang.String value) {
+ public Builder setTransactionPath(
+ java.lang.String value) {
if (value == null) {
- throw new NullPointerException();
- }
- bitField0_ |= 0x00000001;
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000001;
transactionPath_ = value;
onChanged();
return this;
}
-
/**
* <code>required string transactionPath = 1;</code>
*/
onChanged();
return this;
}
-
/**
* <code>required string transactionPath = 1;</code>
*/
public Builder setTransactionPathBytes(
com.google.protobuf.ByteString value) {
if (value == null) {
- throw new NullPointerException();
- }
- bitField0_ |= 0x00000001;
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000001;
transactionPath_ = value;
onChanged();
return this;
// @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.CreateTransactionReply)
}
- public interface ReadyTransactionOrBuilder extends
- com.google.protobuf.MessageOrBuilder {
+ public interface ReadyTransactionOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
}
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.ReadyTransaction}
*/
public static final class ReadyTransaction extends
- com.google.protobuf.GeneratedMessage implements ReadyTransactionOrBuilder {
+ com.google.protobuf.GeneratedMessage
+ implements ReadyTransactionOrBuilder {
// Use ReadyTransaction.newBuilder() to construct.
- private ReadyTransaction(
- com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ private ReadyTransaction(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
super(builder);
this.unknownFields = builder.getUnknownFields();
}
-
- private ReadyTransaction(boolean noInit) {
- this.unknownFields =
- com.google.protobuf.UnknownFieldSet.getDefaultInstance();
- }
+ private ReadyTransaction(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
private static final ReadyTransaction defaultInstance;
-
public static ReadyTransaction getDefaultInstance() {
return defaultInstance;
}
}
private final com.google.protobuf.UnknownFieldSet unknownFields;
-
@java.lang.Override
- public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
return this.unknownFields;
}
-
- private ReadyTransaction(com.google.protobuf.CodedInputStream input,
+ private ReadyTransaction(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
initFields();
done = true;
break;
default: {
- if (!parseUnknownField(input, unknownFields, extensionRegistry,
- tag)) {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
done = true;
}
break;
makeExtensionsImmutable();
}
}
-
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadyTransaction_descriptor;
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadyTransaction_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadyTransaction_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadyTransaction_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction.Builder.class);
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction.Builder.class);
}
public static com.google.protobuf.Parser<ReadyTransaction> PARSER =
new com.google.protobuf.AbstractParser<ReadyTransaction>() {
- public ReadyTransaction parsePartialFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return new ReadyTransaction(input, extensionRegistry);
- }
- };
+ public ReadyTransaction parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new ReadyTransaction(input, extensionRegistry);
+ }
+ };
@java.lang.Override
public com.google.protobuf.Parser<ReadyTransaction> getParserForType() {
return PARSER;
}
- private void initFields() {}
-
+ private void initFields() {
+ }
private byte memoizedIsInitialized = -1;
-
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
- if (isInitialized != -1)
- return isInitialized == 1;
+ if (isInitialized != -1) return isInitialized == 1;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
- throws java.io.IOException {
+ throws java.io.IOException {
getSerializedSize();
getUnknownFields().writeTo(output);
}
private int memoizedSerializedSize = -1;
-
public int getSerializedSize() {
int size = memoizedSerializedSize;
- if (size != -1)
- return size;
+ if (size != -1) return size;
size = 0;
size += getUnknownFields().getSerializedSize();
}
private static final long serialVersionUID = 0L;
-
@java.lang.Override
protected java.lang.Object writeReplace()
throws java.io.ObjectStreamException {
return super.writeReplace();
}
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction parseFrom(
- byte[] data) throws com.google.protobuf.InvalidProtocolBufferException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction parseFrom(
- byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction parseFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction parseDelimitedFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseDelimitedFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction parseDelimitedFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseDelimitedFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction parseFrom(
- com.google.protobuf.CodedInputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
- public static Builder newBuilder() {
- return Builder.create();
- }
-
- public Builder newBuilderForType() {
- return newBuilder();
- }
-
- public static Builder newBuilder(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction prototype) {
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction prototype) {
return newBuilder().mergeFrom(prototype);
}
-
- public Builder toBuilder() {
- return newBuilder(this);
- }
+ public Builder toBuilder() { return newBuilder(this); }
@java.lang.Override
protected Builder newBuilderForType(
Builder builder = new Builder(parent);
return builder;
}
-
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.ReadyTransaction}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessage.Builder<Builder>
- implements
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionOrBuilder {
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadyTransaction_descriptor;
+ implements org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadyTransaction_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadyTransaction_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadyTransaction_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction.Builder.class);
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction.Builder.class);
}
- // Construct using
- // org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction.newBuilder()
+ // Construct using org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
- private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
-
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
}
}
-
private static Builder create() {
return new Builder();
}
return create().mergeFrom(buildPartial());
}
- public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadyTransaction_descriptor;
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadyTransaction_descriptor;
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction getDefaultInstanceForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction
- .getDefaultInstance();
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction getDefaultInstanceForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction.getDefaultInstance();
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction build() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction result =
- buildPartial();
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction build() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction buildPartial() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction result =
- new org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction(
- this);
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction buildPartial() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction result = new org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction(this);
onBuilt();
return result;
}
public Builder mergeFrom(com.google.protobuf.Message other) {
- if (other instanceof org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction) {
- return mergeFrom((org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction) other);
+ if (other instanceof org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction) {
+ return mergeFrom((org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction)other);
} else {
super.mergeFrom(other);
return this;
}
}
- public Builder mergeFrom(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction other) {
- if (other == org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction
- .getDefaultInstance())
- return this;
+ public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction other) {
+ if (other == org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction.getDefaultInstance()) return this;
this.mergeUnknownFields(other.getUnknownFields());
return this;
}
return true;
}
- public Builder mergeFrom(com.google.protobuf.CodedInputStream input,
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction parsedMessage =
- null;
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
- parsedMessage =
- (org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransaction) e
- .getUnfinishedMessage();
+ parsedMessage = (org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransaction) e.getUnfinishedMessage();
throw e;
} finally {
if (parsedMessage != null) {
// @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.ReadyTransaction)
}
- public interface ReadyTransactionReplyOrBuilder extends
- com.google.protobuf.MessageOrBuilder {
+ public interface ReadyTransactionReplyOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
// required string actorPath = 1;
/**
* <code>required string actorPath = 1;</code>
*/
boolean hasActorPath();
-
/**
* <code>required string actorPath = 1;</code>
*/
java.lang.String getActorPath();
-
/**
* <code>required string actorPath = 1;</code>
*/
- com.google.protobuf.ByteString getActorPathBytes();
+ com.google.protobuf.ByteString
+ getActorPathBytes();
}
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.ReadyTransactionReply}
*/
public static final class ReadyTransactionReply extends
- com.google.protobuf.GeneratedMessage implements
- ReadyTransactionReplyOrBuilder {
+ com.google.protobuf.GeneratedMessage
+ implements ReadyTransactionReplyOrBuilder {
// Use ReadyTransactionReply.newBuilder() to construct.
- private ReadyTransactionReply(
- com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ private ReadyTransactionReply(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
super(builder);
this.unknownFields = builder.getUnknownFields();
}
-
- private ReadyTransactionReply(boolean noInit) {
- this.unknownFields =
- com.google.protobuf.UnknownFieldSet.getDefaultInstance();
- }
+ private ReadyTransactionReply(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
private static final ReadyTransactionReply defaultInstance;
-
public static ReadyTransactionReply getDefaultInstance() {
return defaultInstance;
}
}
private final com.google.protobuf.UnknownFieldSet unknownFields;
-
@java.lang.Override
- public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
return this.unknownFields;
}
-
- private ReadyTransactionReply(com.google.protobuf.CodedInputStream input,
+ private ReadyTransactionReply(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
initFields();
done = true;
break;
default: {
- if (!parseUnknownField(input, unknownFields, extensionRegistry,
- tag)) {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
done = true;
}
break;
makeExtensionsImmutable();
}
}
-
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadyTransactionReply_descriptor;
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadyTransactionReply_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadyTransactionReply_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadyTransactionReply_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply.Builder.class);
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply.Builder.class);
}
public static com.google.protobuf.Parser<ReadyTransactionReply> PARSER =
new com.google.protobuf.AbstractParser<ReadyTransactionReply>() {
- public ReadyTransactionReply parsePartialFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return new ReadyTransactionReply(input, extensionRegistry);
- }
- };
+ public ReadyTransactionReply parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new ReadyTransactionReply(input, extensionRegistry);
+ }
+ };
@java.lang.Override
public com.google.protobuf.Parser<ReadyTransactionReply> getParserForType() {
// required string actorPath = 1;
public static final int ACTORPATH_FIELD_NUMBER = 1;
private java.lang.Object actorPath_;
-
/**
* <code>required string actorPath = 1;</code>
*/
public boolean hasActorPath() {
return ((bitField0_ & 0x00000001) == 0x00000001);
}
-
/**
* <code>required string actorPath = 1;</code>
*/
return s;
}
}
-
/**
* <code>required string actorPath = 1;</code>
*/
- public com.google.protobuf.ByteString getActorPathBytes() {
+ public com.google.protobuf.ByteString
+ getActorPathBytes() {
java.lang.Object ref = actorPath_;
if (ref instanceof java.lang.String) {
com.google.protobuf.ByteString b =
- com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
+ com.google.protobuf.ByteString.copyFromUtf8(
+ (java.lang.String) ref);
actorPath_ = b;
return b;
} else {
private void initFields() {
actorPath_ = "";
}
-
private byte memoizedIsInitialized = -1;
-
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
- if (isInitialized != -1)
- return isInitialized == 1;
+ if (isInitialized != -1) return isInitialized == 1;
if (!hasActorPath()) {
memoizedIsInitialized = 0;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
- throws java.io.IOException {
+ throws java.io.IOException {
getSerializedSize();
if (((bitField0_ & 0x00000001) == 0x00000001)) {
output.writeBytes(1, getActorPathBytes());
}
private int memoizedSerializedSize = -1;
-
public int getSerializedSize() {
int size = memoizedSerializedSize;
- if (size != -1)
- return size;
+ if (size != -1) return size;
size = 0;
if (((bitField0_ & 0x00000001) == 0x00000001)) {
- size +=
- com.google.protobuf.CodedOutputStream.computeBytesSize(1,
- getActorPathBytes());
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(1, getActorPathBytes());
}
size += getUnknownFields().getSerializedSize();
memoizedSerializedSize = size;
}
private static final long serialVersionUID = 0L;
-
@java.lang.Override
protected java.lang.Object writeReplace()
throws java.io.ObjectStreamException {
return super.writeReplace();
}
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply parseFrom(
- byte[] data) throws com.google.protobuf.InvalidProtocolBufferException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply parseFrom(
- byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply parseFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply parseDelimitedFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseDelimitedFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply parseDelimitedFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseDelimitedFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply parseFrom(
- com.google.protobuf.CodedInputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
- public static Builder newBuilder() {
- return Builder.create();
- }
-
- public Builder newBuilderForType() {
- return newBuilder();
- }
-
- public static Builder newBuilder(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply prototype) {
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply prototype) {
return newBuilder().mergeFrom(prototype);
}
-
- public Builder toBuilder() {
- return newBuilder(this);
- }
+ public Builder toBuilder() { return newBuilder(this); }
@java.lang.Override
protected Builder newBuilderForType(
Builder builder = new Builder(parent);
return builder;
}
-
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.ReadyTransactionReply}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessage.Builder<Builder>
- implements
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReplyOrBuilder {
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadyTransactionReply_descriptor;
+ implements org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReplyOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadyTransactionReply_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadyTransactionReply_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadyTransactionReply_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply.Builder.class);
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply.Builder.class);
}
- // Construct using
- // org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply.newBuilder()
+ // Construct using org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
- private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
-
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
}
}
-
private static Builder create() {
return new Builder();
}
return create().mergeFrom(buildPartial());
}
- public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadyTransactionReply_descriptor;
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadyTransactionReply_descriptor;
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply getDefaultInstanceForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply
- .getDefaultInstance();
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply getDefaultInstanceForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply.getDefaultInstance();
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply build() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply result =
- buildPartial();
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply build() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply buildPartial() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply result =
- new org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply(
- this);
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply buildPartial() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply result = new org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply(this);
int from_bitField0_ = bitField0_;
int to_bitField0_ = 0;
if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
}
public Builder mergeFrom(com.google.protobuf.Message other) {
- if (other instanceof org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply) {
- return mergeFrom((org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply) other);
+ if (other instanceof org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply) {
+ return mergeFrom((org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply)other);
} else {
super.mergeFrom(other);
return this;
}
}
- public Builder mergeFrom(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply other) {
- if (other == org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply
- .getDefaultInstance())
- return this;
+ public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply other) {
+ if (other == org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply.getDefaultInstance()) return this;
if (other.hasActorPath()) {
bitField0_ |= 0x00000001;
actorPath_ = other.actorPath_;
return true;
}
- public Builder mergeFrom(com.google.protobuf.CodedInputStream input,
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply parsedMessage =
- null;
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
- parsedMessage =
- (org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadyTransactionReply) e
- .getUnfinishedMessage();
+ parsedMessage = (org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadyTransactionReply) e.getUnfinishedMessage();
throw e;
} finally {
if (parsedMessage != null) {
}
return this;
}
-
private int bitField0_;
// required string actorPath = 1;
private java.lang.Object actorPath_ = "";
-
/**
* <code>required string actorPath = 1;</code>
*/
public boolean hasActorPath() {
return ((bitField0_ & 0x00000001) == 0x00000001);
}
-
/**
* <code>required string actorPath = 1;</code>
*/
public java.lang.String getActorPath() {
java.lang.Object ref = actorPath_;
if (!(ref instanceof java.lang.String)) {
- java.lang.String s =
- ((com.google.protobuf.ByteString) ref).toStringUtf8();
+ java.lang.String s = ((com.google.protobuf.ByteString) ref)
+ .toStringUtf8();
actorPath_ = s;
return s;
} else {
return (java.lang.String) ref;
}
}
-
/**
* <code>required string actorPath = 1;</code>
*/
- public com.google.protobuf.ByteString getActorPathBytes() {
+ public com.google.protobuf.ByteString
+ getActorPathBytes() {
java.lang.Object ref = actorPath_;
if (ref instanceof String) {
com.google.protobuf.ByteString b =
- com.google.protobuf.ByteString
- .copyFromUtf8((java.lang.String) ref);
+ com.google.protobuf.ByteString.copyFromUtf8(
+ (java.lang.String) ref);
actorPath_ = b;
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
-
/**
* <code>required string actorPath = 1;</code>
*/
- public Builder setActorPath(java.lang.String value) {
+ public Builder setActorPath(
+ java.lang.String value) {
if (value == null) {
- throw new NullPointerException();
- }
- bitField0_ |= 0x00000001;
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000001;
actorPath_ = value;
onChanged();
return this;
}
-
/**
* <code>required string actorPath = 1;</code>
*/
onChanged();
return this;
}
-
/**
* <code>required string actorPath = 1;</code>
*/
- public Builder setActorPathBytes(com.google.protobuf.ByteString value) {
+ public Builder setActorPathBytes(
+ com.google.protobuf.ByteString value) {
if (value == null) {
- throw new NullPointerException();
- }
- bitField0_ |= 0x00000001;
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000001;
actorPath_ = value;
onChanged();
return this;
// @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.ReadyTransactionReply)
}
- public interface DeleteDataOrBuilder extends
- com.google.protobuf.MessageOrBuilder {
+ public interface DeleteDataOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
// repeated string instanceIdentifierPathArguments = 1;
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
- java.util.List<java.lang.String> getInstanceIdentifierPathArgumentsList();
-
+ java.util.List<java.lang.String>
+ getInstanceIdentifierPathArgumentsList();
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
int getInstanceIdentifierPathArgumentsCount();
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
java.lang.String getInstanceIdentifierPathArguments(int index);
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
- com.google.protobuf.ByteString getInstanceIdentifierPathArgumentsBytes(
- int index);
+ com.google.protobuf.ByteString
+ getInstanceIdentifierPathArgumentsBytes(int index);
}
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.DeleteData}
*/
public static final class DeleteData extends
- com.google.protobuf.GeneratedMessage implements DeleteDataOrBuilder {
+ com.google.protobuf.GeneratedMessage
+ implements DeleteDataOrBuilder {
// Use DeleteData.newBuilder() to construct.
private DeleteData(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
super(builder);
this.unknownFields = builder.getUnknownFields();
}
-
- private DeleteData(boolean noInit) {
- this.unknownFields =
- com.google.protobuf.UnknownFieldSet.getDefaultInstance();
- }
+ private DeleteData(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
private static final DeleteData defaultInstance;
-
public static DeleteData getDefaultInstance() {
return defaultInstance;
}
}
private final com.google.protobuf.UnknownFieldSet unknownFields;
-
@java.lang.Override
- public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
return this.unknownFields;
}
-
- private DeleteData(com.google.protobuf.CodedInputStream input,
+ private DeleteData(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
initFields();
done = true;
break;
default: {
- if (!parseUnknownField(input, unknownFields, extensionRegistry,
- tag)) {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
done = true;
}
break;
}
case 10: {
if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
- instanceIdentifierPathArguments_ =
- new com.google.protobuf.LazyStringArrayList();
+ instanceIdentifierPathArguments_ = new com.google.protobuf.LazyStringArrayList();
mutable_bitField0_ |= 0x00000001;
}
instanceIdentifierPathArguments_.add(input.readBytes());
e.getMessage()).setUnfinishedMessage(this);
} finally {
if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
- instanceIdentifierPathArguments_ =
- new com.google.protobuf.UnmodifiableLazyStringList(
- instanceIdentifierPathArguments_);
+ instanceIdentifierPathArguments_ = new com.google.protobuf.UnmodifiableLazyStringList(instanceIdentifierPathArguments_);
}
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
-
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_DeleteData_descriptor;
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_DeleteData_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_DeleteData_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_DeleteData_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData.Builder.class);
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData.Builder.class);
}
public static com.google.protobuf.Parser<DeleteData> PARSER =
new com.google.protobuf.AbstractParser<DeleteData>() {
- public DeleteData parsePartialFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return new DeleteData(input, extensionRegistry);
- }
- };
+ public DeleteData parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new DeleteData(input, extensionRegistry);
+ }
+ };
@java.lang.Override
public com.google.protobuf.Parser<DeleteData> getParserForType() {
// repeated string instanceIdentifierPathArguments = 1;
public static final int INSTANCEIDENTIFIERPATHARGUMENTS_FIELD_NUMBER = 1;
private com.google.protobuf.LazyStringList instanceIdentifierPathArguments_;
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
- public java.util.List<java.lang.String> getInstanceIdentifierPathArgumentsList() {
+ public java.util.List<java.lang.String>
+ getInstanceIdentifierPathArgumentsList() {
return instanceIdentifierPathArguments_;
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
public int getInstanceIdentifierPathArgumentsCount() {
return instanceIdentifierPathArguments_.size();
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
public java.lang.String getInstanceIdentifierPathArguments(int index) {
return instanceIdentifierPathArguments_.get(index);
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
- public com.google.protobuf.ByteString getInstanceIdentifierPathArgumentsBytes(
- int index) {
+ public com.google.protobuf.ByteString
+ getInstanceIdentifierPathArgumentsBytes(int index) {
return instanceIdentifierPathArguments_.getByteString(index);
}
private void initFields() {
- instanceIdentifierPathArguments_ =
- com.google.protobuf.LazyStringArrayList.EMPTY;
+ instanceIdentifierPathArguments_ = com.google.protobuf.LazyStringArrayList.EMPTY;
}
-
private byte memoizedIsInitialized = -1;
-
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
- if (isInitialized != -1)
- return isInitialized == 1;
+ if (isInitialized != -1) return isInitialized == 1;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
- throws java.io.IOException {
+ throws java.io.IOException {
getSerializedSize();
for (int i = 0; i < instanceIdentifierPathArguments_.size(); i++) {
output.writeBytes(1, instanceIdentifierPathArguments_.getByteString(i));
}
private int memoizedSerializedSize = -1;
-
public int getSerializedSize() {
int size = memoizedSerializedSize;
- if (size != -1)
- return size;
+ if (size != -1) return size;
size = 0;
{
int dataSize = 0;
for (int i = 0; i < instanceIdentifierPathArguments_.size(); i++) {
- dataSize +=
- com.google.protobuf.CodedOutputStream
- .computeBytesSizeNoTag(instanceIdentifierPathArguments_
- .getByteString(i));
+ dataSize += com.google.protobuf.CodedOutputStream
+ .computeBytesSizeNoTag(instanceIdentifierPathArguments_.getByteString(i));
}
size += dataSize;
size += 1 * getInstanceIdentifierPathArgumentsList().size();
}
private static final long serialVersionUID = 0L;
-
@java.lang.Override
protected java.lang.Object writeReplace()
throws java.io.ObjectStreamException {
return super.writeReplace();
}
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData parseFrom(
- byte[] data) throws com.google.protobuf.InvalidProtocolBufferException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData parseFrom(
- byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData parseFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData parseDelimitedFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseDelimitedFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData parseDelimitedFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseDelimitedFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData parseFrom(
- com.google.protobuf.CodedInputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
- public static Builder newBuilder() {
- return Builder.create();
- }
-
- public Builder newBuilderForType() {
- return newBuilder();
- }
-
- public static Builder newBuilder(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData prototype) {
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData prototype) {
return newBuilder().mergeFrom(prototype);
}
-
- public Builder toBuilder() {
- return newBuilder(this);
- }
+ public Builder toBuilder() { return newBuilder(this); }
@java.lang.Override
protected Builder newBuilderForType(
Builder builder = new Builder(parent);
return builder;
}
-
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.DeleteData}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessage.Builder<Builder>
- implements
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataOrBuilder {
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_DeleteData_descriptor;
+ implements org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_DeleteData_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_DeleteData_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_DeleteData_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData.Builder.class);
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData.Builder.class);
}
- // Construct using
- // org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData.newBuilder()
+ // Construct using org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
- private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
-
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
}
}
-
private static Builder create() {
return new Builder();
}
public Builder clear() {
super.clear();
- instanceIdentifierPathArguments_ =
- com.google.protobuf.LazyStringArrayList.EMPTY;
+ instanceIdentifierPathArguments_ = com.google.protobuf.LazyStringArrayList.EMPTY;
bitField0_ = (bitField0_ & ~0x00000001);
return this;
}
return create().mergeFrom(buildPartial());
}
- public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_DeleteData_descriptor;
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_DeleteData_descriptor;
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData getDefaultInstanceForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData
- .getDefaultInstance();
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData getDefaultInstanceForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData.getDefaultInstance();
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData build() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData result =
- buildPartial();
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData build() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData buildPartial() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData result =
- new org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData(
- this);
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData buildPartial() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData result = new org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData(this);
int from_bitField0_ = bitField0_;
if (((bitField0_ & 0x00000001) == 0x00000001)) {
- instanceIdentifierPathArguments_ =
- new com.google.protobuf.UnmodifiableLazyStringList(
- instanceIdentifierPathArguments_);
+ instanceIdentifierPathArguments_ = new com.google.protobuf.UnmodifiableLazyStringList(
+ instanceIdentifierPathArguments_);
bitField0_ = (bitField0_ & ~0x00000001);
}
- result.instanceIdentifierPathArguments_ =
- instanceIdentifierPathArguments_;
+ result.instanceIdentifierPathArguments_ = instanceIdentifierPathArguments_;
onBuilt();
return result;
}
public Builder mergeFrom(com.google.protobuf.Message other) {
- if (other instanceof org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData) {
- return mergeFrom((org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData) other);
+ if (other instanceof org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData) {
+ return mergeFrom((org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData)other);
} else {
super.mergeFrom(other);
return this;
}
}
- public Builder mergeFrom(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData other) {
- if (other == org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData
- .getDefaultInstance())
- return this;
+ public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData other) {
+ if (other == org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData.getDefaultInstance()) return this;
if (!other.instanceIdentifierPathArguments_.isEmpty()) {
if (instanceIdentifierPathArguments_.isEmpty()) {
- instanceIdentifierPathArguments_ =
- other.instanceIdentifierPathArguments_;
+ instanceIdentifierPathArguments_ = other.instanceIdentifierPathArguments_;
bitField0_ = (bitField0_ & ~0x00000001);
} else {
ensureInstanceIdentifierPathArgumentsIsMutable();
- instanceIdentifierPathArguments_
- .addAll(other.instanceIdentifierPathArguments_);
+ instanceIdentifierPathArguments_.addAll(other.instanceIdentifierPathArguments_);
}
onChanged();
}
return true;
}
- public Builder mergeFrom(com.google.protobuf.CodedInputStream input,
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData parsedMessage =
- null;
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
- parsedMessage =
- (org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteData) e
- .getUnfinishedMessage();
+ parsedMessage = (org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteData) e.getUnfinishedMessage();
throw e;
} finally {
if (parsedMessage != null) {
}
return this;
}
-
private int bitField0_;
// repeated string instanceIdentifierPathArguments = 1;
- private com.google.protobuf.LazyStringList instanceIdentifierPathArguments_ =
- com.google.protobuf.LazyStringArrayList.EMPTY;
-
+ private com.google.protobuf.LazyStringList instanceIdentifierPathArguments_ = com.google.protobuf.LazyStringArrayList.EMPTY;
private void ensureInstanceIdentifierPathArgumentsIsMutable() {
if (!((bitField0_ & 0x00000001) == 0x00000001)) {
- instanceIdentifierPathArguments_ =
- new com.google.protobuf.LazyStringArrayList(
- instanceIdentifierPathArguments_);
+ instanceIdentifierPathArguments_ = new com.google.protobuf.LazyStringArrayList(instanceIdentifierPathArguments_);
bitField0_ |= 0x00000001;
- }
+ }
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
- public java.util.List<java.lang.String> getInstanceIdentifierPathArgumentsList() {
- return java.util.Collections
- .unmodifiableList(instanceIdentifierPathArguments_);
+ public java.util.List<java.lang.String>
+ getInstanceIdentifierPathArgumentsList() {
+ return java.util.Collections.unmodifiableList(instanceIdentifierPathArguments_);
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
public int getInstanceIdentifierPathArgumentsCount() {
return instanceIdentifierPathArguments_.size();
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
public java.lang.String getInstanceIdentifierPathArguments(int index) {
return instanceIdentifierPathArguments_.get(index);
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
- public com.google.protobuf.ByteString getInstanceIdentifierPathArgumentsBytes(
- int index) {
+ public com.google.protobuf.ByteString
+ getInstanceIdentifierPathArgumentsBytes(int index) {
return instanceIdentifierPathArguments_.getByteString(index);
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
- public Builder setInstanceIdentifierPathArguments(int index,
- java.lang.String value) {
+ public Builder setInstanceIdentifierPathArguments(
+ int index, java.lang.String value) {
if (value == null) {
- throw new NullPointerException();
- }
- ensureInstanceIdentifierPathArgumentsIsMutable();
+ throw new NullPointerException();
+ }
+ ensureInstanceIdentifierPathArgumentsIsMutable();
instanceIdentifierPathArguments_.set(index, value);
onChanged();
return this;
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
- public Builder addInstanceIdentifierPathArguments(java.lang.String value) {
+ public Builder addInstanceIdentifierPathArguments(
+ java.lang.String value) {
if (value == null) {
- throw new NullPointerException();
- }
- ensureInstanceIdentifierPathArgumentsIsMutable();
+ throw new NullPointerException();
+ }
+ ensureInstanceIdentifierPathArgumentsIsMutable();
instanceIdentifierPathArguments_.add(value);
onChanged();
return this;
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
onChanged();
return this;
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
public Builder clearInstanceIdentifierPathArguments() {
- instanceIdentifierPathArguments_ =
- com.google.protobuf.LazyStringArrayList.EMPTY;
+ instanceIdentifierPathArguments_ = com.google.protobuf.LazyStringArrayList.EMPTY;
bitField0_ = (bitField0_ & ~0x00000001);
onChanged();
return this;
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
public Builder addInstanceIdentifierPathArgumentsBytes(
com.google.protobuf.ByteString value) {
if (value == null) {
- throw new NullPointerException();
- }
- ensureInstanceIdentifierPathArgumentsIsMutable();
+ throw new NullPointerException();
+ }
+ ensureInstanceIdentifierPathArgumentsIsMutable();
instanceIdentifierPathArguments_.add(value);
onChanged();
return this;
// @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.DeleteData)
}
- public interface DeleteDataReplyOrBuilder extends
- com.google.protobuf.MessageOrBuilder {
+ public interface DeleteDataReplyOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
}
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.DeleteDataReply}
*/
public static final class DeleteDataReply extends
- com.google.protobuf.GeneratedMessage implements DeleteDataReplyOrBuilder {
+ com.google.protobuf.GeneratedMessage
+ implements DeleteDataReplyOrBuilder {
// Use DeleteDataReply.newBuilder() to construct.
- private DeleteDataReply(
- com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ private DeleteDataReply(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
super(builder);
this.unknownFields = builder.getUnknownFields();
}
-
- private DeleteDataReply(boolean noInit) {
- this.unknownFields =
- com.google.protobuf.UnknownFieldSet.getDefaultInstance();
- }
+ private DeleteDataReply(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
private static final DeleteDataReply defaultInstance;
-
public static DeleteDataReply getDefaultInstance() {
return defaultInstance;
}
}
private final com.google.protobuf.UnknownFieldSet unknownFields;
-
@java.lang.Override
- public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
return this.unknownFields;
}
-
- private DeleteDataReply(com.google.protobuf.CodedInputStream input,
+ private DeleteDataReply(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
initFields();
done = true;
break;
default: {
- if (!parseUnknownField(input, unknownFields, extensionRegistry,
- tag)) {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
done = true;
}
break;
makeExtensionsImmutable();
}
}
-
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_DeleteDataReply_descriptor;
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_DeleteDataReply_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_DeleteDataReply_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_DeleteDataReply_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply.Builder.class);
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply.Builder.class);
}
public static com.google.protobuf.Parser<DeleteDataReply> PARSER =
new com.google.protobuf.AbstractParser<DeleteDataReply>() {
- public DeleteDataReply parsePartialFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return new DeleteDataReply(input, extensionRegistry);
- }
- };
+ public DeleteDataReply parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new DeleteDataReply(input, extensionRegistry);
+ }
+ };
@java.lang.Override
public com.google.protobuf.Parser<DeleteDataReply> getParserForType() {
return PARSER;
}
- private void initFields() {}
-
+ private void initFields() {
+ }
private byte memoizedIsInitialized = -1;
-
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
- if (isInitialized != -1)
- return isInitialized == 1;
+ if (isInitialized != -1) return isInitialized == 1;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
- throws java.io.IOException {
+ throws java.io.IOException {
getSerializedSize();
getUnknownFields().writeTo(output);
}
private int memoizedSerializedSize = -1;
-
public int getSerializedSize() {
int size = memoizedSerializedSize;
- if (size != -1)
- return size;
+ if (size != -1) return size;
size = 0;
size += getUnknownFields().getSerializedSize();
}
private static final long serialVersionUID = 0L;
-
@java.lang.Override
protected java.lang.Object writeReplace()
throws java.io.ObjectStreamException {
return super.writeReplace();
}
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply parseFrom(
- byte[] data) throws com.google.protobuf.InvalidProtocolBufferException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply parseFrom(
- byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply parseFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply parseDelimitedFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseDelimitedFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply parseDelimitedFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseDelimitedFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply parseFrom(
- com.google.protobuf.CodedInputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
- public static Builder newBuilder() {
- return Builder.create();
- }
-
- public Builder newBuilderForType() {
- return newBuilder();
- }
-
- public static Builder newBuilder(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply prototype) {
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply prototype) {
return newBuilder().mergeFrom(prototype);
}
-
- public Builder toBuilder() {
- return newBuilder(this);
- }
+ public Builder toBuilder() { return newBuilder(this); }
@java.lang.Override
protected Builder newBuilderForType(
Builder builder = new Builder(parent);
return builder;
}
-
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.DeleteDataReply}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessage.Builder<Builder>
- implements
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReplyOrBuilder {
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_DeleteDataReply_descriptor;
+ implements org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReplyOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_DeleteDataReply_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_DeleteDataReply_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_DeleteDataReply_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply.Builder.class);
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply.Builder.class);
}
- // Construct using
- // org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply.newBuilder()
+ // Construct using org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
- private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
-
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
}
}
-
private static Builder create() {
return new Builder();
}
return create().mergeFrom(buildPartial());
}
- public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_DeleteDataReply_descriptor;
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_DeleteDataReply_descriptor;
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply getDefaultInstanceForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply
- .getDefaultInstance();
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply getDefaultInstanceForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply.getDefaultInstance();
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply build() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply result =
- buildPartial();
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply build() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply buildPartial() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply result =
- new org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply(
- this);
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply buildPartial() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply result = new org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply(this);
onBuilt();
return result;
}
public Builder mergeFrom(com.google.protobuf.Message other) {
- if (other instanceof org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply) {
- return mergeFrom((org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply) other);
+ if (other instanceof org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply) {
+ return mergeFrom((org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply)other);
} else {
super.mergeFrom(other);
return this;
}
}
- public Builder mergeFrom(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply other) {
- if (other == org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply
- .getDefaultInstance())
- return this;
+ public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply other) {
+ if (other == org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply.getDefaultInstance()) return this;
this.mergeUnknownFields(other.getUnknownFields());
return this;
}
return true;
}
- public Builder mergeFrom(com.google.protobuf.CodedInputStream input,
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply parsedMessage =
- null;
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
- parsedMessage =
- (org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.DeleteDataReply) e
- .getUnfinishedMessage();
+ parsedMessage = (org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.DeleteDataReply) e.getUnfinishedMessage();
throw e;
} finally {
if (parsedMessage != null) {
// @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.DeleteDataReply)
}
- public interface ReadDataOrBuilder extends
- com.google.protobuf.MessageOrBuilder {
+ public interface ReadDataOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
// required string instanceIdentifierPathArguments = 1;
/**
* <code>required string instanceIdentifierPathArguments = 1;</code>
*/
boolean hasInstanceIdentifierPathArguments();
-
/**
* <code>required string instanceIdentifierPathArguments = 1;</code>
*/
java.lang.String getInstanceIdentifierPathArguments();
-
/**
* <code>required string instanceIdentifierPathArguments = 1;</code>
*/
- com.google.protobuf.ByteString getInstanceIdentifierPathArgumentsBytes();
+ com.google.protobuf.ByteString
+ getInstanceIdentifierPathArgumentsBytes();
}
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.ReadData}
*/
public static final class ReadData extends
- com.google.protobuf.GeneratedMessage implements ReadDataOrBuilder {
+ com.google.protobuf.GeneratedMessage
+ implements ReadDataOrBuilder {
// Use ReadData.newBuilder() to construct.
private ReadData(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
super(builder);
this.unknownFields = builder.getUnknownFields();
}
-
- private ReadData(boolean noInit) {
- this.unknownFields =
- com.google.protobuf.UnknownFieldSet.getDefaultInstance();
- }
+ private ReadData(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
private static final ReadData defaultInstance;
-
public static ReadData getDefaultInstance() {
return defaultInstance;
}
}
private final com.google.protobuf.UnknownFieldSet unknownFields;
-
@java.lang.Override
- public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
return this.unknownFields;
}
-
- private ReadData(com.google.protobuf.CodedInputStream input,
+ private ReadData(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
initFields();
done = true;
break;
default: {
- if (!parseUnknownField(input, unknownFields, extensionRegistry,
- tag)) {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
done = true;
}
break;
makeExtensionsImmutable();
}
}
-
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadData_descriptor;
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadData_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadData_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadData_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData.Builder.class);
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData.Builder.class);
}
public static com.google.protobuf.Parser<ReadData> PARSER =
new com.google.protobuf.AbstractParser<ReadData>() {
- public ReadData parsePartialFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return new ReadData(input, extensionRegistry);
- }
- };
+ public ReadData parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new ReadData(input, extensionRegistry);
+ }
+ };
@java.lang.Override
public com.google.protobuf.Parser<ReadData> getParserForType() {
// required string instanceIdentifierPathArguments = 1;
public static final int INSTANCEIDENTIFIERPATHARGUMENTS_FIELD_NUMBER = 1;
private java.lang.Object instanceIdentifierPathArguments_;
-
/**
* <code>required string instanceIdentifierPathArguments = 1;</code>
*/
public boolean hasInstanceIdentifierPathArguments() {
return ((bitField0_ & 0x00000001) == 0x00000001);
}
-
/**
* <code>required string instanceIdentifierPathArguments = 1;</code>
*/
return s;
}
}
-
/**
* <code>required string instanceIdentifierPathArguments = 1;</code>
*/
- public com.google.protobuf.ByteString getInstanceIdentifierPathArgumentsBytes() {
+ public com.google.protobuf.ByteString
+ getInstanceIdentifierPathArgumentsBytes() {
java.lang.Object ref = instanceIdentifierPathArguments_;
if (ref instanceof java.lang.String) {
com.google.protobuf.ByteString b =
- com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref);
+ com.google.protobuf.ByteString.copyFromUtf8(
+ (java.lang.String) ref);
instanceIdentifierPathArguments_ = b;
return b;
} else {
private void initFields() {
instanceIdentifierPathArguments_ = "";
}
-
private byte memoizedIsInitialized = -1;
-
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
- if (isInitialized != -1)
- return isInitialized == 1;
+ if (isInitialized != -1) return isInitialized == 1;
if (!hasInstanceIdentifierPathArguments()) {
memoizedIsInitialized = 0;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
- throws java.io.IOException {
+ throws java.io.IOException {
getSerializedSize();
if (((bitField0_ & 0x00000001) == 0x00000001)) {
output.writeBytes(1, getInstanceIdentifierPathArgumentsBytes());
}
private int memoizedSerializedSize = -1;
-
public int getSerializedSize() {
int size = memoizedSerializedSize;
- if (size != -1)
- return size;
+ if (size != -1) return size;
size = 0;
if (((bitField0_ & 0x00000001) == 0x00000001)) {
- size +=
- com.google.protobuf.CodedOutputStream.computeBytesSize(1,
- getInstanceIdentifierPathArgumentsBytes());
+ size += com.google.protobuf.CodedOutputStream
+ .computeBytesSize(1, getInstanceIdentifierPathArgumentsBytes());
}
size += getUnknownFields().getSerializedSize();
memoizedSerializedSize = size;
}
private static final long serialVersionUID = 0L;
-
@java.lang.Override
protected java.lang.Object writeReplace()
throws java.io.ObjectStreamException {
return super.writeReplace();
}
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData parseFrom(
- byte[] data) throws com.google.protobuf.InvalidProtocolBufferException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData parseFrom(
- byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData parseFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData parseDelimitedFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseDelimitedFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData parseDelimitedFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseDelimitedFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData parseFrom(
- com.google.protobuf.CodedInputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
- public static Builder newBuilder() {
- return Builder.create();
- }
-
- public Builder newBuilderForType() {
- return newBuilder();
- }
-
- public static Builder newBuilder(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData prototype) {
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData prototype) {
return newBuilder().mergeFrom(prototype);
}
-
- public Builder toBuilder() {
- return newBuilder(this);
- }
+ public Builder toBuilder() { return newBuilder(this); }
@java.lang.Override
protected Builder newBuilderForType(
Builder builder = new Builder(parent);
return builder;
}
-
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.ReadData}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessage.Builder<Builder>
- implements
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataOrBuilder {
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadData_descriptor;
+ implements org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadData_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadData_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadData_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData.Builder.class);
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData.Builder.class);
}
- // Construct using
- // org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData.newBuilder()
+ // Construct using org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
- private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
-
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
}
}
-
private static Builder create() {
return new Builder();
}
return create().mergeFrom(buildPartial());
}
- public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadData_descriptor;
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadData_descriptor;
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData getDefaultInstanceForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData
- .getDefaultInstance();
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData getDefaultInstanceForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData.getDefaultInstance();
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData build() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData result =
- buildPartial();
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData build() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData buildPartial() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData result =
- new org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData(
- this);
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData buildPartial() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData result = new org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData(this);
int from_bitField0_ = bitField0_;
int to_bitField0_ = 0;
if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
to_bitField0_ |= 0x00000001;
}
- result.instanceIdentifierPathArguments_ =
- instanceIdentifierPathArguments_;
+ result.instanceIdentifierPathArguments_ = instanceIdentifierPathArguments_;
result.bitField0_ = to_bitField0_;
onBuilt();
return result;
}
public Builder mergeFrom(com.google.protobuf.Message other) {
- if (other instanceof org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData) {
- return mergeFrom((org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData) other);
+ if (other instanceof org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData) {
+ return mergeFrom((org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData)other);
} else {
super.mergeFrom(other);
return this;
}
}
- public Builder mergeFrom(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData other) {
- if (other == org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData
- .getDefaultInstance())
- return this;
+ public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData other) {
+ if (other == org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData.getDefaultInstance()) return this;
if (other.hasInstanceIdentifierPathArguments()) {
bitField0_ |= 0x00000001;
- instanceIdentifierPathArguments_ =
- other.instanceIdentifierPathArguments_;
+ instanceIdentifierPathArguments_ = other.instanceIdentifierPathArguments_;
onChanged();
}
this.mergeUnknownFields(other.getUnknownFields());
return true;
}
- public Builder mergeFrom(com.google.protobuf.CodedInputStream input,
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData parsedMessage =
- null;
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
- parsedMessage =
- (org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadData) e
- .getUnfinishedMessage();
+ parsedMessage = (org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadData) e.getUnfinishedMessage();
throw e;
} finally {
if (parsedMessage != null) {
}
return this;
}
-
private int bitField0_;
// required string instanceIdentifierPathArguments = 1;
private java.lang.Object instanceIdentifierPathArguments_ = "";
-
/**
* <code>required string instanceIdentifierPathArguments = 1;</code>
*/
public boolean hasInstanceIdentifierPathArguments() {
return ((bitField0_ & 0x00000001) == 0x00000001);
}
-
/**
* <code>required string instanceIdentifierPathArguments = 1;</code>
*/
public java.lang.String getInstanceIdentifierPathArguments() {
java.lang.Object ref = instanceIdentifierPathArguments_;
if (!(ref instanceof java.lang.String)) {
- java.lang.String s =
- ((com.google.protobuf.ByteString) ref).toStringUtf8();
+ java.lang.String s = ((com.google.protobuf.ByteString) ref)
+ .toStringUtf8();
instanceIdentifierPathArguments_ = s;
return s;
} else {
return (java.lang.String) ref;
}
}
-
/**
* <code>required string instanceIdentifierPathArguments = 1;</code>
*/
- public com.google.protobuf.ByteString getInstanceIdentifierPathArgumentsBytes() {
+ public com.google.protobuf.ByteString
+ getInstanceIdentifierPathArgumentsBytes() {
java.lang.Object ref = instanceIdentifierPathArguments_;
if (ref instanceof String) {
com.google.protobuf.ByteString b =
- com.google.protobuf.ByteString
- .copyFromUtf8((java.lang.String) ref);
+ com.google.protobuf.ByteString.copyFromUtf8(
+ (java.lang.String) ref);
instanceIdentifierPathArguments_ = b;
return b;
} else {
return (com.google.protobuf.ByteString) ref;
}
}
-
/**
* <code>required string instanceIdentifierPathArguments = 1;</code>
*/
- public Builder setInstanceIdentifierPathArguments(java.lang.String value) {
+ public Builder setInstanceIdentifierPathArguments(
+ java.lang.String value) {
if (value == null) {
- throw new NullPointerException();
- }
- bitField0_ |= 0x00000001;
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000001;
instanceIdentifierPathArguments_ = value;
onChanged();
return this;
}
-
/**
* <code>required string instanceIdentifierPathArguments = 1;</code>
*/
public Builder clearInstanceIdentifierPathArguments() {
bitField0_ = (bitField0_ & ~0x00000001);
- instanceIdentifierPathArguments_ =
- getDefaultInstance().getInstanceIdentifierPathArguments();
+ instanceIdentifierPathArguments_ = getDefaultInstance().getInstanceIdentifierPathArguments();
onChanged();
return this;
}
-
/**
* <code>required string instanceIdentifierPathArguments = 1;</code>
*/
public Builder setInstanceIdentifierPathArgumentsBytes(
com.google.protobuf.ByteString value) {
if (value == null) {
- throw new NullPointerException();
- }
- bitField0_ |= 0x00000001;
+ throw new NullPointerException();
+ }
+ bitField0_ |= 0x00000001;
instanceIdentifierPathArguments_ = value;
onChanged();
return this;
// @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.ReadData)
}
- public interface ReadDataReplyOrBuilder extends
- com.google.protobuf.MessageOrBuilder {
+ public interface ReadDataReplyOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
// required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 1;
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 1;</code>
*/
boolean hasNormalizedNode();
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 1;</code>
*/
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml getNormalizedNode();
-
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml getNormalizedNode();
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 1;</code>
*/
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder getNormalizedNodeOrBuilder();
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder getNormalizedNodeOrBuilder();
}
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.ReadDataReply}
*/
public static final class ReadDataReply extends
- com.google.protobuf.GeneratedMessage implements ReadDataReplyOrBuilder {
+ com.google.protobuf.GeneratedMessage
+ implements ReadDataReplyOrBuilder {
// Use ReadDataReply.newBuilder() to construct.
- private ReadDataReply(
- com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ private ReadDataReply(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
super(builder);
this.unknownFields = builder.getUnknownFields();
}
-
- private ReadDataReply(boolean noInit) {
- this.unknownFields =
- com.google.protobuf.UnknownFieldSet.getDefaultInstance();
- }
+ private ReadDataReply(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
private static final ReadDataReply defaultInstance;
-
public static ReadDataReply getDefaultInstance() {
return defaultInstance;
}
}
private final com.google.protobuf.UnknownFieldSet unknownFields;
-
@java.lang.Override
- public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
return this.unknownFields;
}
-
- private ReadDataReply(com.google.protobuf.CodedInputStream input,
+ private ReadDataReply(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
initFields();
done = true;
break;
default: {
- if (!parseUnknownField(input, unknownFields, extensionRegistry,
- tag)) {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
done = true;
}
break;
}
case 10: {
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder subBuilder =
- null;
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder subBuilder = null;
if (((bitField0_ & 0x00000001) == 0x00000001)) {
subBuilder = normalizedNode_.toBuilder();
}
- normalizedNode_ =
- input
- .readMessage(
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.PARSER,
- extensionRegistry);
+ normalizedNode_ = input.readMessage(org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.PARSER, extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom(normalizedNode_);
normalizedNode_ = subBuilder.buildPartial();
makeExtensionsImmutable();
}
}
-
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadDataReply_descriptor;
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadDataReply_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadDataReply_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadDataReply_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply.Builder.class);
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply.Builder.class);
}
public static com.google.protobuf.Parser<ReadDataReply> PARSER =
new com.google.protobuf.AbstractParser<ReadDataReply>() {
- public ReadDataReply parsePartialFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return new ReadDataReply(input, extensionRegistry);
- }
- };
+ public ReadDataReply parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new ReadDataReply(input, extensionRegistry);
+ }
+ };
@java.lang.Override
public com.google.protobuf.Parser<ReadDataReply> getParserForType() {
private int bitField0_;
// required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 1;
public static final int NORMALIZEDNODE_FIELD_NUMBER = 1;
- private org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml normalizedNode_;
-
+ private org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml normalizedNode_;
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 1;</code>
*/
public boolean hasNormalizedNode() {
return ((bitField0_ & 0x00000001) == 0x00000001);
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 1;</code>
*/
- public org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml getNormalizedNode() {
+ public org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml getNormalizedNode() {
return normalizedNode_;
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 1;</code>
*/
- public org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder getNormalizedNodeOrBuilder() {
+ public org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder getNormalizedNodeOrBuilder() {
return normalizedNode_;
}
private void initFields() {
- normalizedNode_ =
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml
- .getDefaultInstance();
+ normalizedNode_ = org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.getDefaultInstance();
}
-
private byte memoizedIsInitialized = -1;
-
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
- if (isInitialized != -1)
- return isInitialized == 1;
+ if (isInitialized != -1) return isInitialized == 1;
if (!hasNormalizedNode()) {
memoizedIsInitialized = 0;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
- throws java.io.IOException {
+ throws java.io.IOException {
getSerializedSize();
if (((bitField0_ & 0x00000001) == 0x00000001)) {
output.writeMessage(1, normalizedNode_);
}
private int memoizedSerializedSize = -1;
-
public int getSerializedSize() {
int size = memoizedSerializedSize;
- if (size != -1)
- return size;
+ if (size != -1) return size;
size = 0;
if (((bitField0_ & 0x00000001) == 0x00000001)) {
- size +=
- com.google.protobuf.CodedOutputStream.computeMessageSize(1,
- normalizedNode_);
+ size += com.google.protobuf.CodedOutputStream
+ .computeMessageSize(1, normalizedNode_);
}
size += getUnknownFields().getSerializedSize();
memoizedSerializedSize = size;
}
private static final long serialVersionUID = 0L;
-
@java.lang.Override
protected java.lang.Object writeReplace()
throws java.io.ObjectStreamException {
return super.writeReplace();
}
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply parseFrom(
- byte[] data) throws com.google.protobuf.InvalidProtocolBufferException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply parseFrom(
- byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply parseFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply parseDelimitedFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseDelimitedFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply parseDelimitedFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseDelimitedFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply parseFrom(
- com.google.protobuf.CodedInputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
- public static Builder newBuilder() {
- return Builder.create();
- }
-
- public Builder newBuilderForType() {
- return newBuilder();
- }
-
- public static Builder newBuilder(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply prototype) {
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply prototype) {
return newBuilder().mergeFrom(prototype);
}
-
- public Builder toBuilder() {
- return newBuilder(this);
- }
+ public Builder toBuilder() { return newBuilder(this); }
@java.lang.Override
protected Builder newBuilderForType(
Builder builder = new Builder(parent);
return builder;
}
-
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.ReadDataReply}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessage.Builder<Builder>
- implements
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReplyOrBuilder {
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadDataReply_descriptor;
+ implements org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReplyOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadDataReply_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadDataReply_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadDataReply_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply.Builder.class);
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply.Builder.class);
}
- // Construct using
- // org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply.newBuilder()
+ // Construct using org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
- private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
-
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
getNormalizedNodeFieldBuilder();
}
}
-
private static Builder create() {
return new Builder();
}
public Builder clear() {
super.clear();
if (normalizedNodeBuilder_ == null) {
- normalizedNode_ =
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml
- .getDefaultInstance();
+ normalizedNode_ = org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.getDefaultInstance();
} else {
normalizedNodeBuilder_.clear();
}
return create().mergeFrom(buildPartial());
}
- public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadDataReply_descriptor;
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_ReadDataReply_descriptor;
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply getDefaultInstanceForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply
- .getDefaultInstance();
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply getDefaultInstanceForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply.getDefaultInstance();
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply build() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply result =
- buildPartial();
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply build() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply buildPartial() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply result =
- new org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply(
- this);
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply buildPartial() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply result = new org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply(this);
int from_bitField0_ = bitField0_;
int to_bitField0_ = 0;
if (((from_bitField0_ & 0x00000001) == 0x00000001)) {
}
public Builder mergeFrom(com.google.protobuf.Message other) {
- if (other instanceof org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply) {
- return mergeFrom((org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply) other);
+ if (other instanceof org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply) {
+ return mergeFrom((org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply)other);
} else {
super.mergeFrom(other);
return this;
}
}
- public Builder mergeFrom(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply other) {
- if (other == org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply
- .getDefaultInstance())
- return this;
+ public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply other) {
+ if (other == org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply.getDefaultInstance()) return this;
if (other.hasNormalizedNode()) {
mergeNormalizedNode(other.getNormalizedNode());
}
return true;
}
- public Builder mergeFrom(com.google.protobuf.CodedInputStream input,
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply parsedMessage =
- null;
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
- parsedMessage =
- (org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.ReadDataReply) e
- .getUnfinishedMessage();
+ parsedMessage = (org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.ReadDataReply) e.getUnfinishedMessage();
throw e;
} finally {
if (parsedMessage != null) {
}
return this;
}
-
private int bitField0_;
// required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 1;
- private org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml normalizedNode_ =
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml
- .getDefaultInstance();
- private com.google.protobuf.SingleFieldBuilder<org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml, org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder, org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder> normalizedNodeBuilder_;
-
+ private org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml normalizedNode_ = org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.getDefaultInstance();
+ private com.google.protobuf.SingleFieldBuilder<
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml, org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder, org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder> normalizedNodeBuilder_;
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 1;</code>
*/
public boolean hasNormalizedNode() {
return ((bitField0_ & 0x00000001) == 0x00000001);
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 1;</code>
*/
- public org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml getNormalizedNode() {
+ public org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml getNormalizedNode() {
if (normalizedNodeBuilder_ == null) {
return normalizedNode_;
} else {
return normalizedNodeBuilder_.getMessage();
}
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 1;</code>
*/
- public Builder setNormalizedNode(
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml value) {
+ public Builder setNormalizedNode(org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml value) {
if (normalizedNodeBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
bitField0_ |= 0x00000001;
return this;
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 1;</code>
*/
public Builder setNormalizedNode(
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder builderForValue) {
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder builderForValue) {
if (normalizedNodeBuilder_ == null) {
normalizedNode_ = builderForValue.build();
onChanged();
bitField0_ |= 0x00000001;
return this;
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 1;</code>
*/
- public Builder mergeNormalizedNode(
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml value) {
+ public Builder mergeNormalizedNode(org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml value) {
if (normalizedNodeBuilder_ == null) {
- if (((bitField0_ & 0x00000001) == 0x00000001)
- && normalizedNode_ != org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml
- .getDefaultInstance()) {
+ if (((bitField0_ & 0x00000001) == 0x00000001) &&
+ normalizedNode_ != org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.getDefaultInstance()) {
normalizedNode_ =
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml
- .newBuilder(normalizedNode_).mergeFrom(value)
- .buildPartial();
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.newBuilder(normalizedNode_).mergeFrom(value).buildPartial();
} else {
normalizedNode_ = value;
}
bitField0_ |= 0x00000001;
return this;
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 1;</code>
*/
public Builder clearNormalizedNode() {
if (normalizedNodeBuilder_ == null) {
- normalizedNode_ =
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml
- .getDefaultInstance();
+ normalizedNode_ = org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.getDefaultInstance();
onChanged();
} else {
normalizedNodeBuilder_.clear();
bitField0_ = (bitField0_ & ~0x00000001);
return this;
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 1;</code>
*/
- public org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder getNormalizedNodeBuilder() {
+ public org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder getNormalizedNodeBuilder() {
bitField0_ |= 0x00000001;
onChanged();
return getNormalizedNodeFieldBuilder().getBuilder();
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 1;</code>
*/
- public org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder getNormalizedNodeOrBuilder() {
+ public org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder getNormalizedNodeOrBuilder() {
if (normalizedNodeBuilder_ != null) {
return normalizedNodeBuilder_.getMessageOrBuilder();
} else {
return normalizedNode_;
}
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 1;</code>
*/
- private com.google.protobuf.SingleFieldBuilder<org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml, org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder, org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder> getNormalizedNodeFieldBuilder() {
+ private com.google.protobuf.SingleFieldBuilder<
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml, org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder, org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder>
+ getNormalizedNodeFieldBuilder() {
if (normalizedNodeBuilder_ == null) {
- normalizedNodeBuilder_ =
- new com.google.protobuf.SingleFieldBuilder<org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml, org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder, org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder>(
- normalizedNode_, getParentForChildren(), isClean());
+ normalizedNodeBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml, org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder, org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder>(
+ normalizedNode_,
+ getParentForChildren(),
+ isClean());
normalizedNode_ = null;
}
return normalizedNodeBuilder_;
// @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.ReadDataReply)
}
- public interface WriteDataOrBuilder extends
- com.google.protobuf.MessageOrBuilder {
+ public interface WriteDataOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
// repeated string instanceIdentifierPathArguments = 1;
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
- java.util.List<java.lang.String> getInstanceIdentifierPathArgumentsList();
-
+ java.util.List<java.lang.String>
+ getInstanceIdentifierPathArgumentsList();
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
int getInstanceIdentifierPathArgumentsCount();
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
java.lang.String getInstanceIdentifierPathArguments(int index);
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
- com.google.protobuf.ByteString getInstanceIdentifierPathArgumentsBytes(
- int index);
+ com.google.protobuf.ByteString
+ getInstanceIdentifierPathArgumentsBytes(int index);
// required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 2;
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 2;</code>
*/
boolean hasNormalizedNode();
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 2;</code>
*/
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml getNormalizedNode();
-
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml getNormalizedNode();
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 2;</code>
*/
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder getNormalizedNodeOrBuilder();
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder getNormalizedNodeOrBuilder();
}
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.WriteData}
*/
public static final class WriteData extends
- com.google.protobuf.GeneratedMessage implements WriteDataOrBuilder {
+ com.google.protobuf.GeneratedMessage
+ implements WriteDataOrBuilder {
// Use WriteData.newBuilder() to construct.
private WriteData(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
super(builder);
this.unknownFields = builder.getUnknownFields();
}
-
- private WriteData(boolean noInit) {
- this.unknownFields =
- com.google.protobuf.UnknownFieldSet.getDefaultInstance();
- }
+ private WriteData(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
private static final WriteData defaultInstance;
-
public static WriteData getDefaultInstance() {
return defaultInstance;
}
}
private final com.google.protobuf.UnknownFieldSet unknownFields;
-
@java.lang.Override
- public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
return this.unknownFields;
}
-
- private WriteData(com.google.protobuf.CodedInputStream input,
+ private WriteData(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
initFields();
done = true;
break;
default: {
- if (!parseUnknownField(input, unknownFields, extensionRegistry,
- tag)) {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
done = true;
}
break;
}
case 10: {
if (!((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
- instanceIdentifierPathArguments_ =
- new com.google.protobuf.LazyStringArrayList();
+ instanceIdentifierPathArguments_ = new com.google.protobuf.LazyStringArrayList();
mutable_bitField0_ |= 0x00000001;
}
instanceIdentifierPathArguments_.add(input.readBytes());
break;
}
case 18: {
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder subBuilder =
- null;
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder subBuilder = null;
if (((bitField0_ & 0x00000001) == 0x00000001)) {
subBuilder = normalizedNode_.toBuilder();
}
- normalizedNode_ =
- input
- .readMessage(
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.PARSER,
- extensionRegistry);
+ normalizedNode_ = input.readMessage(org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.PARSER, extensionRegistry);
if (subBuilder != null) {
subBuilder.mergeFrom(normalizedNode_);
normalizedNode_ = subBuilder.buildPartial();
e.getMessage()).setUnfinishedMessage(this);
} finally {
if (((mutable_bitField0_ & 0x00000001) == 0x00000001)) {
- instanceIdentifierPathArguments_ =
- new com.google.protobuf.UnmodifiableLazyStringList(
- instanceIdentifierPathArguments_);
+ instanceIdentifierPathArguments_ = new com.google.protobuf.UnmodifiableLazyStringList(instanceIdentifierPathArguments_);
}
this.unknownFields = unknownFields.build();
makeExtensionsImmutable();
}
}
-
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_WriteData_descriptor;
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_WriteData_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_WriteData_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_WriteData_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData.Builder.class);
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData.Builder.class);
}
public static com.google.protobuf.Parser<WriteData> PARSER =
new com.google.protobuf.AbstractParser<WriteData>() {
- public WriteData parsePartialFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return new WriteData(input, extensionRegistry);
- }
- };
+ public WriteData parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new WriteData(input, extensionRegistry);
+ }
+ };
@java.lang.Override
public com.google.protobuf.Parser<WriteData> getParserForType() {
// repeated string instanceIdentifierPathArguments = 1;
public static final int INSTANCEIDENTIFIERPATHARGUMENTS_FIELD_NUMBER = 1;
private com.google.protobuf.LazyStringList instanceIdentifierPathArguments_;
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
- public java.util.List<java.lang.String> getInstanceIdentifierPathArgumentsList() {
+ public java.util.List<java.lang.String>
+ getInstanceIdentifierPathArgumentsList() {
return instanceIdentifierPathArguments_;
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
public int getInstanceIdentifierPathArgumentsCount() {
return instanceIdentifierPathArguments_.size();
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
public java.lang.String getInstanceIdentifierPathArguments(int index) {
return instanceIdentifierPathArguments_.get(index);
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
- public com.google.protobuf.ByteString getInstanceIdentifierPathArgumentsBytes(
- int index) {
+ public com.google.protobuf.ByteString
+ getInstanceIdentifierPathArgumentsBytes(int index) {
return instanceIdentifierPathArguments_.getByteString(index);
}
// required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 2;
public static final int NORMALIZEDNODE_FIELD_NUMBER = 2;
- private org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml normalizedNode_;
-
+ private org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml normalizedNode_;
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 2;</code>
*/
public boolean hasNormalizedNode() {
return ((bitField0_ & 0x00000001) == 0x00000001);
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 2;</code>
*/
- public org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml getNormalizedNode() {
+ public org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml getNormalizedNode() {
return normalizedNode_;
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 2;</code>
*/
- public org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder getNormalizedNodeOrBuilder() {
+ public org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder getNormalizedNodeOrBuilder() {
return normalizedNode_;
}
private void initFields() {
- instanceIdentifierPathArguments_ =
- com.google.protobuf.LazyStringArrayList.EMPTY;
- normalizedNode_ =
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml
- .getDefaultInstance();
+ instanceIdentifierPathArguments_ = com.google.protobuf.LazyStringArrayList.EMPTY;
+ normalizedNode_ = org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.getDefaultInstance();
}
-
private byte memoizedIsInitialized = -1;
-
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
- if (isInitialized != -1)
- return isInitialized == 1;
+ if (isInitialized != -1) return isInitialized == 1;
if (!hasNormalizedNode()) {
memoizedIsInitialized = 0;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
- throws java.io.IOException {
+ throws java.io.IOException {
getSerializedSize();
for (int i = 0; i < instanceIdentifierPathArguments_.size(); i++) {
output.writeBytes(1, instanceIdentifierPathArguments_.getByteString(i));
}
private int memoizedSerializedSize = -1;
-
public int getSerializedSize() {
int size = memoizedSerializedSize;
- if (size != -1)
- return size;
+ if (size != -1) return size;
size = 0;
{
int dataSize = 0;
for (int i = 0; i < instanceIdentifierPathArguments_.size(); i++) {
- dataSize +=
- com.google.protobuf.CodedOutputStream
- .computeBytesSizeNoTag(instanceIdentifierPathArguments_
- .getByteString(i));
+ dataSize += com.google.protobuf.CodedOutputStream
+ .computeBytesSizeNoTag(instanceIdentifierPathArguments_.getByteString(i));
}
size += dataSize;
size += 1 * getInstanceIdentifierPathArgumentsList().size();
}
if (((bitField0_ & 0x00000001) == 0x00000001)) {
- size +=
- com.google.protobuf.CodedOutputStream.computeMessageSize(2,
- normalizedNode_);
+ size += com.google.protobuf.CodedOutputStream
+ .computeMessageSize(2, normalizedNode_);
}
size += getUnknownFields().getSerializedSize();
memoizedSerializedSize = size;
}
private static final long serialVersionUID = 0L;
-
@java.lang.Override
protected java.lang.Object writeReplace()
throws java.io.ObjectStreamException {
return super.writeReplace();
}
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData parseFrom(
- byte[] data) throws com.google.protobuf.InvalidProtocolBufferException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData parseFrom(
- byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData parseFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData parseDelimitedFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseDelimitedFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData parseDelimitedFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseDelimitedFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData parseFrom(
- com.google.protobuf.CodedInputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
- public static Builder newBuilder() {
- return Builder.create();
- }
-
- public Builder newBuilderForType() {
- return newBuilder();
- }
-
- public static Builder newBuilder(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData prototype) {
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData prototype) {
return newBuilder().mergeFrom(prototype);
}
-
- public Builder toBuilder() {
- return newBuilder(this);
- }
+ public Builder toBuilder() { return newBuilder(this); }
@java.lang.Override
protected Builder newBuilderForType(
Builder builder = new Builder(parent);
return builder;
}
-
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.WriteData}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessage.Builder<Builder>
- implements
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataOrBuilder {
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_WriteData_descriptor;
+ implements org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_WriteData_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_WriteData_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_WriteData_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData.Builder.class);
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData.Builder.class);
}
- // Construct using
- // org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData.newBuilder()
+ // Construct using org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
- private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
-
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
getNormalizedNodeFieldBuilder();
}
}
-
private static Builder create() {
return new Builder();
}
public Builder clear() {
super.clear();
- instanceIdentifierPathArguments_ =
- com.google.protobuf.LazyStringArrayList.EMPTY;
+ instanceIdentifierPathArguments_ = com.google.protobuf.LazyStringArrayList.EMPTY;
bitField0_ = (bitField0_ & ~0x00000001);
if (normalizedNodeBuilder_ == null) {
- normalizedNode_ =
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml
- .getDefaultInstance();
+ normalizedNode_ = org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.getDefaultInstance();
} else {
normalizedNodeBuilder_.clear();
}
return create().mergeFrom(buildPartial());
}
- public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_WriteData_descriptor;
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_WriteData_descriptor;
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData getDefaultInstanceForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData
- .getDefaultInstance();
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData getDefaultInstanceForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData.getDefaultInstance();
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData build() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData result =
- buildPartial();
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData build() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData buildPartial() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData result =
- new org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData(
- this);
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData buildPartial() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData result = new org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData(this);
int from_bitField0_ = bitField0_;
int to_bitField0_ = 0;
if (((bitField0_ & 0x00000001) == 0x00000001)) {
- instanceIdentifierPathArguments_ =
- new com.google.protobuf.UnmodifiableLazyStringList(
- instanceIdentifierPathArguments_);
+ instanceIdentifierPathArguments_ = new com.google.protobuf.UnmodifiableLazyStringList(
+ instanceIdentifierPathArguments_);
bitField0_ = (bitField0_ & ~0x00000001);
}
- result.instanceIdentifierPathArguments_ =
- instanceIdentifierPathArguments_;
+ result.instanceIdentifierPathArguments_ = instanceIdentifierPathArguments_;
if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
to_bitField0_ |= 0x00000001;
}
}
public Builder mergeFrom(com.google.protobuf.Message other) {
- if (other instanceof org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData) {
- return mergeFrom((org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData) other);
+ if (other instanceof org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData) {
+ return mergeFrom((org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData)other);
} else {
super.mergeFrom(other);
return this;
}
}
- public Builder mergeFrom(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData other) {
- if (other == org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData
- .getDefaultInstance())
- return this;
+ public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData other) {
+ if (other == org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData.getDefaultInstance()) return this;
if (!other.instanceIdentifierPathArguments_.isEmpty()) {
if (instanceIdentifierPathArguments_.isEmpty()) {
- instanceIdentifierPathArguments_ =
- other.instanceIdentifierPathArguments_;
+ instanceIdentifierPathArguments_ = other.instanceIdentifierPathArguments_;
bitField0_ = (bitField0_ & ~0x00000001);
} else {
ensureInstanceIdentifierPathArgumentsIsMutable();
- instanceIdentifierPathArguments_
- .addAll(other.instanceIdentifierPathArguments_);
+ instanceIdentifierPathArguments_.addAll(other.instanceIdentifierPathArguments_);
}
onChanged();
}
return true;
}
- public Builder mergeFrom(com.google.protobuf.CodedInputStream input,
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData parsedMessage =
- null;
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
- parsedMessage =
- (org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteData) e
- .getUnfinishedMessage();
+ parsedMessage = (org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteData) e.getUnfinishedMessage();
throw e;
} finally {
if (parsedMessage != null) {
}
return this;
}
-
private int bitField0_;
// repeated string instanceIdentifierPathArguments = 1;
- private com.google.protobuf.LazyStringList instanceIdentifierPathArguments_ =
- com.google.protobuf.LazyStringArrayList.EMPTY;
-
+ private com.google.protobuf.LazyStringList instanceIdentifierPathArguments_ = com.google.protobuf.LazyStringArrayList.EMPTY;
private void ensureInstanceIdentifierPathArgumentsIsMutable() {
if (!((bitField0_ & 0x00000001) == 0x00000001)) {
- instanceIdentifierPathArguments_ =
- new com.google.protobuf.LazyStringArrayList(
- instanceIdentifierPathArguments_);
+ instanceIdentifierPathArguments_ = new com.google.protobuf.LazyStringArrayList(instanceIdentifierPathArguments_);
bitField0_ |= 0x00000001;
- }
+ }
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
- public java.util.List<java.lang.String> getInstanceIdentifierPathArgumentsList() {
- return java.util.Collections
- .unmodifiableList(instanceIdentifierPathArguments_);
+ public java.util.List<java.lang.String>
+ getInstanceIdentifierPathArgumentsList() {
+ return java.util.Collections.unmodifiableList(instanceIdentifierPathArguments_);
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
public int getInstanceIdentifierPathArgumentsCount() {
return instanceIdentifierPathArguments_.size();
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
public java.lang.String getInstanceIdentifierPathArguments(int index) {
return instanceIdentifierPathArguments_.get(index);
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
- public com.google.protobuf.ByteString getInstanceIdentifierPathArgumentsBytes(
- int index) {
+ public com.google.protobuf.ByteString
+ getInstanceIdentifierPathArgumentsBytes(int index) {
return instanceIdentifierPathArguments_.getByteString(index);
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
- public Builder setInstanceIdentifierPathArguments(int index,
- java.lang.String value) {
+ public Builder setInstanceIdentifierPathArguments(
+ int index, java.lang.String value) {
if (value == null) {
- throw new NullPointerException();
- }
- ensureInstanceIdentifierPathArgumentsIsMutable();
+ throw new NullPointerException();
+ }
+ ensureInstanceIdentifierPathArgumentsIsMutable();
instanceIdentifierPathArguments_.set(index, value);
onChanged();
return this;
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
- public Builder addInstanceIdentifierPathArguments(java.lang.String value) {
+ public Builder addInstanceIdentifierPathArguments(
+ java.lang.String value) {
if (value == null) {
- throw new NullPointerException();
- }
- ensureInstanceIdentifierPathArgumentsIsMutable();
+ throw new NullPointerException();
+ }
+ ensureInstanceIdentifierPathArgumentsIsMutable();
instanceIdentifierPathArguments_.add(value);
onChanged();
return this;
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
onChanged();
return this;
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
public Builder clearInstanceIdentifierPathArguments() {
- instanceIdentifierPathArguments_ =
- com.google.protobuf.LazyStringArrayList.EMPTY;
+ instanceIdentifierPathArguments_ = com.google.protobuf.LazyStringArrayList.EMPTY;
bitField0_ = (bitField0_ & ~0x00000001);
onChanged();
return this;
}
-
/**
* <code>repeated string instanceIdentifierPathArguments = 1;</code>
*/
public Builder addInstanceIdentifierPathArgumentsBytes(
com.google.protobuf.ByteString value) {
if (value == null) {
- throw new NullPointerException();
- }
- ensureInstanceIdentifierPathArgumentsIsMutable();
+ throw new NullPointerException();
+ }
+ ensureInstanceIdentifierPathArgumentsIsMutable();
instanceIdentifierPathArguments_.add(value);
onChanged();
return this;
}
// required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 2;
- private org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml normalizedNode_ =
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml
- .getDefaultInstance();
- private com.google.protobuf.SingleFieldBuilder<org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml, org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder, org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder> normalizedNodeBuilder_;
-
+ private org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml normalizedNode_ = org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.getDefaultInstance();
+ private com.google.protobuf.SingleFieldBuilder<
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml, org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder, org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder> normalizedNodeBuilder_;
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 2;</code>
*/
public boolean hasNormalizedNode() {
return ((bitField0_ & 0x00000002) == 0x00000002);
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 2;</code>
*/
- public org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml getNormalizedNode() {
+ public org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml getNormalizedNode() {
if (normalizedNodeBuilder_ == null) {
return normalizedNode_;
} else {
return normalizedNodeBuilder_.getMessage();
}
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 2;</code>
*/
- public Builder setNormalizedNode(
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml value) {
+ public Builder setNormalizedNode(org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml value) {
if (normalizedNodeBuilder_ == null) {
if (value == null) {
throw new NullPointerException();
bitField0_ |= 0x00000002;
return this;
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 2;</code>
*/
public Builder setNormalizedNode(
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder builderForValue) {
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder builderForValue) {
if (normalizedNodeBuilder_ == null) {
normalizedNode_ = builderForValue.build();
onChanged();
bitField0_ |= 0x00000002;
return this;
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 2;</code>
*/
- public Builder mergeNormalizedNode(
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml value) {
+ public Builder mergeNormalizedNode(org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml value) {
if (normalizedNodeBuilder_ == null) {
- if (((bitField0_ & 0x00000002) == 0x00000002)
- && normalizedNode_ != org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml
- .getDefaultInstance()) {
+ if (((bitField0_ & 0x00000002) == 0x00000002) &&
+ normalizedNode_ != org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.getDefaultInstance()) {
normalizedNode_ =
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml
- .newBuilder(normalizedNode_).mergeFrom(value)
- .buildPartial();
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.newBuilder(normalizedNode_).mergeFrom(value).buildPartial();
} else {
normalizedNode_ = value;
}
bitField0_ |= 0x00000002;
return this;
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 2;</code>
*/
public Builder clearNormalizedNode() {
if (normalizedNodeBuilder_ == null) {
- normalizedNode_ =
- org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml
- .getDefaultInstance();
+ normalizedNode_ = org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.getDefaultInstance();
onChanged();
} else {
normalizedNodeBuilder_.clear();
bitField0_ = (bitField0_ & ~0x00000002);
return this;
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 2;</code>
*/
- public org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder getNormalizedNodeBuilder() {
+ public org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder getNormalizedNodeBuilder() {
bitField0_ |= 0x00000002;
onChanged();
return getNormalizedNodeFieldBuilder().getBuilder();
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 2;</code>
*/
- public org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder getNormalizedNodeOrBuilder() {
+ public org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder getNormalizedNodeOrBuilder() {
if (normalizedNodeBuilder_ != null) {
return normalizedNodeBuilder_.getMessageOrBuilder();
} else {
return normalizedNode_;
}
}
-
/**
* <code>required .org.opendaylight.controller.mdsal.NormalizedNodeXml normalizedNode = 2;</code>
*/
- private com.google.protobuf.SingleFieldBuilder<org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml, org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder, org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder> getNormalizedNodeFieldBuilder() {
+ private com.google.protobuf.SingleFieldBuilder<
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml, org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder, org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder>
+ getNormalizedNodeFieldBuilder() {
if (normalizedNodeBuilder_ == null) {
- normalizedNodeBuilder_ =
- new com.google.protobuf.SingleFieldBuilder<org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml, org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder, org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder>(
- normalizedNode_, getParentForChildren(), isClean());
+ normalizedNodeBuilder_ = new com.google.protobuf.SingleFieldBuilder<
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml, org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXml.Builder, org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.NormalizedNodeXmlOrBuilder>(
+ normalizedNode_,
+ getParentForChildren(),
+ isClean());
normalizedNode_ = null;
}
return normalizedNodeBuilder_;
// @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.WriteData)
}
- public interface WriteDataReplyOrBuilder extends
- com.google.protobuf.MessageOrBuilder {
+ public interface WriteDataReplyOrBuilder
+ extends com.google.protobuf.MessageOrBuilder {
}
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.WriteDataReply}
*/
public static final class WriteDataReply extends
- com.google.protobuf.GeneratedMessage implements WriteDataReplyOrBuilder {
+ com.google.protobuf.GeneratedMessage
+ implements WriteDataReplyOrBuilder {
// Use WriteDataReply.newBuilder() to construct.
- private WriteDataReply(
- com.google.protobuf.GeneratedMessage.Builder<?> builder) {
+ private WriteDataReply(com.google.protobuf.GeneratedMessage.Builder<?> builder) {
super(builder);
this.unknownFields = builder.getUnknownFields();
}
-
- private WriteDataReply(boolean noInit) {
- this.unknownFields =
- com.google.protobuf.UnknownFieldSet.getDefaultInstance();
- }
+ private WriteDataReply(boolean noInit) { this.unknownFields = com.google.protobuf.UnknownFieldSet.getDefaultInstance(); }
private static final WriteDataReply defaultInstance;
-
public static WriteDataReply getDefaultInstance() {
return defaultInstance;
}
}
private final com.google.protobuf.UnknownFieldSet unknownFields;
-
@java.lang.Override
- public final com.google.protobuf.UnknownFieldSet getUnknownFields() {
+ public final com.google.protobuf.UnknownFieldSet
+ getUnknownFields() {
return this.unknownFields;
}
-
- private WriteDataReply(com.google.protobuf.CodedInputStream input,
+ private WriteDataReply(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
initFields();
done = true;
break;
default: {
- if (!parseUnknownField(input, unknownFields, extensionRegistry,
- tag)) {
+ if (!parseUnknownField(input, unknownFields,
+ extensionRegistry, tag)) {
done = true;
}
break;
makeExtensionsImmutable();
}
}
-
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_WriteDataReply_descriptor;
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_WriteDataReply_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_WriteDataReply_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_WriteDataReply_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply.Builder.class);
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply.Builder.class);
}
public static com.google.protobuf.Parser<WriteDataReply> PARSER =
new com.google.protobuf.AbstractParser<WriteDataReply>() {
- public WriteDataReply parsePartialFrom(
- com.google.protobuf.CodedInputStream input,
- com.google.protobuf.ExtensionRegistryLite extensionRegistry)
- throws com.google.protobuf.InvalidProtocolBufferException {
- return new WriteDataReply(input, extensionRegistry);
- }
- };
+ public WriteDataReply parsePartialFrom(
+ com.google.protobuf.CodedInputStream input,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ throws com.google.protobuf.InvalidProtocolBufferException {
+ return new WriteDataReply(input, extensionRegistry);
+ }
+ };
@java.lang.Override
public com.google.protobuf.Parser<WriteDataReply> getParserForType() {
return PARSER;
}
- private void initFields() {}
-
+ private void initFields() {
+ }
private byte memoizedIsInitialized = -1;
-
public final boolean isInitialized() {
byte isInitialized = memoizedIsInitialized;
- if (isInitialized != -1)
- return isInitialized == 1;
+ if (isInitialized != -1) return isInitialized == 1;
memoizedIsInitialized = 1;
return true;
}
public void writeTo(com.google.protobuf.CodedOutputStream output)
- throws java.io.IOException {
+ throws java.io.IOException {
getSerializedSize();
getUnknownFields().writeTo(output);
}
private int memoizedSerializedSize = -1;
-
public int getSerializedSize() {
int size = memoizedSerializedSize;
- if (size != -1)
- return size;
+ if (size != -1) return size;
size = 0;
size += getUnknownFields().getSerializedSize();
}
private static final long serialVersionUID = 0L;
-
@java.lang.Override
protected java.lang.Object writeReplace()
throws java.io.ObjectStreamException {
return super.writeReplace();
}
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply parseFrom(
com.google.protobuf.ByteString data)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply parseFrom(
com.google.protobuf.ByteString data,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply parseFrom(
- byte[] data) throws com.google.protobuf.InvalidProtocolBufferException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply parseFrom(byte[] data)
+ throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply parseFrom(
- byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply parseFrom(
+ byte[] data,
+ com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws com.google.protobuf.InvalidProtocolBufferException {
return PARSER.parseFrom(data, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply parseFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply parseFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply parseFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply parseDelimitedFrom(
- java.io.InputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply parseDelimitedFrom(java.io.InputStream input)
+ throws java.io.IOException {
return PARSER.parseDelimitedFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply parseDelimitedFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply parseDelimitedFrom(
java.io.InputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseDelimitedFrom(input, extensionRegistry);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply parseFrom(
- com.google.protobuf.CodedInputStream input) throws java.io.IOException {
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply parseFrom(
+ com.google.protobuf.CodedInputStream input)
+ throws java.io.IOException {
return PARSER.parseFrom(input);
}
-
- public static org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply parseFrom(
+ public static org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply parseFrom(
com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
return PARSER.parseFrom(input, extensionRegistry);
}
- public static Builder newBuilder() {
- return Builder.create();
- }
-
- public Builder newBuilderForType() {
- return newBuilder();
- }
-
- public static Builder newBuilder(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply prototype) {
+ public static Builder newBuilder() { return Builder.create(); }
+ public Builder newBuilderForType() { return newBuilder(); }
+ public static Builder newBuilder(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply prototype) {
return newBuilder().mergeFrom(prototype);
}
-
- public Builder toBuilder() {
- return newBuilder(this);
- }
+ public Builder toBuilder() { return newBuilder(this); }
@java.lang.Override
protected Builder newBuilderForType(
Builder builder = new Builder(parent);
return builder;
}
-
/**
* Protobuf type {@code org.opendaylight.controller.mdsal.WriteDataReply}
*/
public static final class Builder extends
com.google.protobuf.GeneratedMessage.Builder<Builder>
- implements
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReplyOrBuilder {
- public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_WriteDataReply_descriptor;
+ implements org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReplyOrBuilder {
+ public static final com.google.protobuf.Descriptors.Descriptor
+ getDescriptor() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_WriteDataReply_descriptor;
}
- protected com.google.protobuf.GeneratedMessage.FieldAccessorTable internalGetFieldAccessorTable() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_WriteDataReply_fieldAccessorTable
+ protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internalGetFieldAccessorTable() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_WriteDataReply_fieldAccessorTable
.ensureFieldAccessorsInitialized(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply.class,
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply.Builder.class);
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply.class, org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply.Builder.class);
}
- // Construct using
- // org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply.newBuilder()
+ // Construct using org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply.newBuilder()
private Builder() {
maybeForceBuilderInitialization();
}
- private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
+ private Builder(
+ com.google.protobuf.GeneratedMessage.BuilderParent parent) {
super(parent);
maybeForceBuilderInitialization();
}
-
private void maybeForceBuilderInitialization() {
if (com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders) {
}
}
-
private static Builder create() {
return new Builder();
}
return create().mergeFrom(buildPartial());
}
- public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_WriteDataReply_descriptor;
+ public com.google.protobuf.Descriptors.Descriptor
+ getDescriptorForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.internal_static_org_opendaylight_controller_mdsal_WriteDataReply_descriptor;
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply getDefaultInstanceForType() {
- return org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply
- .getDefaultInstance();
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply getDefaultInstanceForType() {
+ return org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply.getDefaultInstance();
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply build() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply result =
- buildPartial();
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply build() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply result = buildPartial();
if (!result.isInitialized()) {
throw newUninitializedMessageException(result);
}
return result;
}
- public org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply buildPartial() {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply result =
- new org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply(
- this);
+ public org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply buildPartial() {
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply result = new org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply(this);
onBuilt();
return result;
}
public Builder mergeFrom(com.google.protobuf.Message other) {
- if (other instanceof org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply) {
- return mergeFrom((org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply) other);
+ if (other instanceof org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply) {
+ return mergeFrom((org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply)other);
} else {
super.mergeFrom(other);
return this;
}
}
- public Builder mergeFrom(
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply other) {
- if (other == org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply
- .getDefaultInstance())
- return this;
+ public Builder mergeFrom(org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply other) {
+ if (other == org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply.getDefaultInstance()) return this;
this.mergeUnknownFields(other.getUnknownFields());
return this;
}
return true;
}
- public Builder mergeFrom(com.google.protobuf.CodedInputStream input,
+ public Builder mergeFrom(
+ com.google.protobuf.CodedInputStream input,
com.google.protobuf.ExtensionRegistryLite extensionRegistry)
throws java.io.IOException {
- org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply parsedMessage =
- null;
+ org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply parsedMessage = null;
try {
parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry);
} catch (com.google.protobuf.InvalidProtocolBufferException e) {
- parsedMessage =
- (org.opendaylight.controller.cluster.datastore.transaction.ShardTransactionMessages.WriteDataReply) e
- .getUnfinishedMessage();
+ parsedMessage = (org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages.WriteDataReply) e.getUnfinishedMessage();
throw e;
} finally {
if (parsedMessage != null) {
// @@protoc_insertion_point(class_scope:org.opendaylight.controller.mdsal.WriteDataReply)
}
- private static com.google.protobuf.Descriptors.Descriptor internal_static_org_opendaylight_controller_mdsal_CloseTransaction_descriptor;
- private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_org_opendaylight_controller_mdsal_CloseTransaction_fieldAccessorTable;
- private static com.google.protobuf.Descriptors.Descriptor internal_static_org_opendaylight_controller_mdsal_CloseTransactionReply_descriptor;
- private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_org_opendaylight_controller_mdsal_CloseTransactionReply_fieldAccessorTable;
- private static com.google.protobuf.Descriptors.Descriptor internal_static_org_opendaylight_controller_mdsal_CreateTransaction_descriptor;
- private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_org_opendaylight_controller_mdsal_CreateTransaction_fieldAccessorTable;
- private static com.google.protobuf.Descriptors.Descriptor internal_static_org_opendaylight_controller_mdsal_CreateTransactionReply_descriptor;
- private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_org_opendaylight_controller_mdsal_CreateTransactionReply_fieldAccessorTable;
- private static com.google.protobuf.Descriptors.Descriptor internal_static_org_opendaylight_controller_mdsal_ReadyTransaction_descriptor;
- private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_org_opendaylight_controller_mdsal_ReadyTransaction_fieldAccessorTable;
- private static com.google.protobuf.Descriptors.Descriptor internal_static_org_opendaylight_controller_mdsal_ReadyTransactionReply_descriptor;
- private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_org_opendaylight_controller_mdsal_ReadyTransactionReply_fieldAccessorTable;
- private static com.google.protobuf.Descriptors.Descriptor internal_static_org_opendaylight_controller_mdsal_DeleteData_descriptor;
- private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_org_opendaylight_controller_mdsal_DeleteData_fieldAccessorTable;
- private static com.google.protobuf.Descriptors.Descriptor internal_static_org_opendaylight_controller_mdsal_DeleteDataReply_descriptor;
- private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_org_opendaylight_controller_mdsal_DeleteDataReply_fieldAccessorTable;
- private static com.google.protobuf.Descriptors.Descriptor internal_static_org_opendaylight_controller_mdsal_ReadData_descriptor;
- private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_org_opendaylight_controller_mdsal_ReadData_fieldAccessorTable;
- private static com.google.protobuf.Descriptors.Descriptor internal_static_org_opendaylight_controller_mdsal_ReadDataReply_descriptor;
- private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_org_opendaylight_controller_mdsal_ReadDataReply_fieldAccessorTable;
- private static com.google.protobuf.Descriptors.Descriptor internal_static_org_opendaylight_controller_mdsal_WriteData_descriptor;
- private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_org_opendaylight_controller_mdsal_WriteData_fieldAccessorTable;
- private static com.google.protobuf.Descriptors.Descriptor internal_static_org_opendaylight_controller_mdsal_WriteDataReply_descriptor;
- private static com.google.protobuf.GeneratedMessage.FieldAccessorTable internal_static_org_opendaylight_controller_mdsal_WriteDataReply_fieldAccessorTable;
-
- public static com.google.protobuf.Descriptors.FileDescriptor getDescriptor() {
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_org_opendaylight_controller_mdsal_CloseTransaction_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_org_opendaylight_controller_mdsal_CloseTransaction_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_org_opendaylight_controller_mdsal_CloseTransactionReply_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_org_opendaylight_controller_mdsal_CloseTransactionReply_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_org_opendaylight_controller_mdsal_CreateTransaction_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_org_opendaylight_controller_mdsal_CreateTransaction_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_org_opendaylight_controller_mdsal_CreateTransactionReply_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_org_opendaylight_controller_mdsal_CreateTransactionReply_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_org_opendaylight_controller_mdsal_ReadyTransaction_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_org_opendaylight_controller_mdsal_ReadyTransaction_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_org_opendaylight_controller_mdsal_ReadyTransactionReply_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_org_opendaylight_controller_mdsal_ReadyTransactionReply_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_org_opendaylight_controller_mdsal_DeleteData_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_org_opendaylight_controller_mdsal_DeleteData_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_org_opendaylight_controller_mdsal_DeleteDataReply_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_org_opendaylight_controller_mdsal_DeleteDataReply_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_org_opendaylight_controller_mdsal_ReadData_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_org_opendaylight_controller_mdsal_ReadData_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_org_opendaylight_controller_mdsal_ReadDataReply_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_org_opendaylight_controller_mdsal_ReadDataReply_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_org_opendaylight_controller_mdsal_WriteData_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_org_opendaylight_controller_mdsal_WriteData_fieldAccessorTable;
+ private static com.google.protobuf.Descriptors.Descriptor
+ internal_static_org_opendaylight_controller_mdsal_WriteDataReply_descriptor;
+ private static
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable
+ internal_static_org_opendaylight_controller_mdsal_WriteDataReply_fieldAccessorTable;
+
+ public static com.google.protobuf.Descriptors.FileDescriptor
+ getDescriptor() {
return descriptor;
}
-
- private static com.google.protobuf.Descriptors.FileDescriptor descriptor;
+ private static com.google.protobuf.Descriptors.FileDescriptor
+ descriptor;
static {
- java.lang.String[] descriptorData =
- {
- "\n\026ShardTransaction.proto\022!org.opendaylig"
- + "ht.controller.mdsal\032\032SimpleNormalizedNod"
- + "e.proto\"\022\n\020CloseTransaction\"\027\n\025CloseTran"
- + "sactionReply\"\023\n\021CreateTransaction\"1\n\026Cre"
- + "ateTransactionReply\022\027\n\017transactionPath\030\001"
- + " \002(\t\"\022\n\020ReadyTransaction\"*\n\025ReadyTransac"
- + "tionReply\022\021\n\tactorPath\030\001 \002(\t\"5\n\nDeleteDa"
- + "ta\022\'\n\037instanceIdentifierPathArguments\030\001 "
- + "\003(\t\"\021\n\017DeleteDataReply\"3\n\010ReadData\022\'\n\037in"
- + "stanceIdentifierPathArguments\030\001 \002(\t\"]\n\rR",
- "eadDataReply\022L\n\016normalizedNode\030\001 \002(\01324.o"
- + "rg.opendaylight.controller.mdsal.Normali"
- + "zedNodeXml\"\202\001\n\tWriteData\022\'\n\037instanceIden"
- + "tifierPathArguments\030\001 \003(\t\022L\n\016normalizedN"
- + "ode\030\002 \002(\01324.org.opendaylight.controller."
- + "mdsal.NormalizedNodeXml\"\020\n\016WriteDataRepl"
- + "yBU\n9org.opendaylight.controller.cluster"
- + ".datastore.transactionB\030ShardTransaction" + "Messages"};
+ java.lang.String[] descriptorData = {
+ "\n\026ShardTransaction.proto\022!org.opendaylig" +
+ "ht.controller.mdsal\032\032SimpleNormalizedNod" +
+ "e.proto\"\022\n\020CloseTransaction\"\027\n\025CloseTran" +
+ "sactionReply\"\023\n\021CreateTransaction\"1\n\026Cre" +
+ "ateTransactionReply\022\027\n\017transactionPath\030\001" +
+ " \002(\t\"\022\n\020ReadyTransaction\"*\n\025ReadyTransac" +
+ "tionReply\022\021\n\tactorPath\030\001 \002(\t\"5\n\nDeleteDa" +
+ "ta\022\'\n\037instanceIdentifierPathArguments\030\001 " +
+ "\003(\t\"\021\n\017DeleteDataReply\"3\n\010ReadData\022\'\n\037in" +
+ "stanceIdentifierPathArguments\030\001 \002(\t\"]\n\rR",
+ "eadDataReply\022L\n\016normalizedNode\030\001 \002(\01324.o" +
+ "rg.opendaylight.controller.mdsal.Normali" +
+ "zedNodeXml\"\202\001\n\tWriteData\022\'\n\037instanceIden" +
+ "tifierPathArguments\030\001 \003(\t\022L\n\016normalizedN" +
+ "ode\030\002 \002(\01324.org.opendaylight.controller." +
+ "mdsal.NormalizedNodeXml\"\020\n\016WriteDataRepl" +
+ "yBV\n:org.opendaylight.controller.protobu" +
+ "ff.messages.transactionB\030ShardTransactio" +
+ "nMessages"
+ };
com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
- new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
- public com.google.protobuf.ExtensionRegistry assignDescriptors(
- com.google.protobuf.Descriptors.FileDescriptor root) {
- descriptor = root;
- internal_static_org_opendaylight_controller_mdsal_CloseTransaction_descriptor =
- getDescriptor().getMessageTypes().get(0);
- internal_static_org_opendaylight_controller_mdsal_CloseTransaction_fieldAccessorTable =
- new com.google.protobuf.GeneratedMessage.FieldAccessorTable(
- internal_static_org_opendaylight_controller_mdsal_CloseTransaction_descriptor,
- new java.lang.String[] {});
- internal_static_org_opendaylight_controller_mdsal_CloseTransactionReply_descriptor =
- getDescriptor().getMessageTypes().get(1);
- internal_static_org_opendaylight_controller_mdsal_CloseTransactionReply_fieldAccessorTable =
- new com.google.protobuf.GeneratedMessage.FieldAccessorTable(
- internal_static_org_opendaylight_controller_mdsal_CloseTransactionReply_descriptor,
- new java.lang.String[] {});
- internal_static_org_opendaylight_controller_mdsal_CreateTransaction_descriptor =
- getDescriptor().getMessageTypes().get(2);
- internal_static_org_opendaylight_controller_mdsal_CreateTransaction_fieldAccessorTable =
- new com.google.protobuf.GeneratedMessage.FieldAccessorTable(
- internal_static_org_opendaylight_controller_mdsal_CreateTransaction_descriptor,
- new java.lang.String[] {});
- internal_static_org_opendaylight_controller_mdsal_CreateTransactionReply_descriptor =
- getDescriptor().getMessageTypes().get(3);
- internal_static_org_opendaylight_controller_mdsal_CreateTransactionReply_fieldAccessorTable =
- new com.google.protobuf.GeneratedMessage.FieldAccessorTable(
- internal_static_org_opendaylight_controller_mdsal_CreateTransactionReply_descriptor,
- new java.lang.String[] {"TransactionPath",});
- internal_static_org_opendaylight_controller_mdsal_ReadyTransaction_descriptor =
- getDescriptor().getMessageTypes().get(4);
- internal_static_org_opendaylight_controller_mdsal_ReadyTransaction_fieldAccessorTable =
- new com.google.protobuf.GeneratedMessage.FieldAccessorTable(
- internal_static_org_opendaylight_controller_mdsal_ReadyTransaction_descriptor,
- new java.lang.String[] {});
- internal_static_org_opendaylight_controller_mdsal_ReadyTransactionReply_descriptor =
- getDescriptor().getMessageTypes().get(5);
- internal_static_org_opendaylight_controller_mdsal_ReadyTransactionReply_fieldAccessorTable =
- new com.google.protobuf.GeneratedMessage.FieldAccessorTable(
- internal_static_org_opendaylight_controller_mdsal_ReadyTransactionReply_descriptor,
- new java.lang.String[] {"ActorPath",});
- internal_static_org_opendaylight_controller_mdsal_DeleteData_descriptor =
- getDescriptor().getMessageTypes().get(6);
- internal_static_org_opendaylight_controller_mdsal_DeleteData_fieldAccessorTable =
- new com.google.protobuf.GeneratedMessage.FieldAccessorTable(
- internal_static_org_opendaylight_controller_mdsal_DeleteData_descriptor,
- new java.lang.String[] {"InstanceIdentifierPathArguments",});
- internal_static_org_opendaylight_controller_mdsal_DeleteDataReply_descriptor =
- getDescriptor().getMessageTypes().get(7);
- internal_static_org_opendaylight_controller_mdsal_DeleteDataReply_fieldAccessorTable =
- new com.google.protobuf.GeneratedMessage.FieldAccessorTable(
- internal_static_org_opendaylight_controller_mdsal_DeleteDataReply_descriptor,
- new java.lang.String[] {});
- internal_static_org_opendaylight_controller_mdsal_ReadData_descriptor =
- getDescriptor().getMessageTypes().get(8);
- internal_static_org_opendaylight_controller_mdsal_ReadData_fieldAccessorTable =
- new com.google.protobuf.GeneratedMessage.FieldAccessorTable(
- internal_static_org_opendaylight_controller_mdsal_ReadData_descriptor,
- new java.lang.String[] {"InstanceIdentifierPathArguments",});
- internal_static_org_opendaylight_controller_mdsal_ReadDataReply_descriptor =
- getDescriptor().getMessageTypes().get(9);
- internal_static_org_opendaylight_controller_mdsal_ReadDataReply_fieldAccessorTable =
- new com.google.protobuf.GeneratedMessage.FieldAccessorTable(
- internal_static_org_opendaylight_controller_mdsal_ReadDataReply_descriptor,
- new java.lang.String[] {"NormalizedNode",});
- internal_static_org_opendaylight_controller_mdsal_WriteData_descriptor =
- getDescriptor().getMessageTypes().get(10);
- internal_static_org_opendaylight_controller_mdsal_WriteData_fieldAccessorTable =
- new com.google.protobuf.GeneratedMessage.FieldAccessorTable(
- internal_static_org_opendaylight_controller_mdsal_WriteData_descriptor,
- new java.lang.String[] {"InstanceIdentifierPathArguments",
- "NormalizedNode",});
- internal_static_org_opendaylight_controller_mdsal_WriteDataReply_descriptor =
- getDescriptor().getMessageTypes().get(11);
- internal_static_org_opendaylight_controller_mdsal_WriteDataReply_fieldAccessorTable =
- new com.google.protobuf.GeneratedMessage.FieldAccessorTable(
- internal_static_org_opendaylight_controller_mdsal_WriteDataReply_descriptor,
- new java.lang.String[] {});
- return null;
- }
- };
+ new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
+ public com.google.protobuf.ExtensionRegistry assignDescriptors(
+ com.google.protobuf.Descriptors.FileDescriptor root) {
+ descriptor = root;
+ internal_static_org_opendaylight_controller_mdsal_CloseTransaction_descriptor =
+ getDescriptor().getMessageTypes().get(0);
+ internal_static_org_opendaylight_controller_mdsal_CloseTransaction_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_org_opendaylight_controller_mdsal_CloseTransaction_descriptor,
+ new java.lang.String[] { });
+ internal_static_org_opendaylight_controller_mdsal_CloseTransactionReply_descriptor =
+ getDescriptor().getMessageTypes().get(1);
+ internal_static_org_opendaylight_controller_mdsal_CloseTransactionReply_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_org_opendaylight_controller_mdsal_CloseTransactionReply_descriptor,
+ new java.lang.String[] { });
+ internal_static_org_opendaylight_controller_mdsal_CreateTransaction_descriptor =
+ getDescriptor().getMessageTypes().get(2);
+ internal_static_org_opendaylight_controller_mdsal_CreateTransaction_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_org_opendaylight_controller_mdsal_CreateTransaction_descriptor,
+ new java.lang.String[] { });
+ internal_static_org_opendaylight_controller_mdsal_CreateTransactionReply_descriptor =
+ getDescriptor().getMessageTypes().get(3);
+ internal_static_org_opendaylight_controller_mdsal_CreateTransactionReply_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_org_opendaylight_controller_mdsal_CreateTransactionReply_descriptor,
+ new java.lang.String[] { "TransactionPath", });
+ internal_static_org_opendaylight_controller_mdsal_ReadyTransaction_descriptor =
+ getDescriptor().getMessageTypes().get(4);
+ internal_static_org_opendaylight_controller_mdsal_ReadyTransaction_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_org_opendaylight_controller_mdsal_ReadyTransaction_descriptor,
+ new java.lang.String[] { });
+ internal_static_org_opendaylight_controller_mdsal_ReadyTransactionReply_descriptor =
+ getDescriptor().getMessageTypes().get(5);
+ internal_static_org_opendaylight_controller_mdsal_ReadyTransactionReply_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_org_opendaylight_controller_mdsal_ReadyTransactionReply_descriptor,
+ new java.lang.String[] { "ActorPath", });
+ internal_static_org_opendaylight_controller_mdsal_DeleteData_descriptor =
+ getDescriptor().getMessageTypes().get(6);
+ internal_static_org_opendaylight_controller_mdsal_DeleteData_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_org_opendaylight_controller_mdsal_DeleteData_descriptor,
+ new java.lang.String[] { "InstanceIdentifierPathArguments", });
+ internal_static_org_opendaylight_controller_mdsal_DeleteDataReply_descriptor =
+ getDescriptor().getMessageTypes().get(7);
+ internal_static_org_opendaylight_controller_mdsal_DeleteDataReply_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_org_opendaylight_controller_mdsal_DeleteDataReply_descriptor,
+ new java.lang.String[] { });
+ internal_static_org_opendaylight_controller_mdsal_ReadData_descriptor =
+ getDescriptor().getMessageTypes().get(8);
+ internal_static_org_opendaylight_controller_mdsal_ReadData_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_org_opendaylight_controller_mdsal_ReadData_descriptor,
+ new java.lang.String[] { "InstanceIdentifierPathArguments", });
+ internal_static_org_opendaylight_controller_mdsal_ReadDataReply_descriptor =
+ getDescriptor().getMessageTypes().get(9);
+ internal_static_org_opendaylight_controller_mdsal_ReadDataReply_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_org_opendaylight_controller_mdsal_ReadDataReply_descriptor,
+ new java.lang.String[] { "NormalizedNode", });
+ internal_static_org_opendaylight_controller_mdsal_WriteData_descriptor =
+ getDescriptor().getMessageTypes().get(10);
+ internal_static_org_opendaylight_controller_mdsal_WriteData_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_org_opendaylight_controller_mdsal_WriteData_descriptor,
+ new java.lang.String[] { "InstanceIdentifierPathArguments", "NormalizedNode", });
+ internal_static_org_opendaylight_controller_mdsal_WriteDataReply_descriptor =
+ getDescriptor().getMessageTypes().get(11);
+ internal_static_org_opendaylight_controller_mdsal_WriteDataReply_fieldAccessorTable = new
+ com.google.protobuf.GeneratedMessage.FieldAccessorTable(
+ internal_static_org_opendaylight_controller_mdsal_WriteDataReply_descriptor,
+ new java.lang.String[] { });
+ return null;
+ }
+ };
com.google.protobuf.Descriptors.FileDescriptor
- .internalBuildGeneratedFileFrom(
- descriptorData,
- new com.google.protobuf.Descriptors.FileDescriptor[] {org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage
- .getDescriptor(),}, assigner);
+ .internalBuildGeneratedFileFrom(descriptorData,
+ new com.google.protobuf.Descriptors.FileDescriptor[] {
+ org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage.getDescriptor(),
+ }, assigner);
}
// @@protoc_insertion_point(outer_class_scope)
import "SimpleNormalizedNode.proto";
-option java_package = "org.opendaylight.controller.cluster.datastore.datachange.notification";
+option java_package = "org.opendaylight.controller.protobuff.messages.datachange.notification";
option java_outer_classname = "DataChangeListenerMessages";
message DataChanged{
package org.opendaylight.controller.mdsal;
-option java_package = "org.opendaylight.controller.cluster.datastore.registration";
+option java_package = "org.opendaylight.controller.protobuff.messages.registration";
option java_outer_classname = "ListenerRegistrationMessages";
message Close {
package org.opendaylight.controller.mdsal;
-option java_package = "org.opendaylight.controller.cluster.datastore.shard";
+option java_package = "org.opendaylight.controller.protobuff.messages.shard";
option java_outer_classname = "ShardManagerMessages";
message FindPrimary {
package org.opendaylight.controller.mdsal;
-
import "SimpleNormalizedNode.proto";
-
-option java_package = "org.opendaylight.controller.cluster.datastore.transaction";
+option java_package = "org.opendaylight.controller.protobuff.messages.transaction";
option java_outer_classname = "ShardTransactionMessages";
message CloseTransaction{
package org.opendaylight.controller.mdsal;
-option java_package = "org.opendaylight.controller.cluster.datastore.transaction";
+option java_package = "org.opendaylight.controller.protobuff.messages.transaction";
option java_outer_classname = "ShardTransactionChainMessages";
message CloseTransactionChain {
package org.opendaylight.controller.mdsal;
-option java_package = "org.opendaylight.controller.cluster.datastore.common";
+option java_package = "org.opendaylight.controller.protobuff.messages.common";
option java_outer_classname = "SimpleNormalizedNodeMessage";
message NormalizedNodeXml {
import org.custommonkey.xmlunit.Diff;
import org.custommonkey.xmlunit.XMLUnit;
import org.junit.Test;
-import org.opendaylight.controller.cluster.datastore.common.SimpleNormalizedNodeMessage;
+import org.opendaylight.controller.protobuff.messages.common.SimpleNormalizedNodeMessage;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-package org.opendaylight.controller.cluster.datastore.messages;
+package org.opendaylight.controller.protobuff.messages;
/**
* This test case is present to ensure that if others have used proper version of protocol buffer.
import org.junit.Assert;
import org.junit.Test;
-import org.opendaylight.controller.cluster.datastore.shard.ShardManagerMessages;
+import org.opendaylight.controller.protobuff.messages.shard.ShardManagerMessages;
import java.io.File;
import java.io.FileInputStream;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.DefaultValue;
+import javax.ws.rs.Encoded;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
-import javax.ws.rs.Encoded;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.UriInfo;
-
import org.opendaylight.controller.sal.restconf.impl.StructuredData;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
/**
- * The URI hierarchy for the RESTCONF resources consists of an entry
- * point container, 4 top-level resources, and 1 field.
- * <li><b>/restconf</b> - {@link #getRoot()}
- * <li><b>/config</b> - {@link #readConfigurationData(String)}
- * {@link #updateConfigurationData(String, CompositeNode)}
- * {@link #createConfigurationData(CompositeNode)}
- * {@link #createConfigurationData(String, CompositeNode)}
- * {@link #deleteConfigurationData(String)}
- * <li><b>/operational</b> - {@link #readOperationalData(String)}
- * <li>/modules - {@link #getModules()}
- * <li>/module
- * </ul>
- * <li><b>/operations</b> - {@link #invokeRpc(String, CompositeNode)}
- * {@link #invokeRpc(String, CompositeNode)}
- * <li>/version (field)
- * </ul>
- * </ul>
+ * The URI hierarchy for the RESTCONF resources consists of an entry point
+ * container, 4 top-level resources, and 1 field.
+ * <ul>
+ * <li><b>/restconf</b> - {@link #getRoot()}
+ * <ul>
+ * <li><b>/config</b> - {@link #readConfigurationData(String)}
+ * {@link #updateConfigurationData(String, CompositeNode)}
+ * {@link #createConfigurationData(CompositeNode)}
+ * {@link #createConfigurationData(String, CompositeNode)}
+ * {@link #deleteConfigurationData(String)}
+ * <li><b>/operational</b> - {@link #readOperationalData(String)}
+ * <li>/modules - {@link #getModules()}
+ * <ul>
+ * <li>/module
+ * </ul>
+ * <li><b>/operations</b> - {@link #invokeRpc(String, CompositeNode)}
+ * {@link #invokeRpc(String, CompositeNode)}
+ * <li>/version (field)
+ * </ul>
+ * </ul>
*/
@Path("/")
public interface RestconfService {
@GET
@Path("/modules")
- @Produces({Draft02.MediaTypes.API+XML, Draft02.MediaTypes.API+JSON,
- MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML, MediaType.TEXT_XML})
- public StructuredData getModules();
+ @Produces({ Draft02.MediaTypes.API + XML, Draft02.MediaTypes.API + JSON, MediaType.APPLICATION_JSON,
+ MediaType.APPLICATION_XML, MediaType.TEXT_XML })
+ public StructuredData getModules(@Context UriInfo uriInfo);
@GET
@Path("/modules/{identifier:.+}")
- @Produces({Draft02.MediaTypes.API+XML, Draft02.MediaTypes.API+JSON,
- MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML, MediaType.TEXT_XML})
- public StructuredData getModules(@PathParam("identifier") String identifier);
+ @Produces({ Draft02.MediaTypes.API + XML, Draft02.MediaTypes.API + JSON, MediaType.APPLICATION_JSON,
+ MediaType.APPLICATION_XML, MediaType.TEXT_XML })
+ public StructuredData getModules(@PathParam("identifier") String identifier, @Context UriInfo uriInfo);
@GET
@Path("/modules/module/{identifier:.+}")
- @Produces({Draft02.MediaTypes.API+XML, Draft02.MediaTypes.API+JSON,
- MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML, MediaType.TEXT_XML})
- public StructuredData getModule(@PathParam("identifier") String identifier);
+ @Produces({ Draft02.MediaTypes.API + XML, Draft02.MediaTypes.API + JSON, MediaType.APPLICATION_JSON,
+ MediaType.APPLICATION_XML, MediaType.TEXT_XML })
+ public StructuredData getModule(@PathParam("identifier") String identifier, @Context UriInfo uriInfo);
@GET
@Path("/operations")
- @Produces({Draft02.MediaTypes.API+XML, Draft02.MediaTypes.API+JSON,
- MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML, MediaType.TEXT_XML})
- public StructuredData getOperations();
+ @Produces({ Draft02.MediaTypes.API + XML, Draft02.MediaTypes.API + JSON, MediaType.APPLICATION_JSON,
+ MediaType.APPLICATION_XML, MediaType.TEXT_XML })
+ public StructuredData getOperations(@Context UriInfo uriInfo);
@GET
@Path("/operations/{identifier:.+}")
- @Produces({Draft02.MediaTypes.API+XML, Draft02.MediaTypes.API+JSON,
- MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML, MediaType.TEXT_XML})
- public StructuredData getOperations(@PathParam("identifier") String identifier);
+ @Produces({ Draft02.MediaTypes.API + XML, Draft02.MediaTypes.API + JSON, MediaType.APPLICATION_JSON,
+ MediaType.APPLICATION_XML, MediaType.TEXT_XML })
+ public StructuredData getOperations(@PathParam("identifier") String identifier, @Context UriInfo uriInfo);
@POST
@Path("/operations/{identifier:.+}")
- @Produces({Draft02.MediaTypes.OPERATION+JSON, Draft02.MediaTypes.OPERATION+XML,
- Draft02.MediaTypes.DATA+JSON, Draft02.MediaTypes.DATA+XML,
- MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML, MediaType.TEXT_XML})
- @Consumes({Draft02.MediaTypes.OPERATION+JSON, Draft02.MediaTypes.OPERATION+XML,
- Draft02.MediaTypes.DATA+JSON, Draft02.MediaTypes.DATA+XML,
- MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML, MediaType.TEXT_XML})
- public StructuredData invokeRpc(@Encoded @PathParam("identifier") String identifier, CompositeNode payload);
+ @Produces({ Draft02.MediaTypes.OPERATION + JSON, Draft02.MediaTypes.OPERATION + XML,
+ Draft02.MediaTypes.DATA + JSON, Draft02.MediaTypes.DATA + XML, MediaType.APPLICATION_JSON,
+ MediaType.APPLICATION_XML, MediaType.TEXT_XML })
+ @Consumes({ Draft02.MediaTypes.OPERATION + JSON, Draft02.MediaTypes.OPERATION + XML,
+ Draft02.MediaTypes.DATA + JSON, Draft02.MediaTypes.DATA + XML, MediaType.APPLICATION_JSON,
+ MediaType.APPLICATION_XML, MediaType.TEXT_XML })
+ public StructuredData invokeRpc(@Encoded @PathParam("identifier") String identifier, CompositeNode payload, @Context UriInfo uriInfo);
@POST
@Path("/operations/{identifier:.+}")
- @Produces({Draft02.MediaTypes.OPERATION+JSON, Draft02.MediaTypes.OPERATION+XML,
- Draft02.MediaTypes.DATA+JSON, Draft02.MediaTypes.DATA+XML,
- MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML, MediaType.TEXT_XML})
- public StructuredData invokeRpc(@Encoded @PathParam("identifier") String identifier, @DefaultValue("") String noPayload);
+ @Produces({ Draft02.MediaTypes.OPERATION + JSON, Draft02.MediaTypes.OPERATION + XML,
+ Draft02.MediaTypes.DATA + JSON, Draft02.MediaTypes.DATA + XML, MediaType.APPLICATION_JSON,
+ MediaType.APPLICATION_XML, MediaType.TEXT_XML })
+ public StructuredData invokeRpc(@Encoded @PathParam("identifier") String identifier,
+ @DefaultValue("") String noPayload, @Context UriInfo uriInfo);
@GET
@Path("/config/{identifier:.+}")
- @Produces({Draft02.MediaTypes.DATA+JSON,Draft02.MediaTypes.DATA+XML,
- MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML, MediaType.TEXT_XML})
+ @Produces({ Draft02.MediaTypes.DATA + JSON, Draft02.MediaTypes.DATA + XML, MediaType.APPLICATION_JSON,
+ MediaType.APPLICATION_XML, MediaType.TEXT_XML })
public StructuredData readConfigurationData(@Encoded @PathParam("identifier") String identifier,
- @Context UriInfo depth);
+ @Context UriInfo uriInfo);
@GET
@Path("/operational/{identifier:.+}")
- @Produces({Draft02.MediaTypes.DATA+JSON,Draft02.MediaTypes.DATA+XML,
- MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML, MediaType.TEXT_XML})
- public StructuredData readOperationalData(@Encoded @PathParam("identifier") String identifier,
- @Context UriInfo depth);
+ @Produces({ Draft02.MediaTypes.DATA + JSON, Draft02.MediaTypes.DATA + XML, MediaType.APPLICATION_JSON,
+ MediaType.APPLICATION_XML, MediaType.TEXT_XML })
+ public StructuredData readOperationalData(@Encoded @PathParam("identifier") String identifier, @Context UriInfo uriInfo);
@PUT
@Path("/config/{identifier:.+}")
- @Consumes({Draft02.MediaTypes.DATA+JSON,Draft02.MediaTypes.DATA+XML,
- MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML, MediaType.TEXT_XML})
+ @Consumes({ Draft02.MediaTypes.DATA + JSON, Draft02.MediaTypes.DATA + XML, MediaType.APPLICATION_JSON,
+ MediaType.APPLICATION_XML, MediaType.TEXT_XML })
public Response updateConfigurationData(@Encoded @PathParam("identifier") String identifier, CompositeNode payload);
@POST
@Path("/config/{identifier:.+}")
- @Consumes({Draft02.MediaTypes.DATA+JSON,Draft02.MediaTypes.DATA+XML,
- MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML, MediaType.TEXT_XML})
+ @Consumes({ Draft02.MediaTypes.DATA + JSON, Draft02.MediaTypes.DATA + XML, MediaType.APPLICATION_JSON,
+ MediaType.APPLICATION_XML, MediaType.TEXT_XML })
public Response createConfigurationData(@Encoded @PathParam("identifier") String identifier, CompositeNode payload);
@POST
@Path("/config")
- @Consumes({Draft02.MediaTypes.DATA+JSON,Draft02.MediaTypes.DATA+XML,
- MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML, MediaType.TEXT_XML})
+ @Consumes({ Draft02.MediaTypes.DATA + JSON, Draft02.MediaTypes.DATA + XML, MediaType.APPLICATION_JSON,
+ MediaType.APPLICATION_XML, MediaType.TEXT_XML })
public Response createConfigurationData(CompositeNode payload);
@DELETE
@GET
@Path("/streams")
- @Produces({Draft02.MediaTypes.API+XML, Draft02.MediaTypes.API+JSON,
- MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML, MediaType.TEXT_XML})
- public StructuredData getAvailableStreams();
-
+ @Produces({ Draft02.MediaTypes.API + XML, Draft02.MediaTypes.API + JSON, MediaType.APPLICATION_JSON,
+ MediaType.APPLICATION_XML, MediaType.TEXT_XML })
+ public StructuredData getAvailableStreams(@Context UriInfo uriInfo);
}
--- /dev/null
+/*
+ * Copyright (c) 2014 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.controller.sal.rest.gson;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonIOException;
+import com.google.gson.JsonNull;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+import com.google.gson.JsonPrimitive;
+import com.google.gson.JsonSyntaxException;
+import com.google.gson.internal.LazilyParsedNumber;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.MalformedJsonException;
+import java.io.EOFException;
+import java.io.IOException;
+
+/**
+ * This class parses JSON elements from a gson JsonReader. It disallows multiple
+ * elements of the same name unlike the default gson JsonParser."
+ */
+public class JsonParser {
+ public JsonElement parse(JsonReader reader) throws JsonIOException, JsonSyntaxException {
+ // code copied from gson's JsonParser and Stream classes
+
+ boolean lenient = reader.isLenient();
+ reader.setLenient(true);
+ boolean isEmpty = true;
+ try {
+ reader.peek();
+ isEmpty = false;
+ return read(reader);
+ } catch (EOFException e) {
+ if (isEmpty) {
+ return JsonNull.INSTANCE;
+ }
+ // The stream ended prematurely so it is likely a syntax error.
+ throw new JsonSyntaxException(e);
+ } catch (MalformedJsonException e) {
+ throw new JsonSyntaxException(e);
+ } catch (IOException e) {
+ throw new JsonIOException(e);
+ } catch (NumberFormatException e) {
+ throw new JsonSyntaxException(e);
+ } catch (StackOverflowError | OutOfMemoryError e) {
+ throw new JsonParseException("Failed parsing JSON source: " + reader + " to Json", e);
+ } finally {
+ reader.setLenient(lenient);
+ }
+ }
+
+ public JsonElement read(JsonReader in) throws IOException {
+ switch (in.peek()) {
+ case STRING:
+ return new JsonPrimitive(in.nextString());
+ case NUMBER:
+ String number = in.nextString();
+ return new JsonPrimitive(new LazilyParsedNumber(number));
+ case BOOLEAN:
+ return new JsonPrimitive(in.nextBoolean());
+ case NULL:
+ in.nextNull();
+ return JsonNull.INSTANCE;
+ case BEGIN_ARRAY:
+ JsonArray array = new JsonArray();
+ in.beginArray();
+ while (in.hasNext()) {
+ array.add(read(in));
+ }
+ in.endArray();
+ return array;
+ case BEGIN_OBJECT:
+ JsonObject object = new JsonObject();
+ in.beginObject();
+ while (in.hasNext()) {
+ final String childName = in.nextName();
+ if (object.has(childName)) {
+ throw new JsonSyntaxException("Duplicate name " + childName + " in JSON input.");
+ }
+ object.add(childName, read(in));
+ }
+ in.endObject();
+ return object;
+ case END_DOCUMENT:
+ case NAME:
+ case END_OBJECT:
+ case END_ARRAY:
+ default:
+ throw new IllegalArgumentException();
+ }
+ }
+}
import java.io.InputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
-
import javax.ws.rs.Consumes;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.ext.MessageBodyReader;
import javax.ws.rs.ext.Provider;
-
import org.opendaylight.controller.sal.rest.api.Draft02;
import org.opendaylight.controller.sal.rest.api.RestconfService;
import org.opendaylight.controller.sal.restconf.impl.RestconfDocumentedException;
public enum JsonToCompositeNodeProvider implements MessageBodyReader<CompositeNode> {
INSTANCE;
- private final static Logger LOG = LoggerFactory.getLogger( JsonToCompositeNodeProvider.class );
+ private final static Logger LOG = LoggerFactory.getLogger(JsonToCompositeNodeProvider.class);
@Override
- public boolean isReadable(final Class<?> type, final Type genericType, final Annotation[] annotations, final MediaType mediaType) {
+ public boolean isReadable(final Class<?> type, final Type genericType,
+ final Annotation[] annotations, final MediaType mediaType) {
return true;
}
@Override
- public CompositeNode readFrom(final Class<CompositeNode> type, final Type genericType, final Annotation[] annotations,
- final MediaType mediaType, final MultivaluedMap<String, String> httpHeaders, final InputStream entityStream)
- throws IOException, WebApplicationException {
+ public CompositeNode readFrom(final Class<CompositeNode> type, final Type genericType,
+ final Annotation[] annotations, final MediaType mediaType,
+ final MultivaluedMap<String, String> httpHeaders,
+ final InputStream entityStream)
+ throws IOException, WebApplicationException {
try {
- return JsonReader.read(entityStream);
+ return JsonToCompositeNodeReader.read(entityStream);
} catch (Exception e) {
LOG.debug( "Error parsing json input", e);
+
throw new RestconfDocumentedException(
"Error parsing input: " + e.getMessage(),
ErrorType.PROTOCOL, ErrorTag.MALFORMED_MESSAGE);
}
}
-
}
import com.google.common.collect.Iterators;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
-import com.google.gson.JsonParser;
import com.google.gson.JsonPrimitive;
+import com.google.gson.stream.JsonReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URI;
-import java.util.Iterator;
import java.util.Map.Entry;
+import java.util.Iterator;
import java.util.Set;
+import org.opendaylight.controller.sal.rest.gson.JsonParser;
import org.opendaylight.controller.sal.rest.impl.RestUtil.PrefixMapingFromJson;
import org.opendaylight.controller.sal.restconf.impl.CompositeNodeWrapper;
import org.opendaylight.controller.sal.restconf.impl.EmptyNodeWrapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-final class JsonReader {
+class JsonToCompositeNodeReader {
private static final Logger LOG = LoggerFactory.getLogger(JsonReader.class);
private static final Splitter COLON_SPLITTER = Splitter.on(':');
- private JsonReader() {
+ private JsonToCompositeNodeReader() {
}
- public static CompositeNodeWrapper read(final InputStream entityStream) throws UnsupportedFormatException {
+ public static CompositeNodeWrapper read(final InputStream entityStream)
+ throws UnsupportedFormatException {
JsonParser parser = new JsonParser();
- JsonElement rootElement = parser.parse(new InputStreamReader(entityStream));
+ JsonElement rootElement = parser.parse(new JsonReader(
+ new InputStreamReader(entityStream)));
if (rootElement.isJsonNull()) {
- //no content, so return null to indicate no input
+ // no content, so return null to indicate no input
return null;
}
throw new UnsupportedFormatException("Root element of Json has to be Object");
}
- Set<Entry<String, JsonElement>> entrySetsOfRootJsonObject = rootElement.getAsJsonObject().entrySet();
+ Set<Entry<String, JsonElement>> entrySetsOfRootJsonObject =
+ rootElement.getAsJsonObject().entrySet();
if (entrySetsOfRootJsonObject.size() != 1) {
throw new UnsupportedFormatException("Json Object should contain one element");
}
"First element in Json Object has to be \"Object\" or \"Array with one Object element\". Other scenarios are not supported yet.");
}
- private static CompositeNodeWrapper createStructureWithRoot(final String rootObjectName, final JsonObject rootObject) {
+ private static CompositeNodeWrapper createStructureWithRoot(final String rootObjectName,
+ final JsonObject rootObject) {
CompositeNodeWrapper firstNode = new CompositeNodeWrapper(getNamespaceFor(rootObjectName),
getLocalNameFor(rootObjectName));
for (Entry<String, JsonElement> childOfFirstNode : rootObject.entrySet()) {
return firstNode;
}
- private static void addChildToParent(final String childName, final JsonElement childType, final CompositeNodeWrapper parent) {
+ private static void addChildToParent(final String childName, final JsonElement childType,
+ final CompositeNodeWrapper parent) {
if (childType.isJsonObject()) {
- CompositeNodeWrapper child = new CompositeNodeWrapper(getNamespaceFor(childName), getLocalNameFor(childName));
+ CompositeNodeWrapper child = new CompositeNodeWrapper(getNamespaceFor(childName),
+ getLocalNameFor(childName));
parent.addValue(child);
for (Entry<String, JsonElement> childOfChild : childType.getAsJsonObject().entrySet()) {
addChildToParent(childOfChild.getKey(), childOfChild.getValue(), child);
} else if (childType.isJsonArray()) {
if (childType.getAsJsonArray().size() == 1 && childType.getAsJsonArray().get(0).isJsonNull()) {
parent.addValue(new EmptyNodeWrapper(getNamespaceFor(childName), getLocalNameFor(childName)));
+
} else {
for (JsonElement childOfChildType : childType.getAsJsonArray()) {
addChildToParent(childName, childOfChildType, parent);
// it could be identityref Built-In Type
URI namespace = getNamespaceFor(value);
if (namespace != null) {
- return new IdentityValuesDTO(namespace.toString(), getLocalNameFor(value), null,value);
+ return new IdentityValuesDTO(namespace.toString(), getLocalNameFor(value), null, value);
}
+
// it is not "prefix:value" but just "value"
return value;
}
import com.google.common.base.Charsets;
import com.google.gson.stream.JsonWriter;
-
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
-
import javax.ws.rs.Produces;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.ext.MessageBodyWriter;
import javax.ws.rs.ext.Provider;
-
import org.opendaylight.controller.sal.rest.api.Draft02;
import org.opendaylight.controller.sal.rest.api.RestconfService;
import org.opendaylight.controller.sal.restconf.impl.RestconfDocumentedException;
@Override
public boolean isWriteable(final Class<?> type, final Type genericType, final Annotation[] annotations, final MediaType mediaType) {
- return type.equals( StructuredData.class );
+ return type.equals(StructuredData.class);
}
@Override
}
JsonWriter writer = new JsonWriter(new OutputStreamWriter(entityStream, Charsets.UTF_8));
- writer.setIndent(" ");
+
+ if (t.isPrettyPrintMode()) {
+ writer.setIndent(" ");
+ } else {
+ writer.setIndent("");
+ }
JsonMapper jsonMapper = new JsonMapper(t.getMountPoint());
jsonMapper.write(writer, data, (DataNodeContainer) t.getSchema());
writer.flush();
}
-
}
import java.io.OutputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
-
import javax.ws.rs.Produces;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
-
import org.opendaylight.controller.sal.rest.api.Draft02;
import org.opendaylight.controller.sal.rest.api.RestconfService;
import org.opendaylight.controller.sal.restconf.impl.RestconfDocumentedException;
@Override
public boolean isWriteable(final Class<?> type, final Type genericType, final Annotation[] annotations, final MediaType mediaType) {
- return type.equals( StructuredData.class );
+ return type.equals(StructuredData.class);
}
@Override
final Transformer trans;
try {
trans = TRANSFORMER.get();
+ if (t.isPrettyPrintMode()) {
+ trans.setOutputProperty(OutputKeys.INDENT, "yes");
+ } else {
+ trans.setOutputProperty(OutputKeys.INDENT, "no");
+ }
} catch (RuntimeException e) {
throw new RestconfDocumentedException(e.getMessage(), ErrorType.TRANSPORT,
ErrorTag.OPERATION_FAILED);
import java.io.InputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
-
import javax.ws.rs.Consumes;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.ext.MessageBodyReader;
import javax.ws.rs.ext.Provider;
import javax.xml.stream.XMLStreamException;
-
import org.opendaylight.controller.sal.rest.api.Draft02;
import org.opendaylight.controller.sal.rest.api.RestconfService;
import org.opendaylight.controller.sal.restconf.impl.RestconfDocumentedException;
public enum XmlToCompositeNodeProvider implements MessageBodyReader<CompositeNode> {
INSTANCE;
- private final static Logger LOG = LoggerFactory.getLogger( XmlToCompositeNodeProvider.class );
+ private final static Logger LOG = LoggerFactory.getLogger(XmlToCompositeNodeProvider.class);
@Override
public boolean isReadable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) {
public CompositeNode readFrom(Class<CompositeNode> type, Type genericType, Annotation[] annotations,
MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream)
throws IOException, WebApplicationException {
- XmlReader xmlReader = new XmlReader();
+ XmlToCompositeNodeReader xmlReader = new XmlToCompositeNodeReader();
try {
return xmlReader.read(entityStream);
} catch (XMLStreamException | UnsupportedFormatException e) {
- LOG.debug( "Error parsing json input", e );
- throw new RestconfDocumentedException(
- "Error parsing input: " + e.getMessage(),
- ErrorType.PROTOCOL, ErrorTag.MALFORMED_MESSAGE );
+ LOG.debug("Error parsing json input", e);
+ throw new RestconfDocumentedException("Error parsing input: " + e.getMessage(), ErrorType.PROTOCOL,
+ ErrorTag.MALFORMED_MESSAGE);
}
}
import org.opendaylight.controller.sal.restconf.impl.SimpleNodeWrapper;
import org.opendaylight.yangtools.yang.data.api.Node;
-public class XmlReader {
+public class XmlToCompositeNodeReader {
private final static XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance();
private XMLEventReader eventReader;
- public CompositeNodeWrapper read(InputStream entityStream) throws XMLStreamException,
- UnsupportedFormatException,
- IOException {
- //Get an XML stream which can be marked, and reset, so we can check and see if there is
- //any content being provided.
+ public CompositeNodeWrapper read(InputStream entityStream) throws XMLStreamException, UnsupportedFormatException,
+ IOException {
+ // Get an XML stream which can be marked, and reset, so we can check and
+ // see if there is
+ // any content being provided.
entityStream = getMarkableStream(entityStream);
- if( isInputStreamEmpty( entityStream ) ) {
+ if (isInputStreamEmpty(entityStream)) {
return null;
}
}
/**
- * If the input stream is not markable, then it wraps the input stream with a buffered stream,
- * which is mark able. That way we can check if the stream is empty safely.
+ * If the input stream is not markable, then it wraps the input stream with
+ * a buffered stream, which is mark able. That way we can check if the
+ * stream is empty safely.
+ *
* @param entityStream
* @return
*/
private InputStream getMarkableStream(InputStream entityStream) {
- if( !entityStream.markSupported() )
- {
- entityStream = new BufferedInputStream( entityStream );
+ if (!entityStream.markSupported()) {
+ entityStream = new BufferedInputStream(entityStream);
}
return entityStream;
}
- private boolean isInputStreamEmpty(InputStream entityStream)
- throws IOException {
+ private boolean isInputStreamEmpty(InputStream entityStream) throws IOException {
boolean isEmpty = false;
- entityStream.mark( 1 );
- if( entityStream.read() == -1 ){
+ entityStream.mark(1);
+ if (entityStream.read() == -1) {
isEmpty = true;
}
entityStream.reset();
checkArgument(event != null, "XML Event cannot be NULL!");
if (event.isStartElement()) {
XMLEvent innerEvent = skipCommentsAndWhitespace();
- if ( innerEvent != null && (innerEvent.isCharacters() || innerEvent.isEndElement())) {
+ if (innerEvent != null && (innerEvent.isCharacters() || innerEvent.isEndElement())) {
return true;
}
}
checkArgument(event != null, "XML Event cannot be NULL!");
if (event.isStartElement()) {
XMLEvent innerEvent = skipCommentsAndWhitespace();
- if( innerEvent != null ) {
+ if (innerEvent != null) {
if (innerEvent.isStartElement()) {
return true;
}
}
private XMLEvent skipCommentsAndWhitespace() throws XMLStreamException {
- while( eventReader.hasNext() ) {
+ while (eventReader.hasNext()) {
XMLEvent event = eventReader.peek();
- if( event.getEventType() == XMLStreamConstants.COMMENT ) {
+ if (event.getEventType() == XMLStreamConstants.COMMENT) {
eventReader.nextEvent();
continue;
}
- if( event.isCharacters() ) {
+ if (event.isCharacters()) {
Characters chars = event.asCharacters();
- if( chars.isWhiteSpace() ) {
+ if (chars.isWhiteSpace()) {
eventReader.nextEvent();
continue;
}
private Object resolveValueOfElement(String value, StartElement startElement) {
// it could be instance-identifier Built-In Type
if (value.startsWith("/")) {
- IdentityValuesDTO iiValue = RestUtil.asInstanceIdentifier(value, new RestUtil.PrefixMapingFromXml(startElement));
+ IdentityValuesDTO iiValue = RestUtil.asInstanceIdentifier(value, new RestUtil.PrefixMapingFromXml(
+ startElement));
if (iiValue != null) {
return iiValue;
}
if (namespaceAndValue.length == 2) {
String namespace = startElement.getNamespaceContext().getNamespaceURI(namespaceAndValue[0]);
if (namespace != null && !namespace.isEmpty()) {
- return new IdentityValuesDTO(namespace, namespaceAndValue[1], namespaceAndValue[0],value);
+ return new IdentityValuesDTO(namespace, namespaceAndValue[1], namespaceAndValue[0], value);
}
}
// it is not "prefix:value" but just "value"
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
-
import java.net.URI;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import java.util.Set;
import java.util.concurrent.Future;
-
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;
import javax.ws.rs.core.UriBuilder;
import javax.ws.rs.core.UriInfo;
-
import org.apache.commons.lang3.StringUtils;
import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.sal.core.api.mount.MountInstance;
import org.opendaylight.yangtools.yang.parser.builder.impl.LeafSchemaNodeBuilder;
public class RestconfImpl implements RestconfService {
+ private enum UriParameters {
+ PRETTY_PRINT( "prettyPrint"),
+ DEPTH( "depth");
+
+ private String uriParameterName;
+ UriParameters(String uriParameterName) {
+ this.uriParameterName = uriParameterName;
+ }
+
+ @Override
+ public String toString() {
+ return uriParameterName;
+ }
+ }
+
private final static RestconfImpl INSTANCE = new RestconfImpl();
private static final int CHAR_NOT_FOUND = -1;
}
@Override
- public StructuredData getModules() {
+ public StructuredData getModules(final UriInfo uriInfo) {
final Module restconfModule = this.getRestconfModule();
final List<Node<?>> modulesAsData = new ArrayList<Node<?>>();
restconfModule, Draft02.RestConfModule.MODULES_CONTAINER_SCHEMA_NODE);
QName qName = modulesSchemaNode.getQName();
final CompositeNode modulesNode = NodeFactory.createImmutableCompositeNode(qName, null, modulesAsData);
- return new StructuredData(modulesNode, modulesSchemaNode, null);
+ return new StructuredData(modulesNode, modulesSchemaNode, null,parsePrettyPrintParameter( uriInfo ));
}
@Override
- public StructuredData getAvailableStreams() {
+ public StructuredData getAvailableStreams(final UriInfo uriInfo) {
Set<String> availableStreams = Notificator.getStreamNames();
final List<Node<?>> streamsAsData = new ArrayList<Node<?>>();
restconfModule, Draft02.RestConfModule.STREAMS_CONTAINER_SCHEMA_NODE);
QName qName = streamsSchemaNode.getQName();
final CompositeNode streamsNode = NodeFactory.createImmutableCompositeNode(qName, null, streamsAsData);
- return new StructuredData(streamsNode, streamsSchemaNode, null);
+ return new StructuredData(streamsNode, streamsSchemaNode, null,parsePrettyPrintParameter( uriInfo ));
}
@Override
- public StructuredData getModules(final String identifier) {
+ public StructuredData getModules(final String identifier,final UriInfo uriInfo) {
Set<Module> modules = null;
MountInstance mountPoint = null;
if (identifier.contains(ControllerContext.MOUNT)) {
restconfModule, Draft02.RestConfModule.MODULES_CONTAINER_SCHEMA_NODE);
QName qName = modulesSchemaNode.getQName();
final CompositeNode modulesNode = NodeFactory.createImmutableCompositeNode(qName, null, modulesAsData);
- return new StructuredData(modulesNode, modulesSchemaNode, mountPoint);
+ return new StructuredData(modulesNode, modulesSchemaNode, mountPoint,parsePrettyPrintParameter( uriInfo ));
}
@Override
- public StructuredData getModule(final String identifier) {
+ public StructuredData getModule(final String identifier,final UriInfo uriInfo) {
final QName moduleNameAndRevision = this.getModuleNameAndRevision(identifier);
Module module = null;
MountInstance mountPoint = null;
final DataSchemaNode moduleSchemaNode = controllerContext.getRestconfModuleRestConfSchemaNode(
restconfModule, Draft02.RestConfModule.MODULE_LIST_SCHEMA_NODE);
final CompositeNode moduleNode = this.toModuleCompositeNode(module, moduleSchemaNode);
- return new StructuredData(moduleNode, moduleSchemaNode, mountPoint);
+ return new StructuredData(moduleNode, moduleSchemaNode, mountPoint,parsePrettyPrintParameter( uriInfo ));
}
@Override
- public StructuredData getOperations() {
+ public StructuredData getOperations(final UriInfo uriInfo) {
Set<Module> allModules = this.controllerContext.getAllModules();
- return this.operationsFromModulesToStructuredData(allModules, null);
+ return this.operationsFromModulesToStructuredData(allModules, null,parsePrettyPrintParameter(uriInfo));
}
@Override
- public StructuredData getOperations(final String identifier) {
+ public StructuredData getOperations(final String identifier,final UriInfo uriInfo) {
Set<Module> modules = null;
MountInstance mountPoint = null;
if (identifier.contains(ControllerContext.MOUNT)) {
ControllerContext.MOUNT, ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE );
}
- return this.operationsFromModulesToStructuredData(modules, mountPoint);
+ return this.operationsFromModulesToStructuredData(modules, mountPoint,parsePrettyPrintParameter(uriInfo));
}
private StructuredData operationsFromModulesToStructuredData(final Set<Module> modules,
- final MountInstance mountPoint) {
+ final MountInstance mountPoint,boolean prettyPrint) {
final List<Node<?>> operationsAsData = new ArrayList<Node<?>>();
Module restconfModule = this.getRestconfModule();
final DataSchemaNode operationsSchemaNode = controllerContext.getRestconfModuleRestConfSchemaNode(
final CompositeNode operationsNode =
NodeFactory.createImmutableCompositeNode(qName, null, operationsAsData);
ContainerSchemaNode schemaNode = fakeOperationsSchemaNode.build();
- return new StructuredData(operationsNode, schemaNode, mountPoint);
+ return new StructuredData(operationsNode, schemaNode, mountPoint,prettyPrint);
}
private Module getRestconfModule() {
}
@Override
- public StructuredData invokeRpc(final String identifier, final CompositeNode payload) {
+ public StructuredData invokeRpc(final String identifier, final CompositeNode payload,final UriInfo uriInfo) {
final RpcExecutor rpc = this.resolveIdentifierInInvokeRpc(identifier);
QName rpcName = rpc.getRpcDefinition().getQName();
URI rpcNamespace = rpcName.getNamespace();
if (Objects.equal(rpcNamespace.toString(), SAL_REMOTE_NAMESPACE) &&
Objects.equal(rpcName.getLocalName(), SAL_REMOTE_RPC_SUBSRCIBE)) {
- return invokeSalRemoteRpcSubscribeRPC(payload, rpc.getRpcDefinition());
+ return invokeSalRemoteRpcSubscribeRPC(payload, rpc.getRpcDefinition(),parsePrettyPrintParameter(uriInfo));
}
validateInput( rpc.getRpcDefinition().getInput(), payload );
- return callRpc(rpc, payload);
+ return callRpc(rpc, payload,parsePrettyPrintParameter(uriInfo));
}
private void validateInput(final DataSchemaNode inputSchema, final CompositeNode payload) {
}
private StructuredData invokeSalRemoteRpcSubscribeRPC(final CompositeNode payload,
- final RpcDefinition rpc) {
+ final RpcDefinition rpc,final boolean prettyPrint) {
final CompositeNode value = this.normalizeNode(payload, rpc.getInput(), null);
final SimpleNode<? extends Object> pathNode = value == null ? null :
value.getFirstSimpleByName( QName.create(rpc.getQName(), "path") );
Notificator.createListener(pathIdentifier, streamName);
}
- return new StructuredData(responseData, rpc.getOutput(), null);
+ return new StructuredData(responseData, rpc.getOutput(), null,prettyPrint);
}
@Override
- public StructuredData invokeRpc(final String identifier, final String noPayload) {
+ public StructuredData invokeRpc(final String identifier, final String noPayload, final UriInfo uriInfo) {
if (StringUtils.isNotBlank(noPayload)) {
throw new RestconfDocumentedException(
"Content must be empty.", ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE );
}
- return invokeRpc( identifier, (CompositeNode)null );
+ return invokeRpc( identifier, (CompositeNode)null,uriInfo);
}
private RpcExecutor resolveIdentifierInInvokeRpc(final String identifier) {
}
- private StructuredData callRpc(final RpcExecutor rpcExecutor, final CompositeNode payload) {
+ private StructuredData callRpc(final RpcExecutor rpcExecutor, final CompositeNode payload,boolean prettyPrint) {
if (rpcExecutor == null) {
throw new RestconfDocumentedException(
"RPC does not exist.", ErrorType.RPC, ErrorTag.UNKNOWN_ELEMENT );
return null; //no output, nothing to send back.
}
- return new StructuredData(rpcResult.getResult(), rpc.getOutput(), null);
+ return new StructuredData(rpcResult.getResult(), rpc.getOutput(), null,prettyPrint);
}
private void checkRpcSuccessAndThrowException(final RpcResult<CompositeNode> rpcResult) {
}
@Override
- public StructuredData readConfigurationData(final String identifier, final UriInfo info) {
+ public StructuredData readConfigurationData(final String identifier, final UriInfo uriInfo) {
final InstanceIdWithSchemaNode iiWithData = this.controllerContext.toInstanceIdentifier(identifier);
CompositeNode data = null;
MountInstance mountPoint = iiWithData.getMountPoint();
data = broker.readConfigurationData(iiWithData.getInstanceIdentifier());
}
- data = pruneDataAtDepth( data, parseDepthParameter( info ) );
- return new StructuredData(data, iiWithData.getSchemaNode(), iiWithData.getMountPoint());
+ data = pruneDataAtDepth( data, parseDepthParameter( uriInfo ) );
+ boolean prettyPrintMode = parsePrettyPrintParameter( uriInfo );
+ return new StructuredData(data, iiWithData.getSchemaNode(), iiWithData.getMountPoint(),prettyPrintMode);
}
@SuppressWarnings("unchecked")
}
private Integer parseDepthParameter( final UriInfo info ) {
- String param = info.getQueryParameters( false ).getFirst( "depth" );
+ String param = info.getQueryParameters( false ).getFirst( UriParameters.DEPTH.toString() );
if( Strings.isNullOrEmpty( param ) || "unbounded".equals( param ) ) {
return null;
}
}
data = pruneDataAtDepth( data, parseDepthParameter( info ) );
- return new StructuredData(data, iiWithData.getSchemaNode(), mountPoint);
+ boolean prettyPrintMode = parsePrettyPrintParameter( info );
+ return new StructuredData(data, iiWithData.getSchemaNode(), mountPoint,prettyPrintMode);
+ }
+
+ private boolean parsePrettyPrintParameter(UriInfo info) {
+ String param = info.getQueryParameters(false).getFirst(UriParameters.PRETTY_PRINT.toString());
+ return Boolean.parseBoolean(param);
}
@Override
final DataNodeContainer schema, final MountInstance mountPoint,
final QName currentAugment ) {
final List<NodeWrapper<?>> children = compositeNodeBuilder.getValues();
+ checkNodeMultiplicityAccordingToSchema(schema,children);
for (final NodeWrapper<? extends Object> child : children) {
final List<DataSchemaNode> potentialSchemaNodes =
this.controllerContext.findInstanceDataChildrenByName(
}
}
+ private void checkNodeMultiplicityAccordingToSchema(final DataNodeContainer dataNodeContainer,
+ final List<NodeWrapper<?>> nodes) {
+ Map<String, Integer> equalNodeNamesToCounts = new HashMap<String, Integer>();
+ for (NodeWrapper<?> child : nodes) {
+ Integer count = equalNodeNamesToCounts.get(child.getLocalName());
+ equalNodeNamesToCounts.put(child.getLocalName(), count == null ? 1 : ++count);
+ }
+
+ for (DataSchemaNode childSchemaNode : dataNodeContainer.getChildNodes()) {
+ if (childSchemaNode instanceof ContainerSchemaNode || childSchemaNode instanceof LeafSchemaNode) {
+ String localName = childSchemaNode.getQName().getLocalName();
+ Integer count = equalNodeNamesToCounts.get(localName);
+ if (count != null && count > 1) {
+ throw new RestconfDocumentedException(
+ "Multiple input data elements were specified for '"
+ + childSchemaNode.getQName().getLocalName()
+ + "'. The data for this element type can only be specified once.",
+ ErrorType.APPLICATION, ErrorTag.BAD_ELEMENT);
+ }
+ }
+ }
+ }
+
private QName normalizeNodeName(final NodeWrapper<? extends Object> nodeBuilder,
final DataSchemaNode schema, final QName previousAugment,
final MountInstance mountPoint) {
private final CompositeNode data;
private final DataSchemaNode schema;
private final MountInstance mountPoint;
+ private final boolean prettyPrintMode;
public StructuredData(final CompositeNode data, final DataSchemaNode schema, final MountInstance mountPoint) {
+ this(data, schema, mountPoint, false);
+ }
+
+ public StructuredData(final CompositeNode data, final DataSchemaNode schema, final MountInstance mountPoint,
+ final boolean preattyPrintMode) {
this.data = data;
this.schema = schema;
this.mountPoint = mountPoint;
+ this.prettyPrintMode = preattyPrintMode;
}
public CompositeNode getData() {
public MountInstance getMountPoint() {
return mountPoint;
}
+
+ public boolean isPrettyPrintMode() {
+ return prettyPrintMode;
+ }
}
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
+import static org.opendaylight.controller.sal.restconf.impl.test.TestUtils.containsStringData;
import java.io.IOException;
import java.util.Collections;
Collections.<Module>emptySet(), prepareDataSchemaNode(),
StructuredDataToJsonProvider.INSTANCE);
assertNotNull(jsonOutput);
- assertTrue(jsonOutput.contains("\"lf1\": \"\""));
+
+// pattern for e.g. > "lf1" : "" < or >"lf1":""<
+ assertTrue(containsStringData(jsonOutput, "\"lf1\"",":","\"\""));
}
private CompositeNode prepareCompositeNode() {
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
+import static org.opendaylight.controller.sal.restconf.impl.test.TestUtils.containsStringData;
import java.io.IOException;
-
import javax.ws.rs.WebApplicationException;
-
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.controller.sal.rest.impl.StructuredDataToJsonProvider;
}
assertNotNull(jsonOutput);
- assertTrue(jsonOutput.contains("\"augment-leaf:lf2\": \"lf2\""));
- assertTrue(jsonOutput.contains("\"augment-container:cont1\": {"));
- assertTrue(jsonOutput.contains("\"augment-container:lf11\": \"lf11\""));
- assertTrue(jsonOutput.contains("\"augment-list:lst1\": ["));
- assertTrue(jsonOutput.contains("\"augment-list:lf11\": \"lf1_1\""));
- assertTrue(jsonOutput.contains("\"augment-list:lf11\": \"lf1_2\""));
- assertTrue(jsonOutput.contains("\"augment-leaflist:lflst1\": ["));
+ assertTrue(containsStringData(jsonOutput,"\"augment-leaf:lf2\"",":", "\"lf2\""));
+ assertTrue(containsStringData(jsonOutput,"\"augment-container:cont1\"",":", "\\{"));
+ assertTrue(containsStringData(jsonOutput,"\"augment-container:lf11\"",":", "\"lf11\""));
+ assertTrue(containsStringData(jsonOutput,"\"augment-list:lst1\"",":", "\\["));
+ assertTrue(containsStringData(jsonOutput,"\"augment-list:lf11\"",":", "\"lf1_1\""));
+ assertTrue(containsStringData(jsonOutput,"\"augment-list:lf11\"",":", "\"lf1_2\""));
+ assertTrue(containsStringData(jsonOutput,"\"augment-leaflist:lflst1\"",":", "\\["));
}
}
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
+import static org.opendaylight.controller.sal.restconf.impl.test.TestUtils.containsStringData;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
-
import javax.ws.rs.WebApplicationException;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.events.StartElement;
import javax.xml.stream.events.XMLEvent;
-
import org.junit.BeforeClass;
-import org.junit.Ignore;
import org.junit.Test;
import org.opendaylight.controller.sal.rest.impl.StructuredDataToJsonProvider;
import org.opendaylight.controller.sal.rest.impl.StructuredDataToXmlProvider;
import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates;
import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeWithValue;
import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
-import org.opendaylight.yangtools.yang.data.api.MutableCompositeNode;
-import org.opendaylight.yangtools.yang.data.api.MutableSimpleNode;
+import org.opendaylight.yangtools.yang.data.api.SimpleNode;
+import org.opendaylight.yangtools.yang.data.impl.ImmutableCompositeNode;
import org.opendaylight.yangtools.yang.data.impl.NodeFactory;
+import org.opendaylight.yangtools.yang.data.impl.util.CompositeNodeBuilder;
public class CnSnToXmlAndJsonInstanceIdentifierTest extends YangAndXmlAndDataSchemaLoader {
CompositeNode cnSn = prepareCnSn(createInstanceIdentifier());
String output = TestUtils.writeCompNodeWithSchemaContextToOutput(cnSn, modules, dataSchemaNode,
StructuredDataToXmlProvider.INSTANCE);
- //uncomment for debug
- // System.out.println(output);
validateXmlOutput(output);
}
- @Ignore
@Test
public void saveCnSnWithLeafListInstIdentifierToXmlTest() throws WebApplicationException, IOException,
- URISyntaxException, XMLStreamException {
+ URISyntaxException, XMLStreamException {
CompositeNode cnSn = prepareCnSn(createInstanceIdentifierWithLeafList());
String output = TestUtils.writeCompNodeWithSchemaContextToOutput(cnSn, modules, dataSchemaNode,
StructuredDataToXmlProvider.INSTANCE);
- //uncomment for debug
- // System.out.println(output);
validateXmlOutputWithLeafList(output);
}
String output = TestUtils.writeCompNodeWithSchemaContextToOutput(cnSn, modules, dataSchemaNode,
StructuredDataToJsonProvider.INSTANCE);
boolean strInOutput = false;
- strInOutput = output
- .contains("\"augment-augment-module:lf111\": \"/instance-identifier-module:cont/instance-identifier-module:cont1/augment-module:lst11[augment-module:keyvalue111=\\\"value1\\\"][augment-module:keyvalue112=\\\"value2\\\"]/augment-augment-module:lf112\"");
+ strInOutput = containsStringData(
+ output,
+ "\"augment-augment-module:lf111\"",
+ ":",
+ "\"/instance-identifier-module:cont/instance-identifier-module:cont1/augment-module:lst11\\[augment-module:keyvalue111=\\\\\"value1\\\\\"\\]\\[augment-module:keyvalue112=\\\\\"value2\\\\\"\\]/augment-augment-module:lf112\"");
if (!strInOutput) {
- strInOutput = output
- .contains("\"augment-augment-module:lf111\": \"/instance-identifier-module:cont/instance-identifier-module:cont1/augment-module:lst11[augment-module:keyvalue111='value1'][augment-module:keyvalue112='value2']/augment-augment-module:lf112\"");
+ strInOutput = containsStringData(
+ output,
+ "\"augment-augment-module:lf111\"",
+ ":",
+ "\"/instance-identifier-module:cont/instance-identifier-module:cont1/augment-module:lst11\\[augment-module:keyvalue111='value1'\\]\\[augment-module:keyvalue112='value2'\\]/augment-augment-module:lf112\"");
}
- //uncomment for debug
- // System.out.println(output);
assertTrue(strInOutput);
}
-
@Test
public void saveCnSnWithLeafListInstIdentifierToJsonTest() throws WebApplicationException, IOException,
- URISyntaxException {
+ URISyntaxException {
CompositeNode cnSn = prepareCnSn(createInstanceIdentifierWithLeafList());
String output = TestUtils.writeCompNodeWithSchemaContextToOutput(cnSn, modules, dataSchemaNode,
StructuredDataToJsonProvider.INSTANCE);
- //uncomment for debug
- // System.out.println(output);
boolean strInOutput = false;
- strInOutput = output
- .contains("\"augment-augment-module:lf111\": \"/instance-identifier-module:cont/instance-identifier-module:cont1/augment-module-leaf-list:lflst11[.='lflst11_1']\"");
+ strInOutput = containsStringData(
+ output,
+ "\"augment-augment-module:lf111\"",
+ ":",
+ "\"/instance-identifier-module:cont/instance-identifier-module:cont1/augment-module-leaf-list:lflst11\\[.='lflst11_1'\\]\"");
if (!strInOutput) {
- strInOutput = output
- .contains("\"augment-augment-module:lf111\": \"/instance-identifier-module:cont/instance-identifier-module:cont1/augment-module-leaf-list:lflst11[.=\\\"lflst11_1\\\"]\"");
+ strInOutput = containsStringData(
+ output,
+ "\"augment-augment-module:lf111\"",
+ ":",
+ "\"/instance-identifier-module:cont/instance-identifier-module:cont1/augment-module-leaf-list:lflst11\\[.=\\\\\"lflst11_1\\\\\"\\]\"");
}
assertTrue(strInOutput);
}
private CompositeNode prepareCnSn(final InstanceIdentifier instanceIdentifier) throws URISyntaxException {
- MutableCompositeNode cont = NodeFactory.createMutableCompositeNode(
- TestUtils.buildQName("cont", "instance:identifier:module", "2014-01-17"), null, null,null,null);
- MutableCompositeNode cont1 = NodeFactory.createMutableCompositeNode(
- TestUtils.buildQName("cont1", "instance:identifier:module", "2014-01-17"), cont, null,null,null);
- MutableCompositeNode lst11 = NodeFactory.createMutableCompositeNode(
- TestUtils.buildQName("lst11", "augment:module", "2014-01-17"), cont1, null,null,null);
-
- MutableSimpleNode<?> lf111 = NodeFactory.createMutableSimpleNode(TestUtils.buildQName("lf111", "augment:augment:module", "2014-01-17"),
- lst11, instanceIdentifier,null,null);
-
-
- lst11.getValue().add(lf111);
- lst11.init();
+ CompositeNodeBuilder<ImmutableCompositeNode> cont = ImmutableCompositeNode.builder();
+ cont.setQName(QName.create("instance:identifier:module", "2014-01-17", "cont"));
- cont1.getValue().add(lst11);
- cont1.init();
+ CompositeNodeBuilder<ImmutableCompositeNode> cont1 = ImmutableCompositeNode.builder();
+ cont1.setQName(QName.create("instance:identifier:module", "2014-01-17", "cont1"));
- cont.getValue().add(cont1);
- cont.init();
+ CompositeNodeBuilder<ImmutableCompositeNode> lst11 = ImmutableCompositeNode.builder();
+ lst11.setQName(QName.create("augment:module", "2014-01-17", "lst11"));
- return cont;
+ SimpleNode<?> lf111 = NodeFactory.createImmutableSimpleNode(
+ QName.create("augment:augment:module", "2014-01-17", "lf111"), null, instanceIdentifier);
+ lst11.add(lf111);
+ cont1.add(lst11.toInstance());
+ cont.add(cont1.toInstance());
+ return cont.toInstance();
}
private InstanceIdentifier createInstanceIdentifier() throws URISyntaxException {
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
import java.io.FileNotFoundException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
-
+import javax.ws.rs.core.MultivaluedHashMap;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.UriInfo;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
-
public class InvokeRpcMethodTest {
private RestconfImpl restconfImpl = null;
private static ControllerContext controllerContext = null;
+ private static UriInfo uriInfo;
@BeforeClass
SchemaContext schemaContext = TestUtils.loadSchemaContext(allModules);
controllerContext = spy( ControllerContext.getInstance() );
controllerContext.setSchemas(schemaContext);
-
+ uriInfo = mock(UriInfo.class);
+ MultivaluedMap<String, String> map = new MultivaluedHashMap<>();
+ map.put("prettyPrint", Collections.singletonList("true"));
+ when(uriInfo.getQueryParameters(any(Boolean.class))).thenReturn(map);
}
@Before
.thenReturn( Futures.<RpcResult<CompositeNode>>immediateFuture(
Rpcs.<CompositeNode>getRpcResult( true ) ) );
- StructuredData structData = restconf.invokeRpc("invoke-rpc-module:rpc-test", payload);
+ StructuredData structData = restconf.invokeRpc("invoke-rpc-module:rpc-test", payload,uriInfo);
assertTrue(structData == null);
}
restconfImpl.setBroker(brokerFacade);
try {
- restconfImpl.invokeRpc("toaster:cancel-toast", "");
+ restconfImpl.invokeRpc("toaster:cancel-toast", "",uriInfo);
fail("Expected an exception to be thrown.");
}
catch (RestconfDocumentedException e) {
restconfImpl.setBroker(brokerFacade);
try {
- restconfImpl.invokeRpc("toaster:cancel-toast", "");
+ restconfImpl.invokeRpc("toaster:cancel-toast", "",uriInfo);
fail("Expected an exception to be thrown.");
}
catch (RestconfDocumentedException e) {
restconfImpl.setBroker(brokerFacade);
StructuredData output = restconfImpl.invokeRpc("toaster:cancel-toast",
- "");
+ "",uriInfo);
assertEquals(null, output);
//additional validation in the fact that the restconfImpl does not throw an exception.
}
@Test
public void testInvokeRpcMethodExpectingNoPayloadButProvidePayload() {
try {
- restconfImpl.invokeRpc("toaster:cancel-toast", " a payload ");
+ restconfImpl.invokeRpc("toaster:cancel-toast", " a payload ",uriInfo);
fail("Expected an exception");
} catch (RestconfDocumentedException e) {
verifyRestconfDocumentedException( e, 0, ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE,
@Test
public void testInvokeRpcMethodWithBadMethodName() {
try {
- restconfImpl.invokeRpc("toaster:bad-method", "");
+ restconfImpl.invokeRpc("toaster:bad-method", "",uriInfo);
fail("Expected an exception");
}
catch (RestconfDocumentedException e) {
restconfImpl.setBroker(brokerFacade);
StructuredData output = restconfImpl.invokeRpc("toaster:make-toast",
- payload);
+ payload,uriInfo);
assertEquals(null, output);
//additional validation in the fact that the restconfImpl does not throw an exception.
}
@Test
public void testThrowExceptionWhenSlashInModuleName() {
try {
- restconfImpl.invokeRpc("toaster/slash", "");
+ restconfImpl.invokeRpc("toaster/slash", "",uriInfo);
fail("Expected an exception.");
}
catch (RestconfDocumentedException e) {
restconfImpl.setBroker(brokerFacade);
- StructuredData output = restconfImpl.invokeRpc("toaster:testOutput", "");
+ StructuredData output = restconfImpl.invokeRpc("toaster:testOutput", "",uriInfo);
assertNotNull( output );
assertSame( compositeNode, output.getData() );
assertNotNull( output.getSchema() );
restconfImpl.setControllerContext( mockedContext );
StructuredData output = restconfImpl.invokeRpc(
"opendaylight-inventory:nodes/node/REMOTE_HOST/yang-ext:mount/toaster:cancel-toast",
- "");
+ "",uriInfo);
assertEquals(null, output);
//additional validation in the fact that the restconfImpl does not throw an exception.
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
-
import javax.ws.rs.client.Entity;
import javax.ws.rs.core.Application;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.UriInfo;
-
import org.glassfish.jersey.server.ResourceConfig;
import org.glassfish.jersey.test.JerseyTest;
import org.junit.BeforeClass;
@Override
protected Application configure() {
/* enable/disable Jersey logs to console */
-// enable(TestProperties.LOG_TRAFFIC);
-// enable(TestProperties.DUMP_ENTITY);
-// enable(TestProperties.RECORD_LOG_LEVEL);
-// set(TestProperties.RECORD_LOG_LEVEL, Level.ALL.intValue());
+ // enable(TestProperties.LOG_TRAFFIC);
+ // enable(TestProperties.DUMP_ENTITY);
+ // enable(TestProperties.RECORD_LOG_LEVEL);
+ // set(TestProperties.RECORD_LOG_LEVEL, Level.ALL.intValue());
ResourceConfig resourceConfig = new ResourceConfig();
resourceConfig = resourceConfig.registerInstances(restconfService, StructuredDataToXmlProvider.INSTANCE,
StructuredDataToJsonProvider.INSTANCE, XmlToCompositeNodeProvider.INSTANCE,
return resourceConfig;
}
- @Test
- public void testPostOperationsWithInputDataMediaTypes() throws UnsupportedEncodingException {
- String uriPrefix = "/operations/";
- String uriPath = "ietf-interfaces:interfaces";
- String uri = uriPrefix + uriPath;
- when(restconfService.invokeRpc(eq(uriPath), any(CompositeNode.class))).thenReturn(null);
- post(uri, Draft02.MediaTypes.OPERATION+JSON, Draft02.MediaTypes.OPERATION+JSON, jsonData);
- verify(restconfService, times(1)).invokeRpc(eq(uriPath), any(CompositeNode.class));
- post(uri, Draft02.MediaTypes.OPERATION+XML, Draft02.MediaTypes.OPERATION+XML, xmlData);
- verify(restconfService, times(2)).invokeRpc(eq(uriPath), any(CompositeNode.class));
- post(uri, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, jsonData);
- verify(restconfService, times(3)).invokeRpc(eq(uriPath), any(CompositeNode.class));
- post(uri, MediaType.APPLICATION_XML, MediaType.APPLICATION_XML, xmlData);
- verify(restconfService, times(4)).invokeRpc(eq(uriPath), any(CompositeNode.class));
- post(uri, MediaType.TEXT_XML, MediaType.TEXT_XML, xmlData);
- verify(restconfService, times(5)).invokeRpc(eq(uriPath), any(CompositeNode.class));
- post(uri, null, MediaType.TEXT_XML, xmlData);
- verify(restconfService, times(6)).invokeRpc(eq(uriPath), any(CompositeNode.class));
-
- // negative tests
- post(uri, MediaType.TEXT_PLAIN, MediaType.TEXT_XML, xmlData);
- verify(restconfService, times(6)).invokeRpc(eq(uriPath), any(CompositeNode.class));
- post(uri, MediaType.TEXT_XML, MediaType.TEXT_PLAIN, xmlData);
- verify(restconfService, times(6)).invokeRpc(eq(uriPath), any(CompositeNode.class));
- }
+ @Test
+ public void testPostOperationsWithInputDataMediaTypes() throws UnsupportedEncodingException {
+ String uriPrefix = "/operations/";
+ String uriPath = "ietf-interfaces:interfaces";
+ String uri = uriPrefix + uriPath;
+ when(restconfService.invokeRpc(eq(uriPath), any(CompositeNode.class), any(UriInfo.class))).thenReturn(null);
+ post(uri, Draft02.MediaTypes.OPERATION + JSON, Draft02.MediaTypes.OPERATION + JSON, jsonData);
+ verify(restconfService, times(1)).invokeRpc(eq(uriPath), any(CompositeNode.class), any(UriInfo.class));
+ post(uri, Draft02.MediaTypes.OPERATION + XML, Draft02.MediaTypes.OPERATION + XML, xmlData);
+ verify(restconfService, times(2)).invokeRpc(eq(uriPath), any(CompositeNode.class), any(UriInfo.class));
+ post(uri, MediaType.APPLICATION_JSON, MediaType.APPLICATION_JSON, jsonData);
+ verify(restconfService, times(3)).invokeRpc(eq(uriPath), any(CompositeNode.class), any(UriInfo.class));
+ post(uri, MediaType.APPLICATION_XML, MediaType.APPLICATION_XML, xmlData);
+ verify(restconfService, times(4)).invokeRpc(eq(uriPath), any(CompositeNode.class), any(UriInfo.class));
+ post(uri, MediaType.TEXT_XML, MediaType.TEXT_XML, xmlData);
+ verify(restconfService, times(5)).invokeRpc(eq(uriPath), any(CompositeNode.class), any(UriInfo.class));
+ post(uri, null, MediaType.TEXT_XML, xmlData);
+ verify(restconfService, times(6)).invokeRpc(eq(uriPath), any(CompositeNode.class), any(UriInfo.class));
+
+ // negative tests
+ post(uri, MediaType.TEXT_PLAIN, MediaType.TEXT_XML, xmlData);
+ verify(restconfService, times(6)).invokeRpc(eq(uriPath), any(CompositeNode.class), any(UriInfo.class));
+ post(uri, MediaType.TEXT_XML, MediaType.TEXT_PLAIN, xmlData);
+ verify(restconfService, times(6)).invokeRpc(eq(uriPath), any(CompositeNode.class), any(UriInfo.class));
+ }
@Test
public void testGetConfigMediaTypes() throws UnsupportedEncodingException {
String uriPath = "ietf-interfaces:interfaces";
String uri = uriPrefix + uriPath;
when(restconfService.readConfigurationData(eq(uriPath), any(UriInfo.class))).thenReturn(null);
- get(uri, Draft02.MediaTypes.DATA+JSON);
+ get(uri, Draft02.MediaTypes.DATA + JSON);
verify(restconfService, times(1)).readConfigurationData(eq(uriPath), any(UriInfo.class));
- get(uri, Draft02.MediaTypes.DATA+XML);
+ get(uri, Draft02.MediaTypes.DATA + XML);
verify(restconfService, times(2)).readConfigurationData(eq(uriPath), any(UriInfo.class));
get(uri, MediaType.APPLICATION_JSON);
verify(restconfService, times(3)).readConfigurationData(eq(uriPath), any(UriInfo.class));
String uriPath = "ietf-interfaces:interfaces";
String uri = uriPrefix + uriPath;
when(restconfService.readOperationalData(eq(uriPath), any(UriInfo.class))).thenReturn(null);
- get(uri, Draft02.MediaTypes.DATA+JSON);
+ get(uri, Draft02.MediaTypes.DATA + JSON);
verify(restconfService, times(1)).readOperationalData(eq(uriPath), any(UriInfo.class));
- get(uri, Draft02.MediaTypes.DATA+XML);
+ get(uri, Draft02.MediaTypes.DATA + XML);
verify(restconfService, times(2)).readOperationalData(eq(uriPath), any(UriInfo.class));
get(uri, MediaType.APPLICATION_JSON);
verify(restconfService, times(3)).readOperationalData(eq(uriPath), any(UriInfo.class));
String uriPath = "ietf-interfaces:interfaces";
String uri = uriPrefix + uriPath;
when(restconfService.updateConfigurationData(eq(uriPath), any(CompositeNode.class))).thenReturn(null);
- put(uri, null, Draft02.MediaTypes.DATA+JSON, jsonData);
+ put(uri, null, Draft02.MediaTypes.DATA + JSON, jsonData);
verify(restconfService, times(1)).updateConfigurationData(eq(uriPath), any(CompositeNode.class));
- put(uri, null, Draft02.MediaTypes.DATA+XML, xmlData);
+ put(uri, null, Draft02.MediaTypes.DATA + XML, xmlData);
verify(restconfService, times(2)).updateConfigurationData(eq(uriPath), any(CompositeNode.class));
put(uri, null, MediaType.APPLICATION_JSON, jsonData);
verify(restconfService, times(3)).updateConfigurationData(eq(uriPath), any(CompositeNode.class));
String uriPath = "ietf-interfaces:interfaces";
String uri = uriPrefix + uriPath;
when(restconfService.createConfigurationData(eq(uriPath), any(CompositeNode.class))).thenReturn(null);
- post(uri, null, Draft02.MediaTypes.DATA+JSON, jsonData);
+ post(uri, null, Draft02.MediaTypes.DATA + JSON, jsonData);
verify(restconfService, times(1)).createConfigurationData(eq(uriPath), any(CompositeNode.class));
- post(uri, null, Draft02.MediaTypes.DATA+XML, xmlData);
+ post(uri, null, Draft02.MediaTypes.DATA + XML, xmlData);
verify(restconfService, times(2)).createConfigurationData(eq(uriPath), any(CompositeNode.class));
post(uri, null, MediaType.APPLICATION_JSON, jsonData);
verify(restconfService, times(3)).createConfigurationData(eq(uriPath), any(CompositeNode.class));
String uriPrefix = "/config/";
String uri = uriPrefix;
when(restconfService.createConfigurationData(any(CompositeNode.class))).thenReturn(null);
- post(uri, null, Draft02.MediaTypes.DATA+JSON, jsonData);
+ post(uri, null, Draft02.MediaTypes.DATA + JSON, jsonData);
verify(restconfService, times(1)).createConfigurationData(any(CompositeNode.class));
- post(uri, null, Draft02.MediaTypes.DATA+XML, xmlData);
+ post(uri, null, Draft02.MediaTypes.DATA + XML, xmlData);
verify(restconfService, times(2)).createConfigurationData(any(CompositeNode.class));
post(uri, null, MediaType.APPLICATION_JSON, jsonData);
verify(restconfService, times(3)).createConfigurationData(any(CompositeNode.class));
--- /dev/null
+/*
+ * Copyright (c) 2014 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.controller.sal.restconf.impl.test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.fail;
+
+import java.util.List;
+import java.util.Set;
+import javax.ws.rs.ext.MessageBodyReader;
+import org.junit.Test;
+import org.opendaylight.controller.sal.rest.impl.JsonToCompositeNodeProvider;
+import org.opendaylight.controller.sal.rest.impl.XmlToCompositeNodeProvider;
+import org.opendaylight.controller.sal.restconf.impl.RestconfDocumentedException;
+import org.opendaylight.controller.sal.restconf.impl.RestconfError;
+import org.opendaylight.controller.sal.restconf.impl.RestconfError.ErrorTag;
+import org.opendaylight.controller.sal.restconf.impl.RestconfError.ErrorType;
+import org.opendaylight.yangtools.yang.data.api.CompositeNode;
+import org.opendaylight.yangtools.yang.model.api.Module;
+
+/**
+ * If more then one data element with equal name exists where container or
+ * leaf schema node should be present the RestconfDocumentedException has to
+ * be raised
+ *
+ * Tests for BUG 1204
+ */
+public class MultipleEqualNamesForDataNodesTest {
+
+ @Test
+ public void multipleEqualNameDataNodeTestForContainerJsonTest() {
+ multipleEqualNameDataNodeTest("/equal-data-node-names/equal-name-data-for-container.json", ErrorType.APPLICATION,
+ ErrorTag.BAD_ELEMENT,JsonToCompositeNodeProvider.INSTANCE);
+ }
+
+ @Test
+ public void multipleEqualNameDataNodeTestForLeafJsonTest() {
+ multipleEqualNameDataNodeTest("/equal-data-node-names/equal-name-data-for-leaf.json", ErrorType.PROTOCOL,
+ ErrorTag.MALFORMED_MESSAGE,JsonToCompositeNodeProvider.INSTANCE);
+ }
+
+ @Test
+ public void multipleEqualNameDataNodeTestForContainerXmlTest() {
+ multipleEqualNameDataNodeTest("/equal-data-node-names/equal-name-data-for-container.xml", ErrorType.APPLICATION,
+ ErrorTag.BAD_ELEMENT,XmlToCompositeNodeProvider.INSTANCE);
+ }
+
+ @Test
+ public void multipleEqualNameDataNodeTestForLeafXmlTest() {
+ multipleEqualNameDataNodeTest("/equal-data-node-names/equal-name-data-for-leaf.xml", ErrorType.APPLICATION,
+ ErrorTag.BAD_ELEMENT,XmlToCompositeNodeProvider.INSTANCE);
+ }
+
+ private void multipleEqualNameDataNodeTest(String path, ErrorType errorType, ErrorTag errorTag,MessageBodyReader<CompositeNode> messageBodyReader) {
+ try {
+ CompositeNode compositeNode = TestUtils.readInputToCnSn(path, false,messageBodyReader);
+ assertNotNull(compositeNode);
+
+ Set<Module> modules = null;
+ modules = TestUtils.loadModulesFrom("/equal-data-node-names/yang");
+ assertNotNull(modules);
+
+ TestUtils.normalizeCompositeNode(compositeNode, modules, "equal-data-node-names" + ":" + "cont");
+ fail("Exception RestconfDocumentedException should be raised");
+ } catch (RestconfDocumentedException e) {
+ List<RestconfError> errors = e.getErrors();
+ assertNotNull(errors);
+
+ assertEquals(1, errors.size());
+
+ RestconfError restconfError = errors.get(0);
+
+ assertEquals(errorType, restconfError.getErrorType());
+ assertEquals(errorTag, restconfError.getErrorTag());
+ }
+ }
+
+}
package org.opendaylight.controller.sal.restconf.impl.test;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
-
import javax.ws.rs.core.Application;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.MultivaluedHashMap;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.UriInfo;
-
import org.glassfish.jersey.server.ResourceConfig;
import org.glassfish.jersey.test.JerseyTest;
import org.junit.BeforeClass;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-
public class RestGetOperationTest extends JerseyTest {
static class NodeData {
return null;
}
+ /**
+ * If includeWhiteChars URI parameter is set to false then no white
+ * characters can be included in returned output
+ * @throws UnsupportedEncodingException
+ */
+ @Test
+ public void getDataWithUriIncludeWhiteCharsParameterTest() throws UnsupportedEncodingException {
+ getDataWithUriIncludeWhiteCharsParameter("config");
+ getDataWithUriIncludeWhiteCharsParameter("operational");
+ }
+
+
+ private void getDataWithUriIncludeWhiteCharsParameter(String target) throws UnsupportedEncodingException {
+ mockReadConfigurationDataMethod();
+ String uri = "/"+target+"/ietf-interfaces:interfaces/interface/eth0";
+ Response response = target(uri).queryParam("prettyPrint", "false").request("application/xml").get();
+ String xmlData = response.readEntity(String.class);
+
+ Pattern pattern = Pattern.compile(".*(>\\s+|\\s+<).*", Pattern.DOTALL);
+ Matcher matcher = pattern.matcher(xmlData);
+ // XML element can't surrounded with white character (e.g "> " or
+ // " <")
+ assertFalse(matcher.matches());
+
+ response = target(uri).queryParam("prettyPrint", "false").request("application/json").get();
+ String jsonData = response.readEntity(String.class);
+ pattern = Pattern.compile(".*(\\}\\s+|\\s+\\{|\\]\\s+|\\s+\\[|\\s+:|:\\s+).*", Pattern.DOTALL);
+ matcher = pattern.matcher(jsonData);
+ // JSON element can't surrounded with white character (e.g "} ", " {",
+ // "] ", " [", " :" or ": ")
+ assertFalse(matcher.matches());
+ }
+
@Test
public void getDataWithUriDepthParameterTest() throws UnsupportedEncodingException {
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
+import com.google.common.base.Preconditions;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
-
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.ext.MessageBodyReader;
import javax.ws.rs.ext.MessageBodyWriter;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
-
import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.sal.restconf.impl.BrokerFacade;
import org.opendaylight.controller.sal.restconf.impl.CompositeNodeWrapper;
import org.w3c.dom.Document;
import org.xml.sax.SAXException;
-import com.google.common.base.Preconditions;
-
public final class TestUtils {
private static final Logger LOG = LoggerFactory.getLogger(TestUtils.class);
}
bufReader.close();
return result.toString();
+ }
+
+ private static Pattern patternForStringsSeparatedByWhiteChars(String ... substrings ) {
+ StringBuilder pattern = new StringBuilder();
+ pattern.append(".*");
+ for (String substring : substrings) {
+ pattern.append(substring);
+ pattern.append("\\s*");
+ }
+ pattern.append(".*");
+ return Pattern.compile(pattern.toString(), Pattern.DOTALL);
+ }
+ public static boolean containsStringData(String jsonOutput,String ...substrings ) {
+ Pattern pattern = patternForStringsSeparatedByWhiteChars(substrings);
+ Matcher matcher = pattern.matcher(jsonOutput);
+ return matcher.matches();
}
}
--- /dev/null
+{
+ "cont":{
+ "cont1":[
+ {
+ "lst11":{
+ "lf111":"value1"
+ }
+ },
+ {
+ "lst11":{
+ "lf111":"value2"
+ }
+ }
+ ]
+ }
+}
\ No newline at end of file
--- /dev/null
+<cont>
+ <cont1>
+ <lst11>
+ <lf111>value1</lf111>
+ </lst11>
+ </cont1>
+ <cont1>
+ <lst11>
+ <lf111>value1</lf111>
+ </lst11>
+ </cont1>
+</cont>
\ No newline at end of file
--- /dev/null
+{
+ "cont":{
+ "cont1":{
+ "lst11":[
+ {
+ "lf111":"value1",
+ "lf111":"value2"
+ },
+ {
+ "lf111":"value3"
+ }
+ ]
+ }
+ }
+}
\ No newline at end of file
--- /dev/null
+<cont>
+ <cont1>
+ <lst11>
+ <lf111>value1</lf111>,
+ <lf111>value2</lf111>,
+ </lst11>
+ <lst11>
+ <lf111>value3</lf111>,
+ </lst11>
+ </cont1>
+</cont>
\ No newline at end of file
--- /dev/null
+/* bug 1204 */
+module equal-data-node-names {
+ namespace "ns:equal:data:node:names";
+
+ prefix "eqdanona";
+ revision 2014-06-26 {
+ }
+
+ container cont {
+ container cont1 {
+ list lst11 {
+ leaf lf111 {
+ type string;
+ }
+ }
+ }
+ }
+}
\ No newline at end of file
{
- "cont": {
- "lf":
- }
+ "cont": {
+ "lf":
+ }
}
\ No newline at end of file
--- /dev/null
+module multiple-nodes {
+ namespace "multiple:nodes";
+ prefix "mod1";
+ revision "2014-06-23";
+
+ container cont {
+ container cont1 {
+ leaf lf11 {
+ type string;
+ }
+ }
+
+ leaf lf1 {
+ type string;
+ }
+ }
+}
\ No newline at end of file
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <parent>
+ <artifactId>sal-parent</artifactId>
+ <groupId>org.opendaylight.controller</groupId>
+ <version>1.1-SNAPSHOT</version>
+ </parent>
+ <modelVersion>4.0.0</modelVersion>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-binding</artifactId>
+ </dependency>
+ </dependencies>
+
+ <artifactId>sal-test-model</artifactId>
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.jacoco</groupId>
+ <artifactId>jacoco-maven-plugin</artifactId>
+ <configuration>
+ <includes>
+ <include>org.opendaylight.controller.*</include>
+ </includes>
+ </configuration>
+ <executions>
+ <execution>
+ <id>pre-test</id>
+ <goals>
+ <goal>prepare-agent</goal>
+ </goals>
+ </execution>
+ <execution>
+ <id>post-test</id>
+ <goals>
+ <goal>report</goal>
+ </goals>
+ <phase>test</phase>
+ </execution>
+ </executions>
+ </plugin>
+ <plugin>
+ <groupId>org.opendaylight.yangtools</groupId>
+ <artifactId>yang-maven-plugin</artifactId>
+ <executions>
+ <execution>
+ <goals>
+ <goal>generate-sources</goal>
+ </goals>
+ <configuration>
+ <codeGenerators>
+ <generator>
+ <codeGeneratorClass>
+ org.opendaylight.yangtools.maven.sal.api.gen.plugin.CodeGeneratorImpl
+ </codeGeneratorClass>
+ <outputBaseDir>${salGeneratorPath}</outputBaseDir>
+ </generator>
+ </codeGenerators>
+ <inspectDependencies>true</inspectDependencies>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ </build>
+ <scm>
+ <connection>scm:git:ssh://git.opendaylight.org:29418/controller.git</connection>
+ <developerConnection>scm:git:ssh://git.opendaylight.org:29418/controller.git</developerConnection>
+ <tag>HEAD</tag>
+ <url>https://wiki.opendaylight.org/view/OpenDaylight_Controller:MD-SAL</url>
+ </scm>
+
+</project>
\ No newline at end of file
--- /dev/null
+module opendaylight-mdsal-list-test {
+
+ namespace "urn:opendaylight:params:xml:ns:yang:controller:md:sal:test:list";
+ prefix list-test;
+
+
+ description
+ "This module contains a collection of YANG definitions used for
+ some test cases.";
+
+ revision 2014-07-01 {
+ description
+ "Test model for testing data broker with nested lists.";
+ }
+
+ grouping two-level-list {
+ list top-level-list {
+ description
+ "Top Level List";
+ key "name";
+ leaf name {
+ type string;
+ }
+ list nested-list {
+ key "name";
+ leaf name {
+ type string;
+ }
+ leaf type {
+ type string;
+ mandatory true;
+ description
+ "Mandatory type of list.";
+ }
+ ordered-by user;
+ description
+ "A list of service functions that compose the service chain";
+ }
+ }
+ }
+
+ container top {
+ uses two-level-list;
+ }
+
+ rpc put-top {
+ input {
+ uses two-level-list;
+ }
+ }
+}
\ No newline at end of file
--- /dev/null
+module opendaylight-test-rpc-service {
+ yang-version 1;
+ namespace "urn:opendaylight:params:xml:ns:yang:controller:md:sal:test:bi:ba:rpcservice";
+ prefix "rpc";
+
+ description
+ "Test model for testing of registering rpc service on binding independent mount point
+ and retrieving rpc service via binding aware mount point.";
+
+ revision "2014-07-01" {
+ description
+ "Initial revision";
+ }
+
+ rpc rock-the-house {
+ input {
+ leaf zip-code {
+ type string;
+ }
+ }
+ }
+}
\ No newline at end of file
--- /dev/null
+*.log
+cache
Code Review / controller.git / commitdiff