/** * Create a builder rooted at this key. * * @return A builder instance */ public InstanceIdentifierBuilder<T> builder() { return new InstanceIdentifierBuilderImpl<>(Item.of(targetType), pathArguments, hash, isWildcarded()); }
@Override public final InstanceIdentifierBuilder<T> builder() { return new InstanceIdentifierBuilderImpl<>(IdentifiableItem.of(getTargetType(), key), pathArguments, hashCode(), isWildcarded()); }
/** * Create a builder rooted at this key. * * @return A builder instance */ public InstanceIdentifierBuilder<T> builder() { return new InstanceIdentifierBuilderImpl<T>(new Item<T>(targetType), pathArguments, hash, isWildcarded()); }
/** * {@inheritDoc} */ @Override protected InstanceIdentifier<FlowCapableNode> getWildcardPath() { return InstanceIdentifier.builder(Nodes.class).child(Node.class). augmentation(FlowCapableNode.class).build(); }
public InstanceIdentifier<Flows> apply() { InstanceIdentifierBuilder<? extends Object> _builder = InstanceIdentifier.builder(); InstanceIdentifierBuilder<Flows> _node = _builder.<Flows>node(Flows.class); InstanceIdentifier<Flows> _instance = _node.toInstance(); return _instance; } }.apply();
@SuppressWarnings("unchecked") public final <N extends Identifiable<K> & ChildOf<? super T>, K extends Identifier<N>> KeyedInstanceIdentifier<N, K> child( final Class<N> listItem, final K listKey) { final PathArgument arg = new IdentifiableItem<>(listItem, listKey); return (KeyedInstanceIdentifier<N, K>) childIdentifier(arg); }
@SuppressWarnings("unchecked") public final <N extends DataObject & Augmentation<? super T>> InstanceIdentifier<N> augmentation( final Class<N> container) { final PathArgument arg = new Item<>(container); return (InstanceIdentifier<N>) childIdentifier(arg); }
/** * Create an InstanceIdentifierBuilder for a specific type of InstanceIdentifier as specified by container. * * @param container Base container * @param <T> Type of the container * @return A new {@link InstanceIdentifierBuilder} * @throws NullPointerException if {@code container} is null */ public static <T extends ChildOf<? extends DataRoot>> InstanceIdentifierBuilder<T> builder( final Class<T> container) { return new InstanceIdentifierBuilderImpl<T>().addWildNode(Item.of(container)); }
@Override Object readResolve() throws ObjectStreamException { return new KeyedInstanceIdentifier<>(getTargetType(), getPathArguments(), isWildcarded(), getHash(), key); } }
/** * Create an InstanceIdentifier for a child container. This method is a more efficient equivalent to * {@code builder().child(container).build()}. * * @param container Container to append * @param <N> Container type * @return An InstanceIdentifier. * @throws NullPointerException if {@code container} is null */ public final <N extends ChildOf<? super T>> InstanceIdentifier<N> child(final Class<N> container) { return childIdentifier(Item.of(container)); }
@Override public <C extends ChoiceIn<? super T> & DataObject, N extends ChildOf<? super C>> InstanceIdentifierBuilder<N> child(final Class<C> caze, final Class<N> container) { return addWildNode(Item.of(caze, container)); }
@SuppressWarnings("unchecked") public final <N extends ChildOf<? super T>> InstanceIdentifier<N> child(final Class<N> container) { final PathArgument arg = new Item<>(container); return (InstanceIdentifier<N>) childIdentifier(arg); }
private static InstanceIdentifier<BridgeRefEntry> getBridgeRefEntryIdentifier(BridgeRefEntryKey bridgeRefEntryKey) { InstanceIdentifier.InstanceIdentifierBuilder<BridgeRefEntry> bridgeRefEntryInstanceIdentifierBuilder = InstanceIdentifier.builder(BridgeRefInfo.class) .child(BridgeRefEntry.class, bridgeRefEntryKey); return bridgeRefEntryInstanceIdentifierBuilder.build(); }