This was overridden to have our own ``empty_values``.
177584
def validate(self, value):
        
        if value in self.empty_values and self.required:
            raise ValidationError(self.error_messages['required'])
1268256
def clean(self):
        
        for key, value in self.values.copy().items():
            if value is None:
                del self.values[key]
242202
public static String[] removeEmpties(final String... values) {
		if (values == null || values.length == 0){
			return new String[0];
		}
		List<String> validValues = new ArrayList<String>();
		for (String value : values){
			if (value != null && value.length() > 0){
				validValues.add(value);
			}
		}
		return validValues.toArray(new String[validValues.size()]);
	}
293596
public static List<String> filterEmptyValues( List<String> values ) {

		List<String> result = new ArrayList<> ();
		for( String s : values ) {
			if( ! Utils.isEmptyOrWhitespaces( s ))
				result.add( s );
		}

		return result;
	}
975670
@Override
  public final void clearCachedValues() {
    super.clearCachedValues();

    if (subTypes != null) {
      for (FunctionType subType : subTypes) {
        subType.clearCachedValues();
      }
    }

    if (!isNativeObjectType()) {
      if (hasInstanceType()) {
        getInstanceType().clearCachedValues();
      }

      if (prototypeSlot != null) {
        ((ObjectType) prototypeSlot.getType()).clearCachedValues();
      }
    }
  }
897718
def set_if_empty(self, param, default):
        
        if not self.has(param):
            self.set(param, default)
1274451
public void clear()
  {
    for (int i = 0; i < _values.length; i++) {
      _keys[i] = null;
      _values[i] = 0;
    }
    
    _size = 0;
  }
125367
def reset(self):
        
        for i in range(len(self.values)):
            self.values[i].delete(0, tk.END)

            if self.defaults[i] is not None:
                self.values[i].insert(0, self.defaults[i])
686354
function (mixedVar) {

            var emptyValues = [undefined, null, false, 0, "", "0"],
                i, length;

            for (i = 0, length = emptyValues.length; i < length; i++) {
                if (mixedVar === emptyValues[i]) {
                    return true;
                }
            }

            if (typeof mixedVar === "object") {
                if ($this.count(mixedVar) === 0) {
                    return true;
                }
            }

            return false;
        }
1235735
public void exp() {
        for (int c=0; c<this.values.length; c++) {
            this.values[c] = s.exp(this.values[c]);
        }
    }
753838
def _empty_value(self, formattype):
        '''
            
        '''
        if formattype.value.idx <= FormatType.BIN_32.value.idx:  # @UndefinedVariable
            return b''
        elif formattype.value.idx <= FormatType.FIXSTR.value.idx:  # @UndefinedVariable  
            return ''
        elif formattype.value.idx <= FormatType.INT_64.value.idx:  # @UndefinedVariable
            return 0
        elif formattype.value.idx <= FormatType.UINT_64.value.idx:  # @UndefinedVariable
            return 0
        elif(formattype is FormatType.FLOAT_32):
            return float(0)
        elif(formattype is FormatType.FLOAT_64):
            return float(0)
1250603
def set_if_empty(*keys, value: nil, &block)
      return unless deep_find(@settings, keys.last.to_s).nil?
      block ? set(*keys, &block) : set(*keys, value: value)
    end
224557
def _validate_empty_attributes(self, attributes):
        """"""
        attrs_to_check = set(self._required) & set(attributes)
        for attr in attrs_to_check:
            value = getattr(self, attr)  # We should always have a value here
            if value is None or value == "":
                raise ValueError(
                    "Attribute %s cannot be None or an empty string since it is required." % attr
                )
503743
function(values) {
      if (!this.isMultiValue) {
        throw new Error(
          this.name + ': does not not support mulitValue.\n' +
          'override isMultiValue'
        );
      }

      var len = values.length;
      var i = 0;
      this.removeAllValues();

      if (len > 0 &&
          typeof(values[0]) === 'object' &&
          'icaltype' in values[0]) {
        this.resetType(values[0].icaltype);
      }

      if (this.isDecorated) {
        for (; i < len; i++) {
          this._setDecoratedValue(values[i], i);
        }
      } else {
        for (; i < len; i++) {
          this.jCal[VALUE_INDEX + i] = values[i];
        }
      }
    }
968786
public Values<V> values () {
		if (values == null)
			values = new Values(this);
		else
			values.reset();
		return values;
	}
1017571
protected final void doValues(final Map<K, ? extends V> entries) {
        apply(entries.isEmpty() ? Nop.instance() : new Values<>(entries));

    }
338543
def flags=(values)
      val = 0
      FRAME_FLAGS_MAP.values_at(*values).each { |c|
        val |= c if c
      }
      @flags_value = val
    end