public static <T extends DataObject> Set<InstanceIdentifier<T>> collectTypeFromSet(Class<T> tClass, Set<InstanceIdentifier<?>> set) { Set<InstanceIdentifier<T>> result = Sets.newHashSet(); for (InstanceIdentifier<?> iid : set) { if (tClass.isAssignableFrom(iid.getTargetType())) { @SuppressWarnings("unchecked") final InstanceIdentifier<T> tIID = (InstanceIdentifier<T>) iid; result.add(tIID); } } return result; }
protected boolean isValidEntryContext(InstanceIdentifier<?> iid) { if (iid == null) { LOG.error("Failed to create Ird: Must provide an entry context"); return false; } if (!iid.getTargetType().equals(Context.class)) { LOG.error("Failed to create Ird: The entry context must point to a alto-resourcepool:context"); return false; } return true; }
@Override public <D extends DataObject & Identifiable<K>, K extends Identifier<D>> void addStructuralListReader(@Nonnull InstanceIdentifier<D> id, @Nonnull Class<? extends Builder<D>> builderType, @Nonnull List<K> staticKeys) { checkArgument(Identifiable.class.isAssignableFrom(id.getTargetType()), "Node %s is not keyed, use addStructuralReader()", id.getTargetType()); add(GenericListReader.createReflexive(id, builderType, staticKeys)); }
public BindingBrokerReader(final InstanceIdentifier<D> instanceIdentifier, final DataBroker dataBroker, final LogicalDatastoreType datastoreType, final Class<B> builderClass) { this.reflexiveReaderCustomizer = new ReflexiveReaderCustomizer<>(instanceIdentifier.getTargetType(), builderClass); this.instanceIdentifier = instanceIdentifier; this.dataBroker = dataBroker; this.datastoreType = datastoreType; }
private void processDeletedData( Map<InstanceIdentifier<?>, DataObject> originalData, Set<InstanceIdentifier<?>> deletedData) { for (InstanceIdentifier<?> iid : deletedData) { if (iid.getTargetType().equals(HostNode.class)) { hostNodeService.deleteHostNode((HostNode) originalData.get(iid)); } else if (iid.getTargetType().equals(Link.class)) { linkService.deleteLink((Link) originalData.get(iid)); } } } });
@Nonnull @Override @SuppressWarnings("unchecked") public Optional<? extends DataObject> read(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nonnull final ReadContext ctx) throws ReadFailedException { LOG.trace("{}: Reading : {}", this, id); checkArgument(id.getTargetType().equals(getManagedDataObjectType().getTargetType())); return readCurrent((InstanceIdentifier<D>) id, ctx); }
public void validate(@Nonnull InstanceIdentifier<?> iid, @Nonnull final DataObject dataObject, @Nonnull final Validator.Extent extent) throws ValidationException { checkNotNull(iid); checkNotNull(dataObject); validatorProvider.validate(iid.getTargetType(), dataObject, extent); }
@Override public <D extends DataObject> void addStructuralReader(@Nonnull InstanceIdentifier<D> id, @Nonnull Class<? extends Builder<D>> builderType) { // prevent case to submit structural reader for list, which would cause fail because target setter consumes // List<TargetType>, not Target type. If node is static list, addStructuralListReader should be used checkArgument(!Identifiable.class.isAssignableFrom(id.getTargetType()), "Structural readers cannot be used for keyed nodes[node type %s], use addStructuralListReader()", id.getTargetType()); add(GenericReader.createReflexive(id, builderType)); }
/** * Find next item in ID after provided type. */ @Nonnull public static InstanceIdentifier.PathArgument getNextId(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nonnull final InstanceIdentifier<? extends DataObject> type) { final Iterable<InstanceIdentifier.PathArgument> pathArguments = id.getPathArguments(); final int i = Iterables.indexOf(pathArguments, input -> input.getType().isAssignableFrom(type.getTargetType())); Preconditions.checkArgument(i >= 0, "Unable to find %s type in %s", type.getTargetType(), id); return Iterables.get(pathArguments, i + 1); }
@SuppressWarnings("unchecked") private void removeData(final Set<InstanceIdentifier<?>> removeData, final Map<InstanceIdentifier<?>, DataObject> originalData) { for (InstanceIdentifier<?> key : removeData) { if (clazz.equals(key.getTargetType())) { final InstanceIdentifier<T> ident = key.firstIdentifierOf(clazz); final DataObject removeValue = originalData.get(key); this.remove(ident, (T)removeValue); } } }
@SuppressWarnings("unchecked") private void removeData(final Set<InstanceIdentifier<?>> removeData, final Map<InstanceIdentifier<?>, DataObject> originalData) { for (InstanceIdentifier<?> key : removeData) { if (clazz.equals(key.getTargetType())) { final InstanceIdentifier<T> ident = key.firstIdentifierOf(clazz); final DataObject removeValue = originalData.get(key); this.remove(ident, (T)removeValue); } } }
/** * {@inheritDoc} */ @Override protected boolean isUpdated(VTenantChange ectx, ChangedData<?> data) { Class<?> type = data.getIdentifier().getTargetType(); VNodeChangeListener<?> listener = LISTENERS.get(type); return listener.isUpdated(data); }
InstanceIdentifierV3(final InstanceIdentifier<T> source) { pathArguments = source.pathArguments; targetType = source.getTargetType(); wildcarded = source.isWildcarded(); hash = source.hashCode(); }
@SuppressWarnings("unchecked") public static <D extends DataObject> InstanceIdentifier<D> appendTypeToId( final InstanceIdentifier<? extends DataObject> parentId, final InstanceIdentifier<D> type) { final InstanceIdentifier.PathArgument t = new InstanceIdentifier.Item<>(type.getTargetType()); return (InstanceIdentifier<D>) InstanceIdentifier.create(Iterables.concat( parentId.getPathArguments(), Collections.singleton(t))); }
@Override public boolean canProcess(@Nonnull final YangInstanceIdentifier identifier) { return !isRoot(identifier) && Identifiable.class.isAssignableFrom(identifierBinding(serializer(), identifier).getTargetType()); }
/** * Transform a keyed instance identifier into a wildcarded one, keeping keys except the last item. */ @SuppressWarnings("unchecked") public static <D extends DataObject> InstanceIdentifier<D> makeIidLastWildcarded(final InstanceIdentifier<D> id) { final InstanceIdentifier.Item<D> wildcardedItem = new InstanceIdentifier.Item<>(id.getTargetType()); final Iterable<InstanceIdentifier.PathArgument> pathArguments = id.getPathArguments(); return (InstanceIdentifier<D>) InstanceIdentifier.create( Iterables.concat( Iterables.limit(pathArguments, Iterables.size(pathArguments) - 1), Collections.singleton(wildcardedItem))); }
/** * Trim InstanceIdentifier at indexOf(type). */ @SuppressWarnings("unchecked") @Nonnull public static <D extends DataObject> InstanceIdentifier<D> cutId(@Nonnull final InstanceIdentifier<? extends DataObject> id, @Nonnull final InstanceIdentifier<D> type) { final Iterable<InstanceIdentifier.PathArgument> pathArguments = id.getPathArguments(); final int i = Iterables.indexOf(pathArguments, input -> input.getType().equals(type.getTargetType())); Preconditions.checkArgument(i >= 0, "ID %s does not contain %s", id, type); return (InstanceIdentifier<D>) InstanceIdentifier.create(Iterables.limit(pathArguments, i + 1)); }
public static <C extends DataObject & Identifiable<K>,K extends Identifier<C>, B extends Builder<C>> Reader<C, B> createReflexive( final InstanceIdentifier<C> id, Class<B> builderClass, final List<K> staticKeys) { return new GenericListReader<>(id, new ReflexiveListReaderCustomizer<>(id.getTargetType(), builderClass, staticKeys)); } }
private void onDataDeleted(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) { Set<InstanceIdentifier<?>> removed = change.getRemovedPaths(); for (InstanceIdentifier<?> eachPath : removed) { if (eachPath.getTargetType() == FlowCapableNodeConnectorStatisticsData.class) { String name = eachPath.firstKeyOf(NodeConnector.class, NodeConnectorKey.class).getId().getValue(); nodeStatisticData.remove(name); } } } });
@Override public boolean canProcess(@Nonnull YangInstanceIdentifier identifier) { return isRoot(identifier) || isContainer(identifierBinding(serializer(), identifier).getTargetType()); }