String value = options.option(config.getLongOption()).getValue();
                applyTo(value, settings, Origin.forCommandLine(config.getLongOption()));
            }
        }
    }

    private void applyTo(String value, T settings, Origin origin) {
        applyTo(getValue(value), settings, origin);
    }

    private E getValue(String value) {
        E enumValue = null;
        if (value != null) {

		return json.Marshal(this.IntVal.GetValue())
	}
	return json.Marshal(this.StrVal.GetValue())
}

func (this *IntOrString) UnmarshalJSONPB(_ *github_com_golang_protobuf_jsonpb.Unmarshaler, value []byte) error {
	return this.UnmarshalJSON(value)
}

func (this *IntOrString) ToKubernetes() intstr.IntOrString {
	if this.IntVal != nil {
		return intstr.FromInt32(this.GetIntVal().GetValue())
	}

    @Override
    String toString() {
        delegate.toString()
    }

    /**
     * @see TestStyledTextOutput#getValue()
     */
    String getValue() {
        return delegate.getValue()
    }

    @Override
    protected void doLineText(CharSequence text) {
        delegate.text(text)
    }

    @Override

      V oldValue = forwardDelegate.putIfAbsent(e.getKey(), e.getValue());
      if (oldValue != null) {
        throw conflictException("key", e.getKey() + "=" + oldValue, entryArray[i]);
      }
      K oldKey = backwardDelegate.putIfAbsent(e.getValue(), e.getKey());
      if (oldKey != null) {
        throw conflictException("value", oldKey + "=" + e.getValue(), entryArray[i]);
      }
    }

        linksOption.getValue().add(extDocUrl)

        when:
        linksOption.writeCollectionValue(writerContextMock)

        then:
        1 * writerContextMock.writeMultilineValuesOption(optionName, [extDocUrl])
    }

    def writeMultipleValues() {
        final String docUrl1 = "docUrl1"
        final String docUrl2 = "docUrl2"

        linksOption.getValue().add(docUrl1)

                return false;
            }
        }
        return true;
    }

    private boolean compareTrivialEntries(ChangeVisitor visitor, Map.Entry<String, S> previousEntry, Map.Entry<String, S> currentEntry, String propertyTitle) {
        S previous = previousEntry.getValue();
        S current = currentEntry.getValue();

// Test simple select.

package main

var counter uint
var shift uint

func GetValue() uint {
	counter++
	return 1 << shift
}

func Send(a, b chan uint) int {
	var i int

LOOP:
	for {
		select {
		case a <- GetValue():
			i++
			a = nil
		case b <- GetValue():
			i++
			b = nil
		default:
			break LOOP
		}
		shift++
	}
	return i
}

        try {
            writer.write("class " + className + " {");
            writer.write("    String getValue() { return \\"");
            String messageFromOptions = options.get("message");
            if (messageFromOptions == null) {
                writer.write(HelperUtil.getValue() + "${suffix}");
            } else {
                writer.write(messageFromOptions);
            }

        // Assign device to ops with device attribute that is empty.
        if (device_attr.getValue().empty()) {
          op->setAttr(kDeviceAttr,
                      builder.getStringAttr(func_device_attr.getValue()));
        }
      } else if (op->getDialect() == tf) {
        // Assign device to all ops in Tensorflow dialect that do not have
        // device attribute.
        op->setAttr(kDeviceAttr,

public abstract class ExecutionResult<T> {
    private static final Success<Void> SUCCESS = new Success<Void>() {
        @Override
        public Void getValue() {
            return null;
        }
    };

    /**
     * Returns the value, if available.
     */
    public abstract T getValue();

    /**
     * Returns the failures in this result, or an empty list if the operation was successful.
     */