Conversion function used in getting the value of the control.
517187
def _fromGUI(self, value):
        

        # One or more of the underlying text control implementations
        # issue an intermediate EVT_TEXT when replacing the control's
        # value, where the intermediate value is an empty string.
        # So, to ensure consistency and to prevent spurious ValueErrors,
        # we make the following test, and react accordingly:
        #
        if value == '':
            if not self.IsNoneAllowed():
                return 0
            else:
                return
        else:
            try:
                return int(value)
            except ValueError:
                if self.IsLongAllowed():
                    try:
                        return long(value)
                    except ValueError:
                        wx.TextCtrl.SetValue(self, "0")
                        return 0
                else:
                    raise
7873
protected Object getValue(SetterMethodCover method, Variable variable) {
        if(method.isTwoDimensionsArray()) 
            return assignValuesToTwoDimensionsArray(method, variable.getSFSArrayValue());
        if(method.isArray())
            return assignValuesToArray(method, variable);
        
        if(method.isColection())
            return assignValuesToCollection(method, variable);

        if(method.isObject())
            return assignValuesToObject(method, variable.getSFSObjectValue());
        if(method.isByte())
            return variable.getIntValue().byteValue();
        if(method.isChar())
            return (char)variable.getIntValue().byteValue();
        if(method.isFloat())
            return variable.getDoubleValue().floatValue();
        if(method.isLong())
            return variable.getDoubleValue().longValue();
        if(method.isShort())
            return variable.getIntValue().shortValue();
        return variable.getValue();
    }
98963
def _get_calculated_value(self, value):
        
        if isinstance(value, types.LambdaType):
            expanded_value = value(self.structure)
            return self._get_calculated_value(expanded_value)
        else:
            # perform one final parsing of the value in case lambda value
            # returned a different type
            return self._parse_value(value)
693678
@Override
    public double getValueAt(final int at) {
        if (userPrecAtCutoff.containsKey(at)) {
            int n = 0;
            double prec = 0.0;
            for (U u : userPrecAtCutoff.get(at).keySet()) {
                double uprec = getValueAt(u, at);
                if (!Double.isNaN(uprec)) {
                    prec += uprec;
                    n++;
                }
            }
            if (n == 0) {
                prec = 0.0;
            } else {
                prec = prec / n;
            }
            return prec;
        }
        return Double.NaN;
    }
213289
public function getConvertedValue()
    {
        if ($this->valueHasBeenConverted === false) {
            $this->convertedValue = $this->executeValueConversion();
            $this->valueHasBeenConverted = true;
        }

        return $this->convertedValue;
    }
1005678
public function getConvertedFromValue()
    {
        if ($this->valueHasBeenConverted === false) {
            $value = $this->executeValueConversion();

            $this->convertedFromValue = $value[0];
            $this->convertedToValue = $value[1];

            $this->valueHasBeenConverted = true;
        }

        return $this->convertedFromValue;
    }
797081
def value(self):
        
        if self._value:
            return self._value
        if self.formatter:
            return self.formatter(self.raw)
        return self.raw
797404
function getFormattedValue(value) {
            let format;

            if (isInteger(value)) {
                format = formatIntegerValue;
            } else {
                format = formatDecimalValue;
            }

            return format(value);
        }
585929
def value(self, data):
        """"""
        value = data.get(self.name)
        if value:
            return int(value)
        return self.default
1082308
def value(self):
        
        if self.opts['int']:
            return int(self.val)
        else:
            return float(self.val)
247216
protected ConversionDirectionType getDirection(Conversion conv, Control cont)
	{
		return getDirection(conv, null, cont);
	}
787795
public T convert(Object value)
    {
        T result = null;
        if (value != null)
        {
            if (getValueClass().isInstance(value))
                result = getValueClass().cast(value);
            else
                result = convertFromString(value.toString());
        }
        return result;
    }
621715
public static String getConvertedStringValue(FacesContext context,
            UIComponent component, Converter converter, SelectItem selectItem)
    {
        return getConvertedStringValue(context, component, converter,
                selectItem.getValue());
    }
1144806
def decimal(self, var, default=NOTSET, force=True):
        
        return self._get(var, default=default, cast=Decimal, force=force)
672121
def value(self):
        
        length = self._value.find(b'\x00')
        if length >= 0:
            return self._value[:length].decode('ascii')
        else:
            return self._value.decode('ascii')
428973
public Object getControlValue()
    {
        String strValue = this.getName();
        int iValue = 0;
        try   {
            iValue = Integer.parseInt(strValue);
        } catch (NumberFormatException ex)  {
        }
        return new Integer(iValue);
    }
216212
def GetValue(self):
    '''
    
    '''
    self.AssertInitialization('Choice')
    if self._widget.GetValue() == self._DEFAULT_VALUE:
      return None
    return ' '.join(
      [self._action.option_strings[0] if self._action.option_strings else '',  # get the verbose copy if available
       self._widget.GetValue()])