Functions: L¶

19 functions (23 overloads) on BasicRuntime.Functions starting with L.

A B C D E F G H I K L M N O P Q R S T U W X Z

LEFT¶

1 overload

static DynamicArray Functions.LEFT(DynamicArray value, DynamicArray length)

Performs the left operation using the supplied value, length.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.LEFT(...) directly (no instance required) when your code needs to perform the left operation using the supplied value, length.

How this member is tested

Act: var result = Functions.LEFT(/* a valid DynamicArray value */, /* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

LEN¶

1 overload · BASIC reference

static DynamicArray Functions.LEN(DynamicArray value)

Performs the len operation using the supplied value.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.LEN(...) directly (no instance required) when your code needs to perform the len operation using the supplied value.

How this member is tested

Act: var result = Functions.LEN(/* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

LENS¶

1 overload

static DynamicArray Functions.LENS(DynamicArray value)

Performs the lens operation using the supplied value.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.LENS(...) directly (no instance required) when your code needs to perform the lens operation using the supplied value.

How this member is tested

Act: var result = Functions.LENS(/* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

LICENSE¶

1 overload · BASIC reference

static DynamicArray Functions.LICENSE()

Performs the license operation.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.LICENSE(...) directly (no instance required) when your code needs to perform the license operation.

How this member is tested

Act: var result = Functions.LICENSE()
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

LINKEDACCOUNTS¶

1 overload

static DynamicArray Functions.LINKEDACCOUNTS()

Performs the linkedaccounts operation.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.LINKEDACCOUNTS(...) directly (no instance required) when your code needs to perform the linkedaccounts operation.

How this member is tested

Act: var result = Functions.LINKEDACCOUNTS()
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

LINK_ACCOUNT¶

1 overload

static DynamicArray Functions.LINK_ACCOUNT(DynamicArray AccountName)

Performs the link_account operation using the supplied AccountName.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.LINK_ACCOUNT(...) directly (no instance required) when your code needs to perform the link_account operation using the supplied AccountName.

How this member is tested

Act: var result = Functions.LINK_ACCOUNT(/* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

LISTACCOUNTS¶

1 overload

static DynamicArray Functions.LISTACCOUNTS()

Performs the listaccounts operation.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.LISTACCOUNTS(...) directly (no instance required) when your code needs to perform the listaccounts operation.

How this member is tested

Act: var result = Functions.LISTACCOUNTS()
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

LISTREADF¶

1 overload

static DynamicArray Functions.LISTREADF()

Performs the listreadf operation.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.LISTREADF(...) directly (no instance required) when your code needs to perform the listreadf operation.

How this member is tested

Act: var result = Functions.LISTREADF()
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

LISTREADU¶

1 overload

static DynamicArray Functions.LISTREADU()

Performs the listreadu operation.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.LISTREADU(...) directly (no instance required) when your code needs to perform the listreadu operation.

How this member is tested

Act: var result = Functions.LISTREADU()
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

LISTU¶

1 overload

static DynamicArray Functions.LISTU()

Performs the listu operation.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.LISTU(...) directly (no instance required) when your code needs to perform the listu operation.

How this member is tested

Act: var result = Functions.LISTU()
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

LISTUSER¶

1 overload

static DynamicArray Functions.LISTUSER()

Performs the listuser operation.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.LISTUSER(...) directly (no instance required) when your code needs to perform the listuser operation.

How this member is tested

Act: var result = Functions.LISTUSER()
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

LiteDBSorter¶

1 overload

static Queue Functions.LiteDBSorter(DatabaseQuery dbQuery, SelectList list, DynamicArray fileVariable)

Performs the lite db sorter operation using the supplied dbQuery, list, fileVariable.


Kind	Method (static)
Returns	`Queue`
Use case	Call Functions.LiteDBSorter(...) directly (no instance required) when your code needs to perform the lite db sorter operation using the supplied dbQuery, list, fileVariable.

How this member is tested

Act: var result = Functions.LiteDBSorter(/* a valid DatabaseQuery value */, /* a valid SelectList value */, /* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of Queue; verify its properties reflect the expected resulting state.

LOC¶

1 overload

static bool Functions.LOC(DynamicArray search, DynamicArray variable, int am, int vm, int svm, int start, string order, DynamicArray pos)

Performs the loc operation using the supplied search, variable, am, vm, svm, start, order, pos.


Kind	Method (static)
Returns	`bool`
Use case	Call Functions.LOC(...) directly (no instance required) when your code needs to perform the loc operation using the supplied search, variable, am, vm, svm, start, order, pos.

How this member is tested

Act: var result = Functions.LOC(/* a valid DynamicArray value */, /* a valid DynamicArray value */, 1, 1, 1, 1, "sample", /* a valid DynamicArray value */)
Assert: result matches the expected true/false outcome.

Expected: Returns true or false, indicating the outcome of the loc check for the given input.

LOCATE¶

5 overloads

Overload 1

static bool Functions.LOCATE(DynamicArray search, DynamicArray variable, DynamicArray Pos, string order)

Performs the locate operation using the supplied search, variable, Pos, order.


Kind	Method (static)
Returns	`bool`
Use case	Call Functions.LOCATE(...) directly (no instance required) when your code needs to perform the locate operation using the supplied search, variable, Pos, order.

How this member is tested

Act: var result = Functions.LOCATE(/* a valid DynamicArray value */, /* a valid DynamicArray value */, /* a valid DynamicArray value */, "sample")
Assert: result matches the expected true/false outcome.

Expected: Returns true or false, indicating the outcome of the locate check for the given input.

Overload 2

static bool Functions.LOCATE(DynamicArray search, DynamicArray variable, int am, DynamicArray Pos, string order)

Performs the locate operation using the supplied search, variable, am, Pos, order.


Kind	Method (static)
Returns	`bool`
Use case	Call Functions.LOCATE(...) directly (no instance required) when your code needs to perform the locate operation using the supplied search, variable, am, Pos, order.

How this member is tested

Act: var result = Functions.LOCATE(/* a valid DynamicArray value */, /* a valid DynamicArray value */, 1, /* a valid DynamicArray value */, "sample")
Assert: result matches the expected true/false outcome.

Expected: Returns true or false, indicating the outcome of the locate check for the given input.

Overload 3

static bool Functions.LOCATE(DynamicArray search, DynamicArray variable, int am, int vm, DynamicArray Pos, string order)

Performs the locate operation using the supplied search, variable, am, vm, Pos, order.


Kind	Method (static)
Returns	`bool`
Use case	Call Functions.LOCATE(...) directly (no instance required) when your code needs to perform the locate operation using the supplied search, variable, am, vm, Pos, order.

How this member is tested

Act: var result = Functions.LOCATE(/* a valid DynamicArray value */, /* a valid DynamicArray value */, 1, 1, /* a valid DynamicArray value */, "sample")
Assert: result matches the expected true/false outcome.

Expected: Returns true or false, indicating the outcome of the locate check for the given input.

Overload 4

static bool Functions.LOCATE(DynamicArray search, DynamicArray variable, int am, int vm, int svm, DynamicArray order, string Pos)

Performs the locate operation using the supplied search, variable, am, vm, svm, order, Pos.


Kind	Method (static)
Returns	`bool`
Use case	Call Functions.LOCATE(...) directly (no instance required) when your code needs to perform the locate operation using the supplied search, variable, am, vm, svm, order, Pos.

How this member is tested

Act: var result = Functions.LOCATE(/* a valid DynamicArray value */, /* a valid DynamicArray value */, 1, 1, 1, /* a valid DynamicArray value */, "sample")
Assert: result matches the expected true/false outcome.

Expected: Returns true or false, indicating the outcome of the locate check for the given input.

Overload 5

static bool Functions.LOCATE(DynamicArray search, DynamicArray variable, int am, int vm, int svm, int start, string order, DynamicArray Pos)

Performs the locate operation using the supplied search, variable, am, vm, svm, start, order, Pos.


Kind	Method (static)
Returns	`bool`
Use case	Call Functions.LOCATE(...) directly (no instance required) when your code needs to perform the locate operation using the supplied search, variable, am, vm, svm, start, order, Pos.

How this member is tested

Act: var result = Functions.LOCATE(/* a valid DynamicArray value */, /* a valid DynamicArray value */, 1, 1, 1, 1, "sample", /* a valid DynamicArray value */)
Assert: result matches the expected true/false outcome.

Expected: Returns true or false, indicating the outcome of the locate check for the given input.

LocateSearch¶

1 overload

static bool Functions.LocateSearch(string search, string value, LocateOrder order, ref bool exactMatch)

Performs the locate search operation using the supplied search, value, order, exactMatch.


Kind	Method (static)
Returns	`bool`
Use case	Call Functions.LocateSearch(...) directly (no instance required) when your code needs to perform the locate search operation using the supplied search, value, order, exactMatch.

How this member is tested

Act: var result = Functions.LocateSearch("sample", "sample", /* a valid LocateOrder value */, ref true)
Assert: result matches the expected true/false outcome.

Expected: Returns true or false, indicating the outcome of the locate search check for the given input.

LOCK¶

1 overload

static bool Functions.LOCK(DynamicArray lockNumber, bool useElse)

Performs the lock operation using the supplied lockNumber, useElse.


Kind	Method (static)
Returns	`bool`
Use case	Call Functions.LOCK(...) directly (no instance required) when your code needs to perform the lock operation using the supplied lockNumber, useElse.

How this member is tested

Act: var result = Functions.LOCK(/* a valid DynamicArray value */, true)
Assert: result matches the expected true/false outcome.

Expected: Returns true or false, indicating the outcome of the lock check for the given input.

LOGTCL¶

1 overload

static void Functions.LOGTCL(string tclStatement)

Performs the logtcl operation using the supplied tclStatement.


Kind	Method (static)
Returns	`void`
Use case	Call Functions.LOGTCL(...) directly (no instance required) when your code needs to perform the logtcl operation using the supplied tclStatement.

How this member is tested

Act: Functions.LOGTCL("sample")
Assert: no exception is thrown and the expected side effect occurred.

Expected: No return value; verify the intended side effect occurred (state change, event raised, or exception NOT thrown for valid input).

LOWER¶

1 overload · BASIC reference

static DynamicArray Functions.LOWER(string value)

Performs the lower operation using the supplied value.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.LOWER(...) directly (no instance required) when your code needs to perform the lower operation using the supplied value.

How this member is tested

Act: var result = Functions.LOWER("sample")
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.

LTS¶

1 overload

static DynamicArray Functions.LTS(DynamicArray array1, DynamicArray array2)

Performs the lts operation using the supplied array1, array2.


Kind	Method (static)
Returns	`DynamicArray`
Use case	Call Functions.LTS(...) directly (no instance required) when your code needs to perform the lts operation using the supplied array1, array2.

How this member is tested

Act: var result = Functions.LTS(/* a valid DynamicArray value */, /* a valid DynamicArray value */)
Assert: result is a non-null instance whose state matches expectations.

Expected: Returns an instance of DynamicArray; verify its properties reflect the expected resulting state.