Moves the line to the given value and rebuilds it
        
        :param      value | <variant>
7711
def setValue( self, value ):
        
        scene = self.scene()
        point = scene.mapFromChart(value, None)
        
        self.setPos(point.x(), self.pos().y())
        self.rebuild(scene.gridRect())
150689
def move_pos(self, line=1, column=1):
        
        return self.chained(move.pos(line=line, column=column))
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
859285
def update(self, value):
        

        value = int(value)

        with self.lock:
            self.value += value
287008
def _fix_value(self, value):
        
        try:
            return self._castfunc(value)
        except:
            error = "Can't put '{0}' ({1}) into a {2}. Expected a {3} object."
            error = error.format(
                value,                  # Input value
                type(value),            # Type of input value
                type(self),             # Type of collection
                self._type              # Expected type of input value
            )
            six.reraise(TypeError, TypeError(error), sys.exc_info()[-1])
1337970
public SFSDataWrapper transform(Object value) {
        if(value == null)
            return transformNullValue(value);
        return transformNotNullValue(value);
    }
667782
public int put(final K key, final int value)
    {
        if (value == missingValue)
        {
            throw new IllegalArgumentException("cannot accept missingValue");
        }

        int oldValue = missingValue;
        @DoNotSub final int mask = values.length - 1;
        @DoNotSub int index = Hashing.hash(key, mask);

        while (missingValue != values[index])
        {
            if (key.equals(keys[index]))
            {
                oldValue = values[index];
                break;
            }

            index = ++index & mask;
        }

        if (missingValue == oldValue)
        {
            ++size;
            keys[index] = key;
        }

        values[index] = value;

        if (size > resizeThreshold)
        {
            increaseCapacity();
        }

        return oldValue;
    }
233814
private void moveToNext(final int i) {
    final int next = iterators.length + i;
    timestamps[i] = timestamps[next];
    values[i] = values[next];
    //LOG.debug("Moving #" + next + " -> #" + i
    //          + ((timestamps[i] & FLAG_FLOAT) == FLAG_FLOAT
    //             ? " float " + Double.longBitsToDouble(values[i])
    //             : " long " + values[i])
    //          + " @ time " + (timestamps[i] & TIME_MASK));
    final SeekableView it = iterators[i];
    if (it.hasNext()) {
      putDataPoint(next, it.next());
    } else {
      endReached(i);
    }
  }
139869
def append(self, value):
        

        # We inline this checks to prevent method invocation each time
        if self.children is None:
            self._parse_children()

        self.children.append(self._make_value(value))

        if self._native is not None:
            self._native.append(self.children[-1].native)

        self._mutated = True
257467
def append(self, value):
        
        # Pack value
        data = self.pack(value)

        # End of file
        self.__file.seek(0, 2)

        # Write packed value
        self.__file.write(data)
344475
public void replace( String param, String value ) {
        int [] range;
        while ( (range = findTemplate( param )) != null )
            buff.replace( range[0], range[1], value );
    }
527403
public function setLineStart($value)
    {
        $this->_validateInt('LineStart', $value);

        if ($this->data['line_start'] === $value) {
            return;
        }

        $this->data['line_start'] = $value;

        $this->_setModified('line_start');
    }
75768
public void updateLongLE(long value) {
        finished = false;
        switch (partialPos) {
            case 0:
                partialK1 = value;
                break;
            case 8:
                partialK2 = value;
                break;
            default:
                throw new IllegalStateException("Cannot mix long with other alignments than 8: " + partialPos);
        }

        partialPos += 8;
        if (partialPos == 16) {
            applyKs(partialK1, partialK2);
            partialPos = 0;
        }
        length += 8;
    }
13231
public void setValue(Object value) {
        if (logger.isDebugEnabled()) {
            logger.debug("Setting buffered value to '" + value + "'");
        }
        final Object oldValue = getValue();
        this.bufferedValue = value;
        updateBuffering();
        fireValueChange(oldValue, bufferedValue);
    }
212437
def value=(value)
      @value = @continuous ? value.to_f : value.round
      @value = [[@value, @range.min].max, @range.max].min
      @handle.x = x + padding_left + ((width - @handle.width) * (@value - @range.min) / (@range.max - @range.min).to_f)
      publish :changed, @value

      @value
    end
1236862
private void produce(IsNullValue value) {
        IsNullValueFrame frame = getFrame();
        frame.pushValue(value);
        newValueOnTOS();
    }
1232746
synchronized long systemUpdate(long value) {

        if (value == currValue) {
            currValue += increment;

            return value;
        }

        if (increment > 0) {
            if (value > currValue) {
                currValue = value + increment;
            }
        } else {
            if (value < currValue) {
                currValue = value + increment;
            }
        }

        return value;
    }