import javax.annotation.Nullable;

/**
 * Represents an element which belongs to some hierarchy.
 *
 * @since 1.0-milestone-5
 */
public interface HierarchicalElement extends Element {

    /**
     * Returns the parent of this element, or {@code null} if there is no parent.
     *
     * @return The parent of this element, or {@code null} if there is no parent.
     * @since 1.0-milestone-5
     */

/**
 * Represents an element in a model. Elements are arranged in a hierarchy.
 */
@Incubating
public interface ModelElement extends Named {
    /**
     * Returns the name of this element. Each element has a name associated with it, that uniquely identifies the element amongst its siblings.
     * Some element have their name generated or automatically assigned, and for these elements the name may not be human consumable.
     */

  @Override
  public int indexOf(@CheckForNull Object element) {
    return delegate().indexOf(element);
  }

  @Override
  public int lastIndexOf(@CheckForNull Object element) {
    return delegate().lastIndexOf(element);
  }

  @Override
  public ListIterator<E> listIterator() {
    return delegate().listIterator();
  }

  @Override
  public ListIterator<E> listIterator(int index) {

  // This reference is used both by the custom field serializer, and by the
  // GWT compiler to infer the elements of the lists that needs to be
  // serialized.
  //
  // Although this reference is non-final, it doesn't change after set creation.
  E element;

  SingletonImmutableSet(E element) {
    this.element = checkNotNull(element);
  }

  @Override
  public int size() {
    return 1;
  }

  @Override

    public IsolatedSet(ImmutableSet<Isolatable<?>> elements) {
        super(elements);
    }

    @Override
    public ValueSnapshot asSnapshot() {
        ImmutableSet.Builder<ValueSnapshot> builder = ImmutableSet.builderWithExpectedSize(elements.size());
        for (Isolatable<?> element : elements) {
            builder.add(element.asSnapshot());
        }
        return new SetValueSnapshot(builder.build());

/**
 * Represents a modifiable form of IvyExtraInfo so that "extra" info elements
 * can be configured on an Ivy publication.
 */
public interface IvyExtraInfoSpec extends IvyExtraInfo {

    /**
     * Puts the specified extra element into the list of extra info elements.
     *
     * @param namespace The namespace of the element to add
     * @param name The name of the element to add
     * @param value The value of the element to add
     */

     */
    @Input
    boolean isEnabled();

    /**
     * Sets element for the rule.
     *
     * @param element Element
     */
    void setElement(String element);

    /**
     * Gets the element for the rule as defined by

        @Mutate
        void connectElementToInput(MutableValue element, Integer input) {
            element.value = input
        }
    }

    def "by-type subject bindings are scoped to the scope of an inner rule"() {
        given:
        registry.registerInstance("element", new MutableValue())
            .registerInstance("input", 10)
            .registerInstance("values", "foo")

                 bool keep_slice_shape = false);

// Creates ops that copy the buffer and update an element at the given index.
// Requires `index` to have tensor<1xi32> type.
Value SetElement(Value index, Value buffer, Value element, OpBuilder builder,
                 Location loc);

// Creates the buffer for the data structure with given element shape, type and
// maximum size.
LogicalResult CreateInitBufferValue(ArrayRef<int64_t> element_shape,

 * according to when the first occurrence of the element was added. When the multiset contains
 * multiple instances of an element, those instances are consecutive in the iteration order. If all
 * occurrences of an element are removed, after which that element is added to the multiset, the
 * element will appear at the end of the iteration.
 *