Sets the validated value from the input field and re-evaluates the module tree according to the input
541868
function () {
			var oModel = this._oDialog.getModel("view"),
				oControl = this._getControl("customDebugValue", this._DEBUG_MODULES_ID),
				oTreeResults;

			try {
				this._validateCustomDebugValue(oControl.getValue());
			} catch (oException)  {
				this._showError(oControl, oException.message);
				return;
			}

			// convert boolean string to boolean value
			if (oModel.getProperty("/CustomDebugMode") === "true") {
				oModel.setProperty("/CustomDebugMode", true);
			}
			if (oModel.getProperty("/CustomDebugMode") === "false") {
				oModel.setProperty("/CustomDebugMode", false);
			}

			// set validated value and update tree accordingly
			window["sap-ui-debug"] = oModel.getProperty("/CustomDebugMode");
			oTreeResults = this._treeHelper.toTreeModel(this._oModuleSystemInfo);
			oModel.setProperty("/DebugModules", [oTreeResults.tree]);

			// adopt tree depth to the deepest currently selected module
			this._getControl("tree", this._DEBUG_MODULES_ID).expandToLevel(Math.max(this._MIN_EXPAND_LEVEL_DEBUG_MODULES, oTreeResults.depth));

			this._updateTreeInfos();
		}
876795
function(scope, newValue) {
            if (!isAssignable) {
               throw new Error('Expression "' + input + '" is not assignable');
            }

            if (tree.a === 'idn') {
                json.set(scope, tree.v, newValue);
            } else if (tree.a === 'bnr') {
                json.set(evaluator(tree.l, scope), evaluator(tree.r, scope), newValue);
            }
        }
202414
function( value, allowAny ) {
		var parsed;
		if ( value !== "" ) {
			parsed = this._parse( value );
			if ( parsed !== null ) {
				if ( !allowAny ) {
					parsed = this._adjustValue( parsed );
				}
				value = this._format( parsed );
			}
		}
		this.element.val( value );
		this._refresh();
	}
554172
public function validate() : void
    {
        if (null === $this->is_valid) {
            if (null === $this->user_value && null !== $this->default_value) {
                // There is a preset value, and its not being changed
                $this->is_valid = true;
            } elseif (in_array($this->user_value, array_keys($this->options)) && !in_array($this->user_value,
                    $this->disabled)
            ) {
                $this->is_valid = true;
            } elseif ('' == $this->user_value && $this->addBlank && !in_array('', $this->disabled)) {
                $this->is_valid = true;
            } elseif (false == $this->validator) {
                // This field does not get validated
                $this->is_valid = true;
            } else {
                $this->is_valid = false;
                $this->error = 'The provided value is not valid. Please enter a valid value.';
            }
        }

        // Check if the input is different from the default value
        if ($this->is_valid && null !== $this->user_value) {
            $this->is_changed = ($this->default_value != $this->user_value);
        }
    }
1317614
public function validate() : void
    {
        if (null === $this->is_valid) {
            if (null === $this->user_value && null !== $this->default_value) {
                // There is a preset value, and its not being changed
                $this->is_valid = true;
            } elseif (null != $this->validator && false != $this->validator) {
                $validator = $this->validator;
                $valids = array();
                $all_valid = true;
                $pieces = explode(',', $this->user_value);
                foreach ($pieces as $piece) {
                    $result = $validator::quickValidate($piece, $this->constraints);
                    if (null !== $result) {
                        $valids[] = $result;
                    } else {
                        $all_valid = false;
                    }
                }
                $this->user_value = implode(',', $valids);
                $this->is_valid = $all_valid;
                if (!$all_valid) {
                    $this->error = 'The provided value is not valid. Please enter a valid value.';
                }
            } else {
                // This field does not get validated
                $this->is_valid = true;
            }
        }

        // Check if the input is different from the default value
        if ($this->is_valid && null !== $this->user_value) {
            $this->is_changed = ($this->default_value != $this->user_value);
        }
    }
1154252
function(item, fieldName) {
			if (fieldName === "FriendlyPath") { //$NON-NLS-0$
				// Just update the "is valid" column
				var rowNode = document.getElementById(this.myTree._treeModel.getId(item));
				var oldCell = lib.$(".isValidCell", rowNode); //$NON-NLS-0$
				var col_no = lib.$$array("td", rowNode).indexOf(oldCell); //$NON-NLS-0$
				var cell = this.renderer.getIsValidCell(col_no, item, rowNode);
				// replace oldCell with cell
				oldCell.parentNode.replaceChild(cell, oldCell);
			}
		}
362046
def validate(self, value):
        
        for validate in self.validates:
            value = validate(value)
        return value
146418
function ( fieldData ) {
            var fieldID    = fieldData.id
              , fieldMeta  = fieldData.meta
              , formValue  = this.props.value
              , fieldValue = getOrNull( fieldData.value, fieldID )
              , fieldErrs  = validate( fieldID, fieldMeta, fieldValue );

            this.props.onChange( merge( formValue, fieldData.value ),
                                 fieldData.value, 
                                 fieldErrs );
        }
977439
def validate_field(self, value):
        '''
        
        '''
        if self.choices:
            value = self.normalize_field(value)
            if value in self.choices:
                return None
            return _('Must be one of: %(choices)s') % {'choices': '; '.join(self.choices)}
        if self.default is not None:
            if value is None or value == '':
                value = self.default
        if self.required and (value is None or value == ''):
            return _('Required field')
3659
function() {
      var response = true;
      
      // Validate all the sub fields
      for (var i = 0 ; i < this.inputs.length ; i++) {
   	   var input = this.inputs[i];
   	   input.setClassFromState(); // update field classes (mark invalid fields...)
   	   var state = input.getState();
   	   if( state == inputEx.stateRequired || state == inputEx.stateInvalid ) {
   		   response = false; // but keep looping on fields to set classes
   	   }
      }
      return response;
   }
672657
def get_validated_object(self, field_type, value):
        
        if field_type.check_value(value) or field_type.can_use_value(value):
            data = field_type.use_value(value)
            self._prepare_child(data)
            return data
        else:
            return None
938213
def validate(self,value):
        '''
        
        '''
        super(ChoiceField,self).validate(value)

        try:
            get_template(value)
        except TemplateDoesNotExist:
            raise ValidationError(_('%s is not a valid template.' % value))
456794
def value_leaf(self, data, schema, tree):
        
        key, value = data
        schema_key, schema_value = schema

        if hasattr(schema_value, '__validator_leaf__'):
            return schema_value(value, tree)
        enforce(value, schema_value, tree, 'value')
521696
def valid(self, value, include_name=True):
		

		# Call the parent valid method and return the result
		return super(Tree, self).valid(value, include_name and [self._name] or [])
40304
public function set( $key, $value = null, $inputValidate = null )
    {

        // decide on the level of input validation
        if( $inputValidate === null ) {
            $inputValidate = static::$inputValidate;
        }

        // set a array / Symfony ParameterBag of properties
        if( is_array($key) || ( $key instanceof \Traversable ) ) {
            $numSet = 0;
            foreach( $key as $_key => $_value ) {
                $numSet += call_user_func( array($this,__FUNCTION__), $_key, $_value, $inputValidate ) ? 1 : 0;
            }
            return $numSet;
        }

        // readonly safety check
        if( $this->readOnlySafetyCheck() ) {
            return false;
        }

        // You can't set a objects id externally
        if( in_array( $key, static::$unsetableProperties ) ) {
            return false;
        }

        // late load. You can't set a property on a unloaded object
        $this->load();

        switch( true ) {

            // got key or we're configured to accept any inputs
            case $inputValidate === self::VALIDATE_DISABLE:
            case array_key_exists( $key, $this->data ):

                if( $value === '' ) {
                    $value = null;
                }

                // validate item ?
                // implementation undecided
                $callback = array( $this, "set_{$key}" );

                $value = is_callable( $callback )
                    ? call_user_func( $callback, $value, $inputValidate )
                    : $value
                    ;

                // anything changed?
                if( isset( $this->data[$key] ) and $this->data[$key] === $value ) {
                    return false;
                }

                $this->initalPropertySet( $key, $value );
                $this->data[$key] = $value;
                return true;

            // unknown property. Class configured to ignore.
            case $inputValidate === self::VALIDATE_STRIP:

                return false;

            // unknown property. Class configured for Exception.
            case $inputValidate === self::VALIDATE_EXCEPTION:

                throw new BadPropertyException( $key, $this, "set() VALIDATE_EXCEPTION." );

            // odd that we should have got this far.
            // debugging check - ensure $inputValidate is one of our allowed inputs
            case !in_array( $inputValidate, array( self::VALIDATE_DISABLE, self::VALIDATE_STRIP, self::VALIDATE_EXCEPTION ), true ):

                throw new \InvalidArgumentException("Bad argument `{$inputValidate}` argument passed to ->set(,,\$inputValidate);");
                return false;

        }

        return false;

    }
486443
function validateInputAsJson() {
  if (this.value) {
    try {
      JSON.parse(this.value);
      setValidationClasses(this, true);
    }
    catch(e) {
      setValidationClasses(this, false);
    }
  }
  else {
    setValidationClasses(this, false)
  }
}
862962
function(inputValue, ruleValue, attribute, callback) {
    var _this = this;
    this._setValidatingData(attribute, inputValue, ruleValue);
    if (typeof callback === 'function') {
      this.callback = callback;
      var handleResponse = function(passes, message) {
        _this.response(passes, message);
      };

      if (this.async) {
        return this._apply(inputValue, ruleValue, attribute, handleResponse);
      } else {
        return handleResponse(this._apply(inputValue, ruleValue, attribute));
      }
    }
    return this._apply(inputValue, ruleValue, attribute);
  }