Append String value to expression that will be parsed to {@link Num} with defined decimal separator


@param value String representation of number
@param decimalSeparator used in string representation of number
@return
434681
public CALC val(String value, char decimalSeparator) {
        infix.add(new Num(value, decimalSeparator));
        return getThis();
    }
157356
public Expression<Integer> eq(int value) {
		String valueString = "'" + value + "'";
		return new Expression<Integer>(this, Operation.eq, valueString);
	}
719024
public static String getDigits(String value) {

    StringBuilder digits = new StringBuilder(value.length());

    for (char chr : value.toCharArray()) {
      if (Character.isDigit(chr)) {
        digits.append(chr);
      }
    }

    return digits.toString();
  }
1107705
private String formatUnits(Number value)
   {
      return (value == null ? null : m_formats.getUnitsDecimalFormat().format(value.doubleValue() / 100));
   }
845618
public static final Integer parseInteger(String value)
   {
      return (value == null || value.length() == 0 ? null : Integer.valueOf(Integer.parseInt(value)));
   }
1273252
protected function createSeparators(int $value, $current, int $sorting): int
    {
        for ($count = 1; $count <= $value; $count++) {
            $sorting = ($sorting + 8);
            $this->createGridElement($current, 'bs_gridSeparator', $sorting);
        }

        return $sorting;
    }
38306
public static final NumericalValue parseNumericalValue (final String value) {
        // return SingleNumericalValue ...
        final Matcher singleValueMatcher = SINGLE_CONSTANT_PATTERN.matcher(value);
        if (singleValueMatcher.matches()) return SingleNumericalValue.parseSingleNumericValue(value);
        // ... NumericalValueRange ...
        final Matcher rangeMatcher = NUMERICAL_RANGE_PATTERN.matcher(value);
        if (rangeMatcher.matches()) return NumericalValueRange.parseNumericalValueRange(value);
        // ... or null
        return null;
    }
587670
protected final boolean complies(final String value, final String constValue, final String separators) {
        if (value == null) {
            return false;
        } else {
            final StringTokenizer tok = new StringTokenizer(value, separators);
            while (tok.hasMoreTokens()) {
                final String t = tok.nextToken();
                if (t.equals(constValue)) {
                    return true;
                }
            }
            return false;
        }

    }
1360617
public Integer convertToInt(String value) {
        Integer result = null;
        if (value != null) {
            result = Integer.valueOf(value);
        }
        return result;
    }
1088587
public static final Double parseCurrency(Number value)
   {
      return (value == null ? null : NumberHelper.getDouble(value.doubleValue() / 100));
   }
953828
public void addValue(String value) {
		contents.add(value);
		if (value.trim().length() > 0) {
			if (contents.size() == 1) {
				containsSingleString = true;
			} else {
				containsSingleString = false;
				containsMarkupText = true;
			}
		}
	}
691074
private void appendValue(Object value) {
        if (value == null) {
            append("null");
        } else if (value instanceof MwsObject) {
            append("{");
            needComma = false;
            ((MwsObject) value).writeFragmentTo(this);
            append("}");
        } else if (value instanceof Boolean || value instanceof Number) {
            append(value.toString());
        } else if (value instanceof String) {
            append("\"");
            escape((String) value);
            append("\"");
        } else if (value instanceof Node) {
            appendValue(MwsUtl.toXmlString((Node) value));
        } else if (value instanceof XMLGregorianCalendar) {
            append(((XMLGregorianCalendar) value).toXMLFormat());
        } else if (value instanceof Enum) {
            append(value.toString());
        } else {
            throw new IllegalArgumentException("Unsupported type "+value.getClass().getName());
        }
        needComma = true;
    }
1062671
public static <T extends Number & Comparable<?>> NumberExpression<T> asNumber(T value) {
        return asNumber(constant(value));
    }
1125047
private static final String correctNumberFormat(String value)
   {
      String result;
      int index = value.indexOf(',');
      if (index == -1)
      {
         result = value;
      }
      else
      {
         char[] chars = value.toCharArray();
         chars[index] = '.';
         result = new String(chars);
      }
      return result;
   }
410120
public void setRemoteSeparator(final String value) {
    if (value != null && value.length() != 1) {
      throw new BuildException("remote separator must be a single character");
    }
    this.remoteSeparator = value.charAt(0);
  }
430148
static Integer integer(String value) {
        Integer result;
        if (value != null) {
            value = value.trim();
            Matcher matcher = INTEGER_PATTERN.matcher(value);
            if (matcher.matches()) {
                result = Integer.parseInt(matcher.group(1).replace(" ", ""));
            } else {
                throw new IllegalArgumentException("Unknown format for value: " + value);
            }
        } else {
            result = null;
        }
        return result;
    }
614011
public static VersionCompare forString(final String value) {

        VersionCompare vers = new VersionCompare();
        if (null == value || "".equals(value)) {
            return vers;
        }

        String[] parr1 = value.split("-", 2);
        String[] v1arr = parr1[0].split("\\.", 3);
        if (v1arr.length > 0) {
            vers.majString = v1arr[0];
            try {
                vers.maj = Integer.parseInt(vers.majString);
            } catch (NumberFormatException e) {
            }
        }
        if (v1arr.length > 1) {
            vers.minString = v1arr[1];
            try {
                vers.min = Integer.parseInt(vers.minString);
            } catch (NumberFormatException e) {
            }
        }
        if (v1arr.length > 2) {
            vers.patchString = v1arr[2];
            try {
                vers.patch = Integer.parseInt(vers.patchString);
            } catch (NumberFormatException e) {
            }
        }
        if (parr1.length > 1) {
            vers.tag = parr1[1];
        }
        return vers;
    }