Update the locator, and trigger a latitude and longitude update.

        Args:
            value (str): New Maidenhead locator string
779559
def locator(self, value):
        
        self._locator = value
        self._latitude, self._longitude = utils.from_grid_locator(value)
405824
def update_position(self, loc):
        """"""
        # This ensures that the new value of the location is set before
        # any other updates take place.
        self._loc = loc
        super(SkewXTick, self).update_position(loc)
268288
def value(self, new_value):
        
        datetime_value = None
        if new_value:
            datetime_value = new_value.strftime("%Y-%M-%dT%H:%M:%SZ")
        self._set_value(datetime_value)
890743
def update(self, value=None):
        

        # Update self.value
        if value is None:
            value = self._current_value + 1
        self._current_value = value

        # Choose the appropriate environment
        if self._ipython_widget:
            try:
                self._update_ipython_widget(value)
            except RuntimeError:
                pass
        else:
            self._update_console(value)
386737
def setValue( self, value ):
        
        if ( self._editor ):
            self._editor.setValue(value)
            return True
        return False
341540
def update_position(self, newpos):
        ''''''
        if getattr(self, 'trail', None) is not None:
            self.trail.update_position(newpos)
        self.latlon = newpos.latlon
        if hasattr(self, 'rotation'):
            self.rotation = newpos.rotation
755823
def this_update(self, value):
        

        if not isinstance(value, datetime):
            raise TypeError(_pretty_message(
                '''
                this_update must be an instance of datetime.datetime, not %s
                ''',
                _type_name(value)
            ))

        self._this_update = value
441108
public void setValue(String value) {
        ImmutableMap.Builder<String, Object> builder = ImmutableMap.builder();
        builder.put("id", id).put("value", value);
        execute(MobileCommand.SET_VALUE, builder.build());
    }
673691
def location(self, value):
        

        if value is not None:
            assert type(value) is umbra.ui.common.Location, \
                "'{0}' attribute: '{1}' type is not 'umbra.ui.common.Location'!".format("location", value)
        self.__location = value
120814
public void setStringValue(String value) {

        if (CmsStringUtil.isNotEmptyOrWhitespaceOnly(value)) {
            try {
                m_editValue = CmsLocationValue.parse(value);
                m_currentValue = m_editValue.cloneValue();
                displayValue();
                if ((m_popup != null) && m_popup.isVisible()) {
                    m_popupContent.displayValues(m_editValue);
                    updateMarkerPosition();
                }
            } catch (Exception e) {
                CmsLog.log(e.getLocalizedMessage() + "\n" + CmsClientStringUtil.getStackTrace(e, "\n"));
            }
        } else {
            m_currentValue = null;
            displayValue();
        }
    }
745216
def setValue(self, value):
        
        self.__value = projex.text.decoded(value) if isinstance(value, (str, unicode)) else value
397527
def set_incoming(self, value):
        
        if not isinstance(value, list):
            raise TypeError("IncomingList new value must be a list")
        for element in value:
            if not isinstance(element, str):
                raise TypeError("IncomingList elements in variable must be of String class")
        self.__incoming_list = value
44485
def update_field_geolocalization(field, value)
      final_value = {
        lat: value[:lat],
        lng: value[:lng],
        address: value[:address]
      }
      field.update(value: final_value)
    end
100263
def update(self, value=None):
        ''

        if value is not None and value is not UnknownLength:
            if (self.maxval is not UnknownLength
                    and not 0 <= value <= self.maxval
                    and not value < self.currval):

                raise ValueError('Value out of range')

            self.currval = value

        if self.start_time is None:
            self.start()
            self.update(value)
        if not self._need_update():
            return

        if self.redirect_stderr and sys.stderr.tell():
            self.fd.write('\r' + ' ' * self.term_width + '\r')
            self._stderr.write(sys.stderr.getvalue())
            self._stderr.flush()
            sys.stderr = StringIO()

        if self.redirect_stdout and sys.stdout.tell():
            self.fd.write('\r' + ' ' * self.term_width + '\r')
            self._stdout.write(sys.stdout.getvalue())
            self._stdout.flush()
            sys.stdout = StringIO()

        now = time.time()
        self.seconds_elapsed = now - self.start_time
        self.next_update = self.currval + self.update_interval
        self.fd.write('\r' + self._format_line())
        self.last_update_time = now
935482
def update(target, path, value):
    
    names = path.split(".")
    names_length = len(names)
    node = target
    for index in range(names_length):
        name = names[index]
        if index == names_length - 1:
            last = True
        else:
            last = False
        if isinstance(node, dict):
            if last:
                node[name] = value
                return
            else:
                if not name in node:
                    node[name] = {}
                node = node[name]
        elif isinstance(node, list):
            name = int(name)
            listpad(node, name+1)
            if last:
                node[name] = value
                return
            else:
                node[name] = {}
                node = node[name]
        else:
            if last:
                setattr(node, name, value)
            else:
                setattr(node, name, {})
                node = getattr(node, name)
791978
def update(self, value):
        
        self.update_internal(value)
        self.emit('changed', self.get_widget_value())
233558
def put(self, value):
        
        io_loop = IOLoop.current()
        new_hole = Future()

        new_put = Future()
        new_put.set_result(new_hole)

        with self._lock:
            self._put, put = new_put, self._put

        answer = Future()

        def _on_put(future):
            if future.exception():  # pragma: no cover (never happens)
                return answer.set_exc_info(future.exc_info())

            old_hole = put.result()
            old_hole.set_result(Node(value, new_hole))
            answer.set_result(None)

        io_loop.add_future(put, _on_put)
        return answer