Find actual data object for location with old_location_name.
        Then call Location class change method to update location name and data.
761860
def change_location(self, old_location_name, new_location_name, new_parent_name=None,
                        new_er_data=None, new_pmag_data=None, replace_data=False):
        
        location = self.find_by_name(old_location_name, self.locations)
        if not location:
            print('-W- {} is not a currently existing location, so it cannot be updated.'.format(old_location_name))
            return False
        location.change_location(new_location_name, new_er_data, new_pmag_data, replace_data)
        return location
1181019
def set_location(self, new_location):
        
        self._load_raw_content()
        self._location = new_location
        self.get_filepath(renew=True)
        return
162808
def update(self, data):
        
        data = values.of({'Data': serialize.object(data), })

        payload = self._version.update(
            'POST',
            self._uri,
            data=data,
        )

        return SyncMapItemInstance(
            self._version,
            payload,
            service_sid=self._solution['service_sid'],
            map_sid=self._solution['map_sid'],
            key=self._solution['key'],
        )
894542
def OnReplaceFind(self, event):
        """"""

        event.text = event.GetFindString()
        event.flags = self._wxflag2flag(event.GetFlags())

        self.OnFind(event)
306635
function (rawData) {
    var oldData = this.data;
    if (!Object.keys(schema).length) { return; }
    this.buildData(rawData);
    this.update(oldData);
  }
178169
def updateRPYLocations(self):
        ''''''
        # Locations
        self.rollText.set_position((self.leftPos+(self.vertSize/10.0),-0.97+(2*self.vertSize)-(self.vertSize/10.0)))
        self.pitchText.set_position((self.leftPos+(self.vertSize/10.0),-0.97+self.vertSize-(0.5*self.vertSize/10.0)))
        self.yawText.set_position((self.leftPos+(self.vertSize/10.0),-0.97))
        # Font Size
        self.rollText.set_size(self.fontSize)
        self.pitchText.set_size(self.fontSize)
        self.yawText.set_size(self.fontSize)
1150130
function replaceWitness(old_witness, new_witness, handleResult){
	if (!ValidationUtils.isValidAddress(new_witness))
		return handleResult("new witness address is invalid");
	readMyWitnesses(function(arrWitnesses){
		if (arrWitnesses.indexOf(old_witness) === -1)
			return handleResult("old witness not known");
		if (arrWitnesses.indexOf(new_witness) >= 0)
			return handleResult("new witness already present");
		var doReplace = function(){
			db.query("UPDATE my_witnesses SET address=? WHERE address=?", [new_witness, old_witness], function(){
				handleResult();
			});
		};
		if (conf.bLight) // absent the full database, there is nothing else to check
			return doReplace();
		db.query(
			"SELECT 1 FROM unit_authors CROSS JOIN units USING(unit) WHERE address=? AND sequence='good' AND is_stable=1 LIMIT 1", 
			[new_witness], 
			function(rows){
				if (rows.length === 0)
					return handleResult("no stable messages from the new witness yet");
				storage.determineIfWitnessAddressDefinitionsHaveReferences(db, [new_witness], function(bHasReferences){
					if (bHasReferences)
						return handleResult("address definition of the new witness has or had references");
					doReplace();
				});
			}
		);
	});
}
526124
void updateLocationEngineNameAndSimulation(LocationEngine locationEngine) {
    if (locationEngine != null) {
      String locationEngineName = locationEngine.getClass().getName();
      boolean isSimulationEnabled = locationEngineName.equals(MOCK_PROVIDER);
      navigationSessionState = navigationSessionState.toBuilder()
        .locationEngineName(locationEngineName)
        .mockLocation(isSimulationEnabled)
        .build();
    }
  }
190719
def get(self, **params):
        '''
        
        '''
        return self.client.get('/v1/reference-data/locations/{0}'
                               .format(self.location_id), **params)
620917
def update(self, new_data: Dict[Text, Dict[Text, Text]]):
        

        for locale, data in new_data.items():
            if locale not in self.dict:
                self.dict[locale] = {}

            self.dict[locale].update(data)
1110700
def update_offset(self, new_offset):
        
        self.offset = new_offset
        self.data_points = self._data_points[self.offset:]
        self.timestamps = self._timestamps[self.offset:]
1292256
def rename(self, new_name):
    
    update = copy.copy(self)
    update.name = new_name
    return self._do_update(update)
764091
def action_update_library_location(_location):
    

    # if not(os.path.exists(_location)):
    # 	os.mkdir(_location)
    # 	printDebug("Creating new folder..", "comment")

    printDebug("Old location: '%s'" % get_home_location(), "comment")

    if os.path.isdir(_location):

        config = SafeConfigParser()
        config_filename = ONTOSPY_LOCAL + '/config.ini'
        config.read(config_filename)
        if not config.has_section('models'):
            config.add_section('models')

        config.set('models', 'dir', _location)
        with open(config_filename, 'w') as f:
            config.write(
                f)  # note: this does not remove previously saved settings

        return _location
    else:
        return None
425805
def update(self, name):
        

        if name is None:
            return

        if name not in self._names:
            # add the name if it isn't already tracked
            self._names[name] = len(self._names)

        result = self._names[name] - self._current
        self._current = self._names[name]
        return result
577500
def update(data)
      headers = @client.make_request(:post, @client.concat_user_path("#{CALL_PATH}/#{id}"), data)[1]
      if headers[:location]
         Client.get_id_from_location_header(headers[:location])
      end
    end
862635
def _on_new_location(self, form):
        """"""
        self._desired_longitude = float(form.data["long"])
        self._desired_latitude = float(form.data["lat"])
        self._desired_zoom = 13
        self._screen.force_update()
767409
def _update_class(self, oldclass, newclass):
        """"""
        olddict = oldclass.__dict__
        newdict = newclass.__dict__

        oldnames = set(olddict)
        newnames = set(newdict)

        for name in newnames - oldnames:
            setattr(oldclass, name, newdict[name])
            notify_info0('Added:', name, 'to', oldclass)
            self.found_change = True

        # Note: not removing old things...
        # for name in oldnames - newnames:
        #    notify_info('Removed:', name, 'from', oldclass)
        #    delattr(oldclass, name)

        for name in (oldnames & newnames) - set(['__dict__', '__doc__']):
            self._update(oldclass, name, olddict[name], newdict[name], is_class_namespace=True)

        old_bases = getattr(oldclass, '__bases__', None)
        new_bases = getattr(newclass, '__bases__', None)
        if str(old_bases) != str(new_bases):
            notify_error('Changing the hierarchy of a class is not supported. %s may be inconsistent.' % (oldclass,))

        self._handle_namespace(oldclass, is_class_namespace=True)