Returns a hash of empty values for all the values that are in the given
 StripeObject.
500643
def empty_values(obj)
      values = case obj
               when Hash         then obj
               when StripeObject then obj.instance_variable_get(:@values)
               else
                 raise ArgumentError, "#empty_values got unexpected object type: #{obj.class.name}"
               end

      values.each_with_object({}) do |(k, _), update|
        update[k] = ""
      end
    end
806322
function isEmptyObject(obj) {
  if (isEmpty(obj) === true) {
    return true;
  }
  if (Object.getOwnPropertyNames(obj).length === 0) {
    //if (Object.keys(obj).length === 0 && Object.getOwnPropertyNames(obj).length === 0) {
    return true;
  }
  return false;
}
872772
function isEmpty(o) {
  for (var key in o) {
    if (o.hasOwnProperty(key)) {
      return false;
    }
  }
  return Object.getOwnPropertySymbols(o).length === 0;
}
561148
def filter_not_empty_values(value):
    """"""
    if not value:
        return None
    data = [x for x in value if x]
    if not data:
        return None
    return data
734705
def without(self, *values):
        
        if self._clean.isDict():
            newlist = {}
            for i, k in enumerate(self.obj):
                # if k not in values:  # use indexof to check identity
                if _(values).indexOf(k) is -1:
                    newlist.set(k, self.obj[k])
        else:
            newlist = []
            for i, v in enumerate(self.obj):
                # if v not in values:  # use indexof to check identity
                if _(values).indexOf(v) is -1:
                    newlist.append(v)

        return self._wrap(newlist)
530912
function _blank(obj) {
        var cache;

        if((cache = typeof obj) !== 'boolean' && (cache !== 'number' || isNaN(obj)) && !obj) return true;
        if(cache == 'string' && obj.replace(/\s/g, '').length === 0) return true;
        if(cache == 'object') {
          if((cache = toString.call(obj)) == '[object Array]' && obj.length === 0) return true;
          if(cache == '[object Object]') {
            for(cache in obj) {
              return false;
            }
            return true;
          }
        }
        return false;
      }
652591
public static <T> Set<T> nullToEmptySet(Set<T> newValue) {
    if (newValue == null) {
      return new HashSet<>();
    }
    return newValue;
  }
1332354
def values(self, key=_absent):
        
        if key is not _absent and key in self._map:
            return self.getlist(key)
        return list(self.itervalues())
1215271
def collect_values_with_count
		values = Hash.new {|h,k| h[k]=0}
		self.class.ecore.eAllAttributes.each do |a|
			v = self.send(:"#{a.name}")
			if v!=nil
				if a.many
					v.each {|el| values[el]+=1}
				else
					values[v]+=1
				end
			end
		end
		values			
	end
813258
function cleanDeep(object) {
  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
      _ref$emptyArrays = _ref.emptyArrays,
      emptyArrays = _ref$emptyArrays === undefined ? true : _ref$emptyArrays,
      _ref$emptyObjects = _ref.emptyObjects,
      emptyObjects = _ref$emptyObjects === undefined ? true : _ref$emptyObjects,
      _ref$emptyStrings = _ref.emptyStrings,
      emptyStrings = _ref$emptyStrings === undefined ? true : _ref$emptyStrings,
      _ref$nullValues = _ref.nullValues,
      nullValues = _ref$nullValues === undefined ? true : _ref$nullValues,
      _ref$undefinedValues = _ref.undefinedValues,
      undefinedValues = _ref$undefinedValues === undefined ? true : _ref$undefinedValues;

  return (0, _lodash6.default)(object, function (result, value, key) {
    // Recurse into arrays and objects.
    if (Array.isArray(value) || (0, _lodash4.default)(value)) {
      value = cleanDeep(value, { emptyArrays: emptyArrays, emptyObjects: emptyObjects, emptyStrings: emptyStrings, nullValues: nullValues, undefinedValues: undefinedValues });
    }

    // Exclude empty objects.
    if (emptyObjects && (0, _lodash4.default)(value) && (0, _lodash2.default)(value)) {
      return;
    }

    // Exclude empty arrays.
    if (emptyArrays && Array.isArray(value) && !value.length) {
      return;
    }

    // Exclude empty strings.
    if (emptyStrings && value === '') {
      return;
    }

    // Exclude null values.
    if (nullValues && value === null) {
      return;
    }

    // Exclude undefined values.
    if (undefinedValues && value === undefined) {
      return;
    }

    // Append when recursing arrays.
    if (Array.isArray(result)) {
      return result.push(value);
    }

    result[key] = value;
  });
}
175833
def fill_null_values(self):
        
        if not self.Model:
            log.info("%s has no model defined" % self.__class__.__name__)
            return

        empty_values = self.Model.get_null_values()
        for field, value in empty_values.items():
            if field not in self._json_params:
                self._json_params[field] = value
987314
def _blank(*objs):
    """"""
    for o in objs:
        if bool(o):
            return BooleanValue(False)
    return BooleanValue(True)
825532
def filter_empty_parameters(func):
    
    @wraps(func)
    def func_wrapper(self, *args, **kwargs):
        my_kwargs = {key: value for key, value in kwargs.items()
                     if value not in EMPTIES}
        args_is_empty = all(arg in EMPTIES for arg in args)

        if (
                {'source', 'material'}.issuperset(my_kwargs) or not my_kwargs
        ) and args_is_empty:
            return
        return func(self, *args, **my_kwargs)

    return func_wrapper
360066
def initialize_values( initial_values, results_hash )
      h = {}
      if initial_values && !initial_values.empty?
        initial_values.each do |k,v|
          h[k.to_s] = v
        end
      end
      
      IR.find_values( results_hash ).each do |i|
        if !i.empty?
          i.each do |k,v|
            h[k.to_s] = v
          end           
        end
      end
      
      h
    end
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;
}
1030234
function isEmpty(obj) {
    var empty = false;

    if (isFalsy(obj)) {
        empty = true;
    } else if (isArray(obj)) {
        empty = obj.length === 0;
    } else if (isObject(obj)) {
        empty = Object.keys(obj).length === 0;
    }

    return empty;
}
415527
function isEmpty(data) {
    if (Array.isArray(data)) {
        return data.length === 0;
    }
    return Object.keys(data).length === 0;
}