if attribute 'name' is mapped to a property, deserialize 'value' into that property
551920
function(name, value) {
      // try to match this attribute to a property (attributes are
      // all lower-case, so this is case-insensitive search)
      var name = this.propertyForAttribute(name);
      if (name) {
        // filter out 'mustached' values, these are to be
        // replaced with bound-data and are not yet values
        // themselves
        if (value && value.search(scope.bindPattern) >= 0) {
          return;
        }
        // get original value
        var currentValue = this[name];
        // deserialize Boolean or Number values from attribute
        var value = this.deserializeValue(value, currentValue);
        // only act if the value has changed
        if (value !== currentValue) {
          // install new value (has side-effects)
          this[name] = value;
        }
      }
    }
247737
function(name, value) {

        if ( typeof(name) == 'string' && /\./.test(name) ) {
            var keys        = name.split(/\./g)
                , newObj    = {}
                , str       = '{'
                , _count    = 0;

            for (var k = 0, len = keys.length; k<len; ++k) {
                str +=  "\""+ keys.splice(0,1)[0] + "\":{";

                ++_count;
                if (k == len-1) {
                    str = str.substr(0, str.length-1);
                    str += "\"_content_\"";
                    for (var c = 0; c<_count; ++c) {
                        str += "}"
                    }
                }
            }

            newObj = parseDataObject(JSON.parse(str), value);
            local._data = merge(local._data, newObj);

        } else if ( typeof(local._data[name]) == 'undefined' ) {
            local._data[name] = value
        }
    }
223173
def _deserialize(self, value, attr, obj):
        
        if value is None:
            return None

        try:
            attribute_elements = [attr_element.split(",") for attr_element in obj.getlist(attr)]
            attribute_params = [param for attr_param in attribute_elements for param in attr_param]

            return PrintableList(super(QueryStringList, self)._deserialize(attribute_params, attr, obj))
        except ValueError:
            raise ValidationError("Invalid query string list argument")
668495
function (node, name, value) {
    var propertyInfo = DOMProperty_1.getPropertyInfo(name);

    if (propertyInfo && DOMProperty_1.shouldSetAttribute(name, value)) {
      var mutationMethod = propertyInfo.mutationMethod;
      if (mutationMethod) {
        mutationMethod(node, value);
      } else if (shouldIgnoreValue(propertyInfo, value)) {
        DOMPropertyOperations.deleteValueForProperty(node, name);
        return;
      } else if (propertyInfo.mustUseProperty) {
        // Contrary to `setAttribute`, object properties are properly
        // `toString`ed by IE8/9.
        node[propertyInfo.propertyName] = value;
      } else {
        var attributeName = propertyInfo.attributeName;
        var namespace = propertyInfo.attributeNamespace;
        // `setAttribute` with objects becomes only `[object]` in IE8/9,
        // ('' + value) makes it output the correct toString()-value.
        if (namespace) {
          node.setAttributeNS(namespace, attributeName, '' + value);
        } else if (propertyInfo.hasBooleanValue || propertyInfo.hasOverloadedBooleanValue && value === true) {
          node.setAttribute(attributeName, '');
        } else {
          node.setAttribute(attributeName, '' + value);
        }
      }
    } else {
      DOMPropertyOperations.setValueForAttribute(node, name, DOMProperty_1.shouldSetAttribute(name, value) ? value : null);
      return;
    }

    {
      var payload = {};
      payload[name] = value;
      ReactInstrumentation.debugTool.onHostOperation({
        instanceID: ReactDOMComponentTree_1.getInstanceFromNode(node)._debugID,
        type: 'update attribute',
        payload: payload
      });
    }
  }
388740
function deserializeParameter(server, name, value, schema) {
    if (!schema) return value;

    const type = schemaType(schema);
    if (!type) server.log('req-params', 'Indeterminate schema type for parameter ' + name, schema);

    if (type === 'array') {
        const format = schema.hasOwnProperty('collectionFormat') ? schema.collectionFormat : 'csv';
        const delimiter = format === 'csv' ? ','
            : format === 'ssv' ? ' '
                : format === 'tsv' ? '\t'
                    : format === 'pipes' ? '|' : ',';
        value = value.split(delimiter);
        if (!schema.items) return value;
        return value.map(item => {
            return deserializeParameter(server, 'items for ' + name, item, schema.items);
        });

    } else if (type === 'boolean') {
        return !(value === 'false' || value === 'null' || value === '0' || value === '');

    } else if (type === 'integer' && rxInteger.test(value)) {
        return parseInt(value);

    } else if (type === 'number' && rxNumber.test(value)) {
        return parseFloat(value);

    } else {
        return value;
    }
}
858516
def deserialize(cls, string):
        """"""

        data = json.loads(string)
        for fieldname, value in data.items():
            data[fieldname] = getattr(cls, fieldname).cache_to_python(value)
        return cls(**data)
1258940
private void buildAttributeValueObject(final String name) {
	attrval.name = name;
	attrval.quality = AttrQuality.ATTR_VALID;
	attrval.time = new TimeVal();
	attrval.r_dim = new AttributeDim();
	attrval.w_dim = new AttributeDim();
	attrval.r_dim.dim_x = 1;
	attrval.r_dim.dim_y = 0;
	attrval.w_dim.dim_x = 0;
	attrval.w_dim.dim_y = 0;
	try {
	    attrval.value = ApiUtil.get_orb().create_any();
	} catch (final DevFailed e) {
	}

	final long now = System.currentTimeMillis();
	attrval.time.tv_sec = (int) (now / 1000);
	attrval.time.tv_usec = (int) (now - attrval.time.tv_sec * 1000) * 1000;
	attrval.time.tv_nsec = 0;
	attrval.err_list = null;
    }
1183547
def _deserialize(self, value, attr, data):
        """"""
        if not self.context.get('convert_dates', True) or not value:
            return value

        value = super(ArrowField, self)._deserialize(value, attr, data)
        timezone = self.get_field_value('timezone')
        target = arrow.get(value)

        if timezone and text_type(target.to(timezone)) != text_type(target):
            raise ValidationError(
                "The provided datetime is not in the "
                "{} timezone.".format(timezone)
            )

        return target
96614
def _from_dict(cls, values, value_filter, dictionary, allow_unset=True):
        """"""
        if not isinstance(dictionary, Mapping):
            raise TypeError('dictionary should be mapping')
        obj = cls(values, value_filter)
        values = obj.__values
        for name, value in dictionary.items():
            if not isinstance(name, string_types):
                raise TypeError('Key %s is not a string' % str(name))
            setattr(values, name, value)
        if obj.missing and not allow_unset:
            raise ValueError('%d value(s) are unset' % len(obj.missing))
        return obj
83971
def _deserialize(self, value, environment=None):
        

        if not isinstance(value, MappingABC):
            raise exc.Invalid(self)

        # traverse items and match against validated struct
        mapping = self._create_deserialize_type(value, environment)

        invalids = []

        for name, item in self:

            # deserialize each item
            try:
                mapping[name] = item.deserialize(
                    value.get(name, values.Undefined), environment
                )

            except exc.IgnoreValue:
                # just ignore this value
                pass

            except exc.Invalid as ex:
                # append this to the list of invalids, so we can return a complete overview of errors
                invalids.append(ex)

        if invalids:
            # on invalids this item is also ``Invalid``
            raise exc.InvalidChildren(self, invalids)

        return mapping
1274215
def _deserialize_value(val, raw: false)
      val = val.pack('C*')
      val = @desc.post_process(val) if !raw && @desc.read_processors?
      val
    end
257505
function (name, value) {
            /*  sanity check scenario  */
            if (typeof name === "undefined")
                throw _cs.exception("access", "no attribute name given");
            var obj = this.obj();
            if (obj === null)
                throw _cs.exception("access", "still no object attached");
            if (typeof obj[name] === "undefined")
                throw _cs.exception("access", "invalid attribute \"" + name + "\"");

            /*  access the attribute  */
            var value_old = obj[name];
            if (typeof value !== "undefined")
                obj[name] = value;
            return value_old;
        }
1060128
def _deserialize(cls, json_body, get_value_and_type):
        

        instance = cls()
        is_set = False
        properties = cls._get_property_names(instance)

        def get_property_detail(name):
            p = [p for p in instance._property_details if p.name == name or p.field_name == name]
            return None if len(p) == 0 else p[0]

        for k in json_body:
            field = json_body[k]
            pd = get_property_detail(k)
            pn = k if not pd else pd.to_property_name(k)
            if pn in properties:
                v, t = get_value_and_type(field)
                initial_value = getattr(instance, pn)
                value = instance._field_to_property(v, t, pd, initial_value)
                setattr(instance, pn, value)
                is_set = True

        return instance if is_set else None
1064088
function (name, opts) {
            var self = this;
            if (typeof name === 'string') {
                if (self.hasAttr(name)) {
                    // if attribute does not have default value, then set to undefined
                    return self.set(name, getDefAttrVal(self, name), opts);
                } else {
                    return self;
                }
            }
            opts = /**@type Object
         @ignore*/
            name;
            var attrs = self.getAttrs(), values = {};    // reset all
            // reset all
            for (name in attrs) {
                values[name] = getDefAttrVal(self, name);
            }
            self.set(values, opts);
            return self;
        }
272780
def _deserialize(self, value, attr, data):
        """"""
        value = super(SanitizedHTML, self)._deserialize(value, attr, data)
        return bleach.clean(
            value,
            tags=self.tags,
            attributes=self.attrs,
            strip=True,
        ).strip()
289365
function (name, value) {
    if (DOMProperty.isReservedProp(name)) {
      return false;
    }
    if ((name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {
      return false;
    }
    if (value === null) {
      return true;
    }
    switch (typeof value) {
      case 'boolean':
        return DOMProperty.shouldAttributeAcceptBooleanValue(name);
      case 'undefined':
      case 'number':
      case 'string':
      case 'object':
        return true;
      default:
        // function, symbol
        return false;
    }
  }
821904
def deserialize_property(value: Any) -> Any:
    
    if value == UNKNOWN:
        return None

    # ListValues are projected to lists
    if isinstance(value, struct_pb2.ListValue):
        return [deserialize_property(v) for v in value]

    # Structs are projected to dictionaries
    if isinstance(value, struct_pb2.Struct):
        return deserialize_properties(value)

    # Everything else is identity projected.
    return value