org.vishia.util

Class StringFunctions_C

java.lang.Object

org.vishia.util.StringFunctions_C

public class StringFunctions_C
extends java.lang.Object

Contains routines to convert String to number format.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
private static class	StringFunctions_C.PrepareAppendablePos Implementation of the StringFunctions_C.PrepareBufferPos for a simple Appendable
static interface	StringFunctions_C.PrepareBufferPos This interface is used also for StringFormatter to use similar approaches for setCharAt and append.

Field Summary

Fields

Modifier and Type	Field and Description
private static long[]	n10a Array with power of 10 to detect the exponent size of a long value.
(package private) static java.lang.String	sNeg
static java.lang.String	version Version, history and license.

Constructor Summary

Constructors

Constructor and Description
StringFunctions_C()

Method Summary

Modifier and Type	Method and Description
static java.lang.Appendable	appendHex(java.lang.Appendable out, long value, int nrofDigits) Append a value in hexa with given number of digits.
static java.lang.Appendable	appendHexLine(java.lang.Appendable out, int[] data, int from, int to, int nrofDigits, int nrFirstLine, int nrWordsPerLine) Appends some lines with hex numbers
static java.lang.Appendable	appendIntPict(java.lang.Appendable appendable, long src, java.lang.String pict) Appends a long value with a dedicated outfit
static java.lang.CharSequence	doubleToStringTruncated(double v1, double v2) Converts the given double to a String representation, whereby the number of digits is minimized, so that the resulting String is a value >=v1 and <= v2 with the minimum of representing digits.
static float	parseFloat(java.lang.CharSequence src, int pos, int sizeP, char decimalpoint, int[] parsedCharsP, java.lang.String separationChars) Parses a given String and convert it to the float number.
static float	parseFloat(java.lang.CharSequence src, int pos, int sizeP, int[] parsedChars) Parsed the given part of a a given charSequence to a float number with dot '.' as decimal point.
static int	parseIntRadix(java.lang.CharSequence srcP, int pos, int sizeP, int radix, int[] parsedChars) Parses an integer value.
static int	parseIntRadix(java.lang.CharSequence srcP, int pos, int sizeP, int radixArg, int[] parsedChars, java.lang.String spaceChars) Parses a given String and convert it to the integer number.
static int	parseIntRadixBack(java.lang.CharSequence srcP, int pos, int sizeP, int radix, int[] parsedChars) Parses a given String backward and convert it to the integer number.
static long	parseLong(java.lang.CharSequence srcP, int posArg, int sizeP, int radix, int[] parsedChars, java.lang.String separatorChars) Parses a given String and convert it to the long number.
static long	parseUlong(java.lang.CharSequence src, int pos, int sizeP, int radixArg, int[] parsedChars, java.lang.String separatorChars) Adequate method for long values, see #parseIntRadix(String, int, int, int, int[], String).
(package private) static boolean	strPicture(long src, java.lang.String pict, java.lang.String posNegPointExp, char cFracSep, StringFunctions_C.PrepareBufferPos bufferPos) This algorithm is taken over from C++ routines in strpict.cpp written by JcHartmut in 1993..1999.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

version

public static final java.lang.String version

Version, history and license.

• 2022-12-28 bugfix parseIntRadix(CharSequence, int, int, int, int[], String): If the number is too long then an overflow has occurred. Now only the max number of characters are parsed without int 32 bit overflow. If the digit is too long, some digits remain after parsing. This is used in #parseFloat(CharSequence, int, int, char, int[]). Before it was fixed, a too long fractional part has caused undefined result. Now the fractional part is converted only with max 31 bit (only 24 are relevant), but possible with more digits for example to recognize "0.00000012345678".
• 2022-03-29 Hartmut new: appendIntPict(Appendable, long, String), for that the strPicture(long, String, String, char, PrepareBufferPos) was moved and adapted from StringFormatter to here, the internal interface StringFunctions_C.PrepareBufferPos allows the adaption (it is simple). That is the basic to append a number in a specific outfit, TODO use also for float and double.
• 2022-03-29 Hartmut new: appendHex(Appendable, long, int) Algorithm copied from StringFormatter.addHex(long, int)
• 2019-05-23 Hartmut new: parseUlong(CharSequence, int, int, int, int[], String) and adaption of the adequate using routines. Note: It is a base routine now used in StringPartScan.scanDigits(int, int, String). It is done because gardening, adequate code unified.
• 2016-10-14 Hartmut bugfix: #parseFloat(CharSequence, int, int, char, int[]) has had a problem with 1 digit after decimal point. This bug was not present in older versions. maybe forced with the last change on 2016-02-07.
• 2016-02-07 Hartmut bugfix: #parseFloat(String, int, int, char, int[]) has had a problem with negative numbers.
• 2015-11-07 Hartmut chg: Now the number conversion routines are moved to StringFunctions_C. Reason: Dispersing the content because for some embedded applications a fine tuning of used sources is necessary.
• 2013-09-07 Hartmut new: #parseFloat(String, int, int, char, int[]) with choiceable separator (123,45, german decimal point)
• 2013-08-10 Hartmut new: #parseIntRadix(String, int, int, int, int[], String) now can skip over some characters. In this kind a number like 2"123'456.1 is able to read.
• 2013-08-10 Hartmut new: #parseLong(String, int, int, int, int[], String) as counterpart to parseInt
• 2012-04-01 Hartmut new #parseIntRadix(String, int, int, int, int[]) etc. taken from C-Sources CRunntimeJavalike/source/Fwc/fw_Simple.c
• 2012-02-19 Hartmut created: basic functions also existent in C (Java2C-usage).

Copyright/Copyleft: For this source the LGPL Lesser General Public License, published by the Free Software Foundation is valid. It means:

1. You can use this source without any restriction for any desired purpose.
2. You can redistribute copies of this source to everybody.
3. Every user of this source, also the user of redistribute copies with or without payment, must accept this license for further using.
4. But the LPGL is not appropriate for a whole software product, if this source is only a part of them. It means, the user must publish this part of source, but don't need to publish the whole source of the own product.
5. You can study and modify (improve) this source for own using or for redistribution, but you have to license the modified sources likewise under this LGPL Lesser General Public License. You mustn't delete this Copyright/Copyleft inscription in this source file.

If you are intent to use this sources without publishing its usage, you can get a second license subscribing a special contract with the author.

See Also:

Constant Field Values

n10a

private static final long[] n10a

Array with power of 10 to detect the exponent size of a long value.

sNeg

static java.lang.String sNeg

Constructor Detail

StringFunctions_C

public StringFunctions_C()

Method Detail

parseIntRadix

public static int parseIntRadix(java.lang.CharSequence srcP,
                                int pos,
                                int sizeP,
                                int radixArg,
                                int[] parsedChars,
                                java.lang.String spaceChars)

Parses a given String and convert it to the integer number. The String may start with a negative sign ('-') and should contain digits after them. The digits for radix > 10 where built by the numbers 'A'..'Z' respectively 'a'..'z', known as hexa numbers A..F or a..f.
If the string contains "0x" or "0X" before digits then the number is read hexadecimal also if radix = 10. This allows accept hexa where decimal is expected.
The number of parsed digits is limited to the int size (32 bit). Whereby on radix==16 also till "0xffffffff" is parsed, but this represents -1, written without negative sign. It is the same as "-0x1" or "-0x00000001".
If for example "3 000 000 000" is given, only "3 000 000 00" is parsed, one "0" remains. If digit characters remain, there are not parsed and able to recognize after srcP.subSequence(parsedChars[0]). But the number of digits is not limited outside of sizeP, for example "0000002123456789" is correctly parsed as result 0x7E916115

Parameters:

srcP - The String, non 0-terminated, see ,,size,,.

pos - The position in src to start.

sizeP - The maximal number of chars to parse. If it is more as the length of the String, no error. Negative: length of srcP shortened, -1 is till end, -2 is till end-1 etc. One can use -1 or Integer.MAX_VALUE to parse till the end of the String

radixArg - The radix of the number, typical 2, 10 or 16, max 36.

parsedChars - maybe null, if not null it should be intialized with int[1] or int[2].
parsedChars [0] number of chars which is used to parse the integer.
[1] number of real used digits. Important if this is the fractional part of a float.

separatorChars - Any character are accept inside the number as a separation character. For Example _ or ' or , to write: 12'345 or 12,234 or 12_345 which is parsed as 12345 in any case. Usual such as "'"

Returns:

the Number.

Throws:

never. - All possible digits where scanned, the rest of non-scanable digits are returned. For example the String contains "-123.45" it returns -123, and the retSize is 3.

parseIntRadix

public static int parseIntRadix(java.lang.CharSequence srcP,
                                int pos,
                                int sizeP,
                                int radix,
                                int[] parsedChars)

Parses an integer value. See parseIntRadix(CharSequence, int, int, int, int[], String)

Parameters:

sizeP - The number of chars to regard at maximum. A value of -1 means: use the whole String till end. sizeP = 0 is possible, then nothing should be parsed and paredCharsP[0] is set to 0. It may be possible that the number of characters to parse will be calculated outside, and 0 is a valid result. If sizeP is > the length, then the whole String is used. You can set both sizeP = -1 or sizeP = Integer.MAXVALUE to deactivate this argument.

parsedChars - maybe null, if not null it should be intialized with int[1] or int[2].
parsedChars [0] number of chars which is used to parse the integer.
[1] number of real used digits. Important if this is the fractional part of a float.

separatorChars - Any character are accept inside the number as a separation character. For Example _ or ' or , to write: 12'345 or 12,234 or 12_345 which is parsed as 12345 in any case. Usual such as "'"

Returns:

parseLong

public static long parseLong(java.lang.CharSequence srcP,
                             int posArg,
                             int sizeP,
                             int radix,
                             int[] parsedChars,
                             java.lang.String separatorChars)

Parses a given String and convert it to the long number. It is the adequate method for long values, see parseIntRadix(CharSequence, int, int, int, int[], String). The String may start with a negative sign ('-') and should contain digits after them. The digits for radix > 10 are 'A'..'Z' respectively 'a'..'z', known as hexa numbers A..F or a..f.
Between any character except '0x' .. '0b' any of the given 'separatorChars' can be written. It is for better readability for the number.
If the string contains "0x" or "0X" before digits then the number is read hexadecimal also if radix = 10. This allows accept hexa where decimal is expected.
If the string contains "0x" or "0X" before digits then the number is read hexadecimal also if radix = 10. This allows accept hexa where decimal is expected.
The number of parsed digits is limited to the int size (32 bit). Whereby on radix==16 also till "0xffffffff" is parsed, but this represents -1, written without negative sign. It is the same as "-0x1" or "-0x00000001".
If for example "3 000 000 000" is given, only "3 000 000 00" is parsed, one "0" remains. If digit characters remain, there are not parsed and able to recognize after srcP.subSequence(parsedChars[0]). But the number of digits is not limited outside of sizeP, for example "0000002123456789" is correctly parsed as result 0x7E916115

Parameters:

srcP - The String, non 0-terminated, see ,,size,,.

pos - The position in src to start.

sizeP - The maximal number of chars to parse. If it is more as the length of the String, no error. Negative: length of srcP shortened, -1 is till end, -2 is till end-1 etc. One can use -1 or Integer.MAX_VALUE to parse till the end of the String

radixArg - The radix of the number, typical 2, 10 or 16, max 36.

parsedChars - maybe null, if not null it should be intialized with int[1] or int[2].
parsedChars [0] number of chars which is used to parse the integer.
[1] number of real used digits. Important if this is the fractional part of a float.

separatorChars - Any character are accept inside the number as a separation character. For Example _ or ' or , to write: 12'345 or 12,234 or 12_345 which is parsed as 12345 in any case. Usual such as "'"

Returns:

the Number.

Throws:

never. - All possible digits where scanned, the rest of non-scanable digits are returned. For example the String contains "-123.45" it returns -123, and the retSize is 3.

parseUlong

public static long parseUlong(java.lang.CharSequence src,
                              int pos,
                              int sizeP,
                              int radixArg,
                              int[] parsedChars,
                              java.lang.String separatorChars)

Adequate method for long values, see #parseIntRadix(String, int, int, int, int[], String).

Parameters:

src - Any CharSequence which should start on pos with a digit representation.

pos - start position in src.

sizeP - The number of chars to regard at maximum. A value of -1 means: use the whole String till end. sizeP = 0 is possible, then nothing should be parsed and paredCharsP[0] is set to 0. It may be possible that the number of characters to parse will be calculated outside, and 0 is a valid result. If sizeP is > the length, then the whole String is used. You can set both sizeP = -1 or sizeP = Integer.MAXVALUE to deactivate this argument.

radix - of the number, it can be any value 0..36- If >10 then characters A..Z or a..z are used for digits. Usually 16 for hex numbers.

parsedChars - maybe null, if not null it should be intialized with int[1] or int[2].
parsedChars [0] number of chars which is used to parse the integer.
[1] number of real used digits. Important if this is the fractional part of a float.

separatorChars - Any character are accept inside the number as a separation character. For Example _ or ' or , to write: 12'345 or 12,234 or 12_345 which is parsed as 12345 in any case. Usual such as "'"

Returns:

The parsed number, 0 if no character is detected.

parseIntRadixBack

public static int parseIntRadixBack(java.lang.CharSequence srcP,
                                    int pos,
                                    int sizeP,
                                    int radix,
                                    int[] parsedChars)

Parses a given String backward and convert it to the integer number. The String may start with a negative sign ('-') and should contain digits after them. The digits for radix > 10 where built by the numbers 'A'..'Z' respectively 'a'..'z', known as hexa numbers A..F or a..f.

Parameters:

srcP - The String.

pos - The position in src to the last digit.

sizeP - The maximum of chars to parse. Should be less or equal pos.

radix - The radix of the number, typical 2, 10 or 16, max 36.

parsedChars - number of chars which is used to parse. The pointer may be null if not necessary. @pjava2c=simpleVariableRef.

Returns:

the Number.

Throws:

never. - All possible digits where scanned, the rest of non-scanable digits are returned. At example the String contains "-123.45" it returns -123, and the retSize is 3.

parseFloat

public static float parseFloat(java.lang.CharSequence src,
                               int pos,
                               int sizeP,
                               int[] parsedChars)

Parsed the given part of a a given charSequence to a float number with dot '.' as decimal point. See #parseFloat(CharSequence, int, int, char, int[])

Parameters:

src - given String

pos - left start positition

sizeP - -1 for whole string, max number of chars to use

parsedChars - number of chars which was used to parse. The pointer may be null if not necessary. @pjava2c=simpleVariableRef.

Returns:

float number

parseFloat

public static float parseFloat(java.lang.CharSequence src,
                               int pos,
                               int sizeP,
                               char decimalpoint,
                               int[] parsedCharsP,
                               java.lang.String separationChars)

Parses a given String and convert it to the float number. An exponent is not regarded yet (TODO). The maximal number of fractional digits is not limited, for example to parse 0.00000000000000012345 as 1.2345e-16

Parameters:

src - The String, see ,,size,,.

pos - The position in src to start.

sizeP - The number of chars to regard at maximum. A value of -1 means: use the whole String till end. sizeP = 0 is possible, then no float was parsed and paredCharsP[0] is set to 0. It may be possible that the number of characters to parse will be calculated outside, and 0 is a valid result. If sizeP is > the length, then the whole String is used. You can set both sizeP = -1 or sizeP = Integer.MAXVALUE to deactivate this argument.

decimalpoint - preferred '.', it is possible to use a ',' for german numbers.

parsedCharsP - [0] number of chars which is used to parse. The pointer may be null if not necessary. @pjava2c=simpleVariableRef.

Returns:

the Number.

appendHex

public static java.lang.Appendable appendHex(java.lang.Appendable out,
                                             long value,
                                             int nrofDigits)
                                      throws java.io.IOException

Append a value in hexa with given number of digits.

Parameters:

out - to append

value -

nrofDigits - if <0 then upper case digits A..F are used, else a..f

Returns:

out to further append

Throws:

java.io.IOException

appendHexLine

public static final java.lang.Appendable appendHexLine(java.lang.Appendable out,
                                                       int[] data,
                                                       int from,
                                                       int to,
                                                       int nrofDigits,
                                                       int nrFirstLine,
                                                       int nrWordsPerLine)
                                                throws java.io.IOException

Appends some lines with hex numbers

Parameters:

out - to this Appendable

data - contains the data

from - start index in data

to - end index in data

nrofDigits - number of digits to present the integer. It is for example 4 to write 16 bit words. Then also only 16 bits are used from data[ix].

nrFirstLine - number of words in the first line before a line break. This allows structuring if data starts with some defined head data. Use same value as nrWordsPerLine to write the full line.

nrWordsPerLine - number of words in a line, usual 16

Returns:

Throws:

java.io.IOException

doubleToStringTruncated

public static final java.lang.CharSequence doubleToStringTruncated(double v1,
                                                                   double v2)

Converts the given double to a String representation, whereby the number of digits is minimized, so that the resulting String is a value >=v1 and <= v2 with the minimum of representing digits. This is used for code generation necessary Strings with only this accuracy

Parameters:

v1 - should be < v2, it is the lower presentation of the exact value

v2 - It is the higher presentation of the value. returned value should be < v2

Returns:

CharSequence contains the proper image of the values. It is a StringBuilder, but it should not be changed.

strPicture

static boolean strPicture(long src,
                          java.lang.String pict,
                          java.lang.String posNegPointExp,
                          char cFracSep,
                          StringFunctions_C.PrepareBufferPos bufferPos)
                   throws java.io.IOException

This algorithm is taken over from C++ routines in strpict.cpp written by JcHartmut in 1993..1999.

Parameters:

src - The number to show

pict - picture or outfit, for example "+33221.11"

• a character which is also contained in posNegPointExp can be used for special functions.
• "1" the digit is always written, write "0" on leading 0
• "2" A space is written on a leading 0
• "3" A leading 0 is omitted. All other digits are written.
• "4".."9", "0" no meaning
• All other character are written as given.

posNegPointExp - String with 4 character which are contained in the pict, usual "+-.E", can be null or lesser if the function is not used. This arguments clarifies the meaning of this special characters. If the character is in the pict and is also found here, it has the following meaning depending on the position where it is found:

• [0] sign also present for a positive number. Use it, use instead posNegPointExp[1] if the number is negative.
• [1] sign only present for a negative number. Omit it if the number is positive.
• [2] character used as decimal point only relevant for float
• [3] character used for the exponent only relevant for float

cFracSep - Character which is used instead a exponent char

Returns:

Throws:

java.io.IOException

appendIntPict

public static java.lang.Appendable appendIntPict(java.lang.Appendable appendable,
                                                 long src,
                                                 java.lang.String pict)
                                          throws java.io.IOException

Appends a long value with a dedicated outfit

Parameters:

appendable - append here

src - the number

pict - picture or outfit, for example "+33221.11"

• + or - is used as position for a sign, write anytime + or - on "+", omit sign on "-" for a positive number.
• "1" the digit is always written, write "0" on leading 0
• "2" A space is written on a leading 0
• "3" A leading 0 is omitted. All other digits are written.
• "4".."9", "0" no meaning
• All other character are written as given.
  For example you can place a decimal point oth 1000^th^ separator to better read the digit.

Returns:

The appendable argument to append more in concatenation.

Throws:

java.io.IOException - not expected