Returns the provided value or null if the value is empty.

@see  #isEmpty(java.lang.Object)
196463
public static <T> T nullIfEmpty(T value) throws IOException {
		return isEmpty(value) ? null : value;
	}
1043709
@Override
    public boolean isEmpty() {
        try {
            // we use this lock to make
            smartLock.readLock().acquire();

            if (currentConsumers.get() > 0)
                synchronize(currentConsumers.get());

            return super.isEmpty();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            smartLock.readLock().release();
        }
    }
202377
function isEmpty(val) {
  return _.isNull(val) || _.isUndefined(val) || _.isNaN(val) || helper.isBlank(val);
}
117279
public boolean isEmpty(String... specialValueAsEmpty) {
		if (Strings.isNullOrEmpty(delegate.get())) {
			return true;
		}
		
		if (null == specialValueAsEmpty || specialValueAsEmpty.length < 1) {
			return false;
		}
		
		if (Gather.from(Arrays.asList(checkNotNull(specialValueAsEmpty))).filter(new Decision<String>(){
			@Override public boolean apply(String input) {
				return isEqual(input, delegate.get());
			}
		}).noneNullList().size() > 0) {
			return true;
		}
		
		return Decisions.isEmpty().apply(delegate.get());
	}
813746
public function isEmpty(): bool
    {
        return $this->isNull()
            || (is_array($this->value) && count($this->value) === 0)
            || (is_string($this->value) && strlen($this->value) === 0);
    }
881502
public final BooleanExpression isEmpty() {
        if (empty == null) {
            empty = Expressions.booleanOperation(Ops.COL_IS_EMPTY, mixin);
        }
        return empty;
    }
707669
@SuppressWarnings("rawtypes")
    public boolean isInputEmpty() {

        final Object fieldValue = getValue();
        final Class<?> fieldType = getType();

        if(fieldValue == null) {
            return true;

        } else if(Collection.class.isAssignableFrom(fieldType) && ((Collection) fieldValue).isEmpty()) {
            return true;

        } else if(fieldType.isArray()) {

            Class<?> componentType = fieldType.getComponentType();
            int length = Utils.getArraySize(fieldValue, componentType);
            if(length > 0) {
                return false;
            }

            return true;

        }

        return super.isInputEmpty();
    }
1111865
public static String nullIfEmpty(String value) {
		return value==null || value.isEmpty() ? null : value;
	}
539789
@JsonIgnore
    public boolean isEmpty() {
        if (!Strings.isNullOrEmpty(formatted)) {
            return false;
        }

        if (!Strings.isNullOrEmpty(familyName)) {
            return false;
        }

        if (!Strings.isNullOrEmpty(givenName)) {
            return false;
        }

        if (!Strings.isNullOrEmpty(middleName)) {
            return false;
        }

        if (!Strings.isNullOrEmpty(honorificPrefix)) {
            return false;
        }

        if (!Strings.isNullOrEmpty(honorificSuffix)) {
            return false;
        }

        return true;
    }
6539
function isEmpty(value) {
	if (Array.isArray(value)) {
		// If first item in array is undefined, we assume there are no parameters
		// This happens as a result of using the rest operator in a mixin
		return value.length === 0 || value[0] === undefined;
	}

	return value === undefined;
}
1358391
function isEmpty(val) {
    return (isUndefined(val) ||
        isNull(val) ||
        (isString(val) && val.length === 0) ||
        (isNumber(val) && isNaN(val)) ||
        (isPlainObject(val) && !array_1.keys(val).length) ||
        (isArray(val) && !val.length));
}
1099683
public boolean isEmpty()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
    {
      SibTr.entry(this, tc, "isEmpty");
      SibTr.exit(tc, "isEmpty", new Object[] {Boolean.valueOf(streamSets.isEmpty()), 
          Boolean.valueOf(flushedStreamSets.isEmpty()),streamSets, this});
    }

    // Don't report empty until any pending flushes have completed.
    // Otherwise we may run into a race with an async delete thread
    // for the destination.
    return (streamSets.isEmpty() && flushedStreamSets.isEmpty());
  }
786434
public boolean isEmpty() {
        return (newTopicPool == null ? true : newTopicPool.isEmpty()) && (updatedTopicPool == null ? true : updatedTopicPool.isEmpty());
    }
575511
function isEmpty (val) {
  if (val === 0) return true;
  if (Number.isNaN(val)) return true;
  return !_.isNumber(val) && _.isEmpty(val);
}
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;
    }
396574
public boolean isEmpty() {
		return _name == null &&
			_comment == null &&
			_description == null &&
			_source == null &&
			_links.isEmpty() &&
			_number == null &&
			_points.isEmpty();
	}
422500
public boolean isEmpty() {
		switch(size()) {
			case 0:
				return true;
			case 1:
				Element element = (Element) arrayList.get(0);
				switch (element.type()) {
					case Element.CHUNK:
						return ((Chunk) element).isEmpty();
					case Element.ANCHOR:
					case Element.PHRASE:
					case Element.PARAGRAPH:
						return ((Phrase) element).isEmpty();
					case Element.LIST:
						return ((List) element).isEmpty();
				}
			return false;
			default:
				return false;
		}
	}