Save the values of those |ChangeItem| objects which are
        handling |Parameter| objects.
546165
def GET_save_parameteritemvalues(self) -> None:
        """"""
        for item in state.parameteritems:
            state.parameteritemvalues[self._id][item.name] = item.value.copy()
246967
private void handleChange(Object propertyId) {

        if (!m_saveBtn.isEnabled()) {
            m_saveBtn.setEnabled(true);
            m_saveExitBtn.setEnabled(true);
        }
        m_model.handleChange(propertyId);

    }
844450
public void onSaveItems(ItemStateChangesLog itemStates)
   {
      try
      {
         ChangesItem changesItem = new ChangesItem();

         for (ItemState state : itemStates.getAllStates())
         {
            if (!state.getData().isNode())
            {
               String nodePath = getPath(state.getData().getQPath().makeParentPath());

               Set<String> parentsWithQuota = quotaPersister.getAllParentNodesWithQuota(rName, wsName, nodePath);

               for (String parent : parentsWithQuota)
               {
                  changesItem.updateNodeChangedSize(parent, state.getChangedSize());
                  addPathsWithAsyncUpdate(changesItem, parent);
               }

               changesItem.updateWorkspaceChangedSize(state.getChangedSize());
            }
            else
            {
               addPathsWithUnknownChangedSize(changesItem, state);
            }
         }

         validatePendingChanges(changesItem);
         pendingChanges.set(changesItem);
      }
      catch (ExceededQuotaLimitException e)
      {
         throw new IllegalStateException(e.getMessage(), e);
      }
   }
547612
def save(self, obj):
        """"""
        if not obj.id:
            obj.id = uuid()

        stored_data = {
            'id': obj.id,
            'value': obj.to_data()
        }

        index_vals = obj.indexes() or {}
        for key in obj.__class__.index_names() or []:
            val = index_vals.get(key, '')
            stored_data[key] = DynamoMappings.map_index_val(val)

        table = self.get_class_table(obj.__class__)
        item = Item(table, data=stored_data)

        item.save(overwrite=True)
900806
function update(v, i, params, {oldValue}) {
      switch (i) {
      case 'children': _unobserveChildren(oldValue); _observeChildren(v); break;
      case 'attrs':    _unobserveAttrs   (oldValue); _observeAttrs   (v); break;
      }
    }
7307
def save(self, obj):
        """"""
        cur = self._conn().cursor()

        tabname = obj.__class__.get_table_name()

        index_names = obj.__class__.index_names() or []

        col_names = ['id', 'value'] + index_names
        value_holders = ['%s'] * len(col_names)
        updates = ['%s = EXCLUDED.%s' % (cn, cn) for cn in col_names[1:]]

        if not obj.id:
            id = uuid()
            obj.id = id

        query = 'insert into {0} ({1}) values ({2}) on conflict(id) do update set {3};'.format(
            tabname,
            ','.join(col_names),
            ','.join(value_holders),
            ','.join(updates),
        )

        values = [obj.id, obj.to_data()]

        index_vals = obj.indexes() or {}
        values += [index_vals.get(name, 'NULL') for name in index_names]

        with self._conn() as conn:
            with conn.cursor() as cur:
                cur.execute(query, tuple(values))
859816
def GET_savedmodifiedconditionitemvalues(self) -> None:
        """"""
        dict_ = state.modifiedconditionitemvalues.get(self._id)
        if dict_ is None:
            self.GET_conditionitemvalues()
        else:
            for name, value in dict_.items():
                self._outputs[name] = value
751376
public void transferItem() {
    Metadata metadata = metadatas.get(index);
    List<?> values = (List<?>) ((List<?>) context.get("items")).get(index);
    getWriter().writeTitle(metadata.dataName, metadata.titles);
    Object[] propValues = new Object[metadata.attrs.length];
    for (Object item : values) {
      for (int i = 0; i < propValues.length; i++) {
        try {
          propValues[i] = propertyExtractor.getPropertyValue(item, metadata.attrs[i]);
        } catch (Exception e) {
          transferResult.addFailure(TransferMessage.ERROR_ATTRS_EXPORT,
              "occur in get property :" + metadata.attrs[i] + " and exception:" + e.getMessage());
        }
      }
      writer.write(propValues);
    }
  }
174029
function(data) { 
			if (data && data.handler.changedItem) {
				data.handler.changedItem();
			} else { 
				explorer.changedItem(); 
			}
		}
703787
void changedValue(Object value) {
		Object oldValue = super.putSilent(VALUE, value);
		if (!Objects.equals(oldValue, value)) {
			fireChange();
		}
	}
110079
function processItemprop(item, processedItems) {
  var property, value, itemtypeHtml, currentItem;

  itemtypeHtml = $(item).parents("[itemtype]").html();

  if (itemtypeHtml) {
    property = $(item).attr('itemprop');
    value    = getPropValue(item);

    currentItem   = arraySearch(processedItems, md5(itemtypeHtml));

    if (currentItem.properties[property]) {
      if (!Array.isArray(currentItem.properties[property])) {
        currentItem.properties[property] = [currentItem.properties[property]];
      }
      currentItem.properties[property].push(value);
    } else {
      currentItem.properties[property] = value;
    }
  }
}
757700
def save_to(self, obj):
        
        if isinstance(obj, dict):
            obj = dict(obj)

        for key in self.changed_fields:
            if key in self.cleaned_data:
                val = self.cleaned_data.get(key)
                set_obj_value(obj, key, val)
        return obj
414219
public synchronized void save() {
        SharedPreferences prefs = loadSharedPreferences("object");

        if (find(getId()) == null) {
            addObject();

            modelListenerHandler.execOnUpdateListeners(this, OnUpdateListener.Status.CREATED);

            if (cache && cachedObjects != null) {
                cachedObjects.add((T) this);
            }
        } else {
            modelListenerHandler.execOnUpdateListeners(this, OnUpdateListener.Status.UPDATED);
        }

        prefs.edit().putString(String.valueOf(getId()), toJson().toString()).commit();
    }
469670
@Override
    public void configurationChanged() {

        HashSet<Param> changedParams = new HashSet();

        // read dynamic parameters
        for (Param param : parameters) {

            if (! param.isStatic()) {

                // preserve current value
                Object oldValue = param.getValue();

                // read new value
                readAndValidateParameter(param);

                // get if parameter value had changed
                if (! ConfigUtil.equalValues(oldValue, param.getValue())) {
                    changedParams.add(param);
                }
            }

        }

        // invoke listeners for all changed parameters
        if (! changedParams.isEmpty()) {

            for (ConfigChangeListener listener : configChangeListeners) {
                listener.configurationChanged(changedParams);
            }

        }

    }
683180
def save(self, obj):
        """"""
        if not obj.id:
            obj.id = uuid()

        index_names = obj.__class__.index_names() or []
        index_dict = obj.indexes() or {}
        index_name_values = [
            (key, index_dict.get(key, ''))
            for key in index_names
        ]

        write_rec(
            obj.__class__.get_table_name(),
            obj.id,
            obj.to_data(),
            index_name_values
        )
983100
public <T> void updateValues(T receiver, ISyncHandler<T, ? extends ISyncableData> handler, Map<String, Object> values)
	{
		if (receiver == null || handler == null)
			return;

		for (Entry<String, Object> entry : values.entrySet())
		{
			ObjectData od = handler.getObjectData(entry.getKey());
			if (od != null)
				od.set(receiver, entry.getValue());
		}
	}
1118604
def save_model(self, request, obj, form, change):
        """"""
        super(GenericPositionsAdmin, self).save_model(request, obj, form,
                                                      change)
        c_type = ContentType.objects.get_for_model(obj)
        try:
            ObjectPosition.objects.get(content_type__pk=c_type.id,
                                       object_id=obj.id)
        except ObjectPosition.DoesNotExist:
            position_objects = ObjectPosition.objects.filter(
                content_type__pk=c_type.id, position__isnull=False).order_by(
                    '-position')
            try:
                position = (position_objects[0].position + 1)
            except IndexError:
                position = 1
            ObjectPosition.objects.create(
                content_object=obj, position=position)