Unit bbutils_template

Adds element e to array a. Returns i with a[i]=e

Adds elements from a2 e to array a. Returns the OLD length of a

Removes element at position i from a (destroying the order of the elements)
Returns e=a[i]

Ensures that a has at least reserveLength elements

returns i with a[i]=e

Removes element at position i from a (destroying the order of the elements)
Returns e=a[i]

Find element e in the array/slice (see above)

Find the smallest element, in the array/slice (see above)

Find the largest element in the array/slice (see above)

Inverts the order of the elements in the array/slice (see above)

Extracts a array slice

Returns the i-th element of the array. If i < 0, the indices are taken from the end of the array. (which is actually the only use case)

Returns the last element of the array, raises exception, iff the array is empty

Returns the last element of the array, returns default, iff the array is empty

Compares two array/slices (interleaved slice parameters, so arrayEqual(a,b,3,3) compares the first 3 elements)

Tests if two array/slices are equal (interleaved slice parameters, so arrayEqual(a,b,3,3) tests the first 3 elements)

Checks if all elements are pairwise unequal

Checks if all elements are pairwise unequal

Checks if all elements are pairwise unequal

Calls proc in an new thread

Calls proc in an new thread

Calls proc in an new thread

Copies min(sourceLen, destLen) characters from source to dest and returns dest

Copies min(sourceLen, destLen) characters from source to dest and returns dest

Returns the substring of s containing all characters after start (including s[start]

Returns a string with all characters between first and last (including first, last)

Returns a string with all characters between start and last (including start, last)

Tests if the strings are case-sensitive equal (same length and same characters) (null-terminated, stops comparison when meeting #0 )

Tests if the strings are case-insensitive equal (same length and same characters) (null-terminated, stops comparison when meeting #0 )

Tests if the strings are case-sensitive equal (same length and same characters) (strict-length, can continue comparison after #0)

Tests if the strings are case-insensitive equal (same length and same characters) (strict-length, can continue comparison after #0)

Tests if the strings are case-sensitive equal (same length and same characters)

Tests if the strings are case-insensitive equal (same length and same characters)

Test if p begins with expectedStart (__STRICT_HELP__, case-sensitive)

Test if p begins with expectedStart (__STRICT_HELP__, case-insensitive)

Tests if the strings are case-insensitive equal (same length and same characters)

Tests if the strings are case-insensitive equal (same length and same characters)

Tests if the strToBeExaminated starts with expectedStart

Tests if the strToBeExaminated starts with expectedStart

Tests if the p starts with expectedStart (p is null-terminated)

Tests if the p starts with expectedStart (p is null-terminated)

Tests if the strToBeExaminated ends with expectedEnd

Tests if the strToBeExaminated ends with expectedEnd

Case sensitive, clever comparison, that basically splits the string into lexicographical and numerical parts and compares them accordingly

Case insensitive, clever comparison, that basically splits the string into lexicographical and numerical parts and compares them accordingly

Searchs the last index of c in s

Counts all occurrences of search in searchIn (case sensitive, stops at #0)

Searchs searched in str case-sensitive (Attention: opposite parameter to pos) (strict length, this function can find #0-bytes)

Searchs searched in str case-insensitive (Attention: opposite parameter to pos) (strict length, this function can find #0-bytes)

Searchs searched in str case-sensitive (Attention: opposite parameter to pos)

Searchs searched in str case-insensitive (Attention: opposite parameter to pos)

Searchs searched in str case-sensitive (Attention: opposite parameter to pos)

Searchs searched in str case-insensitive (Attention: opposite parameter to pos)

Tests if searched exists in str case-sensitive (Attention: opposite parameter to pos)

Tests if searched exists in str case-insensitive (Attention: opposite parameter to pos)

Tests if searched exists in str case-sensitive (Attention: opposite parameter to pos)

Tests if searched exists in str case-insensitive (Attention: opposite parameter to pos)

Removes all occurrences of trimCharacter from the left/right side of the string
It will move the pointer and change length, not modifying the memory pointed to

Removes all occurrences of trimCharacter from the left/right side of the string
It will move the pointer and change length, not modifying the memory pointed to

Removes all occurrences of trimCharacter from the left/right side of the string
It will move the pointer and change length, not modifying the memory pointed to

Removes all occurrences of trimCharacter from the left/right side of the string

Splits the string remainingPart into two parts at the first position of separator, the first part is returned as function result, the second one is again assign to remainingPart (If remainingPart does not contain separator, it returns remainingPart and sets remainingPart := '')

Splits the string remainingPart into two parts at the first position of separator, the first is assign to firstPart, the second one is again assign to remainingPart

Splits the string s into the array splitted at every occurrence of sep

Splits the string s into the array splitted at every occurrence of sep

Joins all string list items to a single string separated by sep.
If limit is set, the string is limited to abs(limit) items. if limit is positive, limitStr is appended; if limitStr is negative, limitStr is inserted in the middle

Joins all string list items to a single string separated by sep.
If limit is set, the string is limited to abs(limit) items. if limit is positive, limitStr is appended; if limitStr is negative, limitStr is inserted in the middle

Converts a str to a bool (for fpc versions previous 2.2)

loads a file as string. The filename is directly passed to the fpc rtl and uses the system encoding

See also

strLoadFromFileUTF8

saves a string as file. The filename is directly passed to the fpc rtl and uses the system encoding

See also

strSaveToFileUTF8

loads a file as string. The filename should be encoded in utf-8

See also

strLoadFromFile

saves a string as file. The filename should be encoded in utf-8

See also

strSaveToFile

converts a size (measured in bytes) to a string (e.g. 1025 -> 1 KiB)

length of an utf8 string
A similar function exists in lclproc, but this unit should be independent of the lcl to make it easier to compile with fpc on the command line
Currently this function also calculates the length of invalid utf8-sequences, in violation of rfc3629

Returns a utf-8 string from the string in encoding from

Converts a utf-8 string to the encoding from

Changes the string encoding from from to toe

Get unicode character character in a certain encoding

Returns the unicode code point of the utf-8 character starting at str[curpos] and increments curpos to the next utf-8 character. Returns a negative value if the character is invalid.

Gets the encoding from an encoding name (e.g. from http-equiv)

This decodes all html entities to the given encoding. If strict is not set it will ignore wrong entities (so e.g. X&Y will remain X&Y and you can call the function even if it contains rogue &).

This decodes all html entities to the given encoding. If strict is not set it will ignore wrong entities (so e.g. X&Y will remain X&Y and you can call the function even if it contains rogue &).

Replace all occurences of x \in toEscape with escapeChar + x

Returns a regex matching s

Returns the first l bytes of p (copies them so O(n))

Creates a string to display the value of a pointer (e.g. 0xDEADBEEF)

Creates a string to display an integer. The result will have at least displayLength digits (digits, not characters, so -1 with length 2, will become -02).

Creates count copies of rep

log 10 rounded down (= number of digits in base 10 - 1)

log_b n rounded down (= number of digits of n in base b - 1)

Given a number n, this procedure calculates the maximal integer e, so that n = pˆe * r

Calculates the greatest common denominator

Checks if two numbers are coprime

Calculates iˆe mod m in O(log(e)) and never exceeding m

Calculates i!

Calculates n|k = n!/k!(n-k)!

expectated value of a binomial distribution

variance of a binomial distribution

deviation(=sqrt(variance)) of a binomial distribution

probability: P(X = k) where X is binomial distributed with n possible values (exact value calculated with binomial coefficients, )

See also

binomialProbabilityApprox

probability: P(X >= k) where X is binomial distributed with n possible values

probability: P(X <= k) where X is binomial distributed with n possible values

probability: P(X >= mu + d or X <= mu - d) where X is binomial distributed with n possible values

expectated value of a binomial distribution (approximates the value with either Poisson or Moivre and Laplace, depending on the variance of the distribution) )

See also

binomialProbability

Z-Score of the value k in a distribution with n outcomes

This calculates the euler phi function totient[i] := phi(i) = |{1 <= j <= i | gcd(i,j) = 0}| for all i <= n.
It uses a sieve approach and is quite fast (10ˆ7 in 3s)
You can also use it to calculate all primes (i is prime iff phi(i) = i - 1)

This calculates the number of divisors: divcount[i] := |{1 <= j <= i | i mod j = 0}| for all i <= n.
Speed: 10ˆ7 in 5s

Week of year

Returns

if year is a leap year (supports negative years, i think)

Reads a date time string given a certain mask (mask is case-sensitive)
The uses the same mask types as FormatDate:
s or ss for a second
n or nn for a minute
h or hh for a hour
d or dd for a numerical day
m or mm for a numerical month, mmm for a short month name, mmmm for a long month name
am/pm or a/p match am/pm or a/p yy, yyyy or [yy]yy for the year. (if the year is < 90, it will become 20yy, else if it is < 100, it will become 19yy, unless you use uppercase Y instead of y)
YY, YYYY or [YY]YY for the year
z, zz, zzz, zzzz for milliseconds (e.g. use [.zzzzzz] for optional ms with exactly 6 digit precision, use [.z[z[z[z[z[z]]]]]] for optional ms with up to 6 digit precision) Z for the ISO time zone (written as regular expressions, it matches 'Z | [+-]hh(:?mm)?'. Z is the only format char (except mmm) matching several characters) The letter formats d/y/h/n/s matches one or two digits, the dd/mm/yy formats require exactly two.
yyyy requires exactly 4 digits, and [yy]yy works with 2 or 4 (there is also [y]yyy for 3 to 4). The year always matches an optional - (e.g. yyyy also matches -0012, but not -012)
Generally [x] marks the part x as optional (it tries all possible combinations, so you shouldn't have more than 10 optional parts)
x+ will match any additional amount of x. (e.g. yy -> 2 digit year, yy+ -> at least 2 digit year, yyyy -> 4 digit year, [yy]yy -> 2 or 4 digit year) "something" can be used to match the input verbatim
whitespace is matched against whitespace (i.e. [ #9#10#13]+ matches [ #9#10#13]+) The function works if the string is latin-1 or utf-8, and it also supports German month names
If a part is not found, it returns high(integer), except for outSecondFraction which will be 0 at not found, and outtimezone which will be NaN

Returns

If input could be matched with mask. It does not check, if the returned values are valid (e.g. month = 13 is allowed, in case you have to match durations)

Reads date/time parts from a input matching a given mask (@see dateTimeParsePartsTry)

Converts a dateTime to a string corresponding to the given mask (same mask as dateTimeParsePartsTry)

Converts a dateTime to a string corresponding to the given mask (same mask as dateTimeParsePartsTry)

Encodes a date time

Reads a time string given a certain mask (@see dateTimeParsePartsTry)

Reads a time string given a certain mask (@see dateTimeParsePartsTry).
This function checks, if the time is valid.

Converts a dateTime to a string corresponding to the given mask (same mask as dateTimeParsePartsTry)

Reads a date string given a certain mask (@see dateTimeParsePartsTry)

Reads a date string given a certain mask (@see dateTimeParsePartsTry)
This function checks, if the date is valid.

Converts a dateTime to a string corresponding to the given mask (same mask as dateTimeParsePartsTry)

Encodes a date as datetime (supports negative years)

Encodes a date as datetime (supports negative years)

Encodes a date as datetime (supports negative years)

General stable sort function
a is the first element in the array to sort, and b is the last. size is the size of every element
compareFunction is a function which compares two pointer to elements of the array, if it is nil, it will compare the raw bytes (which will correspond to an ascending sorting of positive integers).
Currently it uses a combination of merge and insert sort. Merge requires the allocation of additional memory.

general stable sort function (using merge + insert sort in the moment)

Values

• eUnknown:  
• eWindows1252:  
• eUTF8:  

Compare function to compare the two values where a and b points to, return -1 for aˆ<bˆ The data is an TObject to prevent confusing it with a and b. It is the first parameter, so the function use the same call convention like a method

cumulative sum of month days (so. days in month i = dmdcs[i] - dmdcs[i-1])