import org.opendaylight.yangtools.yang.binding.RpcService;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService;
import org.opendaylight.yangtools.yang.data.impl.codec.CodecRegistry;
import org.opendaylight.yangtools.yang.data.impl.codec.DeserializationException;
}
@Override
- public Entry<InstanceIdentifier, CompositeNode> toDataDom(
+ public Entry<YangInstanceIdentifier, CompositeNode> toDataDom(
Entry<org.opendaylight.yangtools.yang.binding.InstanceIdentifier<? extends DataObject>, DataObject> entry) {
return delegate.toDataDom(entry);
}
@Override
- public InstanceIdentifier toDataDom(
+ public YangInstanceIdentifier toDataDom(
org.opendaylight.yangtools.yang.binding.InstanceIdentifier<? extends DataObject> path) {
return delegate.toDataDom(path);
}
}
@Override
- public org.opendaylight.yangtools.yang.binding.InstanceIdentifier<?> fromDataDom(InstanceIdentifier entry)
+ public org.opendaylight.yangtools.yang.binding.InstanceIdentifier<?> fromDataDom(YangInstanceIdentifier entry)
throws DeserializationException {
return delegate.fromDataDom(entry);
}
final DataChangeScope triggeringScope) {
DOMDataChangeListener domDataChangeListener = new TranslatingDataChangeInvoker(store, path, listener,
triggeringScope);
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier domPath = codec.toNormalized(path);
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier domPath = codec.toNormalized(path);
ListenerRegistration<DOMDataChangeListener> domRegistration = domDataBroker.registerDataChangeListener(store,
domPath, domDataChangeListener, triggeringScope);
return new ListenerRegistrationImpl(listener, domRegistration);
}
protected Map<InstanceIdentifier<?>, DataObject> toBinding(
- final Map<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, ? extends NormalizedNode<?, ?>> normalized) {
+ final Map<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, ? extends NormalizedNode<?, ?>> normalized) {
Map<InstanceIdentifier<?>, DataObject> newMap = new HashMap<>();
- for (Map.Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, ? extends NormalizedNode<?, ?>> entry : sortedEntries(normalized)) {
+ for (Map.Entry<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, ? extends NormalizedNode<?, ?>> entry : sortedEntries(normalized)) {
try {
Optional<Entry<InstanceIdentifier<? extends DataObject>, DataObject>> potential = getCodec().toBinding(
entry);
return newMap;
}
- private static <T> Iterable<Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier,T>> sortedEntries(final Map<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, T> map) {
- ArrayList<Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, T>> entries = new ArrayList<>(map.entrySet());
- Collections.sort(entries, new Comparator<Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, T>>() {
+ private static <T> Iterable<Entry<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier,T>> sortedEntries(final Map<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, T> map) {
+ ArrayList<Entry<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, T>> entries = new ArrayList<>(map.entrySet());
+ Collections.sort(entries, new Comparator<Entry<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, T>>() {
@Override
- public int compare(final Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, T> left,
- final Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, T> right) {
+ public int compare(final Entry<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, T> left,
+ final Entry<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, T> right) {
int leftSize = Iterables.size(left.getKey().getPathArguments());
int rightSize = Iterables.size(right.getKey().getPathArguments());
return Integer.compare(leftSize, rightSize);
}
protected Set<InstanceIdentifier<?>> toBinding(
- final Set<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier> normalized) {
+ final Set<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier> normalized) {
Set<InstanceIdentifier<?>> hashSet = new HashSet<>();
- for (org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalizedPath : normalized) {
+ for (org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalizedPath : normalized) {
try {
Optional<InstanceIdentifier<? extends DataObject>> potential = getCodec().toBinding(normalizedPath);
if (potential.isPresent()) {
@Override
public void onDataChanged(
- final AsyncDataChangeEvent<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, NormalizedNode<?, ?>> change) {
+ final AsyncDataChangeEvent<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, NormalizedNode<?, ?>> change) {
bindingDataChangeListener.onDataChanged(new TranslatedDataChangeEvent(change, path));
}
}
private class TranslatedDataChangeEvent implements AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> {
- private final AsyncDataChangeEvent<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, NormalizedNode<?, ?>> domEvent;
+ private final AsyncDataChangeEvent<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, NormalizedNode<?, ?>> domEvent;
private final InstanceIdentifier<?> path;
private Map<InstanceIdentifier<?>, DataObject> createdCache;
private Optional<DataObject> updatedDataCache;
public TranslatedDataChangeEvent(
- final AsyncDataChangeEvent<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, NormalizedNode<?, ?>> change,
+ final AsyncDataChangeEvent<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, NormalizedNode<?, ?>> change,
final InstanceIdentifier<?> path) {
this.domEvent = change;
this.path = path;
import org.opendaylight.yangtools.concepts.Delegator;
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import com.google.common.base.Optional;
import com.google.common.util.concurrent.ListenableFuture;
-abstract class AbstractForwardedTransaction<T extends AsyncTransaction<InstanceIdentifier, NormalizedNode<?, ?>>>
+abstract class AbstractForwardedTransaction<T extends AsyncTransaction<YangInstanceIdentifier, NormalizedNode<?, ?>>>
implements Delegator<T>, Identifiable<Object> {
private final T delegate;
}
@SuppressWarnings("unchecked")
- protected final <S extends AsyncTransaction<InstanceIdentifier, NormalizedNode<?, ?>>> S getDelegateChecked(final Class<S> txType) {
+ protected final <S extends AsyncTransaction<YangInstanceIdentifier, NormalizedNode<?, ?>>> S getDelegateChecked(final Class<S> txType) {
Preconditions.checkState(txType.isInstance(delegate));
return (S) delegate;
}
import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizationOperation;
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Override
protected final void ensureParentsByMerge(final LogicalDatastoreType store,
- final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalizedPath,
+ final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalizedPath,
final InstanceIdentifier<?> path) {
List<PathArgument> currentArguments = new ArrayList<>();
DataNormalizationOperation<?> currentOp = getCodec().getDataNormalizer().getRootOperation();
throw new IllegalArgumentException(String.format("Invalid child encountered in path %s", path), e);
}
currentArguments.add(currentArg);
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier currentPath = org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.create(
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier currentPath = org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.create(
currentArguments);
final Optional<NormalizedNode<?, ?>> d;
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.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public final <U extends DataObject> void put(final LogicalDatastoreType store,
final InstanceIdentifier<U> path, final U data, final boolean createParents) {
- final Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, NormalizedNode<?, ?>> normalized = getCodec()
+ final Entry<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, NormalizedNode<?, ?>> normalized = getCodec()
.toNormalizedNode(path, data);
if(createParents) {
ensureParentsByMerge(store, normalized.getKey(), path);
public final <U extends DataObject> void merge(final LogicalDatastoreType store,
final InstanceIdentifier<U> path, final U data,final boolean createParents) {
- final Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, NormalizedNode<?, ?>> normalized = getCodec()
+ final Entry<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, NormalizedNode<?, ?>> normalized = getCodec()
.toNormalizedNode(path, data);
if(createParents) {
* @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) {
+ final Entry<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, NormalizedNode<?, ?>> normalized) {
if(Identifiable.class.isAssignableFrom(path.getTargetType())) {
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier parentMapPath = getParent(normalized.getKey()).get();
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier 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) {
+ protected static Optional<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier> getParent(
+ final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier 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)));
+ return Optional.of(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.create(Iterables.limit(mapEntryItemPath, parentPathSize)));
} else if(parentPathSize == 0) {
- return Optional.of(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.create(Collections.<PathArgument>emptyList()));
+ return Optional.of(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.create(Collections.<PathArgument>emptyList()));
} else {
return Optional.absent();
}
* @param path
*/
protected abstract void ensureParentsByMerge(LogicalDatastoreType store,
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier key, InstanceIdentifier<?> path);
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier key, InstanceIdentifier<?> path);
protected final void doDelete(final LogicalDatastoreType store,
final InstanceIdentifier<?> path) {
- final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized = getCodec().toNormalized(path);
+ final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized = getCodec().toNormalized(path);
getDelegate().delete(store, normalized);
}
import org.opendaylight.yangtools.yang.binding.DataObject;
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.YangInstanceIdentifier.PathArgument;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.ListenableFuture;
@Override
protected void ensureParentsByMerge(final LogicalDatastoreType store,
- final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalizedPath, final InstanceIdentifier<?> path) {
+ final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalizedPath, final InstanceIdentifier<?> path) {
List<PathArgument> currentArguments = new ArrayList<>();
DataNormalizationOperation<?> currentOp = getCodec().getDataNormalizer().getRootOperation();
Iterator<PathArgument> iterator = normalizedPath.getPathArguments().iterator();
throw new IllegalArgumentException(String.format("Invalid child encountered in path %s", path), e);
}
currentArguments.add(currentArg);
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier currentPath = org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.create(
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier currentPath = org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.create(
currentArguments);
getDelegate().merge(store, currentPath, currentOp.createDefault(currentArg));
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.AugmentationIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
this.bindingToLegacy = mappingService;
}
- public org.opendaylight.yangtools.yang.data.api.InstanceIdentifier toNormalized(
+ public org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier toNormalized(
final InstanceIdentifier<? extends DataObject> binding) {
// Used instance-identifier codec do not support serialization of last
return toNormalizedImpl(binding);
}
- public Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, NormalizedNode<?, ?>> toNormalizedNode(
+ public Entry<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, NormalizedNode<?, ?>> toNormalizedNode(
final InstanceIdentifier<? extends DataObject> bindingPath, final DataObject bindingObject) {
return toNormalizedNode(toBindingEntry(bindingPath, bindingObject));
}
- public Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, NormalizedNode<?, ?>> toNormalizedNode(
+ public Entry<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, NormalizedNode<?, ?>> toNormalizedNode(
final Entry<org.opendaylight.yangtools.yang.binding.InstanceIdentifier<? extends DataObject>, DataObject> binding) {
- Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> legacyEntry = bindingToLegacy
+ Entry<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> legacyEntry = bindingToLegacy
.toDataDom(binding);
- Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, NormalizedNode<?, ?>> normalizedEntry = legacyToNormalized
+ Entry<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, NormalizedNode<?, ?>> normalizedEntry = legacyToNormalized
.toNormalized(legacyEntry);
LOG.trace("Serialization of {}, Legacy Representation: {}, Normalized Representation: {}", binding,
legacyEntry, normalizedEntry);
if (child instanceof AugmentationNode) {
ImmutableList<PathArgument> childArgs = ImmutableList.<PathArgument> builder()
.addAll(normalizedEntry.getKey().getPathArguments()).add(child.getIdentifier()).build();
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier childPath = org.opendaylight.yangtools.yang.data.api.InstanceIdentifier
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier childPath = org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier
.create(childArgs);
return toDOMEntry(childPath, child);
}
*
*/
public Optional<InstanceIdentifier<? extends DataObject>> toBinding(
- final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized)
+ final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized)
throws DeserializationException {
PathArgument lastArgument = Iterables.getLast(normalized.getPathArguments());
}
private Optional<InstanceIdentifier<? extends DataObject>> toBindingAugmented(
- final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized)
+ final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized)
throws DeserializationException {
Optional<InstanceIdentifier<? extends DataObject>> potential = toBindingImpl(normalized);
// Shorthand check, if codec already supports deserialization
// path.
LOG.trace("Looking for candidates to match {}", normalized);
for (QName child : lastArgument.getPossibleChildNames()) {
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier childPath = normalized.node(child);
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier childPath = normalized.node(child);
try {
if (isNotRepresentable(childPath)) {
LOG.trace("Path {} is not BI-representable, skipping it", childPath);
}
private Optional<InstanceIdentifier<? extends DataObject>> toBindingImpl(
- final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized)
+ final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized)
throws DeserializationException {
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier legacyPath;
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier legacyPath;
try {
if (isNotRepresentable(normalized)) {
return Optional.<InstanceIdentifier<? extends DataObject>> of(bindingToLegacy.fromDataDom(legacyPath));
}
- private boolean isNotRepresentable(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized)
+ private boolean isNotRepresentable(final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized)
throws DataNormalizationException {
DataNormalizationOperation<?> op = findNormalizationOperation(normalized);
if (op.isMixin() && op.getIdentifier() instanceof NodeIdentifier) {
}
private DataNormalizationOperation<?> findNormalizationOperation(
- final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized)
+ final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized)
throws DataNormalizationException {
DataNormalizationOperation<?> current = legacyToNormalized.getRootOperation();
for (PathArgument arg : normalized.getPathArguments()) {
key, value);
}
- private static final Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, NormalizedNode<?, ?>> toDOMEntry(
- final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier key, final NormalizedNode<?, ?> value) {
- return new SimpleEntry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, NormalizedNode<?, ?>>(key,
+ private static final Entry<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, NormalizedNode<?, ?>> toDOMEntry(
+ final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier key, final NormalizedNode<?, ?> value) {
+ return new SimpleEntry<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, NormalizedNode<?, ?>>(key,
value);
}
}
public Optional<Entry<org.opendaylight.yangtools.yang.binding.InstanceIdentifier<? extends DataObject>, DataObject>> toBinding(
- final Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, ? extends NormalizedNode<?, ?>> normalized)
+ final Entry<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, ? extends NormalizedNode<?, ?>> normalized)
throws DeserializationException {
Optional<InstanceIdentifier<? extends DataObject>> potentialPath = toBinding(normalized.getKey());
if (potentialPath.isPresent()) {
legacyToNormalized = new DataNormalizer(arg0);
}
- private org.opendaylight.yangtools.yang.data.api.InstanceIdentifier toNormalizedAugmented(
+ private org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier toNormalizedAugmented(
final InstanceIdentifier<?> augPath) {
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier processed = toNormalizedImpl(augPath);
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier processed = toNormalizedImpl(augPath);
// If used instance identifier codec added supports for deserialization
// of last AugmentationIdentifier we will just reuse it
if (isAugmentationIdentifier(processed)) {
return processed;
}
- Optional<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier> additionalSerialized;
+ Optional<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier> additionalSerialized;
additionalSerialized = toNormalizedAugmentedUsingChildContainers(augPath, processed);
if (additionalSerialized.isPresent()) {
* Processed path
* @return
*/
- private Optional<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier> toNormalizedAugmentedUsingChildLeafs(
+ private Optional<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier> toNormalizedAugmentedUsingChildLeafs(
final InstanceIdentifier<?> augPath,
- final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier parentPath) {
+ final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier parentPath) {
try {
DataNormalizationOperation<?> parentOp = legacyToNormalized.getOperation(parentPath);
if(!parentOp.getDataSchemaNode().isPresent()) {
* @return
*/
@SuppressWarnings("rawtypes")
- private Optional<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier> toNormalizedAugmentedUsingChildContainers(
+ private Optional<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier> toNormalizedAugmentedUsingChildContainers(
final InstanceIdentifier<?> augPath,
- final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier parentPath) {
+ final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier parentPath) {
for (Class augChild : BindingReflections.getChildrenClasses(augPath.getTargetType())) {
@SuppressWarnings("unchecked")
InstanceIdentifier<?> childPath = augPath.child(augChild);
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized = toNormalizedImpl(childPath);
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier potentialDiscovered = shortenToLastAugmentation(
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized = toNormalizedImpl(childPath);
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier potentialDiscovered = shortenToLastAugmentation(
normalized, parentPath);
if (potentialDiscovered != null) {
return Optional.of(potentialDiscovered);
&& method.getName().startsWith("get") && method.getParameterTypes().length == 0;
}
- private org.opendaylight.yangtools.yang.data.api.InstanceIdentifier shortenToLastAugmentation(
- final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized,
- final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier parentPath) {
+ private org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier shortenToLastAugmentation(
+ final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized,
+ final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier parentPath) {
int parentSize = Iterables.size(parentPath.getPathArguments());
int position = 0;
int foundPosition = -1;
}
if (foundPosition > 0 && foundPosition > parentSize) {
Iterable<PathArgument> shortened = Iterables.limit(normalized.getPathArguments(), foundPosition);
- return org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.create(shortened);
+ return org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.create(shortened);
}
return null;
}
return InstanceIdentifier.create(Iterables.limit(binding.getPathArguments(), foundPosition));
}
- private org.opendaylight.yangtools.yang.data.api.InstanceIdentifier toNormalizedImpl(
+ private org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier toNormalizedImpl(
final InstanceIdentifier<? extends DataObject> binding) {
- final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier legacyPath = bindingToLegacy
+ final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier legacyPath = bindingToLegacy
.toDataDom(binding);
- final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier normalized = legacyToNormalized
+ final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier normalized = legacyToNormalized
.toNormalized(legacyPath);
return normalized;
}
return Augmentation.class.isAssignableFrom(potential.getTargetType());
}
- private boolean isAugmentationIdentifier(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier processed) {
+ private boolean isAugmentationIdentifier(final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier processed) {
return Iterables.getLast(processed.getPathArguments()) instanceof AugmentationIdentifier;
}
return count;
}
- private static int getAugmentationCount(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier potential) {
+ private static int getAugmentationCount(final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier potential) {
int count = 0;
for (PathArgument arg : potential.getPathArguments()) {
if (arg instanceof AugmentationIdentifier) {
* @param path DOM Path
* @return Node with defaults set on.
*/
- public NormalizedNode<?, ?> getDefaultNodeFor(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier path) {
+ public NormalizedNode<?, ?> getDefaultNodeFor(final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier path) {
Iterator<PathArgument> iterator = path.getPathArguments().iterator();
DataNormalizationOperation<?> currentOp = legacyToNormalized.getRootOperation();
while (iterator.hasNext()) {
AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(BindingIndependentConnector.class);
- private static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier ROOT_BI = org.opendaylight.yangtools.yang.data.api.InstanceIdentifier
+ private static final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier ROOT_BI = org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier
.builder().toInstance();
private BindingIndependentMappingService mappingService;
@Override
public DataObject readOperationalData(final InstanceIdentifier<? extends DataObject> path) {
try {
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier biPath = mappingService.toDataDom(path);
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier biPath = mappingService.toDataDom(path);
CompositeNode result = biDataService.readOperationalData(biPath);
return potentialAugmentationRead(path, biPath, result);
} catch (DeserializationException e) {
}
private DataObject potentialAugmentationRead(InstanceIdentifier<? extends DataObject> path,
- final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier biPath, final CompositeNode result)
+ final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier biPath, final CompositeNode result)
throws DeserializationException {
Class<? extends DataObject> targetType = path.getTargetType();
if (Augmentation.class.isAssignableFrom(targetType)) {
@Override
public DataObject readConfigurationData(final InstanceIdentifier<? extends DataObject> path) {
try {
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier biPath = mappingService.toDataDom(path);
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier biPath = mappingService.toDataDom(path);
CompositeNode result = biDataService.readConfigurationData(biPath);
return potentialAugmentationRead(path, biPath, result);
} catch (DeserializationException e) {
DataModificationTransaction target = biDataService.beginTransaction();
LOG.debug("Created DOM Transaction {} for {},", target.getIdentifier(), source.getIdentifier());
for (InstanceIdentifier<? extends DataObject> entry : source.getRemovedConfigurationData()) {
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier biEntry = mappingService.toDataDom(entry);
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier biEntry = mappingService.toDataDom(entry);
target.removeConfigurationData(biEntry);
LOG.debug("Delete of Binding Configuration Data {} is translated to {}", entry, biEntry);
}
for (InstanceIdentifier<? extends DataObject> entry : source.getRemovedOperationalData()) {
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier biEntry = mappingService.toDataDom(entry);
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier biEntry = mappingService.toDataDom(entry);
target.removeOperationalData(biEntry);
LOG.debug("Delete of Binding Operational Data {} is translated to {}", entry, biEntry);
}
for (Map.Entry<InstanceIdentifier<? extends DataObject>, DataObject> entry : source.getUpdatedConfigurationData()
.entrySet()) {
- Map.Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> biEntry = mappingService
+ Map.Entry<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> biEntry = mappingService
.toDataDom(entry);
target.putConfigurationData(biEntry.getKey(), biEntry.getValue());
LOG.debug("Update of Binding Configuration Data {} is translated to {}", entry, biEntry);
}
for (Map.Entry<InstanceIdentifier<? extends DataObject>, DataObject> entry : source.getUpdatedOperationalData()
.entrySet()) {
- Map.Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> biEntry = mappingService
+ Map.Entry<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> biEntry = mappingService
.toDataDom(entry);
target.putOperationalData(biEntry.getKey(), biEntry.getValue());
LOG.debug("Update of Binding Operational Data {} is translated to {}", entry, biEntry);
@Deprecated
class DomToBindingCommitHandler implements //
RegistrationListener<DataCommitHandlerRegistration<InstanceIdentifier<? extends DataObject>, DataObject>>, //
- DataCommitHandler<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> {
+ DataCommitHandler<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> {
private final Logger LOG = LoggerFactory.getLogger(DomToBindingCommitHandler.class);
}
@Override
- public org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler.DataCommitTransaction<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> requestCommit(
- final DataModification<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> domTransaction) {
+ public org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler.DataCommitTransaction<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> requestCommit(
+ final DataModification<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> domTransaction) {
Object identifier = domTransaction.getIdentifier();
/**
}
private org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction createDomToBindingTransaction(
- final DataModification<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> source) {
+ final DataModification<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> source) {
if (baDataService == null) {
final String msg = "Binding Aware Service is not initialized correctly! DOM to Binding Transaction cannot be created for ";
LOG.error(msg + "{}", source);
org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction target = baDataService
.beginTransaction();
- for (org.opendaylight.yangtools.yang.data.api.InstanceIdentifier entry : source.getRemovedConfigurationData()) {
+ for (org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier entry : source.getRemovedConfigurationData()) {
try {
InstanceIdentifier<?> baEntry = mappingService.fromDataDom(entry);
LOG.error("Ommiting from BA transaction: {}.", entry, e);
}
}
- for (org.opendaylight.yangtools.yang.data.api.InstanceIdentifier entry : source.getRemovedOperationalData()) {
+ for (org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier entry : source.getRemovedOperationalData()) {
try {
InstanceIdentifier<?> baEntry = mappingService.fromDataDom(entry);
LOG.error("Ommiting from BA transaction: {}.", entry, e);
}
}
- for (Map.Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> entry : source
+ for (Map.Entry<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> entry : source
.getUpdatedConfigurationData().entrySet()) {
try {
InstanceIdentifier<?> baKey = mappingService.fromDataDom(entry.getKey());
LOG.error("Ommiting from BA transaction: {}.", entry.getKey(), e);
}
}
- for (Map.Entry<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> entry : source
+ for (Map.Entry<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> entry : source
.getUpdatedOperationalData().entrySet()) {
try {
private final RpcProviderRegistry baRpcRegistry;
private final RpcProviderRegistryImpl baRpcRegistryImpl;
- private final Function<InstanceIdentifier<?>, org.opendaylight.yangtools.yang.data.api.InstanceIdentifier> toDOMInstanceIdentifier;
+ private final Function<InstanceIdentifier<?>, org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier> toDOMInstanceIdentifier;
private final static Method EQUALS_METHOD;
this.rpcServiceType = new WeakReference<Class<? extends RpcService>>(service);
this.supportedRpcs = mappingService.getRpcQNamesFor(service);
- toDOMInstanceIdentifier = new Function<InstanceIdentifier<?>, org.opendaylight.yangtools.yang.data.api.InstanceIdentifier>() {
+ toDOMInstanceIdentifier = new Function<InstanceIdentifier<?>, org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier>() {
@Override
- public org.opendaylight.yangtools.yang.data.api.InstanceIdentifier apply(final InstanceIdentifier<?> input) {
+ public org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier apply(final InstanceIdentifier<?> input) {
return mappingService.toDataDom(input);
}
};
public void registerPaths(final Class<? extends BaseIdentity> context,
final Class<? extends RpcService> service, final Set<InstanceIdentifier<?>> set) {
QName ctx = BindingReflections.findQName(context);
- for (org.opendaylight.yangtools.yang.data.api.InstanceIdentifier path : FluentIterable.from(set).transform(
+ for (org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier path : FluentIterable.from(set).transform(
toDOMInstanceIdentifier)) {
for (org.opendaylight.controller.sal.core.api.Broker.RoutedRpcRegistration reg : registrations) {
reg.registerPath(ctx, path);
public void removePaths(final Class<? extends BaseIdentity> context, final Class<? extends RpcService> service,
final Set<InstanceIdentifier<?>> set) {
QName ctx = BindingReflections.findQName(context);
- for (org.opendaylight.yangtools.yang.data.api.InstanceIdentifier path : FluentIterable.from(set).transform(
+ for (org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier path : FluentIterable.from(set).transform(
toDOMInstanceIdentifier)) {
for (org.opendaylight.controller.sal.core.api.Broker.RoutedRpcRegistration reg : registrations) {
reg.unregisterPath(ctx, path);
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
class DomToBindingTransaction implements
- DataCommitHandler.DataCommitTransaction<InstanceIdentifier, CompositeNode> {
+ DataCommitHandler.DataCommitTransaction<YangInstanceIdentifier, CompositeNode> {
private final org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction backing;
- private final DataModification<InstanceIdentifier, CompositeNode> modification;
+ private final DataModification<YangInstanceIdentifier, CompositeNode> modification;
private final ConcurrentMap<Object, DomToBindingTransaction> bindingOpenedTransactions;
public DomToBindingTransaction(
final org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction backing,
- final DataModification<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> modification,
+ final DataModification<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> modification,
ConcurrentMap<Object, DomToBindingTransaction> bindingOpenedTransactions) {
super();
this.backing = backing;
}
@Override
- public DataModification<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> getModification() {
+ public DataModification<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> getModification() {
return modification;
}
private final BindingMountPointForwardingManager bindingForwardingManager = new BindingMountPointForwardingManager();
private ConcurrentMap<InstanceIdentifier<?>, BindingIndependentConnector> connectors = new ConcurrentHashMap<>();
- private ConcurrentMap<InstanceIdentifier<?>, org.opendaylight.yangtools.yang.data.api.InstanceIdentifier> forwarded = new ConcurrentHashMap<>();
+ private ConcurrentMap<InstanceIdentifier<?>, org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier> forwarded = new ConcurrentHashMap<>();
private ListenerRegistration<MountProvisionListener> domListenerRegistration;
private ListenerRegistration<org.opendaylight.controller.sal.binding.api.mount.MountProviderService.MountProvisionListener> baListenerRegistration;
}
private void tryToDeployConnector(InstanceIdentifier<?> baPath,
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier biPath) {
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier previous = forwarded.putIfAbsent(baPath, biPath);
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier biPath) {
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier previous = forwarded.putIfAbsent(baPath, biPath);
if (previous != null) {
return;
}
return mountConnector;
}
- public synchronized void tryToDeployDomForwarder(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier domPath) {
+ public synchronized void tryToDeployDomForwarder(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier domPath) {
InstanceIdentifier<?> baPath;
try {
baPath = connector.getMappingService().fromDataDom(domPath);
if (potentialConnector != null) {
return;
}
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier domPath = connector.getMappingService().toDataDom(baPath);
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier domPath = connector.getMappingService().toDataDom(baPath);
tryToDeployConnector(baPath, domPath);
}
// FIXME: Implement closeMountPoint
}
- public synchronized void undeployDomForwarder(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier biPath) {
+ public synchronized void undeployDomForwarder(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier biPath) {
// FIXME: Implement closeMountPoint
}
private class DomMountPointForwardingManager implements MountProvisionListener {
@Override
- public void onMountPointCreated(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier path) {
+ public void onMountPointCreated(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier path) {
tryToDeployDomForwarder(path);
}
@Override
- public void onMountPointRemoved(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier path) {
+ public void onMountPointRemoved(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier path) {
undeployDomForwarder(path);
}
}
import org.opendaylight.yangtools.sal.binding.generator.impl.RuntimeGeneratedMappingServiceImpl;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.AugmentationIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
public class BindingNormalizedCodecTest extends AbstractSchemaAwareTest {
private static final InstanceIdentifier<Node> NODE_INSTANCE_ID_BA =
NODES_INSTANCE_ID_BA.child(Node.class, NODE_KEY);
- private static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier NODE_INSTANCE_ID_BI = //
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.builder() //
+ private static final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier NODE_INSTANCE_ID_BI = //
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.builder() //
.node(Nodes.QNAME) //
.nodeWithKey(Node.QNAME, NODE_KEY_BI) //
.toInstance();
return new AugmentationVerifier<Node>(readedNode);
}
- private void assertBindingIndependentVersion(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier nodeId) {
+ private void assertBindingIndependentVersion(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier nodeId) {
CompositeNode node = biDataService.readOperationalData(nodeId);
assertNotNull(node);
}
@Beta
public class BindingTestContext implements AutoCloseable {
- public static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier TREE_ROOT = org.opendaylight.yangtools.yang.data.api.InstanceIdentifier
+ public static final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier TREE_ROOT = org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier
.builder().toInstance();
private static final Logger LOG = LoggerFactory.getLogger(BindingTestContext.class);
@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
+ private static final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier DOM_UNORDERED_LIST_PATH = org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier
.builder(Lists.QNAME).node(UnorderedContainer.QNAME).node(UnorderedList.QNAME).build();
- private static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier DOM_ORDERED_LIST_PATH = org.opendaylight.yangtools.yang.data.api.InstanceIdentifier
+ private static final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier DOM_ORDERED_LIST_PATH = org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier
.builder(Lists.QNAME).node(OrderedContainer.QNAME).node(OrderedList.QNAME).build();
- private static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier DOM_UNKEYED_LIST_PATH = org.opendaylight.yangtools.yang.data.api.InstanceIdentifier
+ private static final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier DOM_UNKEYED_LIST_PATH = org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier
.builder(Lists.QNAME).node(UnkeyedContainer.QNAME).node(UnkeyedList.QNAME).build();
private static final InstanceIdentifier<UnorderedContainer> UNORDERED_CONTAINER_PATH = InstanceIdentifier.builder(Lists.class).child(UnorderedContainer.class).build();
}
private NormalizedNode<?, ?> resolveDataAsserted(
- final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier domPath) {
+ final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier domPath) {
try (DOMDataReadOnlyTransaction readTx = testContext.getDomAsyncDataBroker().newReadOnlyTransaction()){
ListenableFuture<Optional<NormalizedNode<?, ?>>> data = readTx.read(LogicalDatastoreType.OPERATIONAL, domPath);
private void assertXmlRepresentation(final InstanceIdentifier<?> containerPath, final String... childNameValues) {
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier domPath = testContext.getBindingToDomMappingService().toDataDom(containerPath);
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier domPath = testContext.getBindingToDomMappingService().toDataDom(containerPath);
CompositeNode compositeNode = testContext.getDomDataBroker().readOperationalData(domPath);
assertNotNull(compositeNode);
}
private void verifyDataAreStoredProperly() {
- CompositeNode biFlows = biDataService.readConfigurationData(org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.of(Flows.QNAME));
+ CompositeNode biFlows = biDataService.readConfigurationData(org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.of(Flows.QNAME));
assertNotNull(biFlows);
CompositeNode biFlow = biFlows.getFirstCompositeByName(Flow.QNAME);
assertNotNull(biFlow);
.toInstance();
- private static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier NODE_INSTANCE_ID_BI = //
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.builder() //
+ private static final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier NODE_INSTANCE_ID_BI = //
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.builder() //
.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() //
+ private static final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier SUPPORTED_ACTIONS_INSTANCE_ID_BI = //
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.builder() //
.node(Nodes.QNAME) //
.nodeWithKey(Node.QNAME, NODE_KEY_BI) //
.node(SUPPORTED_ACTIONS_QNAME) //
}
private void assertBindingIndependentVersion(
- final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier nodeId) {
+ final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier nodeId) {
CompositeNode node = biDataService.readOperationalData(nodeId);
assertNotNull(node);
}
.augmentation(FlowCapableNode.class) //
.build();
- private static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier NODE_INSTANCE_ID_BI = //
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.builder() //
+ private static final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier NODE_INSTANCE_ID_BI = //
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.builder() //
.node(Nodes.QNAME) //
.nodeWithKey(Node.QNAME, NODE_KEY_BI) //
.toInstance();
assertNull(node);
}
- private void assertBindingIndependentVersion(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier nodeId) {
+ private void assertBindingIndependentVersion(final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier nodeId) {
CompositeNode node = biDataService.readOperationalData(nodeId);
assertNotNull(node);
}
private static final Map<QName, Object> TABLE_KEY_BI = //
ImmutableMap.<QName, Object> of(TABLE_ID_QNAME, TABLE_ID);;
- private static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier FLOW_INSTANCE_ID_BI = //
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.builder() //
+ private static final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier FLOW_INSTANCE_ID_BI = //
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.builder() //
.node(Nodes.QNAME) //
.nodeWithKey(Node.QNAME, NODE_KEY_BI) //
.nodeWithKey(Table.QNAME, TABLE_KEY_BI) //
private static final QName AUGMENTED_GROUP_STATISTICS = QName.create(NodeGroupStatistics.QNAME,
GroupStatistics.QNAME.getLocalName());
- private static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier NODE_INSTANCE_ID_BI = //
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.builder() //
+ private static final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier NODE_INSTANCE_ID_BI = //
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.builder() //
.node(Nodes.QNAME) //
.nodeWithKey(Node.QNAME, NODE_KEY_BI) //
.toInstance();
- private static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier GROUP_STATISTICS_ID_BI = org.opendaylight.yangtools.yang.data.api.InstanceIdentifier
+ private static final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier GROUP_STATISTICS_ID_BI = org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier
//
.builder(NODE_INSTANCE_ID_BI)
.nodeWithKey(QName.create(FlowCapableNode.QNAME, "group"), QName.create(FlowCapableNode.QNAME, "group-id"),
final BigInteger packetCount = BigInteger.valueOf(500L);
- DataReader<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> simpleReader = new DataReader<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode>() {
+ DataReader<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> simpleReader = new DataReader<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode>() {
@Override
- public CompositeNode readConfigurationData(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier arg0) {
+ public CompositeNode readConfigurationData(final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier arg0) {
return null;
}
@Override
- public CompositeNode readOperationalData(final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier arg0) {
+ public CompositeNode readOperationalData(final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier arg0) {
if (arg0.equals(GROUP_STATISTICS_ID_BI)) {
ImmutableCompositeNode data = ImmutableCompositeNode
.builder()
public static final InstanceIdentifier<Node> BA_NODE_C_ID = createBANodeIdentifier(NODE_C);
public static final InstanceIdentifier<Node> BA_NODE_D_ID = createBANodeIdentifier(NODE_D);
- public static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier BI_NODE_A_ID = createBINodeIdentifier(NODE_A);
- public static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier BI_NODE_B_ID = createBINodeIdentifier(NODE_B);
- public static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier BI_NODE_C_ID = createBINodeIdentifier(NODE_C);
- public static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier BI_NODE_D_ID = createBINodeIdentifier(NODE_D);
+ public static final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier BI_NODE_A_ID = createBINodeIdentifier(NODE_A);
+ public static final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier BI_NODE_B_ID = createBINodeIdentifier(NODE_B);
+ public static final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier BI_NODE_C_ID = createBINodeIdentifier(NODE_C);
+ public static final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier BI_NODE_D_ID = createBINodeIdentifier(NODE_D);
return InstanceIdentifier.builder(Nodes.class).child(Node.class, new NodeKey(node)).toInstance();
}
- private static org.opendaylight.yangtools.yang.data.api.InstanceIdentifier createBINodeIdentifier(NodeId node) {
- return org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.builder().node(Nodes.QNAME)
+ private static org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier createBINodeIdentifier(NodeId node) {
+ return org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.builder().node(Nodes.QNAME)
.nodeWithKey(Node.QNAME, NODE_ID_QNAME, node.getValue()).toInstance();
}
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 static final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier BI_MOUNT_ID = createBINodeIdentifier(MOUNT_NODE);
private BindingTestContext testContext;
private MountProvisionService domMountPointService;
schemaContext = mountSchemaContext;
}
- private static org.opendaylight.yangtools.yang.data.api.InstanceIdentifier createBINodeIdentifier(
+ private static org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier createBINodeIdentifier(
final NodeId mountNode) {
- return org.opendaylight.yangtools.yang.data.api.InstanceIdentifier
+ return org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier
.builder().node(Nodes.QNAME)
.nodeWithKey(Node.QNAME, NODE_ID_QNAME, mountNode.getValue())
.toInstance();
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.AugmentationIdentifier;
-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.InstanceIdentifier.NodeWithValue;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.SimpleNode;
import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.AugmentationIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.SimpleNode;
import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
operation = DataNormalizationOperation.from(ctx);
}
- public InstanceIdentifier toNormalized(final InstanceIdentifier legacy) {
+ public YangInstanceIdentifier toNormalized(final YangInstanceIdentifier legacy) {
ImmutableList.Builder<PathArgument> normalizedArgs = ImmutableList.builder();
DataNormalizationOperation<?> currentOp = operation;
throw new IllegalArgumentException(String.format("Failed to normalize path %s", legacy), e);
}
- return InstanceIdentifier.create(normalizedArgs.build());
+ return YangInstanceIdentifier.create(normalizedArgs.build());
}
- public DataNormalizationOperation<?> getOperation(final InstanceIdentifier legacy) throws DataNormalizationException {
+ public DataNormalizationOperation<?> getOperation(final YangInstanceIdentifier legacy) throws DataNormalizationException {
DataNormalizationOperation<?> currentOp = operation;
Iterator<PathArgument> arguments = legacy.getPathArguments().iterator();
return currentOp;
}
- public Map.Entry<InstanceIdentifier, NormalizedNode<?, ?>> toNormalized(
- final Map.Entry<InstanceIdentifier, CompositeNode> legacy) {
+ public Map.Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> toNormalized(
+ final Map.Entry<YangInstanceIdentifier, CompositeNode> legacy) {
return toNormalized(legacy.getKey(), legacy.getValue());
}
- public Map.Entry<InstanceIdentifier, NormalizedNode<?, ?>> toNormalized(final InstanceIdentifier legacyPath,
+ public Map.Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> toNormalized(final YangInstanceIdentifier legacyPath,
final CompositeNode legacyData) {
- InstanceIdentifier normalizedPath = toNormalized(legacyPath);
+ YangInstanceIdentifier normalizedPath = toNormalized(legacyPath);
DataNormalizationOperation<?> currentOp = operation;
for (PathArgument arg : normalizedPath.getPathArguments()) {
Preconditions.checkArgument(currentOp != null,
"Instance Identifier %s does not reference correct schema Node.", normalizedPath);
- return new AbstractMap.SimpleEntry<InstanceIdentifier, NormalizedNode<?, ?>>(normalizedPath,
+ return new AbstractMap.SimpleEntry<YangInstanceIdentifier, NormalizedNode<?, ?>>(normalizedPath,
currentOp.normalize(legacyData));
}
- public InstanceIdentifier toLegacy(final InstanceIdentifier normalized) throws DataNormalizationException {
+ public YangInstanceIdentifier toLegacy(final YangInstanceIdentifier normalized) throws DataNormalizationException {
ImmutableList.Builder<PathArgument> legacyArgs = ImmutableList.builder();
DataNormalizationOperation<?> currentOp = operation;
for (PathArgument normalizedArg : normalized.getPathArguments()) {
legacyArgs.add(normalizedArg);
}
}
- return InstanceIdentifier.create(legacyArgs.build());
+ return YangInstanceIdentifier.create(legacyArgs.build());
}
- public CompositeNode toLegacy(final InstanceIdentifier normalizedPath, final NormalizedNode<?, ?> normalizedData) {
+ public CompositeNode toLegacy(final YangInstanceIdentifier normalizedPath, final NormalizedNode<?, ?> normalizedData) {
// Preconditions.checkArgument(normalizedData instanceof
// DataContainerNode<?>,"Node object %s, %s should be of type DataContainerNode",normalizedPath,normalizedData);
if (normalizedData instanceof DataContainerNode<?>) {
import org.junit.Test;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.AugmentationIdentifier;
-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.InstanceIdentifier.NodeWithValue;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.SimpleNode;
import org.opendaylight.yangtools.yang.data.api.schema.AnyXmlNode;
static final QName NAME_QNAME = QName.create(TEST_QNAME, "name");
static final QName VALUE_QNAME = QName.create(TEST_QNAME, "value");
- static final InstanceIdentifier TEST_PATH = InstanceIdentifier.of(TEST_QNAME);
- static final InstanceIdentifier OUTER_LIST_PATH = InstanceIdentifier.builder(TEST_PATH).node(OUTER_LIST_QNAME)
+ static final YangInstanceIdentifier TEST_PATH = YangInstanceIdentifier.of(TEST_QNAME);
+ static final YangInstanceIdentifier OUTER_LIST_PATH = YangInstanceIdentifier.builder(TEST_PATH).node(OUTER_LIST_QNAME)
.build();
static final QName ONE_QNAME = QName.create(TEST_QNAME, "one");
static final QName TWO_QNAME = QName.create(TEST_QNAME, "two");
static final Short OUTER_LIST_ID = (short) 10;
- static final InstanceIdentifier OUTER_LIST_PATH_LEGACY = InstanceIdentifier.builder(TEST_QNAME)
+ static final YangInstanceIdentifier OUTER_LIST_PATH_LEGACY = YangInstanceIdentifier.builder(TEST_QNAME)
.nodeWithKey(OUTER_LIST_QNAME, ID_QNAME, OUTER_LIST_ID).build();
- static final InstanceIdentifier LEAF_TWO_PATH_LEGACY = InstanceIdentifier.builder(OUTER_LIST_PATH_LEGACY)
+ static final YangInstanceIdentifier LEAF_TWO_PATH_LEGACY = YangInstanceIdentifier.builder(OUTER_LIST_PATH_LEGACY)
.node(TWO_QNAME).build();
static final QName ANY_XML_LEAF_QNAME = QName.create(TEST_QNAME, "leaf");;
SchemaContext testCtx = createTestContext();
DataNormalizer normalizer = new DataNormalizer(testCtx);
- InstanceIdentifier normalizedPath = normalizer.toNormalized(LEAF_TWO_PATH_LEGACY);
+ YangInstanceIdentifier normalizedPath = normalizer.toNormalized(LEAF_TWO_PATH_LEGACY);
verifyNormalizedInstanceIdentifier(normalizedPath, TEST_QNAME, OUTER_LIST_QNAME, new Object[] {
OUTER_LIST_QNAME, ID_QNAME, OUTER_LIST_ID }, OUTER_CHOICE_QNAME, TWO_QNAME);
}
- private void verifyNormalizedInstanceIdentifier(final InstanceIdentifier actual, final Object... expPath) {
+ private void verifyNormalizedInstanceIdentifier(final YangInstanceIdentifier actual, final Object... expPath) {
assertNotNull("Actual InstanceIdentifier is null", actual);
assertEquals("InstanceIdentifier path length", expPath.length, Iterables.size(actual.getPathArguments()));
DataNormalizer normalizer = new DataNormalizer(createTestContext());
- InstanceIdentifier normalized = InstanceIdentifier.builder().node(TEST_QNAME).node(OUTER_LIST_QNAME)
+ YangInstanceIdentifier normalized = YangInstanceIdentifier.builder().node(TEST_QNAME).node(OUTER_LIST_QNAME)
.nodeWithKey(OUTER_LIST_QNAME, ID_QNAME, OUTER_LIST_ID).node(OUTER_CHOICE_QNAME).node(TWO_QNAME)
.build();
- InstanceIdentifier legacy = normalizer.toLegacy(normalized);
+ YangInstanceIdentifier legacy = normalizer.toLegacy(normalized);
assertEquals("Legacy InstanceIdentifier", LEAF_TWO_PATH_LEGACY, legacy);
}
.withNodeIdentifier(new NodeIdentifier(TEST_QNAME)).withChild(testAnyXmlNode).build();
DataNormalizer normalizer = new DataNormalizer(createTestContext());
- Node<?> legacyNode = normalizer.toLegacy(InstanceIdentifier.builder(TEST_QNAME).build(), testContainerNode);
+ Node<?> legacyNode = normalizer.toLegacy(YangInstanceIdentifier.builder(TEST_QNAME).build(), testContainerNode);
verifyLegacyNode(
legacyNode,
DataNormalizer normalizer = new DataNormalizer(createTestContext());
- Node<?> legacyNode = normalizer.toLegacy(InstanceIdentifier.builder(TEST_QNAME).build(), testContainerNode);
+ Node<?> legacyNode = normalizer.toLegacy(YangInstanceIdentifier.builder(TEST_QNAME).build(), testContainerNode);
verifyLegacyNode(
legacyNode,
DataNormalizer normalizer = new DataNormalizer(createTestContext());
- Node<?> legacyNode = normalizer.toLegacy(InstanceIdentifier.builder(TEST_QNAME).build(), testContainerNode);
+ Node<?> legacyNode = normalizer.toLegacy(YangInstanceIdentifier.builder(TEST_QNAME).build(), testContainerNode);
verifyLegacyNode(
legacyNode,
testBuilder.add(unkeyedListBuilder.toInstance());
}
- Entry<InstanceIdentifier, NormalizedNode<?, ?>> normalizedNodeEntry = normalizer
- .toNormalized(new AbstractMap.SimpleEntry<InstanceIdentifier, CompositeNode>(InstanceIdentifier.create(
+ Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalizedNodeEntry = normalizer
+ .toNormalized(new AbstractMap.SimpleEntry<YangInstanceIdentifier, CompositeNode>(YangInstanceIdentifier.create(
ImmutableList.<PathArgument> of(new NodeIdentifier(TEST_QNAME))), testBuilder.toInstance()));
verifyNormalizedInstanceIdentifier(normalizedNodeEntry.getKey(), TEST_QNAME);
CompositeNode anyXmlLegacy = anyXmlBuilder.toInstance();
testBuilder.add(anyXmlLegacy);
- Entry<InstanceIdentifier, NormalizedNode<?, ?>> normalizedNodeEntry = normalizer
- .toNormalized(new AbstractMap.SimpleEntry<InstanceIdentifier, CompositeNode>(InstanceIdentifier.create(
+ Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalizedNodeEntry = normalizer
+ .toNormalized(new AbstractMap.SimpleEntry<YangInstanceIdentifier, CompositeNode>(YangInstanceIdentifier.create(
ImmutableList.<PathArgument> of(new NodeIdentifier(TEST_QNAME))), testBuilder.toInstance()));
verifyNormalizedInstanceIdentifier(normalizedNodeEntry.getKey(), TEST_QNAME);
testBuilder.add(outerContBuilder.toInstance());
- Entry<InstanceIdentifier, NormalizedNode<?, ?>> normalizedNodeEntry = normalizer
- .toNormalized(new AbstractMap.SimpleEntry<InstanceIdentifier, CompositeNode>(InstanceIdentifier.create(
+ Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalizedNodeEntry = normalizer
+ .toNormalized(new AbstractMap.SimpleEntry<YangInstanceIdentifier, CompositeNode>(YangInstanceIdentifier.create(
ImmutableList.<PathArgument> of(new NodeIdentifier(TEST_QNAME))), testBuilder.toInstance()));
verifyNormalizedInstanceIdentifier(normalizedNodeEntry.getKey(), TEST_QNAME);
verifyNormalizedNode(normalizedNodeEntry.getValue(),
expectContainerNode(TEST_QNAME, expectContainerNode(OUTER_CONTAINER_QNAME, expAugmentation)));
- normalizedNodeEntry = normalizer.toNormalized(new AbstractMap.SimpleEntry<InstanceIdentifier, CompositeNode>(
- InstanceIdentifier.create(Lists.newArrayList(new NodeIdentifier(TEST_QNAME), new NodeIdentifier(
+ normalizedNodeEntry = normalizer.toNormalized(new AbstractMap.SimpleEntry<YangInstanceIdentifier, CompositeNode>(
+ YangInstanceIdentifier.create(Lists.newArrayList(new NodeIdentifier(TEST_QNAME), new NodeIdentifier(
OUTER_CONTAINER_QNAME))), outerContBuilder.toInstance()));
verifyNormalizedInstanceIdentifier(normalizedNodeEntry.getKey(), TEST_QNAME, OUTER_CONTAINER_QNAME,
testBuilder.addLeaf(ORDERED_LEAF_LIST_QNAME, "ordered-value" + i);
}
- Entry<InstanceIdentifier, NormalizedNode<?, ?>> normalizedNodeEntry = normalizer
- .toNormalized(new AbstractMap.SimpleEntry<InstanceIdentifier, CompositeNode>(InstanceIdentifier.create(
+ Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalizedNodeEntry = normalizer
+ .toNormalized(new AbstractMap.SimpleEntry<YangInstanceIdentifier, CompositeNode>(YangInstanceIdentifier.create(
ImmutableList.<PathArgument> of(new NodeIdentifier(TEST_QNAME))), testBuilder.toInstance()));
verifyNormalizedInstanceIdentifier(normalizedNodeEntry.getKey(), TEST_QNAME);
import org.opendaylight.controller.sal.core.api.RpcImplementation;
import org.opendaylight.controller.sal.core.api.notify.NotificationListener;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
public interface Connector extends RpcImplementation, NotificationListener {
- Set<InstanceIdentifier> getConfigurationPrefixes();
- Set<InstanceIdentifier> getRuntimePrefixes();
+ Set<YangInstanceIdentifier> getConfigurationPrefixes();
+ Set<YangInstanceIdentifier> getRuntimePrefixes();
void registerListener(ConnectorListener listener);
void unregisterListener(ConnectorListener listener);
import java.util.Set;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
public interface ConnectorListener {
- void onPrefixesAnnounced(Set<InstanceIdentifier> prefixes);
- void onPrefixesWithdrawn(Set<InstanceIdentifier> prefixes);
+ void onPrefixesAnnounced(Set<YangInstanceIdentifier> prefixes);
+ void onPrefixesWithdrawn(Set<YangInstanceIdentifier> prefixes);
}
import org.opendaylight.controller.md.sal.common.api.data.TransactionChainFactory;
import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
import org.opendaylight.controller.sal.core.api.BrokerService;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
/**
*
*/
public interface DOMDataBroker extends
- AsyncDataBroker<InstanceIdentifier, NormalizedNode<?, ?>, DOMDataChangeListener>,
- TransactionChainFactory<InstanceIdentifier, NormalizedNode<?, ?>>, BrokerService, DOMService {
+ AsyncDataBroker<YangInstanceIdentifier, NormalizedNode<?, ?>, DOMDataChangeListener>,
+ TransactionChainFactory<YangInstanceIdentifier, NormalizedNode<?, ?>>, BrokerService, DOMService {
/**
* {@inheritDoc}
package org.opendaylight.controller.md.sal.dom.api;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeListener;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-public interface DOMDataChangeListener extends AsyncDataChangeListener<InstanceIdentifier, NormalizedNode<?, ?>> {
+public interface DOMDataChangeListener extends AsyncDataChangeListener<YangInstanceIdentifier, NormalizedNode<?, ?>> {
}
package org.opendaylight.controller.md.sal.dom.api;
import org.opendaylight.controller.md.sal.common.api.data.AsyncReadOnlyTransaction;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-public interface DOMDataReadOnlyTransaction extends DOMDataReadTransaction, AsyncReadOnlyTransaction<InstanceIdentifier, NormalizedNode<?, ?>> {
+public interface DOMDataReadOnlyTransaction extends DOMDataReadTransaction, AsyncReadOnlyTransaction<YangInstanceIdentifier, NormalizedNode<?, ?>> {
}
import org.opendaylight.controller.md.sal.common.api.data.AsyncReadTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import com.google.common.base.Optional;
* <p>
* For more information on usage and examples, please see the documentation in {@link AsyncReadTransaction}.
*/
-public interface DOMDataReadTransaction extends AsyncReadTransaction<InstanceIdentifier, NormalizedNode<?, ?>> {
+public interface DOMDataReadTransaction extends AsyncReadTransaction<YangInstanceIdentifier, NormalizedNode<?, ?>> {
/**
* Reads data from provided logical data store located at the provided path.
* {@link ListenbleFuture#get()} returns {@link Optional#absent()}.
* </ul>
*/
- ListenableFuture<Optional<NormalizedNode<?,?>>> read(LogicalDatastoreType store,InstanceIdentifier path);
+ ListenableFuture<Optional<NormalizedNode<?,?>>> read(LogicalDatastoreType store,YangInstanceIdentifier path);
}
package org.opendaylight.controller.md.sal.dom.api;
import org.opendaylight.controller.md.sal.common.api.data.AsyncReadWriteTransaction;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-public interface DOMDataReadWriteTransaction extends DOMDataReadTransaction, DOMDataWriteTransaction, AsyncReadWriteTransaction<InstanceIdentifier, NormalizedNode<?, ?>> {
+public interface DOMDataReadWriteTransaction extends DOMDataReadTransaction, DOMDataWriteTransaction, AsyncReadWriteTransaction<YangInstanceIdentifier, NormalizedNode<?, ?>> {
}
import org.opendaylight.controller.md.sal.common.api.data.AsyncWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
/**
* <p>
* For more information on usage and examples, please see the documentation in {@link AsyncWriteTransaction}.
*/
-public interface DOMDataWriteTransaction extends AsyncWriteTransaction<InstanceIdentifier, NormalizedNode<?, ?>> {
+public interface DOMDataWriteTransaction extends AsyncWriteTransaction<YangInstanceIdentifier, NormalizedNode<?, ?>> {
/**
* Stores a piece of data at the specified path. This acts as an add / replace
* @throws IllegalStateException
* if the transaction has already been submitted
*/
- void put(LogicalDatastoreType store, InstanceIdentifier path, NormalizedNode<?, ?> data);
+ void put(LogicalDatastoreType store, YangInstanceIdentifier path, NormalizedNode<?, ?> data);
/**
* Merges a piece of data with the existing data at a specified path. Any pre-existing data
* @throws IllegalStateException
* if the transaction has already been submitted
*/
- void merge(LogicalDatastoreType store, InstanceIdentifier path, NormalizedNode<?, ?> data);
+ void merge(LogicalDatastoreType store, YangInstanceIdentifier path, NormalizedNode<?, ?> data);
}
package org.opendaylight.controller.md.sal.dom.api;
import org.opendaylight.yangtools.concepts.Identifiable;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import com.google.common.base.Optional;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-public interface DOMMountPoint extends Identifiable<InstanceIdentifier> {
+public interface DOMMountPoint extends Identifiable<YangInstanceIdentifier> {
<T extends DOMService> Optional<T> getService(Class<T> cls);
import org.opendaylight.controller.sal.core.api.mount.MountProvisionListener;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.concepts.ObjectRegistration;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import com.google.common.base.Optional;
public interface DOMMountPointService extends BrokerService {
- Optional<DOMMountPoint> getMountPoint(InstanceIdentifier path);
+ Optional<DOMMountPoint> getMountPoint(YangInstanceIdentifier path);
- DOMMountPointBuilder createMountPoint(InstanceIdentifier path);
+ DOMMountPointBuilder createMountPoint(YangInstanceIdentifier path);
ListenerRegistration<MountProvisionListener> registerProvisionListener(MountProvisionListener listener);
package org.opendaylight.controller.md.sal.dom.api;
import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
/**
* <p>
* This interface is type capture of {@link TransactionChain} for DOM Data Contracts.
*/
-public interface DOMTransactionChain extends TransactionChain<InstanceIdentifier, NormalizedNode<?, ?>> {
+public interface DOMTransactionChain extends TransactionChain<YangInstanceIdentifier, NormalizedNode<?, ?>> {
@Override
DOMDataReadOnlyTransaction newReadOnlyTransaction();
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.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.osgi.framework.BundleContext;
/**
void close();
}
- public interface RoutedRpcRegistration extends RpcRegistration, RoutedRegistration<QName, InstanceIdentifier, RpcImplementation> {
+ public interface RoutedRpcRegistration extends RpcRegistration, RoutedRegistration<QName, YangInstanceIdentifier, RpcImplementation> {
}
}
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.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import com.google.common.util.concurrent.ListenableFuture;
public interface RoutedRpcDefaultImplementation {
- ListenableFuture<RpcResult<CompositeNode>> invokeRpc(QName rpc, InstanceIdentifier identifier, CompositeNode input);
+ ListenableFuture<RpcResult<CompositeNode>> invokeRpc(QName rpc, YangInstanceIdentifier identifier, CompositeNode input);
}
import org.opendaylight.controller.sal.core.api.Broker.RpcRegistration;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-public interface RpcProvisionRegistry extends RpcImplementation, BrokerService, RouteChangePublisher<RpcRoutingContext, InstanceIdentifier>, DOMService {
+public interface RpcProvisionRegistry extends RpcImplementation, BrokerService, RouteChangePublisher<RpcRoutingContext, YangInstanceIdentifier>, DOMService {
/**
* Registers an implementation of the rpc.
import org.opendaylight.controller.md.sal.common.api.data.DataReader;
import org.opendaylight.controller.sal.core.api.BrokerService;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
/**
@Deprecated
public interface DataBrokerService extends
BrokerService, //
- DataReader<InstanceIdentifier, CompositeNode>, //
- DataModificationTransactionFactory<InstanceIdentifier, CompositeNode>, //
- DataChangePublisher<InstanceIdentifier, CompositeNode, DataChangeListener> {
+ DataReader<YangInstanceIdentifier, CompositeNode>, //
+ DataModificationTransactionFactory<YangInstanceIdentifier, CompositeNode>, //
+ DataChangePublisher<YangInstanceIdentifier, CompositeNode, DataChangeListener> {
@Override
- public CompositeNode readConfigurationData(InstanceIdentifier path);
+ public CompositeNode readConfigurationData(YangInstanceIdentifier path);
@Override
- public CompositeNode readOperationalData(InstanceIdentifier path);
+ public CompositeNode readOperationalData(YangInstanceIdentifier path);
@Override
DataModificationTransaction beginTransaction();
import org.opendaylight.controller.md.sal.common.api.data.DataChangeEvent;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
/**
*
@Deprecated
public interface DataChangeListener
extends
- org.opendaylight.controller.md.sal.common.api.data.DataChangeListener<InstanceIdentifier, CompositeNode> {
+ org.opendaylight.controller.md.sal.common.api.data.DataChangeListener<YangInstanceIdentifier, CompositeNode> {
@Override
- public void onDataChanged(DataChangeEvent<InstanceIdentifier, CompositeNode> change);
+ public void onDataChanged(DataChangeEvent<YangInstanceIdentifier, CompositeNode> change);
}
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
/**
*
*
*/
@Deprecated
-public interface DataModificationTransaction extends DataModification<InstanceIdentifier, CompositeNode> {
+public interface DataModificationTransaction extends DataModification<YangInstanceIdentifier, CompositeNode> {
/**
* Returns transaction identifier
import org.opendaylight.controller.sal.core.api.Provider;
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
/**
*
@Deprecated
public interface DataProviderService extends
DataBrokerService, //
- DataProvisionService<InstanceIdentifier, CompositeNode>
+ DataProvisionService<YangInstanceIdentifier, CompositeNode>
{
/**
void removeRefresher(DataStoreIdentifier store, DataRefresher refresher);
- Registration registerConfigurationReader(InstanceIdentifier path, DataReader<InstanceIdentifier, CompositeNode> reader);
+ Registration registerConfigurationReader(YangInstanceIdentifier path, DataReader<YangInstanceIdentifier, CompositeNode> reader);
- Registration registerOperationalReader(InstanceIdentifier path, DataReader<InstanceIdentifier, CompositeNode> reader);
+ Registration registerOperationalReader(YangInstanceIdentifier path, DataReader<YangInstanceIdentifier, CompositeNode> reader);
public interface DataRefresher extends Provider.ProviderFunctionality {
import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler;
import org.opendaylight.controller.md.sal.common.api.data.DataReader;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
/**
*
*/
@Deprecated
public interface DataStore extends //
- DataReader<InstanceIdentifier, CompositeNode>,
- DataCommitHandler<InstanceIdentifier, CompositeNode> {
+ DataReader<YangInstanceIdentifier, CompositeNode>,
+ DataCommitHandler<YangInstanceIdentifier, CompositeNode> {
- Iterable<InstanceIdentifier> getStoredConfigurationPaths();
- Iterable<InstanceIdentifier> getStoredOperationalPaths();
+ Iterable<YangInstanceIdentifier> getStoredConfigurationPaths();
+ Iterable<YangInstanceIdentifier> getStoredOperationalPaths();
- boolean containsConfigurationPath(InstanceIdentifier path);
- boolean containsOperationalPath(InstanceIdentifier path);
+ boolean containsConfigurationPath(YangInstanceIdentifier path);
+ boolean containsOperationalPath(YangInstanceIdentifier path);
}
package org.opendaylight.controller.sal.core.api.mount;
import java.util.EventListener;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
public interface MountProvisionListener extends EventListener {
- void onMountPointCreated(InstanceIdentifier path);
+ void onMountPointCreated(YangInstanceIdentifier path);
- void onMountPointRemoved(InstanceIdentifier path);
+ void onMountPointRemoved(YangInstanceIdentifier path);
}
package org.opendaylight.controller.sal.core.api.mount;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
/**
* @deprecated Use org.opendaylight.controller.md.sal.dom.api.DOMMountPointService instead
public interface MountProvisionService extends MountService {
@Override
- public MountProvisionInstance getMountPoint(InstanceIdentifier path);
+ public MountProvisionInstance getMountPoint(YangInstanceIdentifier path);
- MountProvisionInstance createMountPoint(InstanceIdentifier path);
+ MountProvisionInstance createMountPoint(YangInstanceIdentifier path);
- MountProvisionInstance createOrGetMountPoint(InstanceIdentifier path);
+ MountProvisionInstance createOrGetMountPoint(YangInstanceIdentifier path);
ListenerRegistration<MountProvisionListener> registerProvisionListener(MountProvisionListener listener);
package org.opendaylight.controller.sal.core.api.mount;
import org.opendaylight.controller.sal.core.api.BrokerService;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
/**
* Client-level interface for interacting with mount points. It provides access
* @param path Path at which the instance is registered
* @return Reference to the instance, or null if no such instance exists.
*/
- MountInstance getMountPoint(InstanceIdentifier path);
+ MountInstance getMountPoint(YangInstanceIdentifier path);
}
import org.opendaylight.controller.sal.dom.broker.impl.SchemaAwareDataStoreAdapter;
import org.opendaylight.controller.sal.dom.broker.impl.SchemaAwareRpcBroker;
import org.opendaylight.controller.sal.dom.broker.impl.SchemaContextProviders;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
/**
*
}
private DataProviderService createLegacyDataService(final DataStore legacyStore, final SchemaService schemaService) {
- InstanceIdentifier rootPath = InstanceIdentifier.builder().toInstance();
+ YangInstanceIdentifier rootPath = YangInstanceIdentifier.builder().toInstance();
DataBrokerImpl dataService = new DataBrokerImpl();
SchemaAwareDataStoreAdapter wrappedStore = new SchemaAwareDataStoreAdapter();
wrappedStore.changeDelegate(legacyStore);
import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
import org.opendaylight.controller.sal.core.spi.data.DOMStoreTransaction;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import com.google.common.base.Preconditions;
* Subtransaction type
*/
abstract class AbstractDOMForwardedCompositeTransaction<K, T extends DOMStoreTransaction> implements
- AsyncTransaction<InstanceIdentifier, NormalizedNode<?, ?>> {
+ AsyncTransaction<YangInstanceIdentifier, NormalizedNode<?, ?>> {
private final ImmutableMap<K, T> backingTxs;
private final Object identifier;
import org.opendaylight.controller.sal.core.spi.data.DOMStoreThreePhaseCommitCohort;
import org.opendaylight.controller.sal.core.spi.data.DOMStoreTransactionChain;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Override
public ListenerRegistration<DOMDataChangeListener> registerDataChangeListener(final LogicalDatastoreType store,
- final InstanceIdentifier path, final DOMDataChangeListener listener, final DataChangeScope triggeringScope) {
+ final YangInstanceIdentifier path, final DOMDataChangeListener listener, final DataChangeScope triggeringScope) {
DOMStore potentialStore = getTxFactories().get(store);
checkState(potentialStore != null, "Requested logical data store is not available.");
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadOnlyTransaction;
import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadTransaction;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import com.google.common.base.Optional;
* Read Only Transaction, which is composed of several
* {@link DOMStoreReadTransaction} transactions. Subtransaction is selected by
* {@link LogicalDatastoreType} type parameter in
- * {@link #read(LogicalDatastoreType, InstanceIdentifier)}.
+ * {@link #read(LogicalDatastoreType, YangInstanceIdentifier)}.
*/
class DOMForwardedReadOnlyTransaction extends
AbstractDOMForwardedCompositeTransaction<LogicalDatastoreType, DOMStoreReadTransaction> implements
@Override
public ListenableFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store,
- final InstanceIdentifier path) {
+ final YangInstanceIdentifier path) {
return getSubtransaction(store).read(path);
}
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadWriteTransaction;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import com.google.common.base.Optional;
* {@link LogicalDatastoreType} type parameter in:
*
* <ul>
- * <li>{@link #read(LogicalDatastoreType, InstanceIdentifier)}
- * <li>{@link #put(LogicalDatastoreType, InstanceIdentifier, NormalizedNode)}
- * <li>{@link #delete(LogicalDatastoreType, InstanceIdentifier)}
- * <li>{@link #merge(LogicalDatastoreType, InstanceIdentifier, NormalizedNode)}
+ * <li>{@link #read(LogicalDatastoreType, YangInstanceIdentifier)}
+ * <li>{@link #put(LogicalDatastoreType, YangInstanceIdentifier, NormalizedNode)}
+ * <li>{@link #delete(LogicalDatastoreType, YangInstanceIdentifier)}
+ * <li>{@link #merge(LogicalDatastoreType, YangInstanceIdentifier, NormalizedNode)}
* </ul>
* {@link #commit()} will result in invocation of
* {@link DOMDataCommitImplementation#submit(org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction, Iterable)}
@Override
public ListenableFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store,
- final InstanceIdentifier path) {
+ final YangInstanceIdentifier path) {
return getSubtransaction(store).read(path);
}
}
\ No newline at end of file
import org.opendaylight.controller.sal.core.spi.data.DOMStoreThreePhaseCommitCohort;
import org.opendaylight.controller.sal.core.spi.data.DOMStoreWriteTransaction;
import org.opendaylight.yangtools.yang.common.RpcResult;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import com.google.common.base.Preconditions;
* {@link LogicalDatastoreType} type parameter in:
*
* <ul>
- * <li>{@link #put(LogicalDatastoreType, InstanceIdentifier, NormalizedNode)}
- * <li>{@link #delete(LogicalDatastoreType, InstanceIdentifier)}
- * <li>{@link #merge(LogicalDatastoreType, InstanceIdentifier, NormalizedNode)}
+ * <li>{@link #put(LogicalDatastoreType, YangInstanceIdentifier, NormalizedNode)}
+ * <li>{@link #delete(LogicalDatastoreType, YangInstanceIdentifier)}
+ * <li>{@link #merge(LogicalDatastoreType, YangInstanceIdentifier, NormalizedNode)}
* </ul>
* <p>
* {@link #commit()} will result in invocation of
}
@Override
- public void put(final LogicalDatastoreType store, final InstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
checkNotReady();
getSubtransaction(store).write(path, data);
}
@Override
- public void delete(final LogicalDatastoreType store, final InstanceIdentifier path) {
+ public void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path) {
checkNotReady();
getSubtransaction(store).delete(path);
}
@Override
- public void merge(final LogicalDatastoreType store, final InstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
checkNotReady();
getSubtransaction(store).merge(path, data);
}
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
import org.opendaylight.yangtools.yang.model.api.SchemaServiceListener;
}
@Override
- public CompositeNode readConfigurationData(final InstanceIdentifier legacyPath) {
+ public CompositeNode readConfigurationData(final YangInstanceIdentifier legacyPath) {
final BackwardsCompatibleTransaction<?> tx = BackwardsCompatibleTransaction.readOnlyTransaction(backingBroker.newReadOnlyTransaction(),normalizer);
try {
return tx.readConfigurationData(legacyPath);
}
@Override
- public CompositeNode readOperationalData(final InstanceIdentifier legacyPath) {
+ public CompositeNode readOperationalData(final YangInstanceIdentifier legacyPath) {
final BackwardsCompatibleTransaction<?> tx = BackwardsCompatibleTransaction.readOnlyTransaction(backingBroker.newReadOnlyTransaction(),normalizer);
try {
return tx.readOperationalData(legacyPath);
}
@Override
- public ListenerRegistration<DataChangeListener> registerDataChangeListener(final InstanceIdentifier legacyPath,
+ public ListenerRegistration<DataChangeListener> registerDataChangeListener(final YangInstanceIdentifier legacyPath,
final DataChangeListener listener) {
- final InstanceIdentifier normalizedPath = normalizer.toNormalized(legacyPath);
+ final YangInstanceIdentifier normalizedPath = normalizer.toNormalized(legacyPath);
final TranslatingListenerInvoker translatingCfgListener =
TranslatingListenerInvoker.createConfig(listener, normalizer);
@Override
public Registration registerCommitHandler(
- final InstanceIdentifier path, final DataCommitHandler<InstanceIdentifier, CompositeNode> commitHandler) {
+ final YangInstanceIdentifier path, final DataCommitHandler<YangInstanceIdentifier, CompositeNode> commitHandler) {
// FIXME Do real forwarding
- return new AbstractObjectRegistration<DataCommitHandler<InstanceIdentifier,CompositeNode>>(commitHandler) {
+ return new AbstractObjectRegistration<DataCommitHandler<YangInstanceIdentifier,CompositeNode>>(commitHandler) {
@Override
protected void removeRegistration() {
// NOOP
}
@Override
- public ListenerRegistration<RegistrationListener<DataCommitHandlerRegistration<InstanceIdentifier, CompositeNode>>> registerCommitHandlerListener(
- final RegistrationListener<DataCommitHandlerRegistration<InstanceIdentifier, CompositeNode>> commitHandlerListener) {
+ public ListenerRegistration<RegistrationListener<DataCommitHandlerRegistration<YangInstanceIdentifier, CompositeNode>>> registerCommitHandlerListener(
+ final RegistrationListener<DataCommitHandlerRegistration<YangInstanceIdentifier, CompositeNode>> commitHandlerListener) {
return null;
}
@Override
public Registration registerConfigurationReader(
- final InstanceIdentifier path, final DataReader<InstanceIdentifier, CompositeNode> reader) {
+ final YangInstanceIdentifier path, final DataReader<YangInstanceIdentifier, CompositeNode> reader) {
throw new UnsupportedOperationException("Data Reader contract is not supported.");
}
@Override
public Registration registerOperationalReader(
- final InstanceIdentifier path, final DataReader<InstanceIdentifier, CompositeNode> reader) {
+ final YangInstanceIdentifier path, final DataReader<YangInstanceIdentifier, CompositeNode> reader) {
throw new UnsupportedOperationException("Data Reader contract is not supported.");
}
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
};
@Override
- public CompositeNode readConfigurationData(final InstanceIdentifier legacyPath) {
+ public CompositeNode readConfigurationData(final YangInstanceIdentifier legacyPath) {
- InstanceIdentifier normalizedPath = normalizer.toNormalized(legacyPath);
+ YangInstanceIdentifier normalizedPath = normalizer.toNormalized(legacyPath);
ListenableFuture<Optional<NormalizedNode<?, ?>>> normalizedData = asyncTx.read(
LogicalDatastoreType.CONFIGURATION, normalizedPath);
}
@Override
- public CompositeNode readOperationalData(final InstanceIdentifier legacyPath) {
- InstanceIdentifier normalizedPath = normalizer.toNormalized(legacyPath);
+ public CompositeNode readOperationalData(final YangInstanceIdentifier legacyPath) {
+ YangInstanceIdentifier normalizedPath = normalizer.toNormalized(legacyPath);
ListenableFuture<Optional<NormalizedNode<?, ?>>> normalizedData = asyncTx.read(
LogicalDatastoreType.OPERATIONAL, normalizedPath);
}
@Override
- public Map<InstanceIdentifier, CompositeNode> getCreatedConfigurationData() {
+ public Map<YangInstanceIdentifier, CompositeNode> getCreatedConfigurationData() {
return Collections.emptyMap();
}
@Override
- public Map<InstanceIdentifier, CompositeNode> getCreatedOperationalData() {
+ public Map<YangInstanceIdentifier, CompositeNode> getCreatedOperationalData() {
return Collections.emptyMap();
}
@Override
- public Map<InstanceIdentifier, CompositeNode> getOriginalConfigurationData() {
+ public Map<YangInstanceIdentifier, CompositeNode> getOriginalConfigurationData() {
return Collections.emptyMap();
}
@Override
- public Map<InstanceIdentifier, CompositeNode> getOriginalOperationalData() {
+ public Map<YangInstanceIdentifier, CompositeNode> getOriginalOperationalData() {
return Collections.emptyMap();
}
@Override
- public Set<InstanceIdentifier> getRemovedConfigurationData() {
+ public Set<YangInstanceIdentifier> getRemovedConfigurationData() {
return Collections.emptySet();
}
@Override
- public Set<InstanceIdentifier> getRemovedOperationalData() {
+ public Set<YangInstanceIdentifier> getRemovedOperationalData() {
return Collections.emptySet();
}
@Override
- public Map<InstanceIdentifier, CompositeNode> getUpdatedConfigurationData() {
+ public Map<YangInstanceIdentifier, CompositeNode> getUpdatedConfigurationData() {
return Collections.emptyMap();
}
@Override
- public Map<InstanceIdentifier, CompositeNode> getUpdatedOperationalData() {
+ public Map<YangInstanceIdentifier, CompositeNode> getUpdatedOperationalData() {
return Collections.emptyMap();
}
@Override
- public void putConfigurationData(final InstanceIdentifier path, final CompositeNode data) {
+ public void putConfigurationData(final YangInstanceIdentifier path, final CompositeNode data) {
throw new UnsupportedOperationException();
}
@Override
- public void putOperationalData(final InstanceIdentifier path, final CompositeNode data) {
+ public void putOperationalData(final YangInstanceIdentifier path, final CompositeNode data) {
throw new UnsupportedOperationException();
}
@Override
- public void removeConfigurationData(final InstanceIdentifier path) {
+ public void removeConfigurationData(final YangInstanceIdentifier path) {
throw new UnsupportedOperationException();
}
@Override
- public void removeOperationalData(final InstanceIdentifier path) {
+ public void removeOperationalData(final YangInstanceIdentifier path) {
throw new UnsupportedOperationException();
}
}
@Override
- public void putConfigurationData(final InstanceIdentifier legacyPath, final CompositeNode legacyData) {
+ public void putConfigurationData(final YangInstanceIdentifier legacyPath, final CompositeNode legacyData) {
checkNotNull(legacyPath, "Path MUST NOT be null.");
checkNotNull(legacyData, "Data for path %s MUST NOT be null",legacyData);
- Entry<InstanceIdentifier, NormalizedNode<?, ?>> normalizedData = getNormalizer().toNormalized(legacyPath, legacyData);
+ Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalizedData = getNormalizer().toNormalized(legacyPath, legacyData);
putWithEnsuredParents(LogicalDatastoreType.CONFIGURATION, normalizedData.getKey(), normalizedData.getValue());
}
@Override
- public void putOperationalData(final InstanceIdentifier legacyPath, final CompositeNode legacyData) {
+ public void putOperationalData(final YangInstanceIdentifier legacyPath, final CompositeNode legacyData) {
checkNotNull(legacyPath, "Path MUST NOT be null.");
checkNotNull(legacyData, "Data for path %s MUST NOT be null",legacyData);
- Entry<InstanceIdentifier, NormalizedNode<?, ?>> normalizedData = getNormalizer().toNormalized(legacyPath, legacyData);
+ Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalizedData = getNormalizer().toNormalized(legacyPath, legacyData);
putWithEnsuredParents(LogicalDatastoreType.OPERATIONAL, normalizedData.getKey(), normalizedData.getValue());
}
- private void putWithEnsuredParents(final LogicalDatastoreType store, final InstanceIdentifier normalizedPath,
+ private void putWithEnsuredParents(final LogicalDatastoreType store, final YangInstanceIdentifier normalizedPath,
final NormalizedNode<?, ?> normalizedData) {
LOG.trace("write {}:{} ",store,normalizedPath);
throw new IllegalArgumentException(String.format("Invalid child encountered in path %s", normalizedPath), e);
}
currentArguments.add(currentArg);
- InstanceIdentifier currentPath = InstanceIdentifier.create(currentArguments);
+ YangInstanceIdentifier currentPath = YangInstanceIdentifier.create(currentArguments);
boolean isPresent = getDelegate().read(store, currentPath).get().isPresent();
if(isPresent == false && iterator.hasNext()) {
getDelegate().merge(store, currentPath, currentOp.createDefault(currentArg));
}
@Override
- public void removeConfigurationData(final InstanceIdentifier legacyPath) {
+ public void removeConfigurationData(final YangInstanceIdentifier legacyPath) {
checkNotNull(legacyPath, "Path MUST NOT be null.");
getDelegate().delete(LogicalDatastoreType.CONFIGURATION, getNormalizer().toNormalized(legacyPath));
}
@Override
- public void removeOperationalData(final InstanceIdentifier legacyPath) {
+ public void removeOperationalData(final YangInstanceIdentifier legacyPath) {
checkNotNull(legacyPath, "Path MUST NOT be null.");
getDelegate().delete(LogicalDatastoreType.OPERATIONAL, getNormalizer().toNormalized(legacyPath));
}
import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizationException;
import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizer;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import com.google.common.collect.Maps;
public abstract class TranslatingDataChangeEvent implements
-DataChangeEvent<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> {
+DataChangeEvent<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> {
private TranslatingDataChangeEvent() {
}
- public static DataChangeEvent<InstanceIdentifier, CompositeNode> createOperational(
- final AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change, final DataNormalizer normalizer) {
+ public static DataChangeEvent<YangInstanceIdentifier, CompositeNode> createOperational(
+ final AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change, final DataNormalizer normalizer) {
return new OperationalChangeEvent(change, normalizer);
}
- public static DataChangeEvent<InstanceIdentifier, CompositeNode> createConfiguration(
- final AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change, final DataNormalizer normalizer) {
+ public static DataChangeEvent<YangInstanceIdentifier, CompositeNode> createConfiguration(
+ final AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change, final DataNormalizer normalizer) {
return new ConfigurationChangeEvent(change, normalizer);
}
@Override
- public Map<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> getCreatedOperationalData() {
+ public Map<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> getCreatedOperationalData() {
return Collections.emptyMap();
}
@Override
- public Map<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> getCreatedConfigurationData() {
+ public Map<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> getCreatedConfigurationData() {
return Collections.emptyMap();
}
@Override
- public Map<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> getUpdatedOperationalData() {
+ public Map<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> getUpdatedOperationalData() {
return Collections.emptyMap();
}
@Override
- public Map<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> getUpdatedConfigurationData() {
+ public Map<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> getUpdatedConfigurationData() {
return Collections.emptyMap();
}
@Override
- public Set<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier> getRemovedConfigurationData() {
+ public Set<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier> getRemovedConfigurationData() {
return Collections.emptySet();
}
@Override
- public Set<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier> getRemovedOperationalData() {
+ public Set<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier> getRemovedOperationalData() {
return Collections.emptySet();
}
@Override
- public Map<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> getOriginalConfigurationData() {
+ public Map<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> getOriginalConfigurationData() {
return Collections.emptyMap();
}
@Override
- public Map<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> getOriginalOperationalData() {
+ public Map<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> getOriginalOperationalData() {
return Collections.emptyMap();
}
private final static class OperationalChangeEvent extends TranslatingDataChangeEvent {
- private final AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> delegate;
+ private final AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> delegate;
private final DataNormalizer normalizer;
- private Map<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> updatedCache;
+ private Map<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> updatedCache;
- public OperationalChangeEvent(final AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change,
+ public OperationalChangeEvent(final AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change,
final DataNormalizer normalizer) {
this.delegate = change;
this.normalizer = normalizer;
}
@Override
- public Map<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> getCreatedOperationalData() {
+ public Map<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> getCreatedOperationalData() {
return transformToLegacy(normalizer, delegate.getCreatedData());
}
@Override
- public Set<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier> getRemovedOperationalData() {
+ public Set<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier> getRemovedOperationalData() {
return delegate.getRemovedPaths();
}
}
@Override
- public Map<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> getOriginalOperationalData() {
+ public Map<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> getOriginalOperationalData() {
return transformToLegacy(normalizer, delegate.getOriginalData());
}
@Override
- public Map<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> getUpdatedOperationalData() {
+ public Map<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> getUpdatedOperationalData() {
if(updatedCache == null) {
- final Map<InstanceIdentifier, CompositeNode> updated = transformToLegacy(normalizer, delegate.getUpdatedData());
- final Map<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> created = getCreatedConfigurationData();
- final HashMap<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> updatedComposite = new HashMap<>(created.size() + updated.size());
+ final Map<YangInstanceIdentifier, CompositeNode> updated = transformToLegacy(normalizer, delegate.getUpdatedData());
+ final Map<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> created = getCreatedConfigurationData();
+ final HashMap<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> updatedComposite = new HashMap<>(created.size() + updated.size());
updatedComposite.putAll(created);
updatedComposite.putAll(updated);
updatedCache = Collections.unmodifiableMap(updatedComposite);
}
- private static Map<InstanceIdentifier, CompositeNode> transformToLegacy(final DataNormalizer normalizer, final Map<InstanceIdentifier, ? extends NormalizedNode<?, ?>> nodes) {
- final Map<InstanceIdentifier, CompositeNode> legacy = Maps.newHashMap();
+ private static Map<YangInstanceIdentifier, CompositeNode> transformToLegacy(final DataNormalizer normalizer, final Map<YangInstanceIdentifier, ? extends NormalizedNode<?, ?>> nodes) {
+ final Map<YangInstanceIdentifier, CompositeNode> legacy = Maps.newHashMap();
- for (final Map.Entry<InstanceIdentifier, ? extends NormalizedNode<?, ?>> entry : nodes.entrySet()) {
+ for (final Map.Entry<YangInstanceIdentifier, ? extends NormalizedNode<?, ?>> entry : nodes.entrySet()) {
try {
legacy.put(normalizer.toLegacy(entry.getKey()), normalizer.toLegacy(entry.getKey(), entry.getValue()));
} catch (final DataNormalizationException e) {
private final static class ConfigurationChangeEvent extends TranslatingDataChangeEvent {
- private final AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> delegate;
+ private final AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> delegate;
private final DataNormalizer normalizer;
- private Map<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> updatedCache;
+ private Map<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> updatedCache;
- public ConfigurationChangeEvent(final AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change,
+ public ConfigurationChangeEvent(final AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change,
final DataNormalizer normalizer) {
this.delegate = change;
this.normalizer = normalizer;
}
@Override
- public Map<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> getCreatedConfigurationData() {
+ public Map<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> getCreatedConfigurationData() {
return transformToLegacy(normalizer, delegate.getCreatedData());
}
@Override
- public Set<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier> getRemovedConfigurationData() {
+ public Set<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier> getRemovedConfigurationData() {
return delegate.getRemovedPaths();
}
}
@Override
- public Map<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> getOriginalConfigurationData() {
+ public Map<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> getOriginalConfigurationData() {
return transformToLegacy(normalizer, delegate.getOriginalData());
}
@Override
- public Map<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> getUpdatedConfigurationData() {
+ public Map<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> getUpdatedConfigurationData() {
if(updatedCache == null) {
- final Map<InstanceIdentifier, CompositeNode> updated = transformToLegacy(normalizer, delegate.getUpdatedData());
- final Map<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> created = getCreatedConfigurationData();
- final HashMap<org.opendaylight.yangtools.yang.data.api.InstanceIdentifier, CompositeNode> updatedComposite = new HashMap<>(created.size() + updated.size());
+ final Map<YangInstanceIdentifier, CompositeNode> updated = transformToLegacy(normalizer, delegate.getUpdatedData());
+ final Map<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> created = getCreatedConfigurationData();
+ final HashMap<org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier, CompositeNode> updatedComposite = new HashMap<>(created.size() + updated.size());
updatedComposite.putAll(created);
updatedComposite.putAll(updated);
updatedCache = Collections.unmodifiableMap(updatedComposite);
import org.opendaylight.yangtools.concepts.Delegator;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
abstract class TranslatingListenerInvoker implements AutoCloseable, DOMDataChangeListener, Delegator<DataChangeListener> {
}
@Override
- public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> normalizedChange) {
+ public void onDataChanged(final AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> normalizedChange) {
delegate.onDataChanged(getLegacyEvent(normalizer, normalizedChange));
}
- abstract DataChangeEvent<InstanceIdentifier, CompositeNode> getLegacyEvent(final DataNormalizer normalizer,
- final AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> normalizedChange);
+ abstract DataChangeEvent<YangInstanceIdentifier, CompositeNode> getLegacyEvent(final DataNormalizer normalizer,
+ final AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> normalizedChange);
@Override
public DataChangeListener getDelegate() {
return delegate;
}
- abstract void register(final DOMDataBroker backingBroker, final InstanceIdentifier normalizedPath);
+ abstract void register(final DOMDataBroker backingBroker, final YangInstanceIdentifier normalizedPath);
@Override
public void close() {
super(listener, normalizer);
}
- DataChangeEvent<InstanceIdentifier, CompositeNode> getLegacyEvent(final DataNormalizer normalizer, final AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> normalizedChange) {
+ DataChangeEvent<YangInstanceIdentifier, CompositeNode> getLegacyEvent(final DataNormalizer normalizer, final AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> normalizedChange) {
return TranslatingDataChangeEvent.createConfiguration(normalizedChange, normalizer);
}
@Override
- void register(final DOMDataBroker backingBroker, final InstanceIdentifier normalizedPath) {
+ void register(final DOMDataBroker backingBroker, final YangInstanceIdentifier normalizedPath) {
reg = backingBroker.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION, normalizedPath, this,
AsyncDataBroker.DataChangeScope.SUBTREE);
}
super(listener, normalizer);
}
- DataChangeEvent<InstanceIdentifier, CompositeNode> getLegacyEvent(final DataNormalizer normalizer, final AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> normalizedChange) {
+ DataChangeEvent<YangInstanceIdentifier, CompositeNode> getLegacyEvent(final DataNormalizer normalizer, final AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> normalizedChange) {
return TranslatingDataChangeEvent.createOperational(normalizedChange, normalizer);
}
@Override
- void register(final DOMDataBroker backingBroker, final InstanceIdentifier normalizedPath) {
+ void register(final DOMDataBroker backingBroker, final YangInstanceIdentifier normalizedPath) {
reg = backingBroker.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL, normalizedPath, this,
AsyncDataBroker.DataChangeScope.SUBTREE);
}
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.concepts.util.ListenerRegistry;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
public class DOMMountPointServiceImpl implements DOMMountPointService {
- private final Map<InstanceIdentifier, DOMMountPoint> mountPoints = new HashMap<>();
+ private final Map<YangInstanceIdentifier, DOMMountPoint> mountPoints = new HashMap<>();
private final ListenerRegistry<MountProvisionListener> listeners = ListenerRegistry.create();
@Override
- public Optional<DOMMountPoint> getMountPoint(final InstanceIdentifier path) {
+ public Optional<DOMMountPoint> getMountPoint(final YangInstanceIdentifier path) {
return Optional.fromNullable(mountPoints.get(path));
}
@Override
- public DOMMountPointBuilder createMountPoint(final InstanceIdentifier path) {
+ public DOMMountPointBuilder createMountPoint(final YangInstanceIdentifier path) {
Preconditions.checkState(!mountPoints.containsKey(path), "Mount point already exists");
return new DOMMountPointBuilderImpl(path);
}
- public void notifyMountCreated(final InstanceIdentifier identifier) {
+ public void notifyMountCreated(final YangInstanceIdentifier identifier) {
for (final ListenerRegistration<MountProvisionListener> listener : listeners
.getListeners()) {
listener.getInstance().onMountPointCreated(identifier);
}
}
- public void notifyMountRemoved(final InstanceIdentifier identifier) {
+ public void notifyMountRemoved(final YangInstanceIdentifier identifier) {
for (final ListenerRegistration<MountProvisionListener> listener : listeners
.getListeners()) {
listener.getInstance().onMountPointRemoved(identifier);
return new MountRegistration(mountPoint);
}
- public void unregisterMountPoint(final InstanceIdentifier mountPointId) {
+ public void unregisterMountPoint(final YangInstanceIdentifier mountPointId) {
synchronized (mountPoints) {
Preconditions.checkState(mountPoints.containsKey(mountPointId), "Mount point does not exist");
mountPoints.remove(mountPointId);
ClassToInstanceMap<DOMService> services = MutableClassToInstanceMap.create();
private SimpleDOMMountPoint mountPoint;
- private final InstanceIdentifier path;
+ private final YangInstanceIdentifier path;
private SchemaContext schemaContext;
- public DOMMountPointBuilderImpl(final InstanceIdentifier path) {
+ public DOMMountPointBuilderImpl(final YangInstanceIdentifier path) {
this.path = path;
}
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.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
public class BackwardsCompatibleMountPoint implements MountProvisionInstance, SchemaContextProvider, SchemaService {
private final DataProviderService dataReader;
- private final DataReader<InstanceIdentifier,CompositeNode> readWrapper;
+ private final DataReader<YangInstanceIdentifier,CompositeNode> readWrapper;
- private final InstanceIdentifier mountPath;
+ private final YangInstanceIdentifier mountPath;
private final NotificationPublishService notificationPublishService;
private final RpcProvisionRegistry rpcs;
private SchemaContext schemaContext;
- public BackwardsCompatibleMountPoint(final InstanceIdentifier path, final DOMMountPointService.DOMMountPointBuilder mountPointBuilder) {
+ public BackwardsCompatibleMountPoint(final YangInstanceIdentifier path, final DOMMountPointService.DOMMountPointBuilder mountPointBuilder) {
this.mountPath = Preconditions.checkNotNull(path);
Preconditions.checkNotNull(mountPointBuilder);
mountPointBuilder.register();
}
- public BackwardsCompatibleMountPoint(final InstanceIdentifier path, final DOMMountPoint mount) {
+ public BackwardsCompatibleMountPoint(final YangInstanceIdentifier path, final DOMMountPoint mount) {
this.mountPath = Preconditions.checkNotNull(path);
Preconditions.checkNotNull(mount);
}
// TODO Read wrapper is never used ... same in org.opendaylight.controller.sal.dom.broker.MountPointImpl
- public DataReader<InstanceIdentifier, CompositeNode> getReadWrapper() {
+ public DataReader<YangInstanceIdentifier, CompositeNode> getReadWrapper() {
return readWrapper;
}
@Override
- public CompositeNode readConfigurationData(final InstanceIdentifier path) {
+ public CompositeNode readConfigurationData(final YangInstanceIdentifier path) {
return dataReader.readConfigurationData(path);
}
@Override
- public CompositeNode readOperationalData(final InstanceIdentifier path) {
+ public CompositeNode readOperationalData(final YangInstanceIdentifier path) {
return dataReader.readOperationalData(path);
}
@Override
public Registration registerOperationalReader(
- final InstanceIdentifier path, final DataReader<InstanceIdentifier, CompositeNode> reader) {
+ final YangInstanceIdentifier path, final DataReader<YangInstanceIdentifier, CompositeNode> reader) {
return dataReader.registerOperationalReader(path, reader);
}
@Override
public Registration registerConfigurationReader(
- final InstanceIdentifier path, final DataReader<InstanceIdentifier, CompositeNode> reader) {
+ final YangInstanceIdentifier path, final DataReader<YangInstanceIdentifier, CompositeNode> reader) {
return dataReader.registerConfigurationReader(path, reader);
}
}
@Override
- public ListenerRegistration<DataChangeListener> registerDataChangeListener(final InstanceIdentifier path,
+ public ListenerRegistration<DataChangeListener> registerDataChangeListener(final YangInstanceIdentifier path,
final DataChangeListener listener) {
return dataReader.registerDataChangeListener(path, listener);
}
@Override
public Registration registerCommitHandler(
- final InstanceIdentifier path, final DataCommitHandler<InstanceIdentifier, CompositeNode> commitHandler) {
+ final YangInstanceIdentifier path, final DataCommitHandler<YangInstanceIdentifier, CompositeNode> commitHandler) {
return dataReader.registerCommitHandler(path, commitHandler);
}
}
}
- class ReadWrapper implements DataReader<InstanceIdentifier, CompositeNode> {
- private InstanceIdentifier shortenPath(final InstanceIdentifier path) {
- InstanceIdentifier ret = null;
+ class ReadWrapper implements DataReader<YangInstanceIdentifier, CompositeNode> {
+ private YangInstanceIdentifier shortenPath(final YangInstanceIdentifier path) {
+ YangInstanceIdentifier ret = null;
if(mountPath.contains(path)) {
final List<PathArgument> newArgs = path.getPath().subList(mountPath.getPath().size(), path.getPath().size());
- ret = InstanceIdentifier.create(newArgs);
+ ret = YangInstanceIdentifier.create(newArgs);
}
return ret;
}
@Override
- public CompositeNode readConfigurationData(final InstanceIdentifier path) {
- final InstanceIdentifier newPath = shortenPath(path);
+ public CompositeNode readConfigurationData(final YangInstanceIdentifier path) {
+ final YangInstanceIdentifier newPath = shortenPath(path);
if(newPath == null) {
return null;
}
}
@Override
- public CompositeNode readOperationalData(final InstanceIdentifier path) {
- final InstanceIdentifier newPath = shortenPath(path);
+ public CompositeNode readOperationalData(final YangInstanceIdentifier path) {
+ final YangInstanceIdentifier newPath = shortenPath(path);
if(newPath == null) {
return null;
}
}
@Override
- public ListenerRegistration<RegistrationListener<DataCommitHandlerRegistration<InstanceIdentifier, CompositeNode>>> registerCommitHandlerListener(
- final RegistrationListener<DataCommitHandlerRegistration<InstanceIdentifier, CompositeNode>> commitHandlerListener) {
+ public ListenerRegistration<RegistrationListener<DataCommitHandlerRegistration<YangInstanceIdentifier, CompositeNode>>> registerCommitHandlerListener(
+ final RegistrationListener<DataCommitHandlerRegistration<YangInstanceIdentifier, CompositeNode>> commitHandlerListener) {
return dataReader.registerCommitHandlerListener(commitHandlerListener);
}
@Override
- public <L extends RouteChangeListener<RpcRoutingContext, InstanceIdentifier>> ListenerRegistration<L> registerRouteChangeListener(
+ public <L extends RouteChangeListener<RpcRoutingContext, YangInstanceIdentifier>> ListenerRegistration<L> registerRouteChangeListener(
final L listener) {
return rpcs.registerRouteChangeListener(listener);
}
}
@Override
- public ListenerRegistration<DOMDataChangeListener> registerDataChangeListener(final LogicalDatastoreType store, final InstanceIdentifier path, final DOMDataChangeListener listener, final DataChangeScope triggeringScope) {
+ public ListenerRegistration<DOMDataChangeListener> registerDataChangeListener(final LogicalDatastoreType store, final YangInstanceIdentifier path, final DOMDataChangeListener listener, final DataChangeScope triggeringScope) {
throw new UnsupportedOperationException("Register data listener not supported for mount point");
}
}
@Override
- public ListenableFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final InstanceIdentifier path) {
+ public ListenableFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path) {
CompositeNode rawData = null;
}
Preconditions.checkNotNull(rawData, "Unable to read %s data on path %s", store, path);
- final Map.Entry<InstanceIdentifier, NormalizedNode<?, ?>> normalized = normalizer.toNormalized(path, rawData);
+ final Map.Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalized = normalizer.toNormalized(path, rawData);
final Optional<NormalizedNode<?, ?>> normalizedNodeOptional = Optional.<NormalizedNode<?, ?>>fromNullable(normalized.getValue());
return com.google.common.util.concurrent.Futures.immediateFuture(normalizedNodeOptional);
}
}
@Override
- public void put(final LogicalDatastoreType store, final InstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
final CompositeNode legacyData = dataNormalizer.toLegacy(path, data);
try {
- final InstanceIdentifier legacyPath = dataNormalizer.toLegacy(path);
+ final YangInstanceIdentifier legacyPath = dataNormalizer.toLegacy(path);
switch (store) {
case CONFIGURATION: {
}
@Override
- public void merge(final LogicalDatastoreType store, final InstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
// TODO not supported
throw new UnsupportedOperationException("Merge not supported for mount point");
}
@Override
- public void delete(final LogicalDatastoreType store, final InstanceIdentifier path) {
+ public void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path) {
try {
- final InstanceIdentifier legacyPath = dataNormalizer.toLegacy(path);
+ final YangInstanceIdentifier legacyPath = dataNormalizer.toLegacy(path);
switch (store) {
case CONFIGURATION: {
}
@Override
- public ListenableFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final InstanceIdentifier path) {
+ public ListenableFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path) {
return new BackwardsCompatibleReadTransaction(dataReader, dataNormalizer).read(store, path);
}
}
@Override
- public void put(final LogicalDatastoreType store, final InstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
delegateWriteTx.put(store, path, data);
}
@Override
- public void merge(final LogicalDatastoreType store, final InstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
delegateWriteTx.merge(store, path, data);
}
@Override
- public void delete(final LogicalDatastoreType store, final InstanceIdentifier path) {
+ public void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path) {
delegateWriteTx.delete(store, path);
}
import org.opendaylight.controller.sal.core.api.mount.MountProvisionService;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.concepts.util.ListenerRegistry;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
public class BackwardsCompatibleMountPointManager implements MountProvisionService, MountProvisionListener {
private final ListenerRegistry<MountProvisionListener> listeners = ListenerRegistry.create();
- private final ConcurrentMap<InstanceIdentifier, MountProvisionInstance> mounts = new ConcurrentHashMap<>();
+ private final ConcurrentMap<YangInstanceIdentifier, MountProvisionInstance> mounts = new ConcurrentHashMap<>();
private final DOMMountPointService domMountPointService;
}
@Override
- public MountProvisionInstance createMountPoint(final InstanceIdentifier path) {
+ public MountProvisionInstance createMountPoint(final YangInstanceIdentifier path) {
checkState(!mounts.containsKey(path), "Mount already created");
// Create mount point instance, wrap instance of new API with BackwardsCompatibleMountPoint to preserve backwards comatibility
final BackwardsCompatibleMountPoint mount = new BackwardsCompatibleMountPoint(path, domMountPointService.createMountPoint(path));
return mount;
}
- public void notifyMountCreated(final InstanceIdentifier identifier) {
+ public void notifyMountCreated(final YangInstanceIdentifier identifier) {
for (final ListenerRegistration<MountProvisionListener> listener : listeners.getListeners()) {
listener.getInstance().onMountPointCreated(identifier);
}
}
- public void notifyMountRemoved(final InstanceIdentifier identifier) {
+ public void notifyMountRemoved(final YangInstanceIdentifier identifier) {
for (final ListenerRegistration<MountProvisionListener> listener : listeners.getListeners()) {
listener.getInstance().onMountPointRemoved(identifier);
}
@Override
public MountProvisionInstance createOrGetMountPoint(
- final InstanceIdentifier path) {
+ final YangInstanceIdentifier path) {
final MountProvisionInstance mount = getMountPoint(path);
if (mount == null) {
return createMountPoint(path);
}
@Override
- public MountProvisionInstance getMountPoint(final InstanceIdentifier path) {
+ public MountProvisionInstance getMountPoint(final YangInstanceIdentifier path) {
// If the mount point was created here, return directly
if(mounts.containsKey(path)) {
return mounts.get(path);
}
@Override
- public void onMountPointCreated(final InstanceIdentifier path) {
+ public void onMountPointCreated(final YangInstanceIdentifier path) {
notifyMountCreated(path);
}
@Override
- public void onMountPointRemoved(final InstanceIdentifier path) {
+ public void onMountPointRemoved(final YangInstanceIdentifier path) {
notifyMountRemoved(path);
}
}
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.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.osgi.framework.BundleContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
@Override
- public <L extends RouteChangeListener<RpcRoutingContext, InstanceIdentifier>> ListenerRegistration<L> registerRouteChangeListener(
+ public <L extends RouteChangeListener<RpcRoutingContext, YangInstanceIdentifier>> ListenerRegistration<L> registerRouteChangeListener(
final L listener) {
return router.registerRouteChangeListener(listener);
}
import org.opendaylight.controller.sal.dom.broker.impl.DataReaderRouter;
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import com.google.common.util.concurrent.MoreExecutors;
-public class DataBrokerImpl extends AbstractDataBroker<InstanceIdentifier, CompositeNode, DataChangeListener> implements
+public class DataBrokerImpl extends AbstractDataBroker<YangInstanceIdentifier, CompositeNode, DataChangeListener> implements
DataProviderService, AutoCloseable {
private AtomicLong nextTransaction = new AtomicLong();
@Override
public Registration registerConfigurationReader(
- InstanceIdentifier path, DataReader<InstanceIdentifier, CompositeNode> reader) {
+ YangInstanceIdentifier path, DataReader<YangInstanceIdentifier, CompositeNode> reader) {
return getDataReadRouter().registerConfigurationReader(path, reader);
}
@Override
public Registration registerOperationalReader(
- InstanceIdentifier path, DataReader<InstanceIdentifier, CompositeNode> reader) {
+ YangInstanceIdentifier path, DataReader<YangInstanceIdentifier, CompositeNode> reader) {
return getDataReadRouter().registerOperationalReader(path, reader);
}
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.concepts.util.ListenerRegistry;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-public class DataTransactionImpl extends AbstractDataTransaction<InstanceIdentifier, CompositeNode>
+public class DataTransactionImpl extends AbstractDataTransaction<YangInstanceIdentifier, CompositeNode>
implements DataModificationTransaction {
private final ListenerRegistry<DataTransactionListener> listeners = new ListenerRegistry<DataTransactionListener>();
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.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import com.google.common.util.concurrent.ListenableFuture;
private final SchemaAwareRpcBroker rpcs;
private final DataBrokerImpl dataReader;
private final NotificationRouter notificationRouter;
- private final DataReader<InstanceIdentifier,CompositeNode> readWrapper;
+ private final DataReader<YangInstanceIdentifier,CompositeNode> readWrapper;
- private final InstanceIdentifier mountPath;
+ private final YangInstanceIdentifier mountPath;
private SchemaContext schemaContext;
- public MountPointImpl(final InstanceIdentifier path) {
+ public MountPointImpl(final YangInstanceIdentifier path) {
this.mountPath = path;
rpcs = new SchemaAwareRpcBroker(path.toString(),this);
dataReader = new DataBrokerImpl();
readWrapper = new ReadWrapper();
}
- public InstanceIdentifier getMountPath() {
+ public YangInstanceIdentifier getMountPath() {
return mountPath;
}
- public DataReader<InstanceIdentifier, CompositeNode> getReadWrapper() {
+ public DataReader<YangInstanceIdentifier, CompositeNode> getReadWrapper() {
return readWrapper;
}
}
@Override
- public CompositeNode readConfigurationData(final InstanceIdentifier path) {
+ public CompositeNode readConfigurationData(final YangInstanceIdentifier path) {
return dataReader.readConfigurationData(path);
}
@Override
- public CompositeNode readOperationalData(final InstanceIdentifier path) {
+ public CompositeNode readOperationalData(final YangInstanceIdentifier path) {
return dataReader.readOperationalData(path);
}
@Override
public Registration registerOperationalReader(
- final InstanceIdentifier path, final DataReader<InstanceIdentifier, CompositeNode> reader) {
+ final YangInstanceIdentifier path, final DataReader<YangInstanceIdentifier, CompositeNode> reader) {
return dataReader.registerOperationalReader(path, reader);
}
@Override
public Registration registerConfigurationReader(
- final InstanceIdentifier path, final DataReader<InstanceIdentifier, CompositeNode> reader) {
+ final YangInstanceIdentifier path, final DataReader<YangInstanceIdentifier, CompositeNode> reader) {
return dataReader.registerConfigurationReader(path, reader);
}
}
@Override
- public ListenerRegistration<DataChangeListener> registerDataChangeListener(final InstanceIdentifier path,
+ public ListenerRegistration<DataChangeListener> registerDataChangeListener(final YangInstanceIdentifier path,
final DataChangeListener listener) {
return dataReader.registerDataChangeListener(path, listener);
}
@Override
public Registration registerCommitHandler(
- final InstanceIdentifier path, final DataCommitHandler<InstanceIdentifier, CompositeNode> commitHandler) {
+ final YangInstanceIdentifier path, final DataCommitHandler<YangInstanceIdentifier, CompositeNode> commitHandler) {
return dataReader.registerCommitHandler(path, commitHandler);
}
this.schemaContext = schemaContext;
}
- class ReadWrapper implements DataReader<InstanceIdentifier, CompositeNode> {
- private InstanceIdentifier shortenPath(final InstanceIdentifier path) {
- InstanceIdentifier ret = null;
+ class ReadWrapper implements DataReader<YangInstanceIdentifier, CompositeNode> {
+ private YangInstanceIdentifier shortenPath(final YangInstanceIdentifier path) {
+ YangInstanceIdentifier ret = null;
if(mountPath.contains(path)) {
List<PathArgument> newArgs = path.getPath().subList(mountPath.getPath().size(), path.getPath().size());
- ret = InstanceIdentifier.create(newArgs);
+ ret = YangInstanceIdentifier.create(newArgs);
}
return ret;
}
@Override
- public CompositeNode readConfigurationData(final InstanceIdentifier path) {
- InstanceIdentifier newPath = shortenPath(path);
+ public CompositeNode readConfigurationData(final YangInstanceIdentifier path) {
+ YangInstanceIdentifier newPath = shortenPath(path);
if(newPath == null) {
return null;
}
}
@Override
- public CompositeNode readOperationalData(final InstanceIdentifier path) {
- InstanceIdentifier newPath = shortenPath(path);
+ public CompositeNode readOperationalData(final YangInstanceIdentifier path) {
+ YangInstanceIdentifier newPath = shortenPath(path);
if(newPath == null) {
return null;
}
}
@Override
- public ListenerRegistration<RegistrationListener<DataCommitHandlerRegistration<InstanceIdentifier, CompositeNode>>> registerCommitHandlerListener(
- final RegistrationListener<DataCommitHandlerRegistration<InstanceIdentifier, CompositeNode>> commitHandlerListener) {
+ public ListenerRegistration<RegistrationListener<DataCommitHandlerRegistration<YangInstanceIdentifier, CompositeNode>>> registerCommitHandlerListener(
+ final RegistrationListener<DataCommitHandlerRegistration<YangInstanceIdentifier, CompositeNode>> commitHandlerListener) {
return dataReader.registerCommitHandlerListener(commitHandlerListener);
}
@Override
- public <L extends RouteChangeListener<RpcRoutingContext, InstanceIdentifier>> ListenerRegistration<L> registerRouteChangeListener(
+ public <L extends RouteChangeListener<RpcRoutingContext, YangInstanceIdentifier>> ListenerRegistration<L> registerRouteChangeListener(
final L listener) {
return rpcs.registerRouteChangeListener(listener);
}
import org.opendaylight.controller.sal.core.api.mount.MountProvisionService;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.concepts.util.ListenerRegistry;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
@Deprecated
public class MountPointManagerImpl implements MountProvisionService {
private final ListenerRegistry<MountProvisionListener> listeners =
ListenerRegistry.create();
- private final ConcurrentMap<InstanceIdentifier, MountPointImpl> mounts =
+ private final ConcurrentMap<YangInstanceIdentifier, MountPointImpl> mounts =
new ConcurrentHashMap<>();
private DataProviderService dataBroker = null;
@Override
- public MountProvisionInstance createMountPoint(final InstanceIdentifier path) {
+ public MountProvisionInstance createMountPoint(final YangInstanceIdentifier path) {
checkState(!mounts.containsKey(path), "Mount already created");
final MountPointImpl mount = new MountPointImpl(path);
registerMountPoint(mount);
return mount;
}
- public void notifyMountCreated(final InstanceIdentifier identifier) {
+ public void notifyMountCreated(final YangInstanceIdentifier identifier) {
for (final ListenerRegistration<MountProvisionListener> listener : listeners
.getListeners()) {
listener.getInstance().onMountPointCreated(identifier);
@Override
public MountProvisionInstance createOrGetMountPoint(
- final InstanceIdentifier path) {
+ final YangInstanceIdentifier path) {
final MountPointImpl mount = mounts.get(path);
if (mount == null) {
return createMountPoint(path);
}
@Override
- public MountProvisionInstance getMountPoint(final InstanceIdentifier path) {
+ public MountProvisionInstance getMountPoint(final YangInstanceIdentifier path) {
return mounts.get(path);
}
import org.opendaylight.controller.md.sal.common.impl.routing.AbstractDataReadRouter;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.SimpleNode;
import org.opendaylight.yangtools.yang.data.impl.CompositeNodeTOImpl;
import org.slf4j.LoggerFactory;
public class DataReaderRouter extends
-AbstractDataReadRouter<InstanceIdentifier, CompositeNode> {
+AbstractDataReadRouter<YangInstanceIdentifier, CompositeNode> {
private final static Logger LOG = LoggerFactory
.getLogger(DataReaderRouter.class);
private final static URI NETCONF_NAMESPACE = URI
"data");
@Override
- protected CompositeNodeTOImpl merge(final InstanceIdentifier path,
+ protected CompositeNodeTOImpl merge(final YangInstanceIdentifier path,
final Iterable<CompositeNode> data) {
PathArgument pathArgument = Iterables.getLast(path.getPathArguments(), null);
boolean empty = true;
}
public Map<QName, SimpleNode<?>> getKeyNodes(
- final InstanceIdentifier.PathArgument argument,
+ final YangInstanceIdentifier.PathArgument argument,
final CompositeNode node) {
- if (argument instanceof InstanceIdentifier.NodeIdentifierWithPredicates) {
+ if (argument instanceof YangInstanceIdentifier.NodeIdentifierWithPredicates) {
return _getKeyNodes(
- (InstanceIdentifier.NodeIdentifierWithPredicates) argument,
+ (YangInstanceIdentifier.NodeIdentifierWithPredicates) argument,
node);
} else if (argument != null) {
return _getKeyNodes(argument, node);
import org.opendaylight.controller.sal.core.api.data.DataStore;
import org.opendaylight.yangtools.concepts.Delegator;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
public class DataStoreStatsWrapper implements Delegator<DataStore>, DataStore {
}
@Override
- public CompositeNode readConfigurationData(InstanceIdentifier path) {
+ public CompositeNode readConfigurationData(YangInstanceIdentifier path) {
cfgReadCount.incrementAndGet();
final long startTime = System.nanoTime();
try {
}
@Override
- public CompositeNode readOperationalData(InstanceIdentifier path) {
+ public CompositeNode readOperationalData(YangInstanceIdentifier path) {
operReadCount.incrementAndGet();
final long startTime = System.nanoTime();
try {
}
}
- public DataCommitTransaction<InstanceIdentifier, CompositeNode> requestCommit(
- DataModification<InstanceIdentifier, CompositeNode> modification) {
+ public DataCommitTransaction<YangInstanceIdentifier, CompositeNode> requestCommit(
+ DataModification<YangInstanceIdentifier, CompositeNode> modification) {
requestCommitCount.incrementAndGet();
final long startTime = System.nanoTime();
try {
};
@Override
- public boolean containsConfigurationPath(InstanceIdentifier path) {
+ public boolean containsConfigurationPath(YangInstanceIdentifier path) {
return delegate.containsConfigurationPath(path);
}
- public Iterable<InstanceIdentifier> getStoredConfigurationPaths() {
+ public Iterable<YangInstanceIdentifier> getStoredConfigurationPaths() {
return delegate.getStoredConfigurationPaths();
}
- public Iterable<InstanceIdentifier> getStoredOperationalPaths() {
+ public Iterable<YangInstanceIdentifier> getStoredOperationalPaths() {
return delegate.getStoredOperationalPaths();
}
- public boolean containsOperationalPath(InstanceIdentifier path) {
+ public boolean containsOperationalPath(YangInstanceIdentifier path) {
return delegate.containsOperationalPath(path);
}
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger LOG = LoggerFactory
.getLogger(HashMapDataStore.class);
- private final Map<InstanceIdentifier, CompositeNode> configuration = new ConcurrentHashMap<InstanceIdentifier, CompositeNode>();
- private final Map<InstanceIdentifier, CompositeNode> operational = new ConcurrentHashMap<InstanceIdentifier, CompositeNode>();
+ private final Map<YangInstanceIdentifier, CompositeNode> configuration = new ConcurrentHashMap<YangInstanceIdentifier, CompositeNode>();
+ private final Map<YangInstanceIdentifier, CompositeNode> operational = new ConcurrentHashMap<YangInstanceIdentifier, CompositeNode>();
@Override
- public boolean containsConfigurationPath(final InstanceIdentifier path) {
+ public boolean containsConfigurationPath(final YangInstanceIdentifier path) {
return configuration.containsKey(path);
}
@Override
- public boolean containsOperationalPath(final InstanceIdentifier path) {
+ public boolean containsOperationalPath(final YangInstanceIdentifier path) {
return operational.containsKey(path);
}
@Override
- public Iterable<InstanceIdentifier> getStoredConfigurationPaths() {
+ public Iterable<YangInstanceIdentifier> getStoredConfigurationPaths() {
return configuration.keySet();
}
@Override
- public Iterable<InstanceIdentifier> getStoredOperationalPaths() {
+ public Iterable<YangInstanceIdentifier> getStoredOperationalPaths() {
return operational.keySet();
}
@Override
- public CompositeNode readConfigurationData(final InstanceIdentifier path) {
+ public CompositeNode readConfigurationData(final YangInstanceIdentifier path) {
LOG.trace("Reading configuration path {}", path);
return configuration.get(path);
}
@Override
- public CompositeNode readOperationalData(InstanceIdentifier path) {
+ public CompositeNode readOperationalData(YangInstanceIdentifier path) {
LOG.trace("Reading operational path {}", path);
return operational.get(path);
}
@Override
- public DataCommitHandler.DataCommitTransaction<InstanceIdentifier, CompositeNode> requestCommit(
- final DataModification<InstanceIdentifier, CompositeNode> modification) {
+ public DataCommitHandler.DataCommitTransaction<YangInstanceIdentifier, CompositeNode> requestCommit(
+ final DataModification<YangInstanceIdentifier, CompositeNode> modification) {
return new HashMapDataStoreTransaction(modification, this);
}
}
public RpcResult<Void> finish(HashMapDataStoreTransaction transaction) {
- final DataModification<InstanceIdentifier, CompositeNode> modification = transaction
+ final DataModification<YangInstanceIdentifier, CompositeNode> modification = transaction
.getModification();
- for (final InstanceIdentifier removal : modification
+ for (final YangInstanceIdentifier removal : modification
.getRemovedConfigurationData()) {
LOG.trace("Removing configuration path {}", removal);
remove(configuration, removal);
}
- for (final InstanceIdentifier removal : modification
+ for (final YangInstanceIdentifier removal : modification
.getRemovedOperationalData()) {
LOG.trace("Removing operational path {}", removal);
remove(operational, removal);
}
if (LOG.isTraceEnabled()) {
- for (final InstanceIdentifier a : modification
+ for (final YangInstanceIdentifier a : modification
.getUpdatedConfigurationData().keySet()) {
LOG.trace("Adding configuration path {}", a);
}
- for (final InstanceIdentifier a : modification
+ for (final YangInstanceIdentifier a : modification
.getUpdatedOperationalData().keySet()) {
LOG.trace("Adding operational path {}", a);
}
return RpcResultBuilder.<Void> success().build();
}
- public void remove(final Map<InstanceIdentifier, CompositeNode> map,
- final InstanceIdentifier identifier) {
- Set<InstanceIdentifier> affected = new HashSet<InstanceIdentifier>();
- for (final InstanceIdentifier path : map.keySet()) {
+ public void remove(final Map<YangInstanceIdentifier, CompositeNode> map,
+ final YangInstanceIdentifier identifier) {
+ Set<YangInstanceIdentifier> affected = new HashSet<YangInstanceIdentifier>();
+ for (final YangInstanceIdentifier path : map.keySet()) {
if (identifier.contains(path)) {
affected.add(path);
}
}
- for (final InstanceIdentifier pathToRemove : affected) {
+ for (final YangInstanceIdentifier pathToRemove : affected) {
LOG.trace("Removed path {}", pathToRemove);
map.remove(pathToRemove);
}
import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler.DataCommitTransaction;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
public class HashMapDataStoreTransaction implements
- DataCommitTransaction<InstanceIdentifier, CompositeNode> {
- private final DataModification<InstanceIdentifier, CompositeNode> modification;
+ DataCommitTransaction<YangInstanceIdentifier, CompositeNode> {
+ private final DataModification<YangInstanceIdentifier, CompositeNode> modification;
private final HashMapDataStore datastore;
HashMapDataStoreTransaction(
- final DataModification<InstanceIdentifier, CompositeNode> modify,
+ final DataModification<YangInstanceIdentifier, CompositeNode> modify,
final HashMapDataStore store) {
modification = modify;
datastore = store;
}
@Override
- public DataModification<InstanceIdentifier, CompositeNode> getModification() {
+ public DataModification<YangInstanceIdentifier, CompositeNode> getModification() {
return this.modification;
}
import org.opendaylight.controller.sal.core.api.RpcImplementation;
import org.opendaylight.yangtools.concepts.AbstractObjectRegistration;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
class RoutedRpcRegImpl extends AbstractObjectRegistration<RpcImplementation> implements
RoutedRpcRegistration {
}
@Override
- public void registerPath(final QName context, final InstanceIdentifier path) {
+ public void registerPath(final QName context, final YangInstanceIdentifier path) {
router.addPath(context, path, this);
}
@Override
- public void unregisterPath(final QName context, final InstanceIdentifier path) {
+ public void unregisterPath(final QName context, final YangInstanceIdentifier path) {
router.removePath(context, path, this);
}
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.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.SimpleNode;
import com.google.common.collect.ImmutableSet;
private final RpcRoutingStrategy strategy;
private final Set<QName> supportedRpcs;
private final RpcRoutingContext identifier;
- final ConcurrentMap<InstanceIdentifier, RoutedRpcRegImpl> implementations = new ConcurrentHashMap<>();
+ final ConcurrentMap<YangInstanceIdentifier, RoutedRpcRegImpl> implementations = new ConcurrentHashMap<>();
private final SchemaAwareRpcBroker router;
public RoutedRpcSelector(final RpcRoutingStrategy strategy, final SchemaAwareRpcBroker router) {
SimpleNode<?> routeContainer = inputContainer.getFirstSimpleByName(strategy.getLeaf());
checkArgument(routeContainer != null, "Leaf %s must be set with value", strategy.getLeaf());
Object route = routeContainer.getValue();
- checkArgument(route instanceof InstanceIdentifier,
+ checkArgument(route instanceof YangInstanceIdentifier,
"The routed node %s is not an instance identifier", route);
RpcImplementation potential = null;
if (route != null) {
}
}
if (potential == null) {
- return router.invokeRpc(rpc, (InstanceIdentifier) route, input);
+ return router.invokeRpc(rpc, (YangInstanceIdentifier) route, input);
}
checkState(potential != null, "No implementation is available for rpc:%s path:%s", rpc, route);
return potential.invokeRpc(rpc, input);
}
- public void addPath(final QName context, final InstanceIdentifier path, final RoutedRpcRegImpl routedRpcRegImpl) {
+ public void addPath(final QName context, final YangInstanceIdentifier path, final RoutedRpcRegImpl routedRpcRegImpl) {
//checkArgument(strategy.getContext().equals(context),"Supplied context is not supported.");
RoutedRpcRegImpl previous = implementations.put(path, routedRpcRegImpl);
if (previous == null) {
}
- public void removePath(final QName context, final InstanceIdentifier path, final RoutedRpcRegImpl routedRpcRegImpl) {
+ public void removePath(final QName context, final YangInstanceIdentifier path, final RoutedRpcRegImpl routedRpcRegImpl) {
boolean removed = implementations.remove(path, routedRpcRegImpl);
if (removed) {
router.notifyPathWithdrawal(context, strategy.getIdentifier(), path);
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.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.SimpleNode;
import org.opendaylight.yangtools.yang.data.impl.CompositeNodeTOImpl;
private SchemaContext schema = null;
private boolean validationEnabled = false;
- private final DataReader<InstanceIdentifier, CompositeNode> reader = new MergeFirstLevelReader();
+ private final DataReader<YangInstanceIdentifier, CompositeNode> reader = new MergeFirstLevelReader();
@Override
- public boolean containsConfigurationPath(final InstanceIdentifier path) {
+ public boolean containsConfigurationPath(final YangInstanceIdentifier path) {
try {
getDelegateReadLock().lock();
return getDelegate().containsConfigurationPath(path);
}
@Override
- public boolean containsOperationalPath(final InstanceIdentifier path) {
+ public boolean containsOperationalPath(final YangInstanceIdentifier path) {
try {
getDelegateReadLock().lock();
return getDelegate().containsOperationalPath(path);
}
@Override
- public Iterable<InstanceIdentifier> getStoredConfigurationPaths() {
+ public Iterable<YangInstanceIdentifier> getStoredConfigurationPaths() {
try {
getDelegateReadLock().lock();
return getDelegate().getStoredConfigurationPaths();
}
@Override
- public Iterable<InstanceIdentifier> getStoredOperationalPaths() {
+ public Iterable<YangInstanceIdentifier> getStoredOperationalPaths() {
try {
getDelegateReadLock().lock();
return getDelegate().getStoredOperationalPaths();
}
@Override
- public CompositeNode readConfigurationData(final InstanceIdentifier path) {
+ public CompositeNode readConfigurationData(final YangInstanceIdentifier path) {
return reader.readConfigurationData(path);
}
@Override
- public CompositeNode readOperationalData(final InstanceIdentifier path) {
+ public CompositeNode readOperationalData(final YangInstanceIdentifier path) {
return reader.readOperationalData(path);
}
@Override
- public org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler.DataCommitTransaction<InstanceIdentifier, CompositeNode> requestCommit(
- final DataModification<InstanceIdentifier, CompositeNode> modification) {
+ public org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler.DataCommitTransaction<YangInstanceIdentifier, CompositeNode> requestCommit(
+ final DataModification<YangInstanceIdentifier, CompositeNode> modification) {
validateAgainstSchema(modification);
NormalizedDataModification cleanedUp = prepareMergedTransaction(modification);
cleanedUp.status = TransactionStatus.SUBMITED;
this.validationEnabled = validationEnabled;
}
- private void validateAgainstSchema(final DataModification<InstanceIdentifier, CompositeNode> modification) {
+ private void validateAgainstSchema(final DataModification<YangInstanceIdentifier, CompositeNode> modification) {
if (!validationEnabled) {
return;
}
this.schema = null;
}
- protected CompositeNode mergeData(final InstanceIdentifier path, final CompositeNode stored, final CompositeNode modified,
+ protected CompositeNode mergeData(final YangInstanceIdentifier path, final CompositeNode stored, final CompositeNode modified,
final boolean config) {
// long startTime = System.nanoTime();
try {
}
}
- private DataSchemaNode schemaNodeFor(final InstanceIdentifier path) {
+ private DataSchemaNode schemaNodeFor(final YangInstanceIdentifier path) {
checkState(schema != null, "YANG Schema is not available");
return YangSchemaUtils.getSchemaNode(schema, path);
}
private NormalizedDataModification prepareMergedTransaction(
- final DataModification<InstanceIdentifier, CompositeNode> original) {
+ final DataModification<YangInstanceIdentifier, CompositeNode> original) {
NormalizedDataModification normalized = new NormalizedDataModification(original);
LOG.trace("Transaction: {} Removed Configuration {}, Removed Operational {}", original.getIdentifier(),
original.getRemovedConfigurationData(), original.getRemovedConfigurationData());
LOG.trace("Transaction: {} Updated Configuration {}, Updated Operational {}", original.getIdentifier(),
original.getUpdatedConfigurationData().entrySet(), original.getUpdatedOperationalData().entrySet());
- for (InstanceIdentifier entry : original.getRemovedConfigurationData()) {
+ for (YangInstanceIdentifier entry : original.getRemovedConfigurationData()) {
normalized.deepRemoveConfigurationData(entry);
}
- for (InstanceIdentifier entry : original.getRemovedOperationalData()) {
+ for (YangInstanceIdentifier entry : original.getRemovedOperationalData()) {
normalized.deepRemoveOperationalData(entry);
}
- for (Entry<InstanceIdentifier, CompositeNode> entry : original.getUpdatedConfigurationData().entrySet()) {
+ for (Entry<YangInstanceIdentifier, CompositeNode> entry : original.getUpdatedConfigurationData().entrySet()) {
normalized.putDeepConfigurationData(entry.getKey(), entry.getValue());
}
- for (Entry<InstanceIdentifier, CompositeNode> entry : original.getUpdatedOperationalData().entrySet()) {
+ for (Entry<YangInstanceIdentifier, CompositeNode> entry : original.getUpdatedOperationalData().entrySet()) {
normalized.putDeepOperationalData(entry.getKey(), entry.getValue());
}
return normalized;
}
- private Iterable<InstanceIdentifier> getConfigurationSubpaths(final InstanceIdentifier entry) {
+ private Iterable<YangInstanceIdentifier> getConfigurationSubpaths(final YangInstanceIdentifier entry) {
// FIXME: This should be replaced by index
- Iterable<InstanceIdentifier> paths = getStoredConfigurationPaths();
+ Iterable<YangInstanceIdentifier> paths = getStoredConfigurationPaths();
return getChildrenPaths(entry, paths);
}
- public Iterable<InstanceIdentifier> getOperationalSubpaths(final InstanceIdentifier entry) {
+ public Iterable<YangInstanceIdentifier> getOperationalSubpaths(final YangInstanceIdentifier entry) {
// FIXME: This should be indexed
- Iterable<InstanceIdentifier> paths = getStoredOperationalPaths();
+ Iterable<YangInstanceIdentifier> paths = getStoredOperationalPaths();
return getChildrenPaths(entry, paths);
}
- private static final Iterable<InstanceIdentifier> getChildrenPaths(final InstanceIdentifier entry,
- final Iterable<InstanceIdentifier> paths) {
- ImmutableSet.Builder<InstanceIdentifier> children = ImmutableSet.builder();
- for (InstanceIdentifier potential : paths) {
+ private static final Iterable<YangInstanceIdentifier> getChildrenPaths(final YangInstanceIdentifier entry,
+ final Iterable<YangInstanceIdentifier> paths) {
+ ImmutableSet.Builder<YangInstanceIdentifier> children = ImmutableSet.builder();
+ for (YangInstanceIdentifier potential : paths) {
if (entry.contains(potential)) {
children.add(entry);
}
return children.build();
}
- private final Comparator<Entry<InstanceIdentifier, CompositeNode>> preparationComparator = new Comparator<Entry<InstanceIdentifier, CompositeNode>>() {
+ private final Comparator<Entry<YangInstanceIdentifier, CompositeNode>> preparationComparator = new Comparator<Entry<YangInstanceIdentifier, CompositeNode>>() {
@Override
- public int compare(final Entry<InstanceIdentifier, CompositeNode> o1, final Entry<InstanceIdentifier, CompositeNode> o2) {
- InstanceIdentifier o1Key = o1.getKey();
- InstanceIdentifier o2Key = o2.getKey();
+ public int compare(final Entry<YangInstanceIdentifier, CompositeNode> o1, final Entry<YangInstanceIdentifier, CompositeNode> o2) {
+ YangInstanceIdentifier o1Key = o1.getKey();
+ YangInstanceIdentifier o2Key = o2.getKey();
return Integer.compare(o1Key.getPath().size(), o2Key.getPath().size());
}
};
- private class MergeFirstLevelReader implements DataReader<InstanceIdentifier, CompositeNode> {
+ private class MergeFirstLevelReader implements DataReader<YangInstanceIdentifier, CompositeNode> {
@Override
- public CompositeNode readConfigurationData(final InstanceIdentifier path) {
+ public CompositeNode readConfigurationData(final YangInstanceIdentifier path) {
getDelegateReadLock().lock();
try {
if (Iterables.isEmpty(path.getPathArguments())) {
qname = path.getPath().get(path.getPath().size() - 1).getNodeType();
}
- FluentIterable<InstanceIdentifier> directChildren = FluentIterable.from(getStoredConfigurationPaths())
- .filter(new Predicate<InstanceIdentifier>() {
+ FluentIterable<YangInstanceIdentifier> directChildren = FluentIterable.from(getStoredConfigurationPaths())
+ .filter(new Predicate<YangInstanceIdentifier>() {
@Override
- public boolean apply(final InstanceIdentifier input) {
+ public boolean apply(final YangInstanceIdentifier input) {
if (path.contains(input)) {
int nesting = input.getPath().size() - path.getPath().size();
if (nesting == 1) {
return false;
}
});
- for (InstanceIdentifier instanceIdentifier : directChildren) {
+ for (YangInstanceIdentifier instanceIdentifier : directChildren) {
childNodes.add(getDelegate().readConfigurationData(instanceIdentifier));
}
if (original == null && childNodes.isEmpty()) {
}
@Override
- public CompositeNode readOperationalData(final InstanceIdentifier path) {
+ public CompositeNode readOperationalData(final YangInstanceIdentifier path) {
getDelegateReadLock().lock();
try {
if (Iterables.isEmpty(path.getPathArguments())) {
qname = path.getPath().get(path.getPath().size() - 1).getNodeType();
}
- FluentIterable<InstanceIdentifier> directChildren = FluentIterable.from(getStoredOperationalPaths())
- .filter(new Predicate<InstanceIdentifier>() {
+ FluentIterable<YangInstanceIdentifier> directChildren = FluentIterable.from(getStoredOperationalPaths())
+ .filter(new Predicate<YangInstanceIdentifier>() {
@Override
- public boolean apply(final InstanceIdentifier input) {
+ public boolean apply(final YangInstanceIdentifier input) {
if (path.contains(input)) {
int nesting = input.getPath().size() - path.getPath().size();
if (nesting == 1) {
}
});
- for (InstanceIdentifier instanceIdentifier : directChildren) {
+ for (YangInstanceIdentifier instanceIdentifier : directChildren) {
childNodes.add(getDelegate().readOperationalData(instanceIdentifier));
}
if (original == null && childNodes.isEmpty()) {
}
}
- private class NormalizedDataModification extends AbstractDataModification<InstanceIdentifier, CompositeNode> {
+ private class NormalizedDataModification extends AbstractDataModification<YangInstanceIdentifier, CompositeNode> {
private final String CONFIGURATIONAL_DATA_STORE_MARKER = "configurational";
private final String OPERATIONAL_DATA_STORE_MARKER = "operational";
private final Object identifier;
private TransactionStatus status;
- public NormalizedDataModification(final DataModification<InstanceIdentifier, CompositeNode> original) {
+ public NormalizedDataModification(final DataModification<YangInstanceIdentifier, CompositeNode> original) {
super(getDelegate());
identifier = original;
status = TransactionStatus.NEW;
*
* @param entry
*/
- public void deepRemoveOperationalData(final InstanceIdentifier entry) {
- Iterable<InstanceIdentifier> paths = getOperationalSubpaths(entry);
+ public void deepRemoveOperationalData(final YangInstanceIdentifier entry) {
+ Iterable<YangInstanceIdentifier> paths = getOperationalSubpaths(entry);
removeOperationalData(entry);
- for (InstanceIdentifier potential : paths) {
+ for (YangInstanceIdentifier potential : paths) {
removeOperationalData(potential);
}
}
- public void deepRemoveConfigurationData(final InstanceIdentifier entry) {
- Iterable<InstanceIdentifier> paths = getConfigurationSubpaths(entry);
+ public void deepRemoveConfigurationData(final YangInstanceIdentifier entry) {
+ Iterable<YangInstanceIdentifier> paths = getConfigurationSubpaths(entry);
removeConfigurationData(entry);
- for (InstanceIdentifier potential : paths) {
+ for (YangInstanceIdentifier potential : paths) {
removeConfigurationData(potential);
}
}
- public void putDeepConfigurationData(final InstanceIdentifier entryKey, final CompositeNode entryData) {
+ public void putDeepConfigurationData(final YangInstanceIdentifier entryKey, final CompositeNode entryData) {
this.putCompositeNodeData(entryKey, entryData, CONFIGURATIONAL_DATA_STORE_MARKER);
}
- public void putDeepOperationalData(final InstanceIdentifier entryKey, final CompositeNode entryData) {
+ public void putDeepOperationalData(final YangInstanceIdentifier entryKey, final CompositeNode entryData) {
this.putCompositeNodeData(entryKey, entryData, OPERATIONAL_DATA_STORE_MARKER);
}
}
@Override
- protected CompositeNode mergeConfigurationData(final InstanceIdentifier path, final CompositeNode stored,
+ protected CompositeNode mergeConfigurationData(final YangInstanceIdentifier path, final CompositeNode stored,
final CompositeNode modified) {
return mergeData(path, stored, modified, true);
}
@Override
- protected CompositeNode mergeOperationalData(final InstanceIdentifier path, final CompositeNode stored,
+ protected CompositeNode mergeOperationalData(final YangInstanceIdentifier path, final CompositeNode stored,
final CompositeNode modified) {
return mergeData(path, stored, modified, false);
}
- private void putData(final InstanceIdentifier entryKey, final CompositeNode entryData, final String dataStoreIdentifier) {
+ private void putData(final YangInstanceIdentifier entryKey, final CompositeNode entryData, final String dataStoreIdentifier) {
if (dataStoreIdentifier != null && entryKey != null && entryData != null) {
switch (dataStoreIdentifier) {
case (CONFIGURATIONAL_DATA_STORE_MARKER):
}
}
- private void putCompositeNodeData(final InstanceIdentifier entryKey, final CompositeNode entryData,
+ private void putCompositeNodeData(final YangInstanceIdentifier entryKey, final CompositeNode entryData,
final String dataStoreIdentifier) {
this.putData(entryKey, entryData, dataStoreIdentifier);
for (Node<?> child : entryData.getValue()) {
- InstanceIdentifier subEntryId = InstanceIdentifier.builder(entryKey).node(child.getNodeType())
+ YangInstanceIdentifier subEntryId = YangInstanceIdentifier.builder(entryKey).node(child.getNodeType())
.toInstance();
if (child instanceof CompositeNode) {
DataSchemaNode subSchema = schemaNodeFor(subEntryId);
CompositeNode compNode = (CompositeNode) child;
- InstanceIdentifier instanceId = null;
+ YangInstanceIdentifier instanceId = null;
if (subSchema instanceof ListSchemaNode) {
ListSchemaNode listSubSchema = (ListSchemaNode) subSchema;
Map<QName, Object> mapOfSubValues = this.getValuesFromListSchema(listSubSchema,
(CompositeNode) child);
if (mapOfSubValues != null) {
- instanceId = InstanceIdentifier.builder(entryKey)
+ instanceId = YangInstanceIdentifier.builder(entryKey)
.nodeWithKey(listSubSchema.getQName(), mapOfSubValues).toInstance();
}
} else if (subSchema instanceof ContainerSchemaNode) {
ContainerSchemaNode containerSchema = (ContainerSchemaNode) subSchema;
- instanceId = InstanceIdentifier.builder(entryKey).node(subSchema.getQName()).toInstance();
+ instanceId = YangInstanceIdentifier.builder(entryKey).node(subSchema.getQName()).toInstance();
}
if (instanceId != null) {
this.putCompositeNodeData(instanceId, compNode, dataStoreIdentifier);
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.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
private final ListenerRegistry<RpcRegistrationListener> rpcRegistrationListeners = new ListenerRegistry<>();
- private final ListenerRegistry<RouteChangeListener<RpcRoutingContext, InstanceIdentifier>> routeChangeListeners = new ListenerRegistry<>();
+ private final ListenerRegistry<RouteChangeListener<RpcRoutingContext, YangInstanceIdentifier>> routeChangeListeners = new ListenerRegistry<>();
private final String identifier;
}
@Override
- public ListenableFuture<RpcResult<CompositeNode>> invokeRpc(final QName rpc, final InstanceIdentifier route, final CompositeNode input) {
+ public ListenableFuture<RpcResult<CompositeNode>> invokeRpc(final QName rpc, final YangInstanceIdentifier route, final CompositeNode input) {
checkState(defaultDelegate != null, "No implementation is available for rpc:%s path:%s", rpc, route);
return defaultDelegate.invokeRpc(rpc, route, input);
}
implementations.remove(registration.getType(), registration);
}
- void notifyPathAnnouncement(final QName context, final QName identifier, final InstanceIdentifier path) {
+ void notifyPathAnnouncement(final QName context, final QName identifier, final YangInstanceIdentifier path) {
RpcRoutingContext contextWrapped = RpcRoutingContext.create(context, identifier);
- RouteChange<RpcRoutingContext, InstanceIdentifier> change = RoutingUtils.announcementChange(contextWrapped , path);
- for(ListenerRegistration<RouteChangeListener<RpcRoutingContext, InstanceIdentifier>> routeListener : routeChangeListeners) {
+ RouteChange<RpcRoutingContext, YangInstanceIdentifier> change = RoutingUtils.announcementChange(contextWrapped , path);
+ for(ListenerRegistration<RouteChangeListener<RpcRoutingContext, YangInstanceIdentifier>> routeListener : routeChangeListeners) {
try {
routeListener.getInstance().onRouteChange(change);
} catch (Exception e) {
}
- void notifyPathWithdrawal(final QName context,final QName identifier, final InstanceIdentifier path) {
+ void notifyPathWithdrawal(final QName context,final QName identifier, final YangInstanceIdentifier path) {
RpcRoutingContext contextWrapped = RpcRoutingContext.create(context, identifier);
- RouteChange<RpcRoutingContext, InstanceIdentifier> change = RoutingUtils.removalChange(contextWrapped , path);
- for(ListenerRegistration<RouteChangeListener<RpcRoutingContext, InstanceIdentifier>> routeListener : routeChangeListeners) {
+ RouteChange<RpcRoutingContext, YangInstanceIdentifier> change = RoutingUtils.removalChange(contextWrapped , path);
+ for(ListenerRegistration<RouteChangeListener<RpcRoutingContext, YangInstanceIdentifier>> routeListener : routeChangeListeners) {
try {
routeListener.getInstance().onRouteChange(change);
} catch (Exception e) {
}
@Override
- public <L extends RouteChangeListener<RpcRoutingContext, InstanceIdentifier>> ListenerRegistration<L> registerRouteChangeListener(
+ public <L extends RouteChangeListener<RpcRoutingContext, YangInstanceIdentifier>> ListenerRegistration<L> registerRouteChangeListener(
final L listener) {
ListenerRegistration<L> reg = routeChangeListeners.registerWithType(listener);
- RouteChange<RpcRoutingContext, InstanceIdentifier> initial = createInitialRouteChange();
+ RouteChange<RpcRoutingContext, YangInstanceIdentifier> initial = createInitialRouteChange();
try {
listener.onRouteChange(initial);
} catch (Exception e) {
return reg;
}
- private RouteChange<RpcRoutingContext, InstanceIdentifier> createInitialRouteChange() {
+ private RouteChange<RpcRoutingContext, YangInstanceIdentifier> createInitialRouteChange() {
FluentIterable<RoutedRpcSelector> rpcSelectors = FluentIterable.from(implementations.values()).filter(RoutedRpcSelector.class);
- ImmutableMap.Builder<RpcRoutingContext, Set<InstanceIdentifier>> announcements = ImmutableMap.builder();
- ImmutableMap.Builder<RpcRoutingContext, Set<InstanceIdentifier>> removals = ImmutableMap.builder();
+ ImmutableMap.Builder<RpcRoutingContext, Set<YangInstanceIdentifier>> announcements = ImmutableMap.builder();
+ ImmutableMap.Builder<RpcRoutingContext, Set<YangInstanceIdentifier>> removals = ImmutableMap.builder();
for (RoutedRpcSelector routedRpcSelector : rpcSelectors) {
final RpcRoutingContext context = routedRpcSelector.getIdentifier();
- final Set<InstanceIdentifier> paths = ImmutableSet.copyOf(routedRpcSelector.implementations.keySet());
+ final Set<YangInstanceIdentifier> paths = ImmutableSet.copyOf(routedRpcSelector.implementations.keySet());
announcements.put(context, paths);
}
return RoutingUtils.change(announcements.build(), removals.build());
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMTransactionChain;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.osgi.framework.ServiceReference;
public class DOMDataBrokerProxy extends AbstractBrokerServiceProxy<DOMDataBroker> implements DOMDataBroker {
@Override
public ListenerRegistration<DOMDataChangeListener> registerDataChangeListener(final LogicalDatastoreType store,
- final InstanceIdentifier path, final DOMDataChangeListener listener,
+ final YangInstanceIdentifier path, final DOMDataChangeListener listener,
final org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope triggeringScope) {
return getDelegate().registerDataChangeListener(store, path, listener, triggeringScope);
}
import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService;
import org.opendaylight.controller.sal.core.api.mount.MountProvisionListener;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.osgi.framework.ServiceReference;
public class DOMMountPointServiceProxy extends AbstractBrokerServiceProxy<DOMMountPointService> implements DOMMountPointService{
}
@Override
- public Optional<DOMMountPoint> getMountPoint(final InstanceIdentifier path) {
+ public Optional<DOMMountPoint> getMountPoint(final YangInstanceIdentifier path) {
return getDelegate().getMountPoint(path);
}
@Override
- public DOMMountPointBuilder createMountPoint(final InstanceIdentifier path) {
+ public DOMMountPointBuilder createMountPoint(final YangInstanceIdentifier path) {
return getDelegate().createMountPoint(path);
}
import org.opendaylight.controller.sal.core.api.data.DataModificationTransaction;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.osgi.framework.ServiceReference;
public class DataBrokerServiceProxy extends AbstractBrokerServiceProxy<DataBrokerService> implements DataBrokerService {
super(ref, delegate);
}
- public ListenerRegistration<DataChangeListener> registerDataChangeListener(InstanceIdentifier path,
+ public ListenerRegistration<DataChangeListener> registerDataChangeListener(YangInstanceIdentifier path,
DataChangeListener listener) {
return addRegistration(getDelegate().registerDataChangeListener(path, listener));
}
- public CompositeNode readConfigurationData(InstanceIdentifier path) {
+ public CompositeNode readConfigurationData(YangInstanceIdentifier path) {
return getDelegate().readConfigurationData(path);
}
- public CompositeNode readOperationalData(InstanceIdentifier path) {
+ public CompositeNode readOperationalData(YangInstanceIdentifier path) {
return getDelegate().readOperationalData(path);
}
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.concepts.Registration;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.osgi.framework.ServiceReference;
public class DataProviderServiceProxy extends AbstractBrokerServiceProxy<DataProviderService> implements
super(ref, delegate);
}
- public ListenerRegistration<DataChangeListener> registerDataChangeListener(InstanceIdentifier path,
+ public ListenerRegistration<DataChangeListener> registerDataChangeListener(YangInstanceIdentifier path,
DataChangeListener listener) {
return addRegistration(getDelegate().registerDataChangeListener(path, listener));
}
- public CompositeNode readConfigurationData(InstanceIdentifier path) {
+ public CompositeNode readConfigurationData(YangInstanceIdentifier path) {
return getDelegate().readConfigurationData(path);
}
- public CompositeNode readOperationalData(InstanceIdentifier path) {
+ public CompositeNode readOperationalData(YangInstanceIdentifier path) {
return getDelegate().readOperationalData(path);
}
@Override
public Registration registerCommitHandler(
- InstanceIdentifier path, DataCommitHandler<InstanceIdentifier, CompositeNode> commitHandler) {
+ YangInstanceIdentifier path, DataCommitHandler<YangInstanceIdentifier, CompositeNode> commitHandler) {
return addRegistration(getDelegate().registerCommitHandler(path, commitHandler));
}
@Override
public Registration registerConfigurationReader(
- InstanceIdentifier path, DataReader<InstanceIdentifier, CompositeNode> reader) {
+ YangInstanceIdentifier path, DataReader<YangInstanceIdentifier, CompositeNode> reader) {
return addRegistration(getDelegate().registerConfigurationReader(path, reader));
}
@Override
public Registration registerOperationalReader(
- InstanceIdentifier path, DataReader<InstanceIdentifier, CompositeNode> reader) {
+ YangInstanceIdentifier path, DataReader<YangInstanceIdentifier, CompositeNode> reader) {
return addRegistration(getDelegate().registerOperationalReader(path, reader));
}
}
@Override
- public ListenerRegistration<RegistrationListener<DataCommitHandlerRegistration<InstanceIdentifier, CompositeNode>>> registerCommitHandlerListener(
- RegistrationListener<DataCommitHandlerRegistration<InstanceIdentifier, CompositeNode>> commitHandlerListener) {
+ public ListenerRegistration<RegistrationListener<DataCommitHandlerRegistration<YangInstanceIdentifier, CompositeNode>>> registerCommitHandlerListener(
+ RegistrationListener<DataCommitHandlerRegistration<YangInstanceIdentifier, CompositeNode>> commitHandlerListener) {
return addRegistration(getDelegate().registerCommitHandlerListener(commitHandlerListener));
}
}
import org.opendaylight.controller.sal.core.api.mount.MountProvisionListener;
import org.opendaylight.controller.sal.core.api.mount.MountProvisionService;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.osgi.framework.ServiceReference;
public class MountProviderServiceProxy extends AbstractBrokerServiceProxy<MountProvisionService> implements MountProvisionService{
}
@Override
- public MountProvisionInstance getMountPoint(InstanceIdentifier path) {
+ public MountProvisionInstance getMountPoint(YangInstanceIdentifier path) {
return getDelegate().getMountPoint(path);
}
@Override
- public MountProvisionInstance createMountPoint(InstanceIdentifier path) {
+ public MountProvisionInstance createMountPoint(YangInstanceIdentifier path) {
return getDelegate().createMountPoint(path);
}
@Override
- public MountProvisionInstance createOrGetMountPoint(InstanceIdentifier path) {
+ public MountProvisionInstance createOrGetMountPoint(YangInstanceIdentifier path) {
return getDelegate().createOrGetMountPoint(path);
}
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.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.osgi.framework.ServiceReference;
import com.google.common.util.concurrent.ListenableFuture;
}
@Override
- public <L extends RouteChangeListener<RpcRoutingContext, InstanceIdentifier>> ListenerRegistration<L> registerRouteChangeListener(final L listener) {
+ public <L extends RouteChangeListener<RpcRoutingContext, YangInstanceIdentifier>> ListenerRegistration<L> registerRouteChangeListener(final L listener) {
return getDelegate().registerRouteChangeListener(listener);
}
import org.opendaylight.controller.sal.core.api.Broker.RoutedRpcRegistration;
import org.opendaylight.controller.sal.core.api.RpcImplementation;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
public interface RoutedRpcProcessor extends RpcImplementation {
QName getRpcType();
- Map<InstanceIdentifier,RpcImplementation> getRoutes();
+ Map<YangInstanceIdentifier,RpcImplementation> getRoutes();
RpcImplementation getDefaultRoute();
import java.util.Set;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
throw new UnsupportedOperationException("Utility class.");
}
- public static DataSchemaNode getSchemaNode(final SchemaContext schema,final InstanceIdentifier path) {
+ public static DataSchemaNode getSchemaNode(final SchemaContext schema,final YangInstanceIdentifier path) {
checkArgument(schema != null,"YANG Schema must not be null.");
checkArgument(path != null,"Path must not be null.");
return getSchemaNode(schema, FluentIterable.from(path.getPathArguments()).transform(QNAME_FROM_PATH_ARGUMENT));
import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStore;
import org.opendaylight.controller.md.sal.dom.store.impl.TestModel;
import org.opendaylight.controller.sal.core.spi.data.DOMStore;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
return ImmutableNodes.mapEntry(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, i);
}
- private static InstanceIdentifier outerListPath(final int i) {
- return InstanceIdentifier.builder(TestModel.OUTER_LIST_PATH)//
+ private static YangInstanceIdentifier outerListPath(final int i) {
+ return YangInstanceIdentifier.builder(TestModel.OUTER_LIST_PATH)//
.nodeWithKey(TestModel.OUTER_LIST_QNAME, TestModel.ID_QNAME, i) //
.build();
}
int i = 0;
for (DOMDataReadWriteTransaction writeTx :transactions) {
// Writes /test/outer-list/i in writeTx
- InstanceIdentifier path = InstanceIdentifier.builder(outerListPath(i))
+ YangInstanceIdentifier path = YangInstanceIdentifier.builder(outerListPath(i))
.node(TestModel.INNER_LIST_QNAME).build();
writeTx.put(OPERATIONAL, path, ImmutableNodes.mapNodeBuilder(TestModel.INNER_LIST_QNAME).build());
for (int j = 0; j < innerNum; j++) {
- InstanceIdentifier innerPath = InstanceIdentifier.builder(path)
+ YangInstanceIdentifier innerPath = YangInstanceIdentifier.builder(path)
.nodeWithKey(TestModel.INNER_LIST_QNAME, TestModel.NAME_QNAME, String.valueOf(j))
.build();
writeTx.put(
public Void call() throws Exception {
for (int i = 0; i < txNum; i++) {
for (int j = 0; j < innerNum; j++) {
- InstanceIdentifier path = InstanceIdentifier
+ YangInstanceIdentifier path = YangInstanceIdentifier
.builder(outerListPath(i))
//
.node(TestModel.INNER_LIST_QNAME)
import org.opendaylight.controller.md.sal.dom.api.DOMMountPointService.DOMMountPointBuilder;
import org.opendaylight.controller.md.sal.dom.broker.impl.mount.DOMMountPointServiceImpl;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
public class MountPointServiceTest {
private DOMMountPointService mountService;
- private static final InstanceIdentifier PATH = InstanceIdentifier.of(QName.create("namespace", "12-12-2012", "top"));
+ private static final YangInstanceIdentifier PATH = YangInstanceIdentifier.of(QName.create("namespace", "12-12-2012", "top"));
@Before
public void setup() {
package org.opendaylight.controller.md.sal.dom.store.impl;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
public static final QName VALUE_QNAME = QName.create(TEST_QNAME, "value");
private static final String DATASTORE_TEST_YANG = "/odl-datastore-test.yang";
- public static final InstanceIdentifier TEST_PATH = InstanceIdentifier.of(TEST_QNAME);
- public static final InstanceIdentifier OUTER_LIST_PATH = InstanceIdentifier.builder(TEST_PATH).node(OUTER_LIST_QNAME).build();
+ public static final YangInstanceIdentifier TEST_PATH = YangInstanceIdentifier.of(TEST_QNAME);
+ public static final YangInstanceIdentifier OUTER_LIST_PATH = YangInstanceIdentifier.builder(TEST_PATH).node(OUTER_LIST_QNAME).build();
public static final QName TWO_QNAME = QName.create(TEST_QNAME,"two");
public static final QName THREE_QNAME = QName.create(TEST_QNAME,"three");
import org.opendaylight.controller.sal.core.api.mount.MountProvisionListener;
import org.opendaylight.yangtools.concepts.ObjectRegistration;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.slf4j.Logger;
private BackwardsCompatibleMountPointManager compatibleMountPointManager;
static final QName qName = QName.create("namespace", "12-12-1212", "mount");
- static final InstanceIdentifier id = InstanceIdentifier.builder(qName).build();
+ static final YangInstanceIdentifier id = YangInstanceIdentifier.builder(qName).build();
@Before
public void setUp() throws Exception {
public int createdMounts = 0;
@Override
- public void onMountPointCreated(final InstanceIdentifier path) {
+ public void onMountPointCreated(final YangInstanceIdentifier path) {
if(createdMounts++ > 1 ) {
fail("Only one mount point should have been created");
}
}
@Override
- public void onMountPointRemoved(final InstanceIdentifier path) {}
+ public void onMountPointRemoved(final YangInstanceIdentifier path) {}
};
compatibleMountPointManager.registerProvisionListener(listener);
}
private void stubMountService() {
- doReturn(mockMountPointBuilder()).when(domMountPointService).createMountPoint(any(InstanceIdentifier.class));
- doReturn(Optional.of(mockMountPoint())).when(domMountPointService).getMountPoint(any(InstanceIdentifier.class));
+ doReturn(mockMountPointBuilder()).when(domMountPointService).createMountPoint(any(YangInstanceIdentifier.class));
+ doReturn(Optional.of(mockMountPoint())).when(domMountPointService).getMountPoint(any(YangInstanceIdentifier.class));
}
private DOMMountPoint mockMountPoint() {
import org.opendaylight.controller.sal.dom.broker.impl.SchemaContextProvider;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class BackwardsCompatibleMountPointTest {
private static final Logger log = LoggerFactory.getLogger(BackwardsCompatibleMountPointManagerTest.class);
- private static final InstanceIdentifier id = BackwardsCompatibleMountPointManagerTest.id;
+ private static final YangInstanceIdentifier id = BackwardsCompatibleMountPointManagerTest.id;
private final NormalizedNode<?, ?> normalizedNode = mockNormalizedNode();
private final CompositeNode compositeNode = mockCompositeNode();
private DataNormalizer mockNormalizer() throws DataNormalizationException {
final DataNormalizer mock = mock(DataNormalizer.class);
- doReturn(new AbstractMap.SimpleEntry<InstanceIdentifier, NormalizedNode<?, ?>>(id, normalizedNode) {})
- .when(mock).toNormalized(any(InstanceIdentifier.class), any(CompositeNode.class));
- doReturn(compositeNode).when(mock).toLegacy(any(InstanceIdentifier.class), any(NormalizedNode.class));
- doReturn(id).when(mock).toLegacy(any(InstanceIdentifier.class));
+ doReturn(new AbstractMap.SimpleEntry<YangInstanceIdentifier, NormalizedNode<?, ?>>(id, normalizedNode) {})
+ .when(mock).toNormalized(any(YangInstanceIdentifier.class), any(CompositeNode.class));
+ doReturn(compositeNode).when(mock).toLegacy(any(YangInstanceIdentifier.class), any(NormalizedNode.class));
+ doReturn(id).when(mock).toLegacy(any(YangInstanceIdentifier.class));
return mock;
}
doReturn("mockNormalizedNode").when(mock).toString();
return mock;
}
-}
\ No newline at end of file
+}
import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
import org.opendaylight.controller.md.sal.dom.api.DOMService;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import com.google.common.base.Optional;
public class SimpleDOMMountPoint implements DOMMountPoint {
- private final InstanceIdentifier identifier;
+ private final YangInstanceIdentifier identifier;
private final ClassToInstanceMap<DOMService> services;
private final SchemaContext schemaContext;
- public static final SimpleDOMMountPoint create(final InstanceIdentifier identifier, final ClassToInstanceMap<DOMService> services, final SchemaContext ctx) {
+ public static final SimpleDOMMountPoint create(final YangInstanceIdentifier identifier, final ClassToInstanceMap<DOMService> services, final SchemaContext ctx) {
return new SimpleDOMMountPoint(identifier, services, ctx);
}
- private SimpleDOMMountPoint(final InstanceIdentifier identifier, final ClassToInstanceMap<DOMService> services, final SchemaContext ctx) {
+ private SimpleDOMMountPoint(final YangInstanceIdentifier identifier, final ClassToInstanceMap<DOMService> services, final SchemaContext ctx) {
this.identifier = identifier;
this.services = ImmutableClassToInstanceMap.copyOf(services);
this.schemaContext = ctx;
}
@Override
- public InstanceIdentifier getIdentifier() {
+ public YangInstanceIdentifier getIdentifier() {
return identifier;
}
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeListener;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
/**
* registration / interest on receiving data changes.
*
*/
- <L extends AsyncDataChangeListener<InstanceIdentifier, NormalizedNode<?, ?>>> ListenerRegistration<L> registerChangeListener(
- InstanceIdentifier path, L listener, DataChangeScope scope);
+ <L extends AsyncDataChangeListener<YangInstanceIdentifier, NormalizedNode<?, ?>>> ListenerRegistration<L> registerChangeListener(
+ YangInstanceIdentifier path, L listener, DataChangeScope scope);
/**
*
*/
package org.opendaylight.controller.sal.core.spi.data;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import com.google.common.base.Optional;
* {@link java.util.concurrent.Future#get()} returns {@link Optional#absent()}.
* </ul>
*/
- ListenableFuture<Optional<NormalizedNode<?,?>>> read(InstanceIdentifier path);
+ ListenableFuture<Optional<NormalizedNode<?,?>>> read(YangInstanceIdentifier path);
}
*/
package org.opendaylight.controller.sal.core.spi.data;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
public interface DOMStoreWriteTransaction extends DOMStoreTransaction {
* if the client code already sealed transaction and invoked
* {@link #ready()}
*/
- void write(InstanceIdentifier path, NormalizedNode<?, ?> data);
+ void write(YangInstanceIdentifier path, NormalizedNode<?, ?> data);
/**
* Store a provided data at specified path. This acts as a add / replace
* if the client code already sealed transaction and invoked
* {@link #ready()}
*/
- void merge(InstanceIdentifier path, NormalizedNode<?, ?> data);
+ void merge(YangInstanceIdentifier path, NormalizedNode<?, ?> data);
/**
*
* if the client code already sealed transaction and invoked
* {@link #ready()}
*/
- void delete(InstanceIdentifier path);
+ void delete(YangInstanceIdentifier path);
/**
*
package org.opendaylight.controller.md.sal.dom.store.impl;
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.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger LOG = LoggerFactory.getLogger(ChangeListenerNotifyTask.class);
private final Iterable<? extends DataChangeListenerRegistration<?>> listeners;
- private final AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> event;
+ private final AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> event;
public ChangeListenerNotifyTask(final Iterable<? extends DataChangeListenerRegistration<?>> listeners,
- final AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> event) {
+ final AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> event) {
this.listeners = listeners;
this.event = event;
}
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.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import com.google.common.base.Preconditions;
public final class DOMImmutableDataChangeEvent implements
- AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> {
+ AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> {
private static final RemoveEventFactory REMOVE_EVENT_FACTORY = new RemoveEventFactory();
private final NormalizedNode<?, ?> original;
private final NormalizedNode<?, ?> updated;
- private final Map<InstanceIdentifier, NormalizedNode<?, ?>> originalData;
- private final Map<InstanceIdentifier, NormalizedNode<?, ?>> createdData;
- private final Map<InstanceIdentifier, NormalizedNode<?, ?>> updatedData;
- private final Set<InstanceIdentifier> removedPaths;
+ private final Map<YangInstanceIdentifier, NormalizedNode<?, ?>> originalData;
+ private final Map<YangInstanceIdentifier, NormalizedNode<?, ?>> createdData;
+ private final Map<YangInstanceIdentifier, NormalizedNode<?, ?>> updatedData;
+ private final Set<YangInstanceIdentifier> removedPaths;
private final DataChangeScope scope;
}
@Override
- public Map<InstanceIdentifier, NormalizedNode<?, ?>> getOriginalData() {
+ public Map<YangInstanceIdentifier, NormalizedNode<?, ?>> getOriginalData() {
return originalData;
}
@Override
- public Map<InstanceIdentifier, NormalizedNode<?, ?>> getCreatedData() {
+ public Map<YangInstanceIdentifier, NormalizedNode<?, ?>> getCreatedData() {
return createdData;
}
@Override
- public Map<InstanceIdentifier, NormalizedNode<?, ?>> getUpdatedData() {
+ public Map<YangInstanceIdentifier, NormalizedNode<?, ?>> getUpdatedData() {
return updatedData;
}
@Override
- public Set<InstanceIdentifier> getRemovedPaths() {
+ public Set<YangInstanceIdentifier> getRemovedPaths() {
return removedPaths;
}
*
*/
public interface SimpleEventFactory {
- DOMImmutableDataChangeEvent create(InstanceIdentifier path, NormalizedNode<PathArgument,?> data);
+ DOMImmutableDataChangeEvent create(YangInstanceIdentifier path, NormalizedNode<PathArgument,?> data);
}
/**
private NormalizedNode<?, ?> after;
private NormalizedNode<?, ?> before;
- private final Map<InstanceIdentifier, NormalizedNode<?, ?>> original = new HashMap<>();
- private final Map<InstanceIdentifier, NormalizedNode<?, ?>> created = new HashMap<>();
- private final Map<InstanceIdentifier, NormalizedNode<?, ?>> updated = new HashMap<>();
- private final Set<InstanceIdentifier> removed = new HashSet<>();
+ private final Map<YangInstanceIdentifier, NormalizedNode<?, ?>> original = new HashMap<>();
+ private final Map<YangInstanceIdentifier, NormalizedNode<?, ?>> created = new HashMap<>();
+ private final Map<YangInstanceIdentifier, NormalizedNode<?, ?>> updated = new HashMap<>();
+ private final Set<YangInstanceIdentifier> removed = new HashSet<>();
private Builder(final DataChangeScope scope) {
Preconditions.checkNotNull(scope, "Data change scope should not be null.");
return this;
}
- public Builder addCreated(final InstanceIdentifier path, final NormalizedNode<?, ?> node) {
+ public Builder addCreated(final YangInstanceIdentifier path, final NormalizedNode<?, ?> node) {
created.put(path, node);
return this;
}
- public Builder addRemoved(final InstanceIdentifier path, final NormalizedNode<?, ?> node) {
+ public Builder addRemoved(final YangInstanceIdentifier path, final NormalizedNode<?, ?> node) {
original.put(path, node);
removed.add(path);
return this;
}
- public Builder addUpdated(final InstanceIdentifier path, final NormalizedNode<?, ?> before,
+ public Builder addUpdated(final YangInstanceIdentifier path, final NormalizedNode<?, ?> before,
final NormalizedNode<?, ?> after) {
original.put(path, before);
updated.put(path, after);
private static final class RemoveEventFactory implements SimpleEventFactory {
@Override
- public DOMImmutableDataChangeEvent create(final InstanceIdentifier path, final NormalizedNode<PathArgument, ?> data) {
+ public DOMImmutableDataChangeEvent create(final YangInstanceIdentifier path, final NormalizedNode<PathArgument, ?> data) {
return builder(DataChangeScope.BASE) //
.setBefore(data) //
.addRemoved(path, data) //
private static final class CreateEventFactory implements SimpleEventFactory {
@Override
- public DOMImmutableDataChangeEvent create(final InstanceIdentifier path, final NormalizedNode<PathArgument, ?> data) {
+ public DOMImmutableDataChangeEvent create(final YangInstanceIdentifier path, final NormalizedNode<PathArgument, ?> data) {
return builder(DataChangeScope.BASE) //
.setAfter(data) //
.addCreated(path, data) //
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeListener;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-public interface DataChangeListenerRegistration<L extends AsyncDataChangeListener<InstanceIdentifier, NormalizedNode<?, ?>>> extends ListenerRegistration<L> {
+public interface DataChangeListenerRegistration<L extends AsyncDataChangeListener<YangInstanceIdentifier, NormalizedNode<?, ?>>> extends ListenerRegistration<L> {
@Override
L getInstance();
- InstanceIdentifier getPath();
+ YangInstanceIdentifier getPath();
DataChangeScope getScope();
}
import org.opendaylight.yangtools.concepts.AbstractListenerRegistration;
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
executor.shutdownNow();
}
@Override
- public <L extends AsyncDataChangeListener<InstanceIdentifier, NormalizedNode<?, ?>>> ListenerRegistration<L> registerChangeListener(
- final InstanceIdentifier path, final L listener, final DataChangeScope scope) {
+ public <L extends AsyncDataChangeListener<YangInstanceIdentifier, NormalizedNode<?, ?>>> ListenerRegistration<L> registerChangeListener(
+ final YangInstanceIdentifier path, final L listener, final DataChangeScope scope) {
/*
* Make sure commit is not occurring right now. Listener has to be
import org.opendaylight.controller.md.sal.dom.store.impl.tree.ListenerTree;
import org.opendaylight.controller.md.sal.dom.store.impl.tree.ListenerTree.Node;
import org.opendaylight.controller.md.sal.dom.store.impl.tree.ListenerTree.Walker;
-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.InstanceIdentifier.NodeWithValue;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodeContainer;
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeCandidate;
* - After state of current node
* @return Data Change Event of this node and all it's children
*/
- private DOMImmutableDataChangeEvent resolveAnyChangeEvent(final InstanceIdentifier path,
+ private DOMImmutableDataChangeEvent resolveAnyChangeEvent(final YangInstanceIdentifier path,
final Collection<ListenerTree.Node> listeners, final DataTreeCandidateNode node) {
if (node.getModificationType() != ModificationType.UNMODIFIED &&
throw new IllegalStateException(String.format("Unhandled node state %s at %s", node.getModificationType(), path));
}
- private DOMImmutableDataChangeEvent resolveReplacedEvent(final InstanceIdentifier path,
+ private DOMImmutableDataChangeEvent resolveReplacedEvent(final YangInstanceIdentifier path,
final Collection<Node> listeners, final NormalizedNode<?, ?> beforeData,
final NormalizedNode<?, ?> afterData) {
}
}
- private DOMImmutableDataChangeEvent resolveNodeContainerReplaced(final InstanceIdentifier path,
+ private DOMImmutableDataChangeEvent resolveNodeContainerReplaced(final YangInstanceIdentifier path,
final Collection<Node> listeners,
final NormalizedNodeContainer<?, PathArgument, NormalizedNode<PathArgument, ?>> beforeCont,
final NormalizedNodeContainer<?, PathArgument, NormalizedNode<PathArgument, ?>> afterCont) {
for (NormalizedNode<PathArgument, ?> beforeChild : beforeCont.getValue()) {
PathArgument childId = beforeChild.getIdentifier();
alreadyProcessed.add(childId);
- InstanceIdentifier childPath = path.node(childId);
+ YangInstanceIdentifier childPath = path.node(childId);
Collection<ListenerTree.Node> childListeners = getListenerChildrenWildcarded(listeners, childId);
Optional<NormalizedNode<PathArgument, ?>> afterChild = afterCont.getChild(childId);
DOMImmutableDataChangeEvent childChange = resolveNodeContainerChildUpdated(childPath, childListeners,
// and it was not present in previous loop, that means it is
// created.
Collection<ListenerTree.Node> childListeners = getListenerChildrenWildcarded(listeners, childId);
- InstanceIdentifier childPath = path.node(childId);
+ YangInstanceIdentifier childPath = path.node(childId);
childChanges.add(resolveSameEventRecursivelly(childPath , childListeners, afterChild,
DOMImmutableDataChangeEvent.getCreateEventFactory()));
}
return replaceEvent;
}
- private DOMImmutableDataChangeEvent resolveNodeContainerChildUpdated(final InstanceIdentifier path,
+ private DOMImmutableDataChangeEvent resolveNodeContainerChildUpdated(final YangInstanceIdentifier path,
final Collection<Node> listeners, final NormalizedNode<PathArgument, ?> before,
final Optional<NormalizedNode<PathArgument, ?>> after) {
* @param afterState
* @return
*/
- private DOMImmutableDataChangeEvent resolveCreateEvent(final InstanceIdentifier path,
+ private DOMImmutableDataChangeEvent resolveCreateEvent(final YangInstanceIdentifier path,
final Collection<ListenerTree.Node> listeners, final NormalizedNode<?, ?> afterState) {
@SuppressWarnings({ "unchecked", "rawtypes" })
final NormalizedNode<PathArgument, ?> node = (NormalizedNode) afterState;
return resolveSameEventRecursivelly(path, listeners, node, DOMImmutableDataChangeEvent.getCreateEventFactory());
}
- private DOMImmutableDataChangeEvent resolveDeleteEvent(final InstanceIdentifier path,
+ private DOMImmutableDataChangeEvent resolveDeleteEvent(final YangInstanceIdentifier path,
final Collection<ListenerTree.Node> listeners, final NormalizedNode<?, ?> beforeState) {
@SuppressWarnings({ "unchecked", "rawtypes" })
return resolveSameEventRecursivelly(path, listeners, node, DOMImmutableDataChangeEvent.getRemoveEventFactory());
}
- private DOMImmutableDataChangeEvent resolveSameEventRecursivelly(final InstanceIdentifier path,
+ private DOMImmutableDataChangeEvent resolveSameEventRecursivelly(final YangInstanceIdentifier path,
final Collection<Node> listeners, final NormalizedNode<PathArgument, ?> node,
final SimpleEventFactory eventFactory) {
final DOMImmutableDataChangeEvent event = eventFactory.create(path, node);
return propagateEvent;
}
- private DOMImmutableDataChangeEvent resolveSubtreeChangeEvent(final InstanceIdentifier path,
+ private DOMImmutableDataChangeEvent resolveSubtreeChangeEvent(final YangInstanceIdentifier path,
final Collection<ListenerTree.Node> listeners, final DataTreeCandidateNode modification) {
Preconditions.checkArgument(modification.getDataBefore().isPresent(), "Subtree change with before-data not present at path %s", path);
boolean oneModified = false;
for (DataTreeCandidateNode childMod : modification.getChildNodes()) {
PathArgument childId = childMod.getIdentifier();
- InstanceIdentifier childPath = path.node(childId);
+ YangInstanceIdentifier childPath = path.node(childId);
Collection<ListenerTree.Node> childListeners = getListenerChildrenWildcarded(listeners, childId);
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot;
import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadTransaction;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
@Override
- public ListenableFuture<Optional<NormalizedNode<?, ?>>> read(final InstanceIdentifier path) {
+ public ListenableFuture<Optional<NormalizedNode<?, ?>>> read(final YangInstanceIdentifier path) {
checkNotNull(path, "Path must not be null.");
checkState(stableSnapshot != null, "Transaction is closed");
return Futures.immediateFuture(stableSnapshot.readNode(path));
import org.opendaylight.yangtools.yang.data.api.schema.tree.DataTreeSnapshot;
import org.opendaylight.controller.sal.core.spi.data.DOMStoreReadWriteTransaction;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
@Override
- public ListenableFuture<Optional<NormalizedNode<?, ?>>> read(final InstanceIdentifier path) {
+ public ListenableFuture<Optional<NormalizedNode<?, ?>>> read(final YangInstanceIdentifier path) {
LOG.debug("Tx: {} Read: {}", getIdentifier(), path);
try {
return Futures.immediateFuture(getMutatedView().readNode(path));
import org.opendaylight.controller.sal.core.spi.data.DOMStoreThreePhaseCommitCohort;
import org.opendaylight.controller.sal.core.spi.data.DOMStoreWriteTransaction;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
@Override
- public void write(final InstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public void write(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
checkNotReady();
try {
LOG.debug("Tx: {} Write: {}:{}", getIdentifier(), path, data);
}
@Override
- public void merge(final InstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public void merge(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
checkNotReady();
try {
LOG.debug("Tx: {} Merge: {}:{}", getIdentifier(), path, data);
}
@Override
- public void delete(final InstanceIdentifier path) {
+ public void delete(final YangInstanceIdentifier path) {
checkNotReady();
try {
LOG.debug("Tx: {} Delete: {}", getIdentifier(), path);
import org.opendaylight.controller.md.sal.dom.store.impl.DataChangeListenerRegistration;
import org.opendaylight.yangtools.concepts.AbstractListenerRegistration;
import org.opendaylight.yangtools.concepts.Identifiable;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.StoreTreeNode;
import org.slf4j.Logger;
* @param scope Scope of triggering event.
* @return Listener registration
*/
- public <L extends AsyncDataChangeListener<InstanceIdentifier, NormalizedNode<?, ?>>> DataChangeListenerRegistration<L> registerDataChangeListener(final InstanceIdentifier path,
+ public <L extends AsyncDataChangeListener<YangInstanceIdentifier, NormalizedNode<?, ?>>> DataChangeListenerRegistration<L> registerDataChangeListener(final YangInstanceIdentifier path,
final L listener, final DataChangeScope scope) {
// Take the write lock
}
@Override
- public InstanceIdentifier getPath() {
+ public YangInstanceIdentifier getPath() {
return path;
}
}
- private abstract static class DataChangeListenerRegistrationImpl<T extends AsyncDataChangeListener<InstanceIdentifier, NormalizedNode<?, ?>>> extends AbstractListenerRegistration<T> //
+ private abstract static class DataChangeListenerRegistrationImpl<T extends AsyncDataChangeListener<YangInstanceIdentifier, NormalizedNode<?, ?>>> extends AbstractListenerRegistration<T> //
implements DataChangeListenerRegistration<T> {
public DataChangeListenerRegistrationImpl(final T listener) {
super(listener);
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.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.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;
public abstract class AbstractDataChangeListenerTest {
- protected static final InstanceIdentifier TOP_LEVEL = InstanceIdentifier
+ protected static final YangInstanceIdentifier TOP_LEVEL = YangInstanceIdentifier
.of(Top.QNAME);
private static final QName NAME_QNAME = QName.create(Top.QNAME, "name");
protected static final String FOO = "foo";
}
- public static final InstanceIdentifier path(final String topName,
+ public static final YangInstanceIdentifier 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) {
+ public static final YangInstanceIdentifier path(final String topName) {
return TOP_LEVEL.node(TopLevelList.QNAME).node(
new NodeIdentifierWithPredicates(TopLevelList.QNAME,
NAME_QNAME, topName));
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.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import com.google.common.base.Preconditions;
public class DatastoreTestTask {
private final DOMStore store;
- private AsyncDataChangeListener<InstanceIdentifier, NormalizedNode<?, ?>> changeListener;
+ private AsyncDataChangeListener<YangInstanceIdentifier, NormalizedNode<?, ?>> changeListener;
private WriteTransactionCustomizer setup;
private WriteTransactionCustomizer write;
private ReadTransactionVerifier read;
private WriteTransactionCustomizer cleanup;
- private InstanceIdentifier changePath;
+ private YangInstanceIdentifier changePath;
private DataChangeScope changeScope;
private boolean postSetup = false;
private final ChangeEventListener internalListener;
internalListener = new ChangeEventListener();
}
- public DatastoreTestTask changeListener(final InstanceIdentifier path, final DataChangeScope scope,
- final AsyncDataChangeListener<InstanceIdentifier, NormalizedNode<?, ?>> changeListener) {
+ public DatastoreTestTask changeListener(final YangInstanceIdentifier path, final DataChangeScope scope,
+ final AsyncDataChangeListener<YangInstanceIdentifier, NormalizedNode<?, ?>> changeListener) {
this.changeListener = changeListener;
this.changePath = path;
this.changeScope = scope;
return this;
}
- public DatastoreTestTask changeListener(final InstanceIdentifier path, final DataChangeScope scope) {
+ public DatastoreTestTask changeListener(final YangInstanceIdentifier path, final DataChangeScope scope) {
this.changePath = path;
this.changeScope = scope;
return this;
}
}
- public Future<AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>>> getChangeEvent() {
+ public Future<AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>>> getChangeEvent() {
return internalListener.receivedChange;
}
}
private final class ChangeEventListener implements
- AsyncDataChangeListener<InstanceIdentifier, NormalizedNode<?, ?>> {
+ AsyncDataChangeListener<YangInstanceIdentifier, NormalizedNode<?, ?>> {
- protected final SettableFuture<AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>>> receivedChange = SettableFuture
+ protected final SettableFuture<AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>>> receivedChange = SettableFuture
.create();
@Override
- public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change) {
+ public void onDataChanged(final AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change) {
if (postSetup) {
receivedChange.set(change);
}
}
}
- public static final WriteTransactionCustomizer simpleWrite(final InstanceIdentifier path,
+ public static final WriteTransactionCustomizer simpleWrite(final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data) {
return new WriteTransactionCustomizer() {
};
}
- public static final WriteTransactionCustomizer simpleMerge(final InstanceIdentifier path,
+ public static final WriteTransactionCustomizer simpleMerge(final YangInstanceIdentifier path,
final NormalizedNode<?, ?> data) {
return new WriteTransactionCustomizer() {
};
}
- public static final WriteTransactionCustomizer simpleDelete(final InstanceIdentifier path) {
+ public static final WriteTransactionCustomizer simpleDelete(final YangInstanceIdentifier path) {
return new WriteTransactionCustomizer() {
@Override
public void customize(final DOMStoreReadWriteTransaction tx) {
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.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
public class RootScopeSubtreeTest extends DefaultDataChangeListenerTestSuite {
@Override
public void putTopLevelOneNested(final DatastoreTestTask task) throws InterruptedException, ExecutionException {
- AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
assertContains(change.getCreatedData(), TOP_LEVEL, path(FOO), path(FOO, BAR));
assertEmpty(change.getUpdatedData());
public void replaceTopLevelNestedChanged(final DatastoreTestTask task) throws InterruptedException,
ExecutionException {
- AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
assertContains(change.getCreatedData(), path(FOO, BAZ));
assertContains(change.getUpdatedData(), TOP_LEVEL, path(FOO));
protected void putTopLevelWithTwoNested(final DatastoreTestTask task) throws InterruptedException,
ExecutionException {
- AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
assertContains(change.getCreatedData(), TOP_LEVEL, path(FOO), path(FOO, BAR), path(FOO, BAZ));
assertEmpty(change.getUpdatedData());
protected void twoNestedExistsOneIsDeleted(final DatastoreTestTask task) throws InterruptedException,
ExecutionException {
- AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
assertEmpty(change.getCreatedData());
assertContains(change.getUpdatedData(), TOP_LEVEL, path(FOO));
protected void nestedListExistsRootDeleted(final DatastoreTestTask task) throws InterruptedException,
ExecutionException {
- AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
assertEmpty(change.getCreatedData());
assertEmpty(change.getUpdatedData());
@Override
protected void existingOneNestedWriteAdditionalNested(final DatastoreTestTask task) throws InterruptedException, ExecutionException {
- AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
assertContains(change.getCreatedData(), path(FOO,BAZ));
assertNotContains(change.getCreatedData(), path(FOO,BAR));
@Override
protected void existingTopWriteTwoNested(final DatastoreTestTask task) throws InterruptedException, ExecutionException {
- AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
assertContains(change.getCreatedData(), path(FOO,BAR),path(FOO,BAZ));
assertContains(change.getUpdatedData(), TOP_LEVEL, path(FOO));
@Override
protected void existingTopWriteSibling(final DatastoreTestTask task) throws InterruptedException, ExecutionException {
- AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
assertContains(change.getCreatedData(), path(FOO_SIBLING));
assertContains(change.getUpdatedData(), TOP_LEVEL);
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.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
public class SchemaUpdateForTransactionTest {
- private static final InstanceIdentifier TOP_PATH = InstanceIdentifier.of(Top.QNAME);
+ private static final YangInstanceIdentifier TOP_PATH = YangInstanceIdentifier.of(Top.QNAME);
private SchemaContext schemaContext;
private InMemoryDOMDataStore domStore;
package org.opendaylight.controller.md.sal.dom.store.impl;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
public static final QName VALUE_QNAME = QName.create(TEST_QNAME, "value");
private static final String DATASTORE_TEST_YANG = "/odl-datastore-test.yang";
- public static final InstanceIdentifier TEST_PATH = InstanceIdentifier.of(TEST_QNAME);
- public static final InstanceIdentifier OUTER_LIST_PATH = InstanceIdentifier.builder(TEST_PATH).node(OUTER_LIST_QNAME).build();
+ public static final YangInstanceIdentifier TEST_PATH = YangInstanceIdentifier.of(TEST_QNAME);
+ public static final YangInstanceIdentifier OUTER_LIST_PATH = YangInstanceIdentifier.builder(TEST_PATH).node(OUTER_LIST_QNAME).build();
public static final QName TWO_QNAME = QName.create(TEST_QNAME, "two");
public static final QName THREE_QNAME = QName.create(TEST_QNAME, "three");
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.YangInstanceIdentifier;
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(
+ private static final YangInstanceIdentifier TOP_LEVEL_LIST_ALL = TOP_LEVEL.node(TopLevelList.QNAME).node(
TopLevelList.QNAME);
@Override
@Override
public void putTopLevelOneNested(final DatastoreTestTask task) throws InterruptedException, ExecutionException {
- AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
assertNotNull(change);
public void replaceTopLevelNestedChanged(final DatastoreTestTask task) throws InterruptedException,
ExecutionException {
- AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
assertNotNull(change);
assertContains(change.getCreatedData(), path(FOO, BAZ));
protected void putTopLevelWithTwoNested(final DatastoreTestTask task) throws InterruptedException,
ExecutionException {
- AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
assertNotNull(change);
assertFalse(change.getCreatedData().isEmpty());
public void nestedListExistsRootDeleted(final DatastoreTestTask task) throws InterruptedException,
ExecutionException {
- AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
assertEmpty(change.getCreatedData());
assertEmpty(change.getUpdatedData());
@Override
protected void existingTopWriteSibling(final DatastoreTestTask task) throws InterruptedException, ExecutionException {
- AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
assertContains(change.getCreatedData(), path(FOO_SIBLING));
assertNotContains(change.getUpdatedData(), path(FOO), TOP_LEVEL);
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.YangInstanceIdentifier;
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(
+ private static final YangInstanceIdentifier TOP_LEVEL_LIST_ALL = TOP_LEVEL.node(TopLevelList.QNAME).node(
TopLevelList.QNAME);
@Override
@Override
public void putTopLevelOneNested(final DatastoreTestTask task) throws InterruptedException, ExecutionException {
- AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
assertNotNull(change);
public void replaceTopLevelNestedChanged(final DatastoreTestTask task) throws InterruptedException,
ExecutionException {
- AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
assertNotNull(change);
assertContains(change.getCreatedData(), path(FOO, BAZ));
protected void putTopLevelWithTwoNested(final DatastoreTestTask task) throws InterruptedException,
ExecutionException {
- AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
assertNotNull(change);
assertFalse(change.getCreatedData().isEmpty());
public void nestedListExistsRootDeleted(final DatastoreTestTask task) throws InterruptedException,
ExecutionException {
- AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
assertEmpty(change.getCreatedData());
assertEmpty(change.getUpdatedData());
@Override
protected void existingTopWriteSibling(final DatastoreTestTask task) throws InterruptedException, ExecutionException {
- AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
assertContains(change.getCreatedData(), path(FOO_SIBLING));
assertNotContains(change.getUpdatedData(),path(FOO), TOP_LEVEL);
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.YangInstanceIdentifier;
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(
+ private static final YangInstanceIdentifier TOP_LEVEL_LIST_ALL = TOP_LEVEL.node(TopLevelList.QNAME).node(
TopLevelList.QNAME);
@Override
@Override
public void putTopLevelOneNested(final DatastoreTestTask task) throws InterruptedException, ExecutionException {
- AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
assertNotContains(change.getCreatedData(), TOP_LEVEL);
assertContains(change.getCreatedData(), path(FOO), path(FOO, BAR));
public void replaceTopLevelNestedChanged(final DatastoreTestTask task) throws InterruptedException,
ExecutionException {
- AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
assertNotNull(change);
assertContains(change.getCreatedData(), path(FOO, BAZ));
protected void putTopLevelWithTwoNested(final DatastoreTestTask task) throws InterruptedException,
ExecutionException {
- AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
assertNotNull(change);
assertFalse(change.getCreatedData().isEmpty());
protected void twoNestedExistsOneIsDeleted(final DatastoreTestTask task) throws InterruptedException,
ExecutionException {
- AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
assertNotNull(change);
assertTrue(change.getCreatedData().isEmpty());
assertContains(change.getUpdatedData(), path(FOO));
public void nestedListExistsRootDeleted(final DatastoreTestTask task) throws InterruptedException,
ExecutionException {
- AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
assertEmpty(change.getCreatedData());
assertEmpty(change.getUpdatedData());
@Override
protected void existingOneNestedWriteAdditionalNested(final DatastoreTestTask task) throws InterruptedException, ExecutionException {
- AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
assertContains(change.getCreatedData(), path(FOO,BAZ));
assertNotContains(change.getCreatedData(), path(FOO,BAR));
@Override
protected void existingTopWriteTwoNested(final DatastoreTestTask task) throws InterruptedException, ExecutionException {
- AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
assertContains(change.getCreatedData(), path(FOO,BAR),path(FOO,BAZ));
assertContains(change.getUpdatedData(), path(FOO));
@Override
protected void existingTopWriteSibling(final DatastoreTestTask task) throws InterruptedException, ExecutionException {
- AsyncDataChangeEvent<InstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
+ AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change = task.getChangeEvent().get();
assertContains(change.getCreatedData(), path(FOO_SIBLING));
assertNotContains(change.getUpdatedData(), path(FOO), TOP_LEVEL);
import org.opendaylight.controller.sal.connect.util.RemoteDeviceId;
import org.opendaylight.controller.sal.core.api.RpcImplementation;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
final class NetconfDeviceDataBroker implements DOMDataBroker {
}
@Override
- public ListenerRegistration<DOMDataChangeListener> registerDataChangeListener(final LogicalDatastoreType store, final InstanceIdentifier path, final DOMDataChangeListener listener, final DataChangeScope triggeringScope) {
+ public ListenerRegistration<DOMDataChangeListener> registerDataChangeListener(final LogicalDatastoreType store, final YangInstanceIdentifier path, final DOMDataChangeListener listener, final DataChangeScope triggeringScope) {
throw new UnsupportedOperationException("Data change listeners not supported for netconf mount point");
}
import org.opendaylight.controller.sal.core.api.RpcImplementation;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.SimpleNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
this.normalizer = normalizer;
}
- public ListenableFuture<Optional<NormalizedNode<?, ?>>> readConfigurationData(final InstanceIdentifier path) {
+ public ListenableFuture<Optional<NormalizedNode<?, ?>>> readConfigurationData(final YangInstanceIdentifier path) {
final ListenableFuture<RpcResult<CompositeNode>> future = rpc.invokeRpc(NETCONF_GET_CONFIG_QNAME,
NetconfMessageTransformUtil.wrap(NETCONF_GET_CONFIG_QNAME, CONFIG_SOURCE_RUNNING, toFilterStructure(path)));
});
}
- private Optional<NormalizedNode<?, ?>> transform(final InstanceIdentifier path, final CompositeNode node) {
+ private Optional<NormalizedNode<?, ?>> transform(final YangInstanceIdentifier path, final CompositeNode node) {
if(node == null) {
return Optional.absent();
}
}
}
- public ListenableFuture<Optional<NormalizedNode<?, ?>>> readOperationalData(final InstanceIdentifier path) {
+ public ListenableFuture<Optional<NormalizedNode<?, ?>>> readOperationalData(final YangInstanceIdentifier path) {
final ListenableFuture<RpcResult<CompositeNode>> future = rpc.invokeRpc(NETCONF_GET_QNAME, NetconfMessageTransformUtil.wrap(NETCONF_GET_QNAME, toFilterStructure(path)));
return Futures.transform(future, new Function<RpcResult<CompositeNode>, Optional<NormalizedNode<?, ?>>>() {
});
}
- private static Node<?> findNode(final CompositeNode node, final InstanceIdentifier identifier) {
+ private static Node<?> findNode(final CompositeNode node, final YangInstanceIdentifier identifier) {
Node<?> current = node;
- for (final InstanceIdentifier.PathArgument arg : identifier.getPathArguments()) {
+ for (final YangInstanceIdentifier.PathArgument arg : identifier.getPathArguments()) {
if (current instanceof SimpleNode<?>) {
return null;
} else if (current instanceof CompositeNode) {
}
@Override
- public ListenableFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final InstanceIdentifier path) {
- final InstanceIdentifier legacyPath = toLegacyPath(normalizer, path);
+ public ListenableFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path) {
+ final YangInstanceIdentifier legacyPath = toLegacyPath(normalizer, path);
switch (store) {
case CONFIGURATION : {
throw new IllegalArgumentException(String.format("Cannot read data %s for %s datastore, unknown datastore type", path, store));
}
- static InstanceIdentifier toLegacyPath(final DataNormalizer normalizer, final InstanceIdentifier path) {
+ static YangInstanceIdentifier toLegacyPath(final DataNormalizer normalizer, final YangInstanceIdentifier path) {
try {
return normalizer.toLegacy(path);
} catch (final DataNormalizationException e) {
import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.yangtools.yang.common.RpcResult;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
public class NetconfDeviceReadWriteTx implements DOMDataReadWriteTransaction {
}
@Override
- public void put(final LogicalDatastoreType store, final InstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
delegateWriteTx.put(store, path, data);
}
@Override
- public void merge(final LogicalDatastoreType store, final InstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
delegateWriteTx.merge(store, path, data);
}
@Override
- public void delete(final LogicalDatastoreType store, final InstanceIdentifier path) {
+ public void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path) {
delegateWriteTx.delete(store, path);
}
}
@Override
- public ListenableFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final InstanceIdentifier path) {
+ public ListenableFuture<Optional<NormalizedNode<?, ?>>> read(final LogicalDatastoreType store, final YangInstanceIdentifier path) {
return delegateReadTx.read(store, path);
}
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.ModifyAction;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.SimpleNode;
// TODO should the edit operations be blocking ?
@Override
- public void put(final LogicalDatastoreType store, final InstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public void put(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
Preconditions.checkArgument(store == LogicalDatastoreType.CONFIGURATION, "Can merge only configuration, not %s", store);
try {
- final InstanceIdentifier legacyPath = NetconfDeviceReadOnlyTx.toLegacyPath(normalizer, path);
+ final YangInstanceIdentifier legacyPath = NetconfDeviceReadOnlyTx.toLegacyPath(normalizer, path);
final CompositeNode legacyData = normalizer.toLegacy(path, data);
sendEditRpc(createEditConfigStructure(legacyPath, Optional.of(ModifyAction.REPLACE), Optional.fromNullable(legacyData)), Optional.of(ModifyAction.NONE));
} catch (final ExecutionException e) {
}
@Override
- public void merge(final LogicalDatastoreType store, final InstanceIdentifier path, final NormalizedNode<?, ?> data) {
+ public void merge(final LogicalDatastoreType store, final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
Preconditions.checkArgument(store == LogicalDatastoreType.CONFIGURATION, "Can merge only configuration, not %s", store);
try {
- final InstanceIdentifier legacyPath = NetconfDeviceReadOnlyTx.toLegacyPath(normalizer, path);
+ final YangInstanceIdentifier legacyPath = NetconfDeviceReadOnlyTx.toLegacyPath(normalizer, path);
final CompositeNode legacyData = normalizer.toLegacy(path, data);
sendEditRpc(
createEditConfigStructure(legacyPath, Optional.<ModifyAction> absent(), Optional.fromNullable(legacyData)), Optional.<ModifyAction> absent());
}
@Override
- public void delete(final LogicalDatastoreType store, final InstanceIdentifier path) {
+ public void delete(final LogicalDatastoreType store, final YangInstanceIdentifier path) {
Preconditions.checkArgument(store == LogicalDatastoreType.CONFIGURATION, "Can merge only configuration, not %s", store);
try {
}
}
- private CompositeNode createEditConfigStructure(final InstanceIdentifier dataPath, final Optional<ModifyAction> operation,
+ private CompositeNode createEditConfigStructure(final YangInstanceIdentifier dataPath, final Optional<ModifyAction> operation,
final Optional<CompositeNode> lastChildOverride) {
Preconditions.checkArgument(Iterables.isEmpty(dataPath.getPathArguments()) == false, "Instance identifier with empty path %s", dataPath);
- List<InstanceIdentifier.PathArgument> reversedPath = Lists.reverse(dataPath.getPath());
+ List<YangInstanceIdentifier.PathArgument> reversedPath = Lists.reverse(dataPath.getPath());
// Create deepest edit element with expected edit operation
CompositeNode previous = getDeepestEditElement(reversedPath.get(0), operation, lastChildOverride);
reversedPath.remove(0);
// Create edit structure in reversed order
- for (final InstanceIdentifier.PathArgument arg : reversedPath) {
+ for (final YangInstanceIdentifier.PathArgument arg : reversedPath) {
final CompositeNodeBuilder<ImmutableCompositeNode> builder = ImmutableCompositeNode.builder();
builder.setQName(arg.getNodeType());
}
}
- private Map<QName, Object> getPredicates(final InstanceIdentifier.PathArgument arg) {
+ private Map<QName, Object> getPredicates(final YangInstanceIdentifier.PathArgument arg) {
Map<QName, Object> predicates = Collections.emptyMap();
- if (arg instanceof InstanceIdentifier.NodeIdentifierWithPredicates) {
- predicates = ((InstanceIdentifier.NodeIdentifierWithPredicates) arg).getKeyValues();
+ if (arg instanceof YangInstanceIdentifier.NodeIdentifierWithPredicates) {
+ predicates = ((YangInstanceIdentifier.NodeIdentifierWithPredicates) arg).getKeyValues();
}
return predicates;
}
- private CompositeNode getDeepestEditElement(final InstanceIdentifier.PathArgument arg, final Optional<ModifyAction> operation, final Optional<CompositeNode> lastChildOverride) {
+ private CompositeNode getDeepestEditElement(final YangInstanceIdentifier.PathArgument arg, final Optional<ModifyAction> operation, final Optional<CompositeNode> lastChildOverride) {
final CompositeNodeBuilder<ImmutableCompositeNode> builder = ImmutableCompositeNode.builder();
builder.setQName(arg.getNodeType());
import org.opendaylight.yangtools.yang.common.RpcError.ErrorSeverity;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.impl.CompositeNodeTOImpl;
import org.opendaylight.yangtools.yang.data.impl.ImmutableCompositeNode;
.create("urn:ietf:params:netconf:capability:rollback-on-error:1.0");
public static String ROLLBACK_ON_ERROR_OPTION = "rollback-on-error";
- public static Node<?> toFilterStructure(final InstanceIdentifier identifier) {
+ public static Node<?> toFilterStructure(final YangInstanceIdentifier identifier) {
Node<?> previous = null;
if (Iterables.isEmpty(identifier.getPathArguments())) {
return null;
}
- for (final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument component : identifier.getReversePathArguments()) {
- if (component instanceof InstanceIdentifier.NodeIdentifierWithPredicates) {
- previous = toNode((InstanceIdentifier.NodeIdentifierWithPredicates)component, previous);
+ for (final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument component : identifier.getReversePathArguments()) {
+ if (component instanceof YangInstanceIdentifier.NodeIdentifierWithPredicates) {
+ previous = toNode((YangInstanceIdentifier.NodeIdentifierWithPredicates)component, previous);
} else {
previous = toNode(component, previous);
}
return filter("subtree", previous);
}
- static Node<?> toNode(final InstanceIdentifier.NodeIdentifierWithPredicates argument, final Node<?> node) {
+ static Node<?> toNode(final YangInstanceIdentifier.NodeIdentifierWithPredicates argument, final Node<?> node) {
final List<Node<?>> list = new ArrayList<>();
for (final Map.Entry<QName, Object> arg : argument.getKeyValues().entrySet()) {
list.add(new SimpleNodeTOImpl(arg.getKey(), null, arg.getValue()));
return input;
}
- static Node<?> toNode(final InstanceIdentifier.PathArgument argument, final Node<?> node) {
+ static Node<?> toNode(final YangInstanceIdentifier.PathArgument argument, final Node<?> node) {
if (node != null) {
return new CompositeNodeTOImpl(argument.getNodeType(), null, Collections.<Node<?>> singletonList(node));
} else {
public class RemoteDeviceId {
private final String name;
- private final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier path;
+ private final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier path;
private final InstanceIdentifier<Node> bindingPath;
private final NodeKey key;
return InstanceIdentifier.builder(Nodes.class).child(Node.class, key).build();
}
- private static org.opendaylight.yangtools.yang.data.api.InstanceIdentifier createBIPath(final String name) {
- final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.InstanceIdentifierBuilder builder =
- org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.builder();
+ private static org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier createBIPath(final String name) {
+ final org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.InstanceIdentifierBuilder builder =
+ org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.builder();
builder.node(Nodes.QNAME).nodeWithKey(Node.QNAME, QName.create(Node.QNAME.getNamespace(), Node.QNAME.getRevision(), "id"), name);
return builder.build();
return bindingPath;
}
- public org.opendaylight.yangtools.yang.data.api.InstanceIdentifier getPath() {
+ public org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier getPath() {
return path;
}
import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node;
import org.opendaylight.yangtools.concepts.Identifiable;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.AugmentationIdentifier;
-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.InstanceIdentifier.NodeWithValue;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages;
import org.opendaylight.controller.cluster.datastore.node.utils.PathUtils;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
import org.slf4j.Logger;
}
- public NormalizedNodeMessages.Container encode(InstanceIdentifier id, NormalizedNode node){
+ public NormalizedNodeMessages.Container encode(YangInstanceIdentifier id, NormalizedNode node){
String parentPath = "";
if(id != null){
}
- public NormalizedNode<?,?> decode(InstanceIdentifier id, NormalizedNodeMessages.Node node){
+ public NormalizedNode<?,?> decode(YangInstanceIdentifier id, NormalizedNodeMessages.Node node){
NodeToNormalizedNodeBuilder currentOp = NodeToNormalizedNodeBuilder.from(ctx);
- for(InstanceIdentifier.PathArgument pathArgument : id.getPath()){
+ for(YangInstanceIdentifier.PathArgument pathArgument : id.getPath()){
currentOp = currentOp.getChild(pathArgument);
}
if(id.getPath().size() < 1){
nodeType = null;
} else {
- final InstanceIdentifier.PathArgument pathArgument = id.getPath().get(id.getPath().size() - 1);
- if(pathArgument instanceof InstanceIdentifier.AugmentationIdentifier){
+ final YangInstanceIdentifier.PathArgument pathArgument = id.getPath().get(id.getPath().size() - 1);
+ if(pathArgument instanceof YangInstanceIdentifier.AugmentationIdentifier){
nodeType = null;
} else {
nodeType = pathArgument.getNodeType();
import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages;
import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages.Node;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
builderParent.setPath(dataContainerNode.getIdentifier().toString())
.setType(type);
- final Iterable<DataContainerChild<? extends InstanceIdentifier.PathArgument, ?>> value =
+ final Iterable<DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?>> value =
dataContainerNode.getValue();
for (NormalizedNode<?, ?> node : value) {
Node.Builder builderChild = Node.newBuilder();
package org.opendaylight.controller.cluster.datastore.node.utils;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import java.util.HashSet;
import java.util.Set;
return doesMatch;
}
- public InstanceIdentifier.AugmentationIdentifier getPathArgument(){
+ public YangInstanceIdentifier.AugmentationIdentifier getPathArgument(){
Set<QName> childNames = new HashSet<QName>();
final String childQNames = matcher.group(1);
.create(name.trim()));
}
- return new InstanceIdentifier.AugmentationIdentifier(null, childNames);
+ return new YangInstanceIdentifier.AugmentationIdentifier(null, childNames);
}
}
package org.opendaylight.controller.cluster.datastore.node.utils;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import java.util.HashMap;
import java.util.Map;
public class NodeIdentifierFactory {
- private static final Map<String, InstanceIdentifier.PathArgument> cache = new HashMap<>();
- public static InstanceIdentifier.PathArgument getArgument(String id){
- InstanceIdentifier.PathArgument value = cache.get(id);
+ private static final Map<String, YangInstanceIdentifier.PathArgument> cache = new HashMap<>();
+ public static YangInstanceIdentifier.PathArgument getArgument(String id){
+ YangInstanceIdentifier.PathArgument value = cache.get(id);
if(value == null){
synchronized (cache){
value = cache.get(id);
return value;
}
- private static InstanceIdentifier.PathArgument createPathArgument(String id){
+ private static YangInstanceIdentifier.PathArgument createPathArgument(String id){
final NodeIdentifierWithPredicatesGenerator
nodeIdentifierWithPredicatesGenerator = new NodeIdentifierWithPredicatesGenerator(id);
if(nodeIdentifierWithPredicatesGenerator.matches()){
package org.opendaylight.controller.cluster.datastore.node.utils;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
public class NodeIdentifierGenerator {
private final String id;
this.qName = QNameFactory.create(id);
}
- public InstanceIdentifier.PathArgument getArgument(){
- return new InstanceIdentifier.NodeIdentifier(qName);
+ public YangInstanceIdentifier.PathArgument getArgument(){
+ return new YangInstanceIdentifier.NodeIdentifier(qName);
}
}
package org.opendaylight.controller.cluster.datastore.node.utils;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.impl.codec.TypeDefinitionAwareCodec;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
return doesMatch;
}
- public InstanceIdentifier.NodeIdentifierWithPredicates getPathArgument(){
+ public YangInstanceIdentifier.NodeIdentifierWithPredicates getPathArgument(){
final String group = matcher.group(2);
final String[] keyValues = group.split(",");
Map<QName, Object> nameValues = new HashMap<>();
}
}
- return new InstanceIdentifier.NodeIdentifierWithPredicates(QNameFactory.create(matcher.group(1)), nameValues);
+ return new YangInstanceIdentifier.NodeIdentifierWithPredicates(QNameFactory.create(matcher.group(1)), nameValues);
}
package org.opendaylight.controller.cluster.datastore.node.utils;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
return doesMatch;
}
- public InstanceIdentifier.PathArgument getPathArgument(){
+ public YangInstanceIdentifier.PathArgument getPathArgument(){
final String name = matcher.group(1);
final String value = matcher.group(2);
- return new InstanceIdentifier.NodeWithValue(
+ return new YangInstanceIdentifier.NodeWithValue(
QNameFactory.create(name), value);
}
}
package org.opendaylight.controller.cluster.datastore.node.utils;
import com.google.common.base.Preconditions;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.MixinNode;
String newParentPath = parentPath + "/" + dataContainerNode.getIdentifier().toString();
- final Iterable<DataContainerChild<? extends InstanceIdentifier.PathArgument,?>> value = dataContainerNode.getValue();
+ final Iterable<DataContainerChild<? extends YangInstanceIdentifier.PathArgument,?>> value = dataContainerNode.getValue();
for(NormalizedNode<?,?> node : value){
if(node instanceof MixinNode && node instanceof NormalizedNodeContainer){
navigateNormalizedNodeContainerMixin(level, newParentPath, (NormalizedNodeContainer<?, ?, ?>) node);
import org.opendaylight.controller.cluster.datastore.node.utils.NormalizedNodeGetter;
import org.opendaylight.controller.cluster.datastore.node.utils.NormalizedNodeNavigator;
import org.opendaylight.controller.cluster.datastore.util.TestModel;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
assertNotNull("Schema context must not be null.", schemaContext);
}
- private InstanceIdentifier instanceIdentifierFromString(String s){
+ private YangInstanceIdentifier instanceIdentifierFromString(String s){
String[] ids = s.split("/");
- List<InstanceIdentifier.PathArgument> pathArguments = new ArrayList<>();
+ List<YangInstanceIdentifier.PathArgument> pathArguments = new ArrayList<>();
for(String nodeId : ids){
if(!"".equals(nodeId)) {
pathArguments.add(NodeIdentifierFactory.getArgument(nodeId));
}
}
- final InstanceIdentifier instanceIdentifier = InstanceIdentifier.create(pathArguments);
+ final YangInstanceIdentifier instanceIdentifier = YangInstanceIdentifier.create(pathArguments);
return instanceIdentifier;
}
NormalizedNodeGetter normalizedNodeGetter = new NormalizedNodeGetter(id);
new NormalizedNodeNavigator(normalizedNodeGetter).navigate(
- InstanceIdentifier.builder().build().toString(), documentOne);
+ YangInstanceIdentifier.builder().build().toString(), documentOne);
// Validate the value of id can be retrieved from the normalized node
NormalizedNode output = normalizedNodeGetter.getOutput();
final NormalizedNodeToNodeCodec normalizedNodeToNodeCodec = new NormalizedNodeToNodeCodec(schemaContext);
- Container container = normalizedNodeToNodeCodec.encode(InstanceIdentifier.builder().build(), documentOne);
+ Container container = normalizedNodeToNodeCodec.encode(YangInstanceIdentifier.builder().build(), documentOne);
final NormalizedNode<?, ?> decode = normalizedNodeToNodeCodec.decode(instanceIdentifierFromString("/(urn:opendaylight:params:xml:ns:yang:controller:md:sal:dom:store:test?revision=2014-03-13)test"),container.getNormalizedNode());
assertNotNull(decode != null);
//let us ensure that the return decode normalized node encode returns same container
- Container containerResult = normalizedNodeToNodeCodec.encode(InstanceIdentifier.builder().build(), decode);
+ Container containerResult = normalizedNodeToNodeCodec.encode(YangInstanceIdentifier.builder().build(), decode);
assertEquals(container.getParentPath(),containerResult.getParentPath());
assertEquals(container.getNormalizedNode().getChildCount(),container.getNormalizedNode().getChildCount());
import org.opendaylight.controller.protobuff.messages.common.NormalizedNodeMessages;
import org.opendaylight.controller.cluster.datastore.util.NormalizedNodeXmlConverterTest;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
import java.util.Iterator;
*/
public class NormalizedNodeToProtocolBufferNodeTest {
- private String instanceIdentifierToString(InstanceIdentifier id){
- Iterable<InstanceIdentifier.PathArgument> iterable = id.getPathArguments();
+ private String instanceIdentifierToString(YangInstanceIdentifier id){
+ Iterable<YangInstanceIdentifier.PathArgument> iterable = id.getPathArguments();
Iterator iterator = iterable.iterator();
String path="";
while (iterator.hasNext()) {
@Test
public void testNormalizedNodeToNodeSerialization (){
NormalizedNode<?,?> nn = NormalizedNodeXmlConverterTest.augmentChoiceExpectedNode();
- InstanceIdentifier id = InstanceIdentifier.create(
+ YangInstanceIdentifier id = YangInstanceIdentifier.create(
Lists.newArrayList(NormalizedNodeXmlConverterTest.getNodeIdentifier("container")));
NormalizedNodeToProtocolBufferNode nnn = new NormalizedNodeToProtocolBufferNode();
QName CH2_QNAME = QName.create("urn:opendaylight:params:xml:ns:yang:controller:test", "2014-03-13", "ch2");
NormalizedNode
choice = NormalizedNodeXmlConverterTest.augmentChoiceExpectedNode()
- .getChild(new InstanceIdentifier.NodeIdentifier(CH2_QNAME))
+ .getChild(new YangInstanceIdentifier.NodeIdentifier(CH2_QNAME))
.get();
- InstanceIdentifier id = InstanceIdentifier.create(
+ YangInstanceIdentifier id = YangInstanceIdentifier.create(
Lists.newArrayList(NormalizedNodeXmlConverterTest.getNodeIdentifier("ch2")));
NormalizedNodeToProtocolBufferNode nnn = new NormalizedNodeToProtocolBufferNode();
import org.junit.Test;
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.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
return null;
}
- public static InstanceIdentifier.NodeIdentifier getNodeIdentifier(
+ public static YangInstanceIdentifier.NodeIdentifier getNodeIdentifier(
final String localName) {
- return new InstanceIdentifier.NodeIdentifier(QName.create(
+ return new YangInstanceIdentifier.NodeIdentifier(QName.create(
URI.create(NAMESPACE), revision, localName));
}
- public static InstanceIdentifier.AugmentationIdentifier getAugmentIdentifier(
+ public static YangInstanceIdentifier.AugmentationIdentifier getAugmentIdentifier(
final String... childNames) {
Set<QName> qn = Sets.newHashSet();
qn.add(getNodeIdentifier(childName).getNodeType());
}
- return new InstanceIdentifier.AugmentationIdentifier(qn);
+ return new YangInstanceIdentifier.AugmentationIdentifier(qn);
}
public static ContainerNode augmentChoiceExpectedNode() {
- DataContainerNodeBuilder<InstanceIdentifier.NodeIdentifier, ContainerNode> b =
+ DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> b =
Builders.containerBuilder();
b.withNodeIdentifier(getNodeIdentifier("container"));
}
private static ContainerNode listLeafListWithAttributes() {
- DataContainerNodeBuilder<InstanceIdentifier.NodeIdentifier, ContainerNode> b =
+ DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> b =
Builders.containerBuilder();
b.withNodeIdentifier(getNodeIdentifier("container"));
Map<QName, Object> predicates = Maps.newHashMap();
predicates.put(getNodeIdentifier("uint32InList").getNodeType(), 3L);
- DataContainerNodeBuilder<InstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> list1Builder =
+ DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> list1Builder =
Builders.mapEntryBuilder().withNodeIdentifier(
- new InstanceIdentifier.NodeIdentifierWithPredicates(
+ new YangInstanceIdentifier.NodeIdentifierWithPredicates(
getNodeIdentifier("list").getNodeType(), predicates));
- NormalizedNodeBuilder<InstanceIdentifier.NodeIdentifier, Object, LeafNode<Object>> uint32InListBuilder =
+ NormalizedNodeBuilder<YangInstanceIdentifier.NodeIdentifier, Object, LeafNode<Object>> uint32InListBuilder =
Builders.leafBuilder().withNodeIdentifier(
getNodeIdentifier("uint32InList"));
listBuilder.withChild(list1Builder.build());
b.withChild(listBuilder.build());
- NormalizedNodeBuilder<InstanceIdentifier.NodeIdentifier, Object, LeafNode<Object>> booleanBuilder =
+ NormalizedNodeBuilder<YangInstanceIdentifier.NodeIdentifier, Object, LeafNode<Object>> booleanBuilder =
Builders.leafBuilder().withNodeIdentifier(getNodeIdentifier("boolean"));
booleanBuilder.withValue(false);
b.withChild(booleanBuilder.build());
Builders.leafSetBuilder().withNodeIdentifier(
getNodeIdentifier("leafList"));
- NormalizedNodeBuilder<InstanceIdentifier.NodeWithValue, Object, LeafSetEntryNode<Object>> leafList1Builder =
+ NormalizedNodeBuilder<YangInstanceIdentifier.NodeWithValue, Object, LeafSetEntryNode<Object>> leafList1Builder =
Builders.leafSetEntryBuilder().withNodeIdentifier(
- new InstanceIdentifier.NodeWithValue(getNodeIdentifier("leafList")
+ new YangInstanceIdentifier.NodeWithValue(getNodeIdentifier("leafList")
.getNodeType(), "a"));
leafList1Builder.withValue("a");
package org.opendaylight.controller.cluster.datastore.util;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
"/odl-datastore-test-notification.yang";
- public static final InstanceIdentifier TEST_PATH = InstanceIdentifier
+ public static final YangInstanceIdentifier TEST_PATH = YangInstanceIdentifier
.of(TEST_QNAME);
- public static final InstanceIdentifier DESC_PATH = InstanceIdentifier
+ public static final YangInstanceIdentifier DESC_PATH = YangInstanceIdentifier
.builder(TEST_PATH).node(DESC_QNAME).build();
- public static final InstanceIdentifier OUTER_LIST_PATH = InstanceIdentifier
+ public static final YangInstanceIdentifier OUTER_LIST_PATH = YangInstanceIdentifier
.builder(TEST_PATH).node(OUTER_LIST_QNAME).build();
public static final QName TWO_QNAME = QName.create(TEST_QNAME, "two");
public static final QName THREE_QNAME = QName.create(TEST_QNAME, "three");
public static final QName GRAND_CHILD_NAME_QNAME = QName.create(FAMILY_QNAME,
"grand-child-name");
- public static final InstanceIdentifier FAMILY_PATH = InstanceIdentifier
+ public static final YangInstanceIdentifier FAMILY_PATH = YangInstanceIdentifier
.of(FAMILY_QNAME);
- public static final InstanceIdentifier FAMILY_DESC_PATH = InstanceIdentifier
+ public static final YangInstanceIdentifier FAMILY_DESC_PATH = YangInstanceIdentifier
.builder(FAMILY_PATH).node(DESC_QNAME).build();
- public static final InstanceIdentifier CHILDREN_PATH = InstanceIdentifier
+ public static final YangInstanceIdentifier CHILDREN_PATH = YangInstanceIdentifier
.builder(FAMILY_PATH).node(CHILDREN_QNAME).build();
private static final Integer FIRST_CHILD_ID = 1;
private static final String SECOND_GRAND_CHILD_NAME = "second grand child";
// first child
- private static final InstanceIdentifier CHILDREN_1_PATH = InstanceIdentifier
+ private static final YangInstanceIdentifier CHILDREN_1_PATH = YangInstanceIdentifier
.builder(CHILDREN_PATH)
.nodeWithKey(CHILDREN_QNAME, CHILD_NUMBER_QNAME, FIRST_CHILD_ID) //
.build();
- private static final InstanceIdentifier CHILDREN_1_NAME_PATH =
- InstanceIdentifier.builder(CHILDREN_PATH)
+ private static final YangInstanceIdentifier CHILDREN_1_NAME_PATH =
+ YangInstanceIdentifier.builder(CHILDREN_PATH)
.nodeWithKey(CHILDREN_QNAME, CHILD_NAME_QNAME, FIRST_CHILD_NAME) //
.build();
- private static final InstanceIdentifier CHILDREN_2_PATH = InstanceIdentifier
+ private static final YangInstanceIdentifier CHILDREN_2_PATH = YangInstanceIdentifier
.builder(CHILDREN_PATH)
.nodeWithKey(CHILDREN_QNAME, CHILD_NUMBER_QNAME, SECOND_CHILD_ID) //
.build();
- private static final InstanceIdentifier CHILDREN_2_NAME_PATH =
- InstanceIdentifier.builder(CHILDREN_PATH)
+ private static final YangInstanceIdentifier CHILDREN_2_NAME_PATH =
+ YangInstanceIdentifier.builder(CHILDREN_PATH)
.nodeWithKey(CHILDREN_QNAME, CHILD_NAME_QNAME, SECOND_CHILD_NAME) //
.build();
- private static final InstanceIdentifier GRAND_CHILD_1_PATH =
- InstanceIdentifier.builder(CHILDREN_1_PATH)
+ private static final YangInstanceIdentifier GRAND_CHILD_1_PATH =
+ YangInstanceIdentifier.builder(CHILDREN_1_PATH)
.node(GRAND_CHILDREN_QNAME)
//
.nodeWithKey(GRAND_CHILDREN_QNAME, GRAND_CHILD_NUMBER_QNAME,
FIRST_GRAND_CHILD_ID) //
.build();
- private static final InstanceIdentifier GRAND_CHILD_1_NAME_PATH =
- InstanceIdentifier.builder(CHILDREN_1_PATH)
+ private static final YangInstanceIdentifier GRAND_CHILD_1_NAME_PATH =
+ YangInstanceIdentifier.builder(CHILDREN_1_PATH)
.node(GRAND_CHILDREN_QNAME)
//
.nodeWithKey(GRAND_CHILDREN_QNAME, GRAND_CHILD_NAME_QNAME,
FIRST_GRAND_CHILD_NAME) //
.build();
- private static final InstanceIdentifier GRAND_CHILD_2_PATH =
- InstanceIdentifier.builder(CHILDREN_2_PATH)
+ private static final YangInstanceIdentifier GRAND_CHILD_2_PATH =
+ YangInstanceIdentifier.builder(CHILDREN_2_PATH)
.node(GRAND_CHILDREN_QNAME)
//
.nodeWithKey(GRAND_CHILDREN_QNAME, GRAND_CHILD_NUMBER_QNAME,
SECOND_GRAND_CHILD_ID) //
.build();
- private static final InstanceIdentifier GRAND_CHILD_2_NAME_PATH =
- InstanceIdentifier.builder(CHILDREN_2_PATH)
+ private static final YangInstanceIdentifier GRAND_CHILD_2_NAME_PATH =
+ YangInstanceIdentifier.builder(CHILDREN_2_PATH)
.node(GRAND_CHILDREN_QNAME)
//
.nodeWithKey(GRAND_CHILDREN_QNAME, GRAND_CHILD_NAME_QNAME,
SECOND_GRAND_CHILD_NAME) //
.build();
- private static final InstanceIdentifier DESC_PATH_ID = InstanceIdentifier
+ private static final YangInstanceIdentifier DESC_PATH_ID = YangInstanceIdentifier
.builder(DESC_PATH).build();
- private static final InstanceIdentifier OUTER_LIST_1_PATH =
- InstanceIdentifier.builder(OUTER_LIST_PATH)
+ private static final YangInstanceIdentifier OUTER_LIST_1_PATH =
+ YangInstanceIdentifier.builder(OUTER_LIST_PATH)
.nodeWithKey(OUTER_LIST_QNAME, ID_QNAME, ONE_ID) //
.build();
- private static final InstanceIdentifier OUTER_LIST_2_PATH =
- InstanceIdentifier.builder(OUTER_LIST_PATH)
+ private static final YangInstanceIdentifier OUTER_LIST_2_PATH =
+ YangInstanceIdentifier.builder(OUTER_LIST_PATH)
.nodeWithKey(OUTER_LIST_QNAME, ID_QNAME, TWO_ID) //
.build();
- private static final InstanceIdentifier TWO_TWO_PATH = InstanceIdentifier
+ private static final YangInstanceIdentifier TWO_TWO_PATH = YangInstanceIdentifier
.builder(OUTER_LIST_2_PATH).node(INNER_LIST_QNAME) //
.nodeWithKey(INNER_LIST_QNAME, NAME_QNAME, TWO_TWO_NAME) //
.build();
- private static final InstanceIdentifier TWO_TWO_VALUE_PATH =
- InstanceIdentifier.builder(TWO_TWO_PATH).node(VALUE_QNAME) //
+ private static final YangInstanceIdentifier TWO_TWO_VALUE_PATH =
+ YangInstanceIdentifier.builder(TWO_TWO_PATH).node(VALUE_QNAME) //
.build();
private static final MapEntryNode BAR_NODE = mapEntryBuilder(
return ImmutableContainerNodeBuilder
.create()
.withNodeIdentifier(
- new InstanceIdentifier.NodeIdentifier(schemaContext.getQName()))
+ new YangInstanceIdentifier.NodeIdentifier(schemaContext.getQName()))
.withChild(createTestContainer()).build();
}
ImmutableLeafSetEntryNodeBuilder
.create()
.withNodeIdentifier(
- new InstanceIdentifier.NodeWithValue(QName.create(TEST_QNAME,
+ new YangInstanceIdentifier.NodeWithValue(QName.create(TEST_QNAME,
"shoe"), "nike")).withValue("nike").build();
final LeafSetEntryNode<Object> puma =
ImmutableLeafSetEntryNodeBuilder
.create()
.withNodeIdentifier(
- new InstanceIdentifier.NodeWithValue(QName.create(TEST_QNAME,
+ new YangInstanceIdentifier.NodeWithValue(QName.create(TEST_QNAME,
"shoe"), "puma")).withValue("puma").build();
final LeafSetNode<Object> shoes =
ImmutableLeafSetNodeBuilder
.create()
.withNodeIdentifier(
- new InstanceIdentifier.NodeIdentifier(QName.create(TEST_QNAME,
+ new YangInstanceIdentifier.NodeIdentifier(QName.create(TEST_QNAME,
"shoe"))).withChild(nike).withChild(puma).build();
ImmutableLeafSetEntryNodeBuilder
.create()
.withNodeIdentifier(
- (new InstanceIdentifier.NodeWithValue(QName.create(TEST_QNAME,
+ (new YangInstanceIdentifier.NodeWithValue(QName.create(TEST_QNAME,
"number"), 5))).withValue(5).build();
final LeafSetEntryNode<Object> fifteen =
ImmutableLeafSetEntryNodeBuilder
.create()
.withNodeIdentifier(
- (new InstanceIdentifier.NodeWithValue(QName.create(TEST_QNAME,
+ (new YangInstanceIdentifier.NodeWithValue(QName.create(TEST_QNAME,
"number"), 15))).withValue(15).build();
final LeafSetNode<Object> numbers =
ImmutableLeafSetNodeBuilder
.create()
.withNodeIdentifier(
- new InstanceIdentifier.NodeIdentifier(QName.create(TEST_QNAME,
+ new YangInstanceIdentifier.NodeIdentifier(QName.create(TEST_QNAME,
"number"))).withChild(five).withChild(fifteen).build();
Set<QName> childAugmentations = new HashSet<>();
childAugmentations.add(AUG_QNAME);
- final InstanceIdentifier.AugmentationIdentifier augmentationIdentifier =
- new InstanceIdentifier.AugmentationIdentifier(null, childAugmentations);
+ final YangInstanceIdentifier.AugmentationIdentifier augmentationIdentifier =
+ new YangInstanceIdentifier.AugmentationIdentifier(null, childAugmentations);
final AugmentationNode augmentationNode =
Builders.augmentationBuilder()
.withNodeIdentifier(augmentationIdentifier)
.build();
return ImmutableContainerNodeBuilder
.create()
- .withNodeIdentifier(new InstanceIdentifier.NodeIdentifier(TEST_QNAME))
+ .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TEST_QNAME))
.withChild(ImmutableNodes.leafNode(DESC_QNAME, DESC))
.withChild(augmentationNode)
.withChild(shoes)
public static ContainerNode createFamily() {
- final DataContainerNodeAttrBuilder<InstanceIdentifier.NodeIdentifier, ContainerNode> familyContainerBuilder =
+ final DataContainerNodeAttrBuilder<YangInstanceIdentifier.NodeIdentifier, ContainerNode> familyContainerBuilder =
ImmutableContainerNodeBuilder.create().withNodeIdentifier(
- new InstanceIdentifier.NodeIdentifier(FAMILY_QNAME));
+ new YangInstanceIdentifier.NodeIdentifier(FAMILY_QNAME));
final CollectionNodeBuilder<MapEntryNode, MapNode> childrenBuilder =
mapNodeBuilder(CHILDREN_QNAME);
- final DataContainerNodeBuilder<InstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> firstChildBuilder =
+ final DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> firstChildBuilder =
mapEntryBuilder(CHILDREN_QNAME, CHILD_NUMBER_QNAME, FIRST_CHILD_ID);
- final DataContainerNodeBuilder<InstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> secondChildBuilder =
+ final DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> secondChildBuilder =
mapEntryBuilder(CHILDREN_QNAME, CHILD_NUMBER_QNAME, SECOND_CHILD_ID);
- final DataContainerNodeBuilder<InstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> firstGrandChildBuilder =
+ final DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> firstGrandChildBuilder =
mapEntryBuilder(GRAND_CHILDREN_QNAME, GRAND_CHILD_NUMBER_QNAME,
FIRST_GRAND_CHILD_ID);
- final DataContainerNodeBuilder<InstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> secondGrandChildBuilder =
+ final DataContainerNodeBuilder<YangInstanceIdentifier.NodeIdentifierWithPredicates, MapEntryNode> secondGrandChildBuilder =
mapEntryBuilder(GRAND_CHILDREN_QNAME, GRAND_CHILD_NUMBER_QNAME,
SECOND_GRAND_CHILD_ID);
import org.opendaylight.controller.sal.restconf.impl.RestCodec;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.SimpleNode;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
writeStringRepresentation(writer, node, baseType, QName.class);
}
} else if (baseType instanceof InstanceIdentifierTypeDefinition) {
- if (node.getValue() instanceof InstanceIdentifier) {
+ if (node.getValue() instanceof YangInstanceIdentifier) {
IdentityValuesDTO valueDTO = (IdentityValuesDTO) RestCodec.from(baseType, mountPoint).serialize(
node.getValue());
writeIdentityValuesDTOToJson(writer, valueDTO);
} else {
- writeStringRepresentation(writer, node, baseType, InstanceIdentifier.class);
+ writeStringRepresentation(writer, node, baseType, YangInstanceIdentifier.class);
}
} else if (baseType instanceof DecimalTypeDefinition || baseType instanceof IntegerTypeDefinition
|| baseType instanceof UnsignedIntegerTypeDefinition) {
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class BrokerFacade implements DataReader<InstanceIdentifier, CompositeNode> {
+public class BrokerFacade implements DataReader<YangInstanceIdentifier, CompositeNode> {
private final static Logger LOG = LoggerFactory.getLogger(BrokerFacade.class);
private final static BrokerFacade INSTANCE = new BrokerFacade();
}
@Override
- public CompositeNode readConfigurationData(final InstanceIdentifier path) {
+ public CompositeNode readConfigurationData(final YangInstanceIdentifier path) {
this.checkPreconditions();
LOG.trace("Read Configuration via Restconf: {}", path);
}
public CompositeNode readConfigurationDataBehindMountPoint(final MountInstance mountPoint,
- final InstanceIdentifier path) {
+ final YangInstanceIdentifier path) {
this.checkPreconditions();
LOG.trace("Read Configuration via Restconf: {}", path);
}
@Override
- public CompositeNode readOperationalData(final InstanceIdentifier path) {
+ public CompositeNode readOperationalData(final YangInstanceIdentifier path) {
this.checkPreconditions();
BrokerFacade.LOG.trace("Read Operational via Restconf: {}", path);
}
public CompositeNode readOperationalDataBehindMountPoint(final MountInstance mountPoint,
- final InstanceIdentifier path) {
+ final YangInstanceIdentifier path) {
this.checkPreconditions();
BrokerFacade.LOG.trace("Read Operational via Restconf: {}", path);
return context.rpc(type, payload);
}
- public Future<RpcResult<TransactionStatus>> commitConfigurationDataPut(final InstanceIdentifier path,
+ public Future<RpcResult<TransactionStatus>> commitConfigurationDataPut(final YangInstanceIdentifier path,
final CompositeNode payload) {
this.checkPreconditions();
}
public Future<RpcResult<TransactionStatus>> commitConfigurationDataPutBehindMountPoint(
- final MountInstance mountPoint, final InstanceIdentifier path, final CompositeNode payload) {
+ final MountInstance mountPoint, final YangInstanceIdentifier path, final CompositeNode payload) {
this.checkPreconditions();
final DataModificationTransaction transaction = mountPoint.beginTransaction();
return transaction.commit();
}
- public Future<RpcResult<TransactionStatus>> commitConfigurationDataPost(final InstanceIdentifier path,
+ public Future<RpcResult<TransactionStatus>> commitConfigurationDataPost(final YangInstanceIdentifier path,
final CompositeNode payload) {
this.checkPreconditions();
}
public Future<RpcResult<TransactionStatus>> commitConfigurationDataPostBehindMountPoint(
- final MountInstance mountPoint, final InstanceIdentifier path, final CompositeNode payload) {
+ final MountInstance mountPoint, final YangInstanceIdentifier path, final CompositeNode payload) {
this.checkPreconditions();
final DataModificationTransaction transaction = mountPoint.beginTransaction();
return transaction.commit();
}
- public Future<RpcResult<TransactionStatus>> commitConfigurationDataDelete(final InstanceIdentifier path) {
+ public Future<RpcResult<TransactionStatus>> commitConfigurationDataDelete(final YangInstanceIdentifier path) {
this.checkPreconditions();
return deleteDataAtTarget(path, dataService.beginTransaction());
}
public Future<RpcResult<TransactionStatus>> commitConfigurationDataDeleteBehindMountPoint(
- final MountInstance mountPoint, final InstanceIdentifier path) {
+ final MountInstance mountPoint, final YangInstanceIdentifier path) {
this.checkPreconditions();
return deleteDataAtTarget(path, mountPoint.beginTransaction());
}
- private Future<RpcResult<TransactionStatus>> deleteDataAtTarget(final InstanceIdentifier path,
+ private Future<RpcResult<TransactionStatus>> deleteDataAtTarget(final YangInstanceIdentifier path,
final DataModificationTransaction transaction) {
LOG.info("Delete Configuration via Restconf: {}", path);
CompositeNode redDataAtPath = transaction.readConfigurationData(path);
return;
}
- InstanceIdentifier path = listener.getPath();
+ YangInstanceIdentifier path = listener.getPath();
final ListenerRegistration<DataChangeListener> registration = dataService.registerDataChangeListener(path,
listener);
import org.opendaylight.controller.sal.restconf.impl.RestconfError.ErrorType;
import org.opendaylight.yangtools.concepts.Codec;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.InstanceIdentifierBuilder;
-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.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.InstanceIdentifierBuilder;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceCaseNode;
import org.opendaylight.yangtools.yang.model.api.ChoiceNode;
ErrorType.PROTOCOL, ErrorTag.INVALID_VALUE);
}
- InstanceIdentifierBuilder builder = InstanceIdentifier.builder();
+ InstanceIdentifierBuilder builder = YangInstanceIdentifier.builder();
Module latestModule = this.getLatestModule(globalSchema, startModule);
InstanceIdWithSchemaNode iiWithSchemaNode = this.collectPathArguments(builder, pathArgs, latestModule, null,
toMountPointIdentifier);
module.getRevision());
}
- public DataNodeContainer getDataNodeContainerFor(final InstanceIdentifier path) {
+ public DataNodeContainer getDataNodeContainerFor(final YangInstanceIdentifier path) {
this.checkPreconditions();
final Iterable<PathArgument> elements = path.getPathArguments();
return node;
}
- public String toFullRestconfIdentifier(final InstanceIdentifier path) {
+ public String toFullRestconfIdentifier(final YangInstanceIdentifier path) {
this.checkPreconditions();
final Iterable<PathArgument> elements = path.getPathArguments();
ErrorType.APPLICATION, ErrorTag.OPERATION_NOT_SUPPORTED);
}
- final InstanceIdentifier partialPath = builder.toInstance();
+ final YangInstanceIdentifier partialPath = builder.toInstance();
final MountInstance mount = mountService.getMountPoint(partialPath);
if (mount == null) {
LOG.debug("Instance identifier to missing mount point: {}", partialPath);
}
if (returnJustMountPoint) {
- InstanceIdentifier instance = InstanceIdentifier.builder().toInstance();
+ YangInstanceIdentifier instance = YangInstanceIdentifier.builder().toInstance();
return new InstanceIdWithSchemaNode(instance, mountPointSchema, mount);
}
if (strings.size() == 1) {
- InstanceIdentifier instance = InstanceIdentifier.builder().toInstance();
+ YangInstanceIdentifier instance = YangInstanceIdentifier.builder().toInstance();
return new InstanceIdWithSchemaNode(instance, mountPointSchema, mount);
}
}
List<String> subList = strings.subList(1, strings.size());
- return this.collectPathArguments(InstanceIdentifier.builder(), subList, moduleBehindMountPoint, mount,
+ return this.collectPathArguments(YangInstanceIdentifier.builder(), subList, moduleBehindMountPoint, mount,
returnJustMountPoint);
}
package org.opendaylight.controller.sal.restconf.impl;
import org.opendaylight.controller.sal.core.api.mount.MountInstance;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
public class InstanceIdWithSchemaNode {
- private final InstanceIdentifier instanceIdentifier;
+ private final YangInstanceIdentifier instanceIdentifier;
private final DataSchemaNode schemaNode;
private final MountInstance mountPoint;
- public InstanceIdWithSchemaNode(InstanceIdentifier instanceIdentifier, DataSchemaNode schemaNode,
+ public InstanceIdWithSchemaNode(YangInstanceIdentifier instanceIdentifier, DataSchemaNode schemaNode,
MountInstance mountPoint) {
this.instanceIdentifier = instanceIdentifier;
this.schemaNode = schemaNode;
this.mountPoint = mountPoint;
}
- public InstanceIdentifier getInstanceIdentifier() {
+ public YangInstanceIdentifier getInstanceIdentifier() {
return instanceIdentifier;
}
import org.opendaylight.controller.sal.restconf.impl.IdentityValuesDTO.Predicate;
import org.opendaylight.yangtools.concepts.Codec;
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.InstanceIdentifier.NodeWithValue;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.codec.IdentityrefCodec;
import org.opendaylight.yangtools.yang.data.api.codec.InstanceIdentifierCodec;
import org.opendaylight.yangtools.yang.data.api.codec.LeafrefCodec;
}
@Override
- public IdentityValuesDTO serialize(final InstanceIdentifier data) {
+ public IdentityValuesDTO serialize(final YangInstanceIdentifier data) {
IdentityValuesDTO identityValuesDTO = new IdentityValuesDTO();
for (PathArgument pathArgument : data.getPathArguments()) {
IdentityValue identityValue = qNameToIdentityValue(pathArgument.getNodeType());
}
@Override
- public InstanceIdentifier deserialize(final IdentityValuesDTO data) {
+ public YangInstanceIdentifier deserialize(final IdentityValuesDTO data) {
List<PathArgument> result = new ArrayList<PathArgument>();
IdentityValue valueWithNamespace = data.getValuesWithNamespaces().get(0);
Module module = getModuleByNamespace(valueWithNamespace.getNamespace(), mountPoint);
}
}
- return result.isEmpty() ? null : InstanceIdentifier.create(result);
+ return result.isEmpty() ? null : YangInstanceIdentifier.create(result);
}
private List<Predicate> keyValuesToPredicateList(final Map<QName, Object> keyValues) {
import org.opendaylight.yangtools.yang.common.RpcError;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.InstanceIdentifierBuilder;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.InstanceIdentifierBuilder;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.MutableCompositeNode;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.SimpleNode;
rpc.getQName(), "path"));
final Object pathValue = pathNode == null ? null : pathNode.getValue();
- if (!(pathValue instanceof InstanceIdentifier)) {
+ if (!(pathValue instanceof YangInstanceIdentifier)) {
throw new RestconfDocumentedException("Instance identifier was not normalized correctly.",
ErrorType.APPLICATION, ErrorTag.OPERATION_FAILED);
}
- final InstanceIdentifier pathIdentifier = ((InstanceIdentifier) pathValue);
+ final YangInstanceIdentifier pathIdentifier = ((YangInstanceIdentifier) pathValue);
String streamName = null;
if (!Iterables.isEmpty(pathIdentifier.getPathArguments())) {
String fullRestconfIdentifier = this.controllerContext.toFullRestconfIdentifier(pathIdentifier);
private InstanceIdWithSchemaNode addLastIdentifierFromData(final InstanceIdWithSchemaNode identifierWithSchemaNode,
final CompositeNode data, final DataSchemaNode schemaOfData) {
- InstanceIdentifier instanceIdentifier = null;
+ YangInstanceIdentifier instanceIdentifier = null;
if (identifierWithSchemaNode != null) {
instanceIdentifier = identifierWithSchemaNode.getInstanceIdentifier();
}
- final InstanceIdentifier iiOriginal = instanceIdentifier;
+ final YangInstanceIdentifier iiOriginal = instanceIdentifier;
InstanceIdentifierBuilder iiBuilder = null;
if (iiOriginal == null) {
- iiBuilder = InstanceIdentifier.builder();
+ iiBuilder = YangInstanceIdentifier.builder();
} else {
- iiBuilder = InstanceIdentifier.builder(iiOriginal);
+ iiBuilder = YangInstanceIdentifier.builder(iiOriginal);
}
if ((schemaOfData instanceof ListSchemaNode)) {
iiBuilder.node(schemaOfData.getQName());
}
- InstanceIdentifier instance = iiBuilder.toInstance();
+ YangInstanceIdentifier instance = iiBuilder.toInstance();
MountInstance mountPoint = null;
if (identifierWithSchemaNode != null) {
mountPoint = identifierWithSchemaNode.getMountPoint();
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-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.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private final XmlMapper xmlMapper = new XmlMapper();
private final SimpleDateFormat rfc3339 = new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ssZ");
- private final InstanceIdentifier path;
+ private final YangInstanceIdentifier path;
private ListenerRegistration<DataChangeListener> registration;
private final String streamName;
private Set<Channel> subscribers = new ConcurrentSet<>();
* @param streamName
* The name of the stream.
*/
- ListenerAdapter(final InstanceIdentifier path, final String streamName) {
+ ListenerAdapter(final YangInstanceIdentifier path, final String streamName) {
Preconditions.checkNotNull(path);
Preconditions.checkArgument(streamName != null && !streamName.isEmpty());
this.path = path;
}
@Override
- public void onDataChanged(final DataChangeEvent<InstanceIdentifier, CompositeNode> change) {
+ public void onDataChanged(final DataChangeEvent<YangInstanceIdentifier, CompositeNode> change) {
if (!change.getCreatedConfigurationData().isEmpty() || !change.getCreatedOperationalData().isEmpty()
|| !change.getUpdatedConfigurationData().isEmpty() || !change.getUpdatedOperationalData().isEmpty()
|| !change.getRemovedConfigurationData().isEmpty() || !change.getRemovedOperationalData().isEmpty()) {
* DataChangeEvent
* @return Data in printable form.
*/
- private String prepareXmlFrom(final DataChangeEvent<InstanceIdentifier, CompositeNode> change) {
+ private String prepareXmlFrom(final DataChangeEvent<YangInstanceIdentifier, CompositeNode> change) {
Document doc = createDocument();
Element notificationElement = doc.createElementNS("urn:ietf:params:xml:ns:netconf:notification:1.0",
"notification");
*/
private void addValuesToDataChangedNotificationEventElement(final Document doc,
final Element dataChangedNotificationEventElement,
- final DataChangeEvent<InstanceIdentifier, CompositeNode> change) {
+ final DataChangeEvent<YangInstanceIdentifier, CompositeNode> change) {
addValuesFromDataToElement(doc, change.getCreatedConfigurationData(), dataChangedNotificationEventElement,
Store.CONFIG, Operation.CREATED);
addValuesFromDataToElement(doc, change.getCreatedOperationalData(), dataChangedNotificationEventElement,
* @param doc
* {@link Document}
* @param data
- * Set of {@link InstanceIdentifier}.
+ * Set of {@link YangInstanceIdentifier}.
* @param element
* {@link Element}
* @param store
* @param operation
* {@link Operation}
*/
- private void addValuesFromDataToElement(final Document doc, final Set<InstanceIdentifier> data,
+ private void addValuesFromDataToElement(final Document doc, final Set<YangInstanceIdentifier> data,
final Element element, final Store store, final Operation operation) {
if (data == null || data.isEmpty()) {
return;
}
- for (InstanceIdentifier path : data) {
+ for (YangInstanceIdentifier path : data) {
Node node = createDataChangeEventElement(doc, path, null, store, operation);
element.appendChild(node);
}
* @param doc
* {@link Document}
* @param data
- * Map of {@link InstanceIdentifier} and {@link CompositeNode}.
+ * Map of {@link YangInstanceIdentifier} and {@link CompositeNode}.
* @param element
* {@link Element}
* @param store
* @param operation
* {@link Operation}
*/
- private void addValuesFromDataToElement(final Document doc, final Map<InstanceIdentifier, CompositeNode> data,
+ private void addValuesFromDataToElement(final Document doc, final Map<YangInstanceIdentifier, CompositeNode> data,
final Element element, final Store store, final Operation operation) {
if (data == null || data.isEmpty()) {
return;
}
- for (Entry<InstanceIdentifier, CompositeNode> entry : data.entrySet()) {
+ for (Entry<YangInstanceIdentifier, CompositeNode> entry : data.entrySet()) {
Node node = createDataChangeEventElement(doc, entry.getKey(), entry.getValue(), store, operation);
element.appendChild(node);
}
* {@link Operation}
* @return {@link Node} node represented by changed event element.
*/
- private Node createDataChangeEventElement(final Document doc, final InstanceIdentifier path,
+ private Node createDataChangeEventElement(final Document doc, final YangInstanceIdentifier path,
final CompositeNode data, final Store store, final Operation operation) {
Element dataChangeEventElement = doc.createElement("data-change-event");
* {@link CompositeNode}
* @return Data in XML format.
*/
- private Node translateToXml(final InstanceIdentifier path, final CompositeNode data) {
+ private Node translateToXml(final YangInstanceIdentifier path, final CompositeNode data) {
DataNodeContainer schemaNode = ControllerContext.getInstance().getDataNodeContainerFor(path);
if (schemaNode == null) {
LOG.info(
* @param element
* {@link Element}
*/
- private void addPathAsValueToElement(final InstanceIdentifier path, final Element element) {
+ private void addPathAsValueToElement(final YangInstanceIdentifier path, final Element element) {
// Map< key = namespace, value = prefix>
Map<String, String> prefixes = new HashMap<>();
- InstanceIdentifier instanceIdentifier = path;
+ YangInstanceIdentifier instanceIdentifier = path;
StringBuilder textContent = new StringBuilder();
// FIXME: BUG-1281: this is duplicated code from yangtools (BUG-1275)
*
* @return Path pointed to data in data store.
*/
- public InstanceIdentifier getPath() {
+ public YangInstanceIdentifier getPath() {
return path;
}
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
/**
* {@link Notificator} is responsible to create, remove and find {@link ListenerAdapter} listener.
public class Notificator {
private static Map<String, ListenerAdapter> listenersByStreamName = new ConcurrentHashMap<>();
- private static Map<InstanceIdentifier, ListenerAdapter> listenersByInstanceIdentifier = new ConcurrentHashMap<>();
+ private static Map<YangInstanceIdentifier, ListenerAdapter> listenersByInstanceIdentifier = new ConcurrentHashMap<>();
private static final Lock lock = new ReentrantLock();
private Notificator() {
}
/**
- * Gets {@link ListenerAdapter} listener specified by {@link InstanceIdentifier} path.
+ * Gets {@link ListenerAdapter} listener specified by {@link YangInstanceIdentifier} path.
*
* @param path
* Path to data in data repository.
* @return ListenerAdapter
*/
- public static ListenerAdapter getListenerFor(InstanceIdentifier path) {
+ public static ListenerAdapter getListenerFor(YangInstanceIdentifier path) {
return listenersByInstanceIdentifier.get(path);
}
/**
- * Checks if the listener specified by {@link InstanceIdentifier} path exist.
+ * Checks if the listener specified by {@link YangInstanceIdentifier} path exist.
*
* @param path
* Path to data in data repository.
* @return True if the listener exist, false otherwise.
*/
- public static boolean existListenerFor(InstanceIdentifier path) {
+ public static boolean existListenerFor(YangInstanceIdentifier path) {
return listenersByInstanceIdentifier.containsKey(path);
}
/**
- * Creates new {@link ListenerAdapter} listener from {@link InstanceIdentifier} path and stream name.
+ * Creates new {@link ListenerAdapter} listener from {@link YangInstanceIdentifier} path and stream name.
*
* @param path
* Path to data in data repository.
* @param streamName
* The name of the stream.
- * @return New {@link ListenerAdapter} listener from {@link InstanceIdentifier} path and stream name.
+ * @return New {@link ListenerAdapter} listener from {@link YangInstanceIdentifier} path and stream name.
*/
- public static ListenerAdapter createListener(InstanceIdentifier path, String streamName) {
+ public static ListenerAdapter createListener(YangInstanceIdentifier path, String streamName) {
ListenerAdapter listener = new ListenerAdapter(path, streamName);
try {
lock.lock();
}
/**
- * Looks for listener determined by {@link InstanceIdentifier} path and removes it.
+ * Looks for listener determined by {@link YangInstanceIdentifier} path and removes it.
*
* @param path
* InstanceIdentifier
*/
- public static void removeListener(InstanceIdentifier path) {
+ public static void removeListener(YangInstanceIdentifier path) {
ListenerAdapter listener = listenersByInstanceIdentifier.get(path);
deleteListener(listener);
}
import org.opendaylight.controller.sal.restconf.impl.test.TestUtils;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.impl.ImmutableCompositeNode;
import org.opendaylight.yangtools.yang.data.impl.util.CompositeNodeBuilder;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
Builder<TransactionStatus> futureBuilder = new DummyFuture.Builder<TransactionStatus>();
futureBuilder.rpcResult(new DummyRpcResult.Builder<TransactionStatus>().result(TransactionStatus.COMMITED)
.build());
- when(brokerFacade.commitConfigurationDataPut(any(InstanceIdentifier.class), any(CompositeNode.class)))
+ when(brokerFacade.commitConfigurationDataPut(any(YangInstanceIdentifier.class), any(CompositeNode.class)))
.thenReturn(futureBuilder.build());
}
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.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.impl.ImmutableCompositeNode;
/**
QName qname = QName.create("node");
- InstanceIdentifier instanceID = InstanceIdentifier.builder().node(qname).toInstance();
+ YangInstanceIdentifier instanceID = YangInstanceIdentifier.builder().node(qname).toInstance();
@Before
public void setUp() throws Exception {
public void testCommitConfigurationDataPost() {
Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture(null);
- Map<InstanceIdentifier, CompositeNode> nodeMap = new ImmutableMap.Builder<InstanceIdentifier, CompositeNode>()
+ Map<YangInstanceIdentifier, CompositeNode> nodeMap = new ImmutableMap.Builder<YangInstanceIdentifier, CompositeNode>()
.put(instanceID, dataNode).build();
when(dataBroker.beginTransaction()).thenReturn(mockTransaction);
public void testCommitConfigurationDataPostBehindMountPoint() {
Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture(null);
- Map<InstanceIdentifier, CompositeNode> nodeMap = new ImmutableMap.Builder<InstanceIdentifier, CompositeNode>()
+ Map<YangInstanceIdentifier, CompositeNode> nodeMap = new ImmutableMap.Builder<YangInstanceIdentifier, CompositeNode>()
.put(instanceID, dataNode).build();
when(mockMountInstance.beginTransaction()).thenReturn(mockTransaction);
Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture(null);
when(dataBroker.beginTransaction()).thenReturn(mockTransaction);
- when(mockTransaction.readConfigurationData(any(InstanceIdentifier.class))).thenReturn(
+ when(mockTransaction.readConfigurationData(any(YangInstanceIdentifier.class))).thenReturn(
ImmutableCompositeNode.builder().toInstance());
mockTransaction.removeConfigurationData(instanceID);
when(mockTransaction.commit()).thenReturn(expFuture);
Future<RpcResult<TransactionStatus>> expFuture = Futures.immediateFuture(null);
when(mockMountInstance.beginTransaction()).thenReturn(mockTransaction);
- when(mockTransaction.readConfigurationData(any(InstanceIdentifier.class))).thenReturn(
+ when(mockTransaction.readConfigurationData(any(YangInstanceIdentifier.class))).thenReturn(
ImmutableCompositeNode.builder().toInstance());
mockTransaction.removeConfigurationData(instanceID);
when(mockTransaction.commit()).thenReturn(expFuture);
import org.opendaylight.controller.sal.rest.impl.StructuredDataToXmlProvider;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-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.InstanceIdentifier.NodeWithValue;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.SimpleNode;
import org.opendaylight.yangtools.yang.data.impl.ImmutableCompositeNode;
import org.opendaylight.yangtools.yang.data.impl.NodeFactory;
}
- private CompositeNode prepareCnSn(final InstanceIdentifier instanceIdentifier) throws URISyntaxException {
+ private CompositeNode prepareCnSn(final YangInstanceIdentifier instanceIdentifier) throws URISyntaxException {
CompositeNodeBuilder<ImmutableCompositeNode> cont = ImmutableCompositeNode.builder();
cont.setQName(QName.create("instance:identifier:module", "2014-01-17", "cont"));
return cont.toInstance();
}
- private InstanceIdentifier createInstanceIdentifier() throws URISyntaxException {
+ private YangInstanceIdentifier createInstanceIdentifier() throws URISyntaxException {
List<PathArgument> pathArguments = new ArrayList<>();
pathArguments.add(new NodeIdentifier(new QName(new URI("instance:identifier:module"), "cont")));
pathArguments.add(new NodeIdentifier(new QName(new URI("instance:identifier:module"), "cont1")));
pathArguments.add(new NodeIdentifier(new QName(new URI("augment:augment:module"), "lf112")));
- return InstanceIdentifier.create(pathArguments);
+ return YangInstanceIdentifier.create(pathArguments);
}
- private InstanceIdentifier createInstanceIdentifierWithLeafList() throws URISyntaxException {
+ private YangInstanceIdentifier createInstanceIdentifierWithLeafList() throws URISyntaxException {
List<PathArgument> pathArguments = new ArrayList<>();
pathArguments.add(new NodeIdentifier(new QName(new URI("instance:identifier:module"), "cont")));
pathArguments.add(new NodeIdentifier(new QName(new URI("instance:identifier:module"), "cont1")));
pathArguments.add(new NodeWithValue(new QName(new URI("augment:module:leaf:list"), "lflst11"), "lflst11_1"));
- return InstanceIdentifier.create(pathArguments);
+ return YangInstanceIdentifier.create(pathArguments);
}
}
import org.opendaylight.controller.sal.restconf.impl.ControllerContext;
import org.opendaylight.controller.sal.restconf.impl.RestconfImpl;
import org.opendaylight.yangtools.yang.common.RpcResult;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
public void deleteConfigStatusCodes() throws UnsupportedEncodingException {
String uri = "/config/test-interface:interfaces";
Future<RpcResult<TransactionStatus>> dummyFuture = createFuture(TransactionStatus.COMMITED);
- when(brokerFacade.commitConfigurationDataDelete(any(InstanceIdentifier.class))).thenReturn(dummyFuture);
+ when(brokerFacade.commitConfigurationDataDelete(any(YangInstanceIdentifier.class))).thenReturn(dummyFuture);
Response response = target(uri).request(MediaType.APPLICATION_XML).delete();
assertEquals(200, response.getStatus());
dummyFuture = createFuture(TransactionStatus.FAILED);
- when(brokerFacade.commitConfigurationDataDelete(any(InstanceIdentifier.class))).thenReturn(dummyFuture);
+ when(brokerFacade.commitConfigurationDataDelete(any(YangInstanceIdentifier.class))).thenReturn(dummyFuture);
response = target(uri).request(MediaType.APPLICATION_XML).delete();
assertEquals(500, response.getStatus());
}
import org.opendaylight.controller.sal.restconf.impl.SimpleNodeWrapper;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.impl.ImmutableCompositeNode;
import org.opendaylight.yangtools.yang.data.impl.util.CompositeNodeBuilder;
public void getDataWithUrlMountPoint() throws UnsupportedEncodingException, URISyntaxException {
when(
brokerFacade.readConfigurationDataBehindMountPoint(any(MountInstance.class),
- any(InstanceIdentifier.class))).thenReturn(prepareCnDataForMountPointTest());
+ any(YangInstanceIdentifier.class))).thenReturn(prepareCnDataForMountPointTest());
MountInstance mountInstance = mock(MountInstance.class);
when(mountInstance.getSchemaContext()).thenReturn(schemaContextTestModule);
MountService mockMountService = mock(MountService.class);
- when(mockMountService.getMountPoint(any(InstanceIdentifier.class))).thenReturn(mountInstance);
+ when(mockMountService.getMountPoint(any(YangInstanceIdentifier.class))).thenReturn(mountInstance);
ControllerContext.getInstance().setMountService(mockMountService);
* Slashes in URI behind mount point. lst1 element with key GigabitEthernet0%2F0%2F0%2F0 (GigabitEthernet0/0/0/0) is
* requested via GET HTTP operation. It is tested whether %2F character is replaced with simple / in
* InstanceIdentifier parameter in method
- * {@link BrokerFacade#readConfigurationDataBehindMountPoint(MountInstance, InstanceIdentifier)} which is called in
+ * {@link BrokerFacade#readConfigurationDataBehindMountPoint(MountInstance, YangInstanceIdentifier)} which is called in
* method {@link RestconfImpl#readConfigurationData}
*
*
@Test
public void getDataWithSlashesBehindMountPoint() throws UnsupportedEncodingException, URISyntaxException,
ParseException {
- InstanceIdentifier awaitedInstanceIdentifier = prepareInstanceIdentifierForList();
+ YangInstanceIdentifier awaitedInstanceIdentifier = prepareInstanceIdentifierForList();
when(
brokerFacade.readConfigurationDataBehindMountPoint(any(MountInstance.class),
eq(awaitedInstanceIdentifier))).thenReturn(prepareCnDataForMountPointTest());
MountInstance mountInstance = mock(MountInstance.class);
when(mountInstance.getSchemaContext()).thenReturn(schemaContextTestModule);
MountService mockMountService = mock(MountService.class);
- when(mockMountService.getMountPoint(any(InstanceIdentifier.class))).thenReturn(mountInstance);
+ when(mockMountService.getMountPoint(any(YangInstanceIdentifier.class))).thenReturn(mountInstance);
ControllerContext.getInstance().setMountService(mockMountService);
assertEquals(200, get(uri, MediaType.APPLICATION_XML));
}
- private InstanceIdentifier prepareInstanceIdentifierForList() throws URISyntaxException, ParseException {
+ private YangInstanceIdentifier prepareInstanceIdentifierForList() throws URISyntaxException, ParseException {
List<PathArgument> parameters = new ArrayList<>();
Date revision = new SimpleDateFormat("yyyy-MM-dd").parse("2014-01-09");
QName qNameList = QName.create(uri, revision, "lst1");
QName qNameKeyList = QName.create(uri, revision, "lf11");
- parameters.add(new InstanceIdentifier.NodeIdentifier(qNameCont));
- parameters.add(new InstanceIdentifier.NodeIdentifierWithPredicates(qNameList, qNameKeyList,
+ parameters.add(new YangInstanceIdentifier.NodeIdentifier(qNameCont));
+ parameters.add(new YangInstanceIdentifier.NodeIdentifierWithPredicates(qNameList, qNameKeyList,
"GigabitEthernet0/0/0/0"));
- return InstanceIdentifier.create(parameters);
+ return YangInstanceIdentifier.create(parameters);
}
@Test
public void getDataMountPointIntoHighestElement() throws UnsupportedEncodingException, URISyntaxException {
when(
brokerFacade.readConfigurationDataBehindMountPoint(any(MountInstance.class),
- any(InstanceIdentifier.class))).thenReturn(prepareCnDataForMountPointTest());
+ any(YangInstanceIdentifier.class))).thenReturn(prepareCnDataForMountPointTest());
MountInstance mountInstance = mock(MountInstance.class);
when(mountInstance.getSchemaContext()).thenReturn(schemaContextTestModule);
MountService mockMountService = mock(MountService.class);
- when(mockMountService.getMountPoint(any(InstanceIdentifier.class))).thenReturn(mountInstance);
+ when(mockMountService.getMountPoint(any(YangInstanceIdentifier.class))).thenReturn(mountInstance);
ControllerContext.getInstance().setMountService(mockMountService);
MountInstance mountInstance = mock(MountInstance.class);
when(mountInstance.getSchemaContext()).thenReturn(schemaContextBehindMountPoint);
MountService mockMountService = mock(MountService.class);
- when(mockMountService.getMountPoint(any(InstanceIdentifier.class))).thenReturn(mountInstance);
+ when(mockMountService.getMountPoint(any(YangInstanceIdentifier.class))).thenReturn(mountInstance);
controllerContext.setMountService(mockMountService);
MountInstance mountInstance = mock(MountInstance.class);
when(mountInstance.getSchemaContext()).thenReturn(schemaContextBehindMountPoint);
MountService mockMountService = mock(MountService.class);
- when(mockMountService.getMountPoint(any(InstanceIdentifier.class))).thenReturn(mountInstance);
+ when(mockMountService.getMountPoint(any(YangInstanceIdentifier.class))).thenReturn(mountInstance);
controllerContext.setMountService(mockMountService);
MountInstance mountInstance = mock(MountInstance.class);
when(mountInstance.getSchemaContext()).thenReturn(schemaContextBehindMountPoint);
MountService mockMountService = mock(MountService.class);
- when(mockMountService.getMountPoint(any(InstanceIdentifier.class))).thenReturn(mountInstance);
+ when(mockMountService.getMountPoint(any(YangInstanceIdentifier.class))).thenReturn(mountInstance);
controllerContext.setMountService(mockMountService);
}
private void mockReadOperationalDataMethod() {
- when(brokerFacade.readOperationalData(any(InstanceIdentifier.class))).thenReturn(answerFromGet);
+ when(brokerFacade.readOperationalData(any(YangInstanceIdentifier.class))).thenReturn(answerFromGet);
}
private void mockReadConfigurationDataMethod() {
- when(brokerFacade.readConfigurationData(any(InstanceIdentifier.class))).thenReturn(answerFromGet);
+ when(brokerFacade.readConfigurationData(any(YangInstanceIdentifier.class))).thenReturn(answerFromGet);
}
private static CompositeNode prepareCompositeNodeWithIetfInterfacesInterfacesData() {
toSimpleNodeData(toNestedQName("depth3-leaf2"), "depth3-leaf2-value")),
toSimpleNodeData(toNestedQName("depth2-leaf1"), "depth2-leaf1-value")));
- when(brokerFacade.readConfigurationData(any(InstanceIdentifier.class))).thenReturn(depth1Cont);
+ when(brokerFacade.readConfigurationData(any(YangInstanceIdentifier.class))).thenReturn(depth1Cont);
// Test config with depth 1
toSimpleNodeData(toNestedQName("depth4-leaf1"), "depth4-leaf1-value")),
toSimpleNodeData(toNestedQName("depth3-leaf1"), "depth3-leaf1-value")));
- when(brokerFacade.readOperationalData(any(InstanceIdentifier.class))).thenReturn(depth2Cont1);
+ when(brokerFacade.readOperationalData(any(YangInstanceIdentifier.class))).thenReturn(depth2Cont1);
response = target("/operational/nested-module:depth1-cont/depth2-cont1").queryParam("depth", "3")
.request("application/xml").get();
import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
rpcResult).build();
when(
brokerFacade.commitConfigurationDataPostBehindMountPoint(any(MountInstance.class),
- any(InstanceIdentifier.class), any(CompositeNode.class))).thenReturn(dummyFuture);
+ any(YangInstanceIdentifier.class), any(CompositeNode.class))).thenReturn(dummyFuture);
MountInstance mountInstance = mock(MountInstance.class);
when(mountInstance.getSchemaContext()).thenReturn(schemaContextTestModule);
MountService mockMountService = mock(MountService.class);
- when(mockMountService.getMountPoint(any(InstanceIdentifier.class))).thenReturn(mountInstance);
+ when(mockMountService.getMountPoint(any(YangInstanceIdentifier.class))).thenReturn(mountInstance);
ControllerContext.getInstance().setMountService(mockMountService);
dummyFuture = new DummyFuture.Builder<TransactionStatus>().build();
}
- when(brokerFacade.commitConfigurationDataPost(any(InstanceIdentifier.class), any(CompositeNode.class)))
+ when(brokerFacade.commitConfigurationDataPost(any(YangInstanceIdentifier.class), any(CompositeNode.class)))
.thenReturn(dummyFuture);
}
Future<RpcResult<TransactionStatus>> dummyFuture = new DummyFuture.Builder<TransactionStatus>().rpcResult(
rpcResult).build();
- when(brokerFacade.commitConfigurationDataPost(any(InstanceIdentifier.class), any(CompositeNode.class)))
+ when(brokerFacade.commitConfigurationDataPost(any(YangInstanceIdentifier.class), any(CompositeNode.class)))
.thenReturn(dummyFuture);
- ArgumentCaptor<InstanceIdentifier> instanceIdCaptor = ArgumentCaptor.forClass(InstanceIdentifier.class);
+ ArgumentCaptor<YangInstanceIdentifier> instanceIdCaptor = ArgumentCaptor.forClass(YangInstanceIdentifier.class);
ArgumentCaptor<CompositeNode> compNodeCaptor = ArgumentCaptor.forClass(CompositeNode.class);
String URI_1 = "/config";
public void createConfigurationDataNullTest() throws UnsupportedEncodingException {
initMocking();
- when(brokerFacade.commitConfigurationDataPost(any(InstanceIdentifier.class), any(CompositeNode.class)))
+ when(brokerFacade.commitConfigurationDataPost(any(YangInstanceIdentifier.class), any(CompositeNode.class)))
.thenReturn(null);
String URI_1 = "/config";
import org.opendaylight.controller.sal.restconf.impl.RestconfImpl;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
public class RestPutOperationTest extends JerseyTest {
rpcResult).build();
when(
brokerFacade.commitConfigurationDataPutBehindMountPoint(any(MountInstance.class),
- any(InstanceIdentifier.class), any(CompositeNode.class))).thenReturn(dummyFuture);
+ any(YangInstanceIdentifier.class), any(CompositeNode.class))).thenReturn(dummyFuture);
MountInstance mountInstance = mock(MountInstance.class);
when(mountInstance.getSchemaContext()).thenReturn(schemaContextTestModule);
MountService mockMountService = mock(MountService.class);
- when(mockMountService.getMountPoint(any(InstanceIdentifier.class))).thenReturn(mountInstance);
+ when(mockMountService.getMountPoint(any(YangInstanceIdentifier.class))).thenReturn(mountInstance);
ControllerContext.getInstance().setMountService(mockMountService);
rpcResult).build();
when(
brokerFacade.commitConfigurationDataPutBehindMountPoint(any(MountInstance.class),
- any(InstanceIdentifier.class), any(CompositeNode.class))).thenReturn(dummyFuture);
+ any(YangInstanceIdentifier.class), any(CompositeNode.class))).thenReturn(dummyFuture);
MountInstance mountInstance = mock(MountInstance.class);
when(mountInstance.getSchemaContext()).thenReturn(schemaContextTestModule);
MountService mockMountService = mock(MountService.class);
- when(mockMountService.getMountPoint(any(InstanceIdentifier.class))).thenReturn(mountInstance);
+ when(mockMountService.getMountPoint(any(YangInstanceIdentifier.class))).thenReturn(mountInstance);
ControllerContext.getInstance().setMountService(mockMountService);
.build();
Future<RpcResult<TransactionStatus>> dummyFuture = new DummyFuture.Builder<TransactionStatus>().rpcResult(
rpcResult).build();
- when(brokerFacade.commitConfigurationDataPut(any(InstanceIdentifier.class), any(CompositeNode.class)))
+ when(brokerFacade.commitConfigurationDataPut(any(YangInstanceIdentifier.class), any(CompositeNode.class)))
.thenReturn(dummyFuture);
}
import org.opendaylight.controller.sal.restconf.impl.ControllerContext;
import org.opendaylight.controller.sal.restconf.impl.RestconfImpl;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
CompositeNode loadedCompositeNode = TestUtils.readInputToCnSn("/parts/ietf-interfaces_interfaces.xml",
XmlToCompositeNodeProvider.INSTANCE);
BrokerFacade brokerFacade = mock(BrokerFacade.class);
- when(brokerFacade.readOperationalData(any(InstanceIdentifier.class))).thenReturn(loadedCompositeNode);
+ when(brokerFacade.readOperationalData(any(YangInstanceIdentifier.class))).thenReturn(loadedCompositeNode);
assertEquals(loadedCompositeNode, brokerFacade.readOperationalData(null));
}
import org.opendaylight.controller.sal.restconf.impl.StructuredData;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
controllerContext.setSchemas(TestUtils.loadSchemaContext(modules));
- when(mockedBrokerFacade.commitConfigurationDataPut(any(InstanceIdentifier.class), any(CompositeNode.class)))
+ when(mockedBrokerFacade.commitConfigurationDataPut(any(YangInstanceIdentifier.class), any(CompositeNode.class)))
.thenReturn(
new DummyFuture.Builder().rpcResult(
new DummyRpcResult.Builder<TransactionStatus>().result(TransactionStatus.COMMITED)
import org.opendaylight.controller.sal.restconf.impl.InstanceIdWithSchemaNode;
import org.opendaylight.controller.sal.restconf.impl.RestconfDocumentedException;
import org.opendaylight.controller.sal.restconf.impl.RestconfImpl;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
} else {
when(mountInstance.getSchemaContext()).thenReturn(null);
}
- when(mountService.getMountPoint(any(InstanceIdentifier.class))).thenReturn(mountInstance);
+ when(mountService.getMountPoint(any(YangInstanceIdentifier.class))).thenReturn(mountInstance);
}
}
import org.opendaylight.controller.sal.rest.impl.XmlToCompositeNodeProvider;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-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.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeWithValue;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.SimpleNode;
public class XmlAndJsonToCnSnInstanceIdentifierTest extends YangAndXmlAndDataSchemaLoader {
private void verifyLeafListPredicate(CompositeNode cnSn) throws URISyntaxException {
SimpleNode<?> lf11 = getSnWithInstanceIdentifierWhenLeafList(cnSn);
Object value = lf11.getValue();
- assertTrue(value instanceof InstanceIdentifier);
+ assertTrue(value instanceof YangInstanceIdentifier);
- InstanceIdentifier instanceIdentifier = (InstanceIdentifier) value;
+ YangInstanceIdentifier instanceIdentifier = (YangInstanceIdentifier) value;
List<PathArgument> pathArguments = instanceIdentifier.getPath();
assertEquals(3, pathArguments.size());
String revisionDate = "2014-01-17";
private void verifyListPredicate(CompositeNode cnSn) throws URISyntaxException {
SimpleNode<?> lf111 = getSnWithInstanceIdentifierWhenList(cnSn);
Object value = lf111.getValue();
- assertTrue(value instanceof InstanceIdentifier);
+ assertTrue(value instanceof YangInstanceIdentifier);
- InstanceIdentifier instanceIdentifier = (InstanceIdentifier) value;
+ YangInstanceIdentifier instanceIdentifier = (YangInstanceIdentifier) value;
List<PathArgument> pathArguments = instanceIdentifier.getPath();
assertEquals(4, pathArguments.size());
String revisionDate = "2014-01-17";
import org.opendaylight.controller.sal.rest.doc.swagger.Resource;
import org.opendaylight.controller.sal.rest.doc.swagger.ResourceList;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifierWithPredicates;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
private static final String DATASTORES_LABEL = "Datastores";
private MountProvisionService mountService;
- private final Map<InstanceIdentifier, Long> instanceIdToLongId = new TreeMap<>(
- new Comparator<InstanceIdentifier>() {
+ private final Map<YangInstanceIdentifier, Long> instanceIdToLongId = new TreeMap<>(
+ new Comparator<YangInstanceIdentifier>() {
@Override
- public int compare(final InstanceIdentifier o1, final InstanceIdentifier o2) {
+ public int compare(final YangInstanceIdentifier o1, final YangInstanceIdentifier o2) {
return o1.toString().compareToIgnoreCase(o2.toString());
}
});
- private final Map<Long, InstanceIdentifier> longIdToInstanceId = new HashMap<>();
+ private final Map<Long, YangInstanceIdentifier> longIdToInstanceId = new HashMap<>();
private final Object lock = new Object();
private final AtomicLong idKey = new AtomicLong(0);
Map<String, Long> urlToId = new HashMap<>();
synchronized (lock) {
SchemaContext context = globalSchema.getGlobalContext();
- for (Entry<InstanceIdentifier, Long> entry : instanceIdToLongId.entrySet()) {
+ for (Entry<YangInstanceIdentifier, Long> entry : instanceIdToLongId.entrySet()) {
String modName = findModuleName(entry.getKey(), context);
urlToId.put(generateUrlPrefixFromInstanceID(entry.getKey(), modName),
entry.getValue());
this.globalSchema = globalSchema;
}
- private String findModuleName(final InstanceIdentifier id, final SchemaContext context) {
+ private String findModuleName(final YangInstanceIdentifier id, final SchemaContext context) {
PathArgument rootQName = id.getPathArguments().iterator().next();
for (Module mod : context.getModules()) {
if (mod.getDataChildByName(rootQName.getNodeType()) != null) {
return null;
}
- private String generateUrlPrefixFromInstanceID(final InstanceIdentifier key, final String moduleName) {
+ private String generateUrlPrefixFromInstanceID(final YangInstanceIdentifier key, final String moduleName) {
StringBuilder builder = new StringBuilder();
if (moduleName != null) {
builder.append(moduleName);
builder.append('/');
}
builder.append(name);
- if (arg instanceof InstanceIdentifier.NodeIdentifierWithPredicates) {
+ if (arg instanceof YangInstanceIdentifier.NodeIdentifierWithPredicates) {
NodeIdentifierWithPredicates nodeId = (NodeIdentifierWithPredicates) arg;
for (Entry<QName, Object> entry : nodeId.getKeyValues().entrySet()) {
builder.append('/').append(entry.getValue());
return builder.append('/').toString();
}
- private String getYangMountUrl(final InstanceIdentifier key) {
+ private String getYangMountUrl(final YangInstanceIdentifier key) {
String modName = findModuleName(key, globalSchema.getGlobalContext());
return generateUrlPrefixFromInstanceID(key, modName) + "yang-ext:mount/";
}
public ResourceList getResourceList(final UriInfo uriInfo, final Long id) {
- InstanceIdentifier iid = getInstanceId(id);
+ YangInstanceIdentifier iid = getInstanceId(id);
if (iid == null) {
return null; // indicating not found.
}
return list;
}
- private InstanceIdentifier getInstanceId(final Long id) {
- InstanceIdentifier instanceId;
+ private YangInstanceIdentifier getInstanceId(final Long id) {
+ YangInstanceIdentifier instanceId;
synchronized (lock) {
instanceId = longIdToInstanceId.get(id);
}
return instanceId;
}
- private SchemaContext getSchemaContext(final InstanceIdentifier id) {
+ private SchemaContext getSchemaContext(final YangInstanceIdentifier id) {
if (id == null) {
return null;
}
public ApiDeclaration getMountPointApi(final UriInfo uriInfo, final Long id, final String module, final String revision) {
- InstanceIdentifier iid = getInstanceId(id);
+ YangInstanceIdentifier iid = getInstanceId(id);
SchemaContext context = getSchemaContext(iid);
String urlPrefix = getYangMountUrl(iid);
if (context == null) {
}
@Override
- public void onMountPointCreated(final InstanceIdentifier path) {
+ public void onMountPointCreated(final YangInstanceIdentifier path) {
synchronized (lock) {
Long idLong = idKey.incrementAndGet();
instanceIdToLongId.put(path, idLong);
}
@Override
- public void onMountPointRemoved(final InstanceIdentifier path) {
+ public void onMountPointRemoved(final YangInstanceIdentifier path) {
synchronized (lock) {
Long id = instanceIdToLongId.remove(path);
longIdToInstanceId.remove(id);
import org.opendaylight.controller.sal.rest.doc.swagger.Resource;
import org.opendaylight.controller.sal.rest.doc.swagger.ResourceList;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
public class MountPointSwaggerTest {
private static final String HTTP_URL = "http://localhost/path";
- private static final InstanceIdentifier instanceId = InstanceIdentifier.builder()
+ private static final YangInstanceIdentifier instanceId = YangInstanceIdentifier.builder()
.node(QName.create("nodes"))
.nodeWithKey(QName.create("node"), QName.create("id"), "123").build();
private static final String INSTANCE_URL = "nodes/node/123/";
import java.util.Collections;
import org.opendaylight.controller.netconf.cli.writer.OutFormatter;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.ChoiceNodeBaseSerializer;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.NodeSerializerDispatcher;
protected NodeSerializerDispatcher<String> getNodeDispatcher() {
return dispatcher;
}
-}
\ No newline at end of file
+}
import com.google.common.base.Preconditions;
import com.google.common.collect.Iterables;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.schema.AugmentationNode;
import org.opendaylight.yangtools.yang.data.api.schema.ChoiceNode;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
@Override
public final Iterable<String> dispatchChildElement(final Object childSchema,
- final DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> dataContainerChild) {
+ final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
if (dataContainerChild instanceof ContainerNode) {
return onContainerNode(childSchema, dataContainerChild);
} else if (dataContainerChild instanceof LeafNode<?>) {
}
private Iterable<String> onAugmentationSchema(final Object childSchema,
- final DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> dataContainerChild) {
+ final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
checkSchemaCompatibility(childSchema, AugmentationSchema.class, dataContainerChild);
return factory.getAugmentationNodeSerializer().serialize((AugmentationSchema) childSchema,
(AugmentationNode) dataContainerChild);
}
private Iterable<String> onChoiceNode(final Object childSchema,
- final DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> dataContainerChild) {
+ final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
checkSchemaCompatibility(childSchema, org.opendaylight.yangtools.yang.model.api.ChoiceNode.class,
dataContainerChild);
return factory.getChoiceNodeSerializer().serialize(
}
private Iterable<String> onListNode(final Object childSchema,
- final DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> dataContainerChild) {
+ final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
checkSchemaCompatibility(childSchema, ListSchemaNode.class, dataContainerChild);
return factory.getMapNodeSerializer().serialize((ListSchemaNode) childSchema, (MapNode) dataContainerChild);
}
private Iterable<String> onLeafListNode(final Object childSchema,
- final DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> dataContainerChild) {
+ final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
checkSchemaCompatibility(childSchema, LeafListSchemaNode.class, dataContainerChild);
return factory.getLeafSetNodeSerializer().serialize((LeafListSchemaNode) childSchema,
(LeafSetNode<?>) dataContainerChild);
}
private Iterable<String> onLeafNode(final Object childSchema,
- final DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> dataContainerChild) {
+ final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
checkSchemaCompatibility(childSchema, LeafSchemaNode.class, dataContainerChild);
final Iterable<String> elements = factory.getLeafNodeSerializer().serialize((LeafSchemaNode) childSchema,
(LeafNode<?>) dataContainerChild);
}
private static void checkOnlyOneSerializedElement(final Iterable<?> elements,
- final DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> dataContainerChild) {
+ final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
final int size = Iterables.size(elements);
Preconditions.checkArgument(size == 1,
"Unexpected count of elements for entry serialized from: %s, should be 1, was: %s", dataContainerChild,
}
private Iterable<String> onContainerNode(final Object childSchema,
- final DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> dataContainerChild) {
+ final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
checkSchemaCompatibility(childSchema, ContainerSchemaNode.class, dataContainerChild);
final Iterable<String> elements = factory.getContainerNodeSerializer().serialize(
}
private static void checkSchemaCompatibility(final Object childSchema, final Class<?> containerSchemaNodeClass,
- final DataContainerChild<? extends InstanceIdentifier.PathArgument, ?> dataContainerChild) {
+ final DataContainerChild<? extends YangInstanceIdentifier.PathArgument, ?> dataContainerChild) {
Preconditions.checkArgument(containerSchemaNodeClass.isAssignableFrom(childSchema.getClass()),
"Incompatible schema: %s with node: %s, expected: %s", childSchema, dataContainerChild,
containerSchemaNodeClass);
}
-}
\ No newline at end of file
+}
import org.opendaylight.controller.netconf.cli.io.ConsoleIO;
import org.opendaylight.controller.netconf.cli.writer.OutFormatter;
import org.opendaylight.controller.netconf.cli.writer.WriteException;
-import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.Node;
import org.opendaylight.yangtools.yang.data.api.schema.DataContainerChild;
import org.opendaylight.yangtools.yang.data.impl.schema.transform.base.serializer.NodeSerializerDispatcher;
return null;
}
-}
\ No newline at end of file
+}