Return current value
185360
def get_value(self, index):
        """"""
        if index.column() == 0:
            return self.keys[ index.row() ]
        elif index.column() == 1:
            return self.types[ index.row() ]
        elif index.column() == 2:
            return self.sizes[ index.row() ]
        else:
            return self._data[ self.keys[index.row()] ]
1238842
public function current()
    {
        $consumeValue = $this->valueConsumer;
        $current = parent::current();
        $consumeValue($current);
        return $current;
    }
1212463
public function current()
    {
        $sKey = key($this->values);

        return (true === isset($this->values[$sKey])) ? $this->values[$sKey] : null;
    }
85620
def current(self, fields=None):
        """"""
        if fields is None:
            deferred_fields = self.deferred_fields
            if deferred_fields:
                fields = [
                    field for field in self.fields
                    if field not in deferred_fields
                ]
            else:
                fields = self.fields

        return dict((f, self.get_field_value(f)) for f in fields)
549042
def get_value(self, name):
        """"""
        value = self.shellwidget.get_value(name)
        # Reset temporal variable where value is saved to
        # save memory
        self.shellwidget._kernel_value = None
        return value
469351
protected function _fetchCurrent()
    {
        if ($this->_current !== null) {
            return $this->_current;
        }

        return $this->_current = parent::current();
    }
1149432
public function current()
    {
        $offset = 0;

        foreach ($this->observer as $observer) {
            if ($offset === $this->position) {
                return $observer;
            }
            ++$offset;
        }
    }
59864
function getCurrentValue(stream, key) {
	if (stream._currentEvent && stream._currentEvent.type === key) {
		return stream._currentEvent.value;
	} else {
		var names = keyNames[key];
		if (!names) {
			return stream[key];
		}
		var VALUE,
			valueHandler = function(value) {
				VALUE = value;
			};
		stream[names.on](valueHandler);
		stream[names.off](valueHandler);
		return VALUE;
	}
}
960147
def _get_current_label(self):
        """"""
        if len(self._last) == 0:
            raise StopIteration
        return self._last[:self._last.find(":")]
5017
def _GetValue(self, name):
    """"""
    for value in self.values:
      if value.name == name:
        return value
685265
def get_current():
    """"""
    global current
    if exists( SETTINGSFILE ):
        f = open( SETTINGSFILE ).read()
        current = re.findall('config[^\s]+.+', f)[1].split('/')[-1]
        return current
    else:
        return "** Not Set **"
643938
def get_current_value(self):
        
        if self.agent.training:
            # Linear annealed: f(x) = ax + b.
            a = -float(self.value_max - self.value_min) / float(self.nb_steps)
            b = float(self.value_max)
            value = max(self.value_min, a * float(self.agent.step) + b)
        else:
            value = self.value_test
        return value
465438
public function current()
    {
        if (array_key_exists($this->position, $this->results)) {
            return $this->results[$this->position];
        }
    }
265083
public function current() {

		$current = parent :: current();

		if(null !== $current) {

			if(false === is_string($current) && false === is_numeric($current) && true === $this -> is_multidimensional($current)) {

				if($this -> convert !== self :: TYPE_ARRAY) {
					return trigger_error(sprintf('Multidimensional Array can not be converted to "%s" type in "%s"', $this -> convert, __METHOD__), E_USER_ERROR);	
				}

				return $current;
			}

			switch($this -> convert) {

				case self :: TYPE_ARRAY: 
					return $current;

				case self :: TYPE_OBJECT: 
					return (object) $current;

				case self :: TYPE_JSON: 
					return json_encode($current);

				default : 

					if(false === class_exists($this -> entity)) {
						return trigger_error(sprintf('"%s" is not a valid type or Entity class file in %s', $type, __METHOD__), E_USER_ERROR);
					}

					$entity = new $this -> entity();

					$entity -> setAdapter($this -> adapter);
					$entity -> fromArray($current);

					return $entity;
			}
		}
	}
1333698
protected function current()
    {
        if (count($this->stack)) {
            return $this->stack[count($this->stack) -1];
        }
        return null;
    }
173259
def current_pos(self):
        """"""
        new_ptr = _decode(
            self._read_fixed_block(0x0020), self.lo_fix_format['current_pos'])
        if new_ptr == self._current_ptr:
            return self._current_ptr
        if self._current_ptr and new_ptr != self.inc_ptr(self._current_ptr):
            logger.error(
                'unexpected ptr change %06x -> %06x', self._current_ptr, new_ptr)
        self._current_ptr = new_ptr
        return self._current_ptr
878482
def current() -> 'Process':
        
        curr = greenlet.getcurrent()
        if not isinstance(curr, Process):
            raise TypeError("Current greenlet does not correspond to a Process instance.")
        return cast(Process, greenlet.getcurrent())