Update all attributes at charge_account. This method uses
 <tt>update_attribute!</tt> recurring for each attrubute.
 <tt>attrubutes_valies</tt> should be a hash with attribute and value to
 be updated.
428902
def update_attributes!(attributes_values)
      attributes_values.each do |attribute, value|
        update_attribute! attribute, value, false
      end
    ensure
      reload_attributes!
    end
1048994
def update_attributes(datas)
      search_attributes.each do |val|
        self.send("#{val.field}=", val.cast_value(datas[val.field]))
      end
    end
289301
def update
      self.resource = resource_class.to_adapter.get!(send(:"current_#{resource_name}").to_key)
      prev_unconfirmed_email = resource.unconfirmed_email if resource.respond_to?(:unconfirmed_email)

      if (resource.password? && resource.update_with_password(account_update_params)) ||
        (!resource.password? && resource.update_attributes(account_update_params))
        if is_navigational_format?
          flash_key = update_needs_confirmation?(resource, prev_unconfirmed_email) ?
            :update_needs_confirmation : :updated
          set_flash_message :notice, flash_key
        end
        sign_in resource_name, resource, :bypass => true
        respond_with resource, :location => after_update_path_for(resource)
      else
        clean_up_passwords resource
        respond_with resource
      end
    end
71011
def uniquify_attributes(attributes)
      attributes.each do |ka|
        oldval = send(ka)
        next unless String === oldval
        newval = UniquifierCache.instance.get(self, oldval)
        set_property_value(ka, newval)
        logger.debug { "Reset #{qp} #{ka} from #{oldval} to unique value #{newval}." }
      end
    end
1181877
def update(attrs)
      old_attrs = @attributes.dup
      Model.no_change_tracking do
        assign_all_attributes(attrs, false)

        validate!.then do |errs|
          if errs && errs.present?
            # Revert wholesale
            @attributes = old_attrs
            Promise.new.resolve(errs)
          else
            # Persist
            persist_changes(nil)
          end
        end
      end
    end
1322782
def update_attributes!(attributes)
      attributes.each { |attribute, value| write_attribute(attribute, value) }
      save!
    end
1161181
private void updateAttributesCache(String key, Attributes missAttrs, Attributes cachedAttrs) {
        final String METHODNAME = "updateAttributeCache(key,missAttrs,cachedAttrs)";
        if (missAttrs.size() > 0) {
            boolean newAttr = false; // differentiate between a new entry and an entry we'll update so we change the cache correctly and maintain the creation TTL.
            if (cachedAttrs != null) {
                cachedAttrs = (Attributes) cachedAttrs.clone();
            } else {
                cachedAttrs = new BasicAttributes(true);
                newAttr = true;
            }

            //Set extIdAttrs = iLdapConfigMgr.getExtIds();
            for (NamingEnumeration<?> neu = missAttrs.getAll(); neu.hasMoreElements();) {
                Attribute attr = (Attribute) neu.nextElement();
                // If the size of the attributes is larger than the limit, don not cache it.
                if (!(iAttrsSizeLmit > 0 && attr.size() > iAttrsSizeLmit)) {
                    cachedAttrs.put(attr);
                }
            }
            if (newAttr) {
                getAttributesCache().put(key, cachedAttrs, 1, iAttrsCacheTimeOut, 0, null);
            } else {
                getAttributesCache().put(key, cachedAttrs);
            }
            if (tc.isDebugEnabled()) {
                Tr.debug(tc, METHODNAME + " Update " + iAttrsCacheName + "(size: " + getAttributesCache().size() + " newEntry: " + newAttr + ")\n" + key + ": " + cachedAttrs);
            }
        }
    }
1065887
def salesforce_attributes_to_update(include_all = false)
      {}.tap do |hash|
        self.class.salesforce_sync_attribute_mapping.each do |key, value|
          if self.respond_to?(value)

            #Checkboxes in SFDC Cannot be nil.  Here we check for boolean field type and set nil values to be false
            attribute_value = self.send(value)
            if is_boolean?(value) && attribute_value.nil?
              attribute_value = false
            end

            hash[key] = attribute_value if include_all || salesforce_should_update_attribute?(value)
          end
        end
      end
    end
1134816
def update(attributes)
      load_attributes(
          Core::RestApi.instance.put(path, attributes, if_match_header))
    end
1323907
public boolean updateAttributes(final Collection<Attribute> attrToSend) {
		if (!this.sentAttrSpecifications) {
			log.error("Haven't sent type specifications yet, can't send solutions.");
			return false;
		}
		for (Iterator<Attribute> iter = attrToSend.iterator(); iter.hasNext();) {
			Attribute soln = iter.next();
			Integer solutionTypeAlias = this.attributeAliases.get(soln
					.getAttributeName());
			if (solutionTypeAlias == null) {
				log.error(
						"Cannot send solution: Unregistered attribute type: {}",
						soln.getAttributeName());
				iter.remove();
				continue;
			}
			soln.setAttributeNameAlias(solutionTypeAlias.intValue());
		}

		AttributeUpdateMessage message = new AttributeUpdateMessage();

		message.setCreateId(this.createIds);

		message.setAttributes(attrToSend.toArray(new Attribute[] {}));

		this.session.write(message);
		log.debug("Sent {} to {}", message, this);

		return true;
	}
387155
def update(self, attributes):
        
        for attribute in attributes:
            setattr(self, attribute, attributes[attribute])
        return self
598322
def update_attributes(self, id, old_attrs, new_attrs):
        
        update = dict()
        set_value = {'attributes.' + k: v for k, v in new_attrs.items() if v is not None}
        if set_value:
            update['$set'] = set_value
        unset_value = {'attributes.' + k: v for k, v in new_attrs.items() if v is None}
        if unset_value:
            update['$unset'] = unset_value

        if update:
            response = self.get_db().alerts.update_one({'_id': {'$regex': '^' + id}}, update=update)
            return response.matched_count > 0
1227027
def update_attributes(attr = {})
      attr.each_pair do |k, v|
        if v.is_a?(Array) || v.is_a?(Hash)
          send("#{k}=", v.dup)
        else
          send("#{k}=", v)
        end
      end
    end
1118541
def update_attributes(properties_hash)
      self.class.get_class_properties.each do |property|
        key = property[:name].to_sym
        if properties_hash.has_key? key
          self.setValue(properties_hash[key], forKey:key)
        end
      end
    end
1093889
def update_attribute(self, attr, value):
        """"""
        update = [fapi._attr_up(attr, value)]
        r = fapi.update_workspace_attributes(self.namespace, self.name,
                                             update, self.api_url)
        fapi._check_response_code(r, 200)
599907
def perform_update(self, data, instance):
        

        for key, val in data.items():
            setattr(instance, key, val)
358099
def update(attributes)
      assert_update_clean_only(:update)

      dirty_attributes = model.new(attributes).dirty_attributes
      dirty_attributes.empty? || all? { |resource| resource.update(attributes) }
    end