while (i < backingList.size()) {
                Element<T> candidate = backingList.get(i);
                if (candidate.isRealized()) {
                    List<T> collected = candidate.getValues();
                    int j = nextSubIndex + 1;
                    while (j < collected.size()) {
                        T value = collected.get(j);

      return failure();
    }

    auto perm1_value = llvm::dyn_cast<DenseElementsAttr>(perm1.getValue())
                           .getValues<int32_t>();
    auto perm2_value = llvm::dyn_cast<DenseElementsAttr>(perm2.getValue())
                           .getValues<int32_t>();

    llvm::SmallVector<int32_t> perm1_arr(perm1_value.begin(),
                                         perm1_value.end());

func (m *sharedMem) valueCopy() []byte {
	ref := m.valueRef()
	return bytes.Clone(ref)
}

// setValue copies the data in b into the shared memory buffer and sets
// the length. len(b) must be less than or equal to the capacity of the buffer
// (as returned by cap(m.value())).
func (m *sharedMem) setValue(b []byte) {
	v := m.valueRef()
	if len(b) > cap(v) {

        return name;
    }

    public void setName(final String name) {
        this.name = name;
    }

    public String getValue() {
        return value;
    }

    public void setValue(final String value) {
        this.value = value;
    }

    public boolean isValid() {
        if (StringUtil.isBlank(name) || (value == null)) {
            return false;
        }

        return true;

    } finally {
      function = null;
    }

    /*
     * If set()/setValue() throws an Error, we let it propagate. Why? The most likely Error is a
     * StackOverflowError (from deep transform(..., directExecutor()) nesting), and calling
     * setException(stackOverflowError) would fail:
     *
     * - If the stack overflowed before set()/setValue() could even store the result in the output

     *
     * @return 値
     */
    public T getValue() {
        return value;
    }

    /**
     * 値を設定します。
     *
     * @param value
     *            値
     */
    public void setValue(final T value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return value.toString();
    }

        return new OptionLessStringsJavadocOptionFileOption(Lists.newArrayList(value));
    }

    @Override
    public List<String> getValue() {
        return value;
    }

    @Override
    public void setValue(List<String> value) {
        if (value == null) {
            this.value.clear();
        } else {
            this.value = value;
        }
    }

    @Override

        Xpp3Dom t1s1 = new Xpp3Dom("topsub1");
        t1s1.setValue("t1s1Value");
        t1s1.setInputLocation("t1s1");

        t1.addChild(t1s1);

        // create the recessive DOM
        Xpp3Dom t2 = new Xpp3Dom("top");
        t2.setInputLocation("t2top");

        Xpp3Dom t2s1 = new Xpp3Dom("topsub1");
        t2s1.setValue("t2s1Value");
        t2s1.setInputLocation("t2s1");

        for (CommandLineOptionConfiguration config : commandLineOptionConfigurations) {
            if (options.hasOption(config.getLongOption())) {
                List<String> value = options.option(config.getLongOption()).getValues();
                applyTo(value, settings, Origin.forCommandLine(config.getLongOption()));
            }
        }
    }

    public abstract void applyTo(List<String> values, T settings, Origin origin);

  public final K getKey() {
    return key;
  }

  @Override
  @ParametricNullness
  public final V getValue() {
    return value;
  }

  @Override
  @ParametricNullness
  public final V setValue(@ParametricNullness V value) {
    throw new UnsupportedOperationException();
  }

  private static final long serialVersionUID = 0;