<code>optional string instance = 1;</code>
558129
public java.lang.String getInstance() {
    java.lang.Object ref = instance_;
    if (ref instanceof java.lang.String) {
      return (java.lang.String) ref;
    } else {
      com.google.protobuf.ByteString bs = 
          (com.google.protobuf.ByteString) ref;
      java.lang.String s = bs.toStringUtf8();
      if (bs.isValidUtf8()) {
        instance_ = s;
      }
      return s;
    }
  }
313945
public Optional<String> getString(String key) {
        return Optional.ofNullable(configuration.getString(key));
    }
2889
public void selectExample(final ExampleData example) {
		try {
			StringBuilder exampleName = new StringBuilder();
			if (example.getExampleGroupName() != null && !example.getExampleGroupName().equals("")) {
				exampleName.append(example.getExampleGroupName()).append(" - ");
			}
			exampleName.append(example.getExampleName());
			selectExample(example.getExampleClass().newInstance(), exampleName.toString());
		} catch (Exception e) {
			WMessages.getInstance(this).error("Error selecting example \"" + example.
					getExampleName() + '"');
			selectExample(new ErrorComponent(e.getMessage(), e), "Error");
		}
	}
1018623
public static PactDslRootValue stringType(String example) {
    PactDslRootValue value = new PactDslRootValue();
    value.setValue(example);
    value.setMatcher(TypeMatcher.INSTANCE);
    return value;
  }
1181604
@NotNull
    public static OptionalInt ofNullable(@Nullable Integer value) {
        return value == null ? EMPTY : new OptionalInt(value);
    }
1080035
function isInstanceOf(value, expectedInstance, message, id) {
    if (message === void 0) { message = ''; }
    if (id === void 0) { id = ''; }
    if (this.enabled && !(value instanceof expectedInstance)) {
        throw ValueException.unexpectedValue(assertionTypes.INSTANCE_OF, value, expectedInstance, message, id);
    }
}
781301
public static <T> Stringifier<T> checkInstance(Stringifier<T> stringifier) {
		return INSTANCE==stringifier?null:stringifier;
	}
137137
public static String requireNotEmpty(final String str) throws NullPointerException, IllegalArgumentException {
	if (str.length() == 0) {
	    throw new IllegalArgumentException();
	}
	return str;
    }
623917
public static <T> Optional<T> of(final T optionalValue) {   //NOPMD
        checkNotNull(optionalValue, "Optional value may not be null in method of");
        return new Optional<T>(optionalValue);
    }
1279783
public static <C> C getInstanceOf( Object argument,
                                       Class<C> expectedClass,
                                       String name ) {
        isInstanceOf(argument, expectedClass, name);
        return expectedClass.cast(argument);
    }
39947
public Object getInstanceOf(String key){

			try {
				ClassLoader loader = Thread.currentThread().getContextClassLoader();

				return Class.forName((String)classesMap.get(key),true,loader).newInstance();

			} catch (IllegalAccessException e) {
				logger.logp(Level.SEVERE,"JspClassFactory","getInstanceOf","jsp.error.function.classnotfound",(String) classesMap.get(key));
			} catch (InstantiationException e) {
				logger.logp(Level.SEVERE,"JspClassFactory","getInstanceOf","jsp.error.function.classnotfound",(String) classesMap.get(key));
			} catch (ClassNotFoundException e) {
				logger.logp(Level.SEVERE,"JspClassFactory","getInstanceOf","jsp.error.function.classnotfound",(String) classesMap.get(key));
			}
			return null;
	}
1212326
@javax.annotation.Nonnull
    public java.util.Optional<String> optionalText() {
        return java.util.Optional.ofNullable(mText);
    }
105993
@SuppressWarnings({"unchecked", "rawtypes"})
    protected Object constructFromString( final String stringValue, final String argumentName) {
        final Class clazz = getUnderlyingFieldClass();
        try {
            if (clazz.isEnum()) {
                try {
                    return Enum.valueOf(clazz, stringValue);
                } catch (final IllegalArgumentException e) {
                    throw new CommandLineException.BadArgumentValue(
                            argumentName,
                            stringValue,
                            String.format("'%s' is not a valid value for %s. Allowed values are %s",
                                    stringValue,
                                    clazz.getSimpleName(),
                                    getEnumOptions(clazz)));
                }
            }
            // Need to use getDeclaredConstructor() instead of getConstructor() in case the constructor
            // is non-public. Set it to be accessible if it isn't already.
            final Constructor<?> ctor = clazz.getDeclaredConstructor(String.class);
            ctor.setAccessible(true);
            return ctor.newInstance(stringValue);
        } catch (final NoSuchMethodException e) {
            // Shouldn't happen because we've checked for presence of ctor
            throw new CommandLineException.ShouldNeverReachHereException(
                    String.format("Cannot find string ctor for %s", clazz.getName()), e);
        } catch (final InstantiationException e) {
            throw new CommandLineException.CommandLineParserInternalException(
                    String.format("Abstract class '%s' cannot be used for an argument value type.", clazz.getSimpleName()), e);
        } catch (final IllegalAccessException e) {
            throw new CommandLineException.CommandLineParserInternalException(
                    String.format("String constructor for argument value type '%s' must be public.", clazz.getSimpleName()), e);
        } catch (final InvocationTargetException e) {
            throw new CommandLineException.BadArgumentValue(
                    argumentName,
                    stringValue,
                    String.format("Failure constructing '%s' from the string '%s'.", clazz.getSimpleName(), stringValue));
        }
    }
1237171
public static boolean isInstance(final @NonNull Optional<?> optional, final @NonNull Class<?> type) {
    return optional.isPresent() && type.isInstance(optional.get());
  }
45772
public static <V> Input<V> optional(@Nullable V value) {
    if (value == null) {
      return absent();
    } else {
      return fromNullable(value);
    }
  }
966575
public Optional<Integer> getInteger(String key) {
        Objects.requireNonNull(key, Required.KEY.toString());

        String value = this.values.get(key);
        if (StringUtils.isNotBlank(value) && NumberUtils.isCreatable(value)) {
            return Optional.of(Integer.valueOf(value));
        }

        return Optional.empty();
    }
639624
@Override
    public Pair<Optional<E1>, Optional<E2>> next() {
        return Pair.of(former.next(), latter.next());
    }