Returns a mapping of items to their new values. The mapping includes only items whose value or raw string value
        has changed in the context.
343826
def values(self):
        
        report = {}
        for k, k_changes in self._changes.items():
            if len(k_changes) == 1:
                report[k] = k_changes[0].new_value
            elif k_changes[0].old_value != k_changes[-1].new_value:
                report[k] = k_changes[-1].new_value
        return report
263837
def get_mapping(self, other):
        
        m = next(self._matcher(other).isomorphisms_iter(), None)
        if m:
            return {v: k for k, v in m.items()}
1348430
def create_new_values(self):
        
        model = self.queryset.model
        pks = []
        extra_create_kwargs = self.extra_create_kwargs()
        for value in self._new_values:
            create_kwargs = {self.create_field: value}
            create_kwargs.update(extra_create_kwargs)
            new_item = self.create_item(**create_kwargs)
            pks.append(new_item.pk)
        return model.objects.filter(pk__in=pks)
130248
def _get_changes(cls, diff_dict):
        '''
        
        '''
        changes_strings = []
        for p in sorted(diff_dict.keys()):
            if sorted(diff_dict[p].keys()) == ['new', 'old']:
                # Some string formatting
                old_value = diff_dict[p]['old']
                if diff_dict[p]['old'] == cls.NONE_VALUE:
                    old_value = 'nothing'
                elif isinstance(diff_dict[p]['old'], six.string_types):
                    old_value = '\'{0}\''.format(diff_dict[p]['old'])
                elif isinstance(diff_dict[p]['old'], list):
                    old_value = '\'{0}\''.format(
                        ', '.join(diff_dict[p]['old']))
                new_value = diff_dict[p]['new']
                if diff_dict[p]['new'] == cls.NONE_VALUE:
                    new_value = 'nothing'
                elif isinstance(diff_dict[p]['new'], six.string_types):
                    new_value = '\'{0}\''.format(diff_dict[p]['new'])
                elif isinstance(diff_dict[p]['new'], list):
                    new_value = '\'{0}\''.format(', '.join(diff_dict[p]['new']))
                changes_strings.append('{0} from {1} to {2}'.format(
                    p, old_value, new_value))
            else:
                sub_changes = cls._get_changes(diff_dict[p])
                if sub_changes:
                    changes_strings.append('{0}:'.format(p))
                    changes_strings.extend(['  {0}'.format(c)
                                           for c in sub_changes])
        return changes_strings
940701
protected void remapRows() {
        rowMap = new HashMap<>();
        final FacesContext context = FacesContext.getCurrentInstance();
        final Map<String, Object> requestMap = context.getExternalContext().getRequestMap();
        final Collection<?> values = (Collection<?>) getValue();
        final String var = getVar();
        for (final Object obj : values) {
            requestMap.put(var, obj);
            try {
                final String key = getRowKeyValueAsString(context);
                rowMap.put(key, obj);
            }
            finally {
                requestMap.remove(var);
            }
        }
    }
1087190
function newContext(context, params) {
  if (!params) {
    return context;
  }

  return assign({}, context, {
    data: params.data ? arrayPush(params.data, context.data) : context.data,
    parent: params.newParent ? context : context.parent,
    index: 'index' in params ? params.index : context.index,
    item: 'item' in params ? params.item : context.item
  });
}
994847
def _get_changes(self):
        ''''''
        result = dict( (f['id'], f.get('value','')) for f in self._data if f.get('changed', False) )
        self._clear_changes
        return result
124772
def load(self, rawdata):
        
        if isinstance(rawdata, str):
            self.__parse_string(rawdata)
        else:
            # self.update() wouldn't call our custom __setitem__
            for key, value in rawdata.items():
                self[key] = value
        return
976078
def old_values(self):
        ''''''
        def get_old_values_and_key(item):
            values = item.old_values
            values.update({self._key: item.past_dict[self._key]})
            return values

        return [get_old_values_and_key(el)
                for el in self._get_recursive_difference('all')
                if el.diffs and el.past_dict]
58932
def sync_map_items(self):
        
        if self._sync_map_items is None:
            self._sync_map_items = SyncMapItemList(
                self._version,
                service_sid=self._solution['service_sid'],
                map_sid=self._solution['sid'],
            )
        return self._sync_map_items
240890
def update(self, data):
        
        result = None
        if data:
            _dumps = self._dumps
            data = {
                key: _dumps(value)
                for key, value in data.items()}
            result = self._client.hmset(self.key_prefix, data)
        return result
1216775
def map(self, callback):
        
        if isinstance(self._items, dict):
            return Collection(list(map(callback, self._items.values())))

        return Collection(list(map(callback, self._items)))
670355
public static <T extends ViewTraverse<T>> Map<String, Object> replaceDataReferences(
            final Map<String, Object> input,
            final T currentContext,
            final BiFunction<Integer, String, T> viewMap,
            final Converter<String, String> converter,
            final MultiDataContext<T, DataContext> data
    )
    {
        return replaceDataReferences(input, currentContext, viewMap, converter, data, false, false);
    }
9291
def changed_fields(self, from_db=False):
        
        if self.exist:
            current_dict = self.clean_value()
            # `from_db` attr is set False as default, when a `ListNode` is
            # initialized just after above `clean_value` is called. `from_db` flags
            # in 'list node sets' makes differences between clean_data and object._data.

            db_data = self._initial_data
            if from_db:
                # Thus, after clean_value, object's data is taken from db again.
                db_data = self.objects.data().get(self.key)[0]

            set_current, set_past = set(current_dict.keys()), set(db_data.keys())
            intersect = set_current.intersection(set_past)
            return set(o for o in intersect if db_data[o] != current_dict[o])
1092145
def mapping_ref(self, es_mappings):
        

        new_map = {}
        for key, value in es_mappings.items():
            for sub_key, sub_value in value.items():
                new_map["/".join([key, sub_key])] = \
                        mapping_fields(sub_value['properties'])
        return new_map
31665
@Pure
	public List<Object> getAddedValues() {
		if (this.newValues == null) {
			return Collections.emptyList();
		}
		return Collections.unmodifiableList(this.newValues);
	}
893768
def changes(self, columns=None, recurse=True, flags=0, inflated=False):
        
        output = {}
        is_record = self.isRecord()
        schema = self.schema()
        columns = [schema.column(c) for c in columns] if columns else \
                   schema.columns(recurse=recurse, flags=flags).values()

        context = self.context(inflated=inflated)
        with ReadLocker(self.__dataLock):
            for col in columns:
                old, curr = self.__values.get(col.name(), (None, None))
                if col.testFlag(col.Flags.ReadOnly):
                    continue
                elif not is_record:
                    old = None

                check_old = col.restore(old, context)
                check_curr = col.restore(curr, context)
                try:
                    different = check_old != check_curr
                except StandardError:
                    different = True

                if different:
                    output[col] = (check_old, check_curr)

        return output