From f3539b33ca4562dbac6ba745d6ce0775c83dc7c4 Mon Sep 17 00:00:00 2001 From: Tony Tkacik Date: Wed, 29 Jan 2014 13:00:22 +0000 Subject: [PATCH 1/1] Added utility SynchronizedTransaction wrapper implementation. Change-Id: Ic35661a59fde08f0ec0b72121cd2e3dedf1de480 Signed-off-by: Tony Tkacik --- .../api/data/SynchronizedTransaction.java | 186 ++++++++++++++++++ 1 file changed, 186 insertions(+) create mode 100644 opendaylight/md-sal/sal-binding-api/src/main/java/org/opendaylight/controller/sal/binding/api/data/SynchronizedTransaction.java diff --git a/opendaylight/md-sal/sal-binding-api/src/main/java/org/opendaylight/controller/sal/binding/api/data/SynchronizedTransaction.java b/opendaylight/md-sal/sal-binding-api/src/main/java/org/opendaylight/controller/sal/binding/api/data/SynchronizedTransaction.java new file mode 100644 index 0000000000..d7cb926775 --- /dev/null +++ b/opendaylight/md-sal/sal-binding-api/src/main/java/org/opendaylight/controller/sal/binding/api/data/SynchronizedTransaction.java @@ -0,0 +1,186 @@ +/* + * 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.api.data; + +import java.util.Map; +import java.util.Set; +import java.util.concurrent.Future; + +import org.opendaylight.controller.md.sal.common.api.TransactionStatus; +import org.opendaylight.yangtools.concepts.Delegator; +import org.opendaylight.yangtools.concepts.ListenerRegistration; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yangtools.yang.common.RpcResult; + +import com.google.common.base.Preconditions; + +/** + * Synchronized wrapper for DataModificationTransaction. + * + * To get instance of synchronized wrapper use {@link #from(DataModificationTransaction)} + * + */ +public final class SynchronizedTransaction implements DataModificationTransaction,Delegator { + + private final DataModificationTransaction delegate; + + private SynchronizedTransaction(DataModificationTransaction delegate) { + this.delegate = delegate; + } + + /** + * Returns synchronized wrapper on supplied transaction. + * + * @param transaction Transaction for which synchronized wrapper should be created. + * @return Synchronized wrapper over transaction. + */ + public static final SynchronizedTransaction from(DataModificationTransaction transaction) { + Preconditions.checkArgument(transaction != null, "Transaction must not be null."); + if (transaction instanceof SynchronizedTransaction) { + return (SynchronizedTransaction) transaction; + } + return new SynchronizedTransaction(transaction); + } + + @Override + public synchronized Map, DataObject> getCreatedOperationalData() { + return delegate.getCreatedOperationalData(); + } + + @Override + public synchronized Map, DataObject> getCreatedConfigurationData() { + return delegate.getCreatedConfigurationData(); + } + + @Override + public synchronized DataObject readOperationalData(InstanceIdentifier path) { + return delegate.readOperationalData(path); + } + + @Override + public synchronized TransactionStatus getStatus() { + return delegate.getStatus(); + } + + @Override + public synchronized Map, DataObject> getUpdatedOperationalData() { + return delegate.getUpdatedOperationalData(); + } + + @Deprecated + public synchronized void putRuntimeData(InstanceIdentifier path, DataObject data) { + delegate.putRuntimeData(path, data); + } + + @Override + public synchronized Object getIdentifier() { + return delegate.getIdentifier(); + } + + @Override + public synchronized DataObject readConfigurationData(InstanceIdentifier path) { + return delegate.readConfigurationData(path); + } + + @Override + public synchronized Future> commit() { + return delegate.commit(); + } + + @Override + public synchronized void putOperationalData(InstanceIdentifier path, DataObject data) { + delegate.putOperationalData(path, data); + } + + @Override + public synchronized void putConfigurationData(InstanceIdentifier path, DataObject data) { + delegate.putConfigurationData(path, data); + } + + @Override + public synchronized Map, DataObject> getUpdatedConfigurationData() { + return delegate.getUpdatedConfigurationData(); + } + + @Deprecated + public synchronized void removeRuntimeData(InstanceIdentifier path) { + delegate.removeRuntimeData(path); + } + + @Override + public synchronized void removeOperationalData(InstanceIdentifier path) { + delegate.removeOperationalData(path); + } + + @Override + public synchronized void removeConfigurationData(InstanceIdentifier path) { + delegate.removeConfigurationData(path); + } + + @Override + public synchronized Set> getRemovedConfigurationData() { + return delegate.getRemovedConfigurationData(); + } + + @Override + public synchronized Set> getRemovedOperationalData() { + return delegate.getRemovedOperationalData(); + } + + @Override + public synchronized Map, DataObject> getOriginalConfigurationData() { + return delegate.getOriginalConfigurationData(); + } + + @Override + public synchronized ListenerRegistration registerListener(DataTransactionListener listener) { + return delegate.registerListener(listener); + } + + @Override + public synchronized Map, DataObject> getOriginalOperationalData() { + return delegate.getOriginalOperationalData(); + } + + @Override + public synchronized DataModificationTransaction getDelegate() { + return delegate; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + ((delegate == null) ? 0 : delegate.hashCode()); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()){ + return false; + } + SynchronizedTransaction other = (SynchronizedTransaction) obj; + if (delegate == null) { + if (other.delegate != null) { + return false; + } + } else if (!delegate.equals(other.delegate)) { + return false; + } + return true; + } +} + -- 2.36.6