if allowsEmpty, returns null for the case no key entry or null value
769627
public static CaptureStyle getCaptureStyleValue(Map<String, Object> yamlObject,
            String key, boolean allowsEmpty) throws YamlConvertException {
        Object obj = getObjectValue(yamlObject, key, allowsEmpty);
        if (obj == null && allowsEmpty) {
            return null;
        }
        String objStr;
        if (obj == null) {
            objStr = null;
        } else {
            objStr = obj.toString();
        }
        CaptureStyle result = CaptureStyle.getEnum(objStr);
        if (result != null) {
            return result;
        } else {
            throw new YamlConvertException(String.format(MSG_VALUE_NOT_CAPTURE_STYLE, key, objStr));
        }
    }
896652
@Override
    public boolean contains(@NonNull String key) {
        if (key == null) { throw new IllegalArgumentException("key cannot be null."); }

        synchronized (lock) {
            return !getMValue(internalDict, key).isEmpty();
        }
    }
76654
public boolean isEmpty() {
		return _name == null &&
			_description == null &&
			(_author == null || _author.isEmpty()) &&
			_copyright == null &&
			_links.isEmpty() &&
			_time == null &&
			_keywords == null &&
			_bounds == null;
	}
884047
protected void assertNotNullOrEmpty(String value, String message) throws IllegalArgumentException {
        if (value == null || value.length() == 0) {
            throw new IllegalArgumentException(message);
        }
    }
1256541
public void containsEntry(@NullableDecl Object key, @NullableDecl Object value) {
    Entry<Object, Object> entry = Maps.immutableEntry(key, value);
    if (!actual().entrySet().contains(entry)) {
      List<Object> keyList = Lists.newArrayList(key);
      List<Object> valueList = Lists.newArrayList(value);
      if (hasMatchingToStringPair(actual().keySet(), keyList)) {
        failWithoutActual(
            simpleFact(
                lenientFormat(
                    "Not true that %s contains entry <%s (%s)>. However, it does contain keys "
                        + "<%s>.",
                    actualAsString(),
                    entry,
                    objectToTypeName(entry),
                    countDuplicatesAndAddTypeInfo(
                        retainMatchingToString(actual().keySet(), keyList /* itemsToCheck */)))));
      } else if (hasMatchingToStringPair(actual().values(), valueList)) {
        failWithoutActual(
            simpleFact(
                lenientFormat(
                    "Not true that %s contains entry <%s (%s)>. However, it does contain values "
                        + "<%s>.",
                    actualAsString(),
                    entry,
                    objectToTypeName(entry),
                    countDuplicatesAndAddTypeInfo(
                        retainMatchingToString(actual().values(), valueList /* itemsToCheck */)))));
      } else if (actual().containsKey(key)) {
        Object actualValue = actual().get(key);
        /*
         * In the case of a null expected or actual value, clarify that the key *is* present and
         * *is* expected to be present. That is, get() isn't returning null to indicate that the key
         * is missing, and the user isn't making an assertion that the key is missing.
         */
        StandardSubjectBuilder check = check("get(%s)", key);
        if (value == null || actualValue == null) {
          check = check.withMessage("key is present but with a different value");
        }
        // See the comment on IterableSubject's use of failEqualityCheckForEqualsWithoutDescription.
        check.that(actualValue).failEqualityCheckForEqualsWithoutDescription(value);
      } else if (actual().containsValue(value)) {
        Set<Object> keys = new LinkedHashSet<>();
        for (Entry<?, ?> actualEntry : actual().entrySet()) {
          if (Objects.equal(actualEntry.getValue(), value)) {
            keys.add(actualEntry.getKey());
          }
        }
        failWithoutActual(
            simpleFact(
                lenientFormat(
                    "Not true that %s contains entry <%s>. "
                        + "However, the following keys are mapped to <%s>: %s",
                    actualAsString(), entry, value, keys)));
      } else {
        failWithActual("expected to contain entry", entry);
      }
    }
  }
1088511
public static boolean isEmpty(Object value) {
		return (null == value || (value instanceof String && StrUtil.isEmpty((String) value)));
	}
1101697
function isEmpty (val) {
  if (null == val) return true;
  if ('number' == typeof val) return 0 === val;
  if (undefined !== val.length) return 0 === val.length;
  for (var key in val) if (has.call(val, key)) return false;
  return true;
}
594651
public static boolean isEmpty(String aString)  {
    	boolean result = true;
    	if (aString != null && aString.trim().length()>0) { 
    		if (!aString.trim().toUpperCase().equals("NULL")) { 
    		   result = false;
    		}
    	}
    	return result;
    }
369671
private void setNonEmptyStringParameter(String key, String value){
        if (value == null){
            parameters.remove(key);
        }
        else if (value.length() == 0){
            throw new IllegalArgumentException("Value cannot be empty.");
        }
        else{
            parameters.put(key, value);
        }
    }
1097144
function get(name) {
    validateArgumentsLength(arguments.length, 1);
    var entries = getInternalParamsState(this).entries;
    var key = name + '';
    var i = 0;
    for (; i < entries.length; i++) if (entries[i].key === key) return entries[i].value;
    return null;
  }
1334867
def put_if_empty(self, key, value):
        
        if self.has_data_for_key(key):
            return False
        self.put_data(key, value)
        return True
520822
public boolean isEmpty(Transaction transaction)
                    throws ObjectManagerException
    {
        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.entry(this, cclass,
                        "isEmpty",
                        "Transaction=" + transaction);

        boolean empty = true; // Empty status to return.
        for (int i = 0; i < subLists.length; i++) {
            if (!subLists[i].isEmpty(transaction)) {
                empty = false;
                break;
            }
        } // for subLists.

        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.exit(this, cclass,
                       "size",
                       "return=" + empty);
        return empty;
    }
187068
public static String notEmptyIfNotNull(String value, String name, String info) {
        if (value == null) {
            return value;
        }

        if (value.trim().length() == 0) {
            throw new IllegalArgumentException(name + " cannot be empty" + (info == null ? "" : ", " + info));
        }
        return value.trim();
    }
141635
function isEmpty() {
        if (_valueType === 'string') {
            _valid = _valid && _value === '';
        } else if (_valueType instanceof Array) {
            _valid = _valid && _value.length === 0;
        }
        return _guard;
    }
1020130
public static boolean isEmpty(String value) {
		int strLen;
		if (value == null || (strLen = value.length()) == 0) {
			return true;
		}
		for (int i = 0; i < strLen; i++) {
			if ((Character.isWhitespace(value.charAt(i)) == false)) {
				return false;
			}
		}
		return true;
	}
566588
function isEmpty(str) {
            if (null === str || typeof str === 'undefined') {
                return true;
            }

            if (typeof str === 'string') {
                return (0 === str.length);
            }

            if (typeof str === 'object' && Array.isArray(str)) {
                return (0 === str.length);
            }

            return false;
        }
210792
public static boolean isEmpty(final String str, final boolean trim) {
	if (!trim) return isEmpty(str);
	return str == null || str.trim().length() == 0;
    }