Get the modified data
326002
def export_modified_data(self):
        
        # TODO: why None? Try to get a better flag
        result = {key: None for key in self.__deleted_fields__}

        for key, value in self.__modified_data__.items():
            if key in result.keys():
                continue
            try:
                result[key] = value.export_modified_data()
            except AttributeError:
                result[key] = value

        for key, value in self.__original_data__.items():
            if key in result.keys():
                continue
            try:
                if value.is_modified():
                    result[key] = value.export_modified_data()
            except AttributeError:
                pass

        return result
990765
def __updateDataItem(self):
        """"""
        uri = self.getUri()        
        self.__dataItem = self.__parseResponseServer(uri)
776278
public function getUpdatedAt() : ?string 
    {
        if ( ! $this->hasUpdatedAt()) {
            $this->setUpdatedAt($this->getDefaultUpdatedAt());
        }
        return $this->updatedAt;
    }
497477
def modified(self):
        ''
        return dateutil.parser.parse(str(self.f.latestRevision.modified))
554890
def updateData(self, state_data, action_data, reward_data):
        
#        self.dataLock.acquire()

        self.state_data[:, self.updates] = state_data
        self.action_data[:, self.updates] = action_data
        self.reward_data[0, self.updates] = reward_data
        self.updates += 1
        self._render()
723927
public function getUserData()
    {
        if ($this->_oUserData === null) {
            $this->_oUserData = Registry::getConfig()->getRequestParameter('editval');
        }

        return $this->_oUserData;
    }
1215014
def _update_data(self, data={}):
        ''''''

        # Store the changes to prevent this update from affecting it
        pending_changes = self._changes or {}
        try:
            del self._changes
        except:
            pass

        # Map custom fields into our custom fields object
        try:
            custom_field_data = data.pop('custom_fields')
        except KeyError:
            pass
        else:
            self.custom_fields = Custom_Fields(custom_field_data)

        # Map all other dictionary data to object attributes
        for key, value in data.iteritems():
            lookup_key = self._field_type.get(key, key)

            # if it's a datetime object, turn into proper DT object
            if lookup_key == 'datetime' or lookup_key == 'date':
                self.__dict__[key] = datetime_parse(value)
            else:
                # Check to see if there's cache data for this item.
                # Will return an object if it's recognized as one.
                self.__dict__[key] = self._redmine.check_cache(lookup_key, value)


        # Set the changes dict to track all changes from here on out
        self._changes = pending_changes
873475
def index(self, value):
        
        if self.__modified_data__ is not None:
            return self.__modified_data__.index(value)
        return self.__original_data__.index(value)
458156
def get_current_data(self):
        """"""
        if self.current_imuid in self.calibration_data:
            return self.calibration_data[self.current_imuid]

        return {}
876067
def update(self, data):
        
        if not data:
            return
        _rk, _dumps = self.get_key, self._dumps
        data = self._client.mset({
            _rk(key): _dumps(value)
            for key, value in data.items()})
784958
def export_data(self):
        
        result = {}
        data = self.__original_data__.copy()
        data.update(self.__modified_data__)
        for key, value in data.items():
            if key in self.__deleted_fields__:
                continue

            try:
                result[key] = value.export_data()
            except AttributeError:
                result[key] = value

        return result
1017901
def modified(self):
        
        # "... in the form YYYY-MM-DD HH:MM:SS, in UTC"
        if self._modified is None:
            self._modified = datetime.strptime(
                self._modified_unparsed,
                '%Y-%m-%d %H:%M:%S'
            )
        return self._modified
147803
def export_deleted_fields(self):
        
        result = []
        if self.__modified_data__ is not None:
            return result

        for index, item in enumerate(self):
            try:
                deleted_fields = item.export_deleted_fields()
                result.extend(['{}.{}'.format(index, key) for key in deleted_fields])
            except AttributeError:
                pass
        return result
1212854
def export_modifications(self):
        
        if self.__modified_data__ is not None:
            return self.export_data()

        result = {}

        for key, value in enumerate(self.__original_data__):
            try:
                if not value.is_modified():
                    continue
                modifications = value.export_modifications()
            except AttributeError:
                continue

            try:
                result.update({'{}.{}'.format(key, f): v for f, v in modifications.items()})
            except AttributeError:
                result[key] = modifications

        return result
1326386
def get_updated_userdata(data)
      result = RightScale::CloudUtilities.parse_rightscale_userdata(data)
      api_url       = "https://#{result['RS_server']}/api"
      client_id     = result['RS_rn_id']
      client_secret = result['RS_rn_auth']
      new_userdata = retrieve_updated_data(api_url, client_id , client_secret)
      if (new_userdata.to_s.empty?)
        return data
      else
        return new_userdata
      end
    end
160778
public function getAffectedRowData()
    {
        $data = array();

        $description = $this->getEntityDescription();

        switch ($this->getEntityState()) {
            case AnDomain::STATE_NEW :
                //get all the serializable property/value pairs
                foreach ($description->getProperty() as $name => $property) {
                    if ($property instanceof AnDomainPropertySerializable) {
                        $data[$name] = $name;
                    }
                }
                //@TODO why are we forcing to unset the property
                //unset($data[$description->getIdentityProperty()->getName()]);
                break;
            case AnDomain::STATE_MODIFIED :
                //get all the updated serializable property/value pairs
                $data = array_keys($this->_modified);
                break;
            case  AnDomain::STATE_DELETED :
                break;
            default :
                return $data;
        }

        $tmp = array();

        foreach ($data as $name) {
            $value = $this->get($name);
            $property = $description->getProperty($name);
            $tmp = array_merge($tmp, $property->serialize($value));
        }

        $data = $tmp;

        if ($description->getInheritanceColumn() && $this->getEntityState() == AnDomain::STATE_NEW) {
            $data[(string) $description->getInheritanceColumn()] = (string) $description->getInheritanceColumnValue();
        }

        return $data;
    }
96971
@Nonnull
    public Collection<F> modifiedFields() {
           return Arrays.stream(descriptor().getFields())
                        .filter(this::isModified)
                        .collect(Collectors.toList());
     }