PROCEDURE assertNoDuplicatesInTableRow(tblControl is Control, cbColName is Control, vOldValue is Variant, sDialogText is string )
nFoundIndex is int
nRetValDialog, nRetValInput are int
vSearchValue, vNewValue is string
vSearchValue = cbColName
nFoundIndex = TableSearch(cbColName, vSearchValue)
WHILE ((nFoundIndex > 0) AND (nFoundIndex <> tblControl))
nRetValDialog = Dialog(sDialogText, ["Change", "Cancel"], 1, 2)
IF (nRetValDialog = 1) THEN
nRetValInput = Input("New value", vNewValue)
IF nRetValInput = 2 THEN
MySelf = vOldValue
BREAK
ELSE
nFoundIndex = TableSearch(cbColName, vNewValue)
IF nFoundIndex = tblControl THEN
MySelf = vNewValue
BREAK
END
END
ELSE
MySelf = vOldValue
BREAK
END
END
Asked ChatGPT to refactor ist:
Answer: Get rid of the loop and recall recursivly.
IF nFoundIndex > 0 AND nFoundIndex <> tblControl THEN Dialog(„Duplicate value found. Please enter a different value.“, [„OK“], 1, 1) assertNoDuplicatesInTableRow(tblControl, cbColName, vOldValue, sDialogText) ELSE MySelf = vNewValue END
That of course not WLanguage bu thte idea is decent:
One can write it this way:
PROCEDURE assertNoDuplicatesInTableRow(tblControl is Control, cbColName is Control, vOldValue is Variant, sDialogText is string )
nFoundIndex is int
nRetValDialog, nRetValInput are int
vSearchValue, vNewValue is Variant
vSearchValue = cbColName
nFoundIndex = TableSearch(cbColName, cbColName)
IF ((nFoundIndex > 0) AND (nFoundIndex <> tblControl)) THEN
nRetValDialog = Dialog(sDialogText, ["Change", "Cancel"], 1, 2)
IF nRetValDialog = 2 THEN
MySelf = vOldValue
ELSE
nRetValInput = Input("New value", vNewValue)
IF nRetValInput = 2 THEN
MySelf = vOldValue
// BREAK
ELSE
cbColName.Value = vNewValue
assertNoDuplicatesInTableRow(tblControl,cbColName, vOldValue, sDialogText)
END
END
END
//WHILE ((nFoundIndex > 0) and (nFoundIndex <> tblControl))
// nRetValDialog = Dialog(sDialogText, ["Change", "Cancel"], 1, 2)
// IF (nRetValDialog = 1) THEN
// nRetValInput = Input("New value", vNewValue)
// IF nRetValInput = 2 THEN
// MySelf = vOldValue
// BREAK
// ELSE
// nFoundIndex = TableSearch(cbColName, vNewValue)
// IF nFoundIndex = tblControl THEN
// MySelf = vNewValue
// break
// END
// END
// ELSE
// MySelf = vOldValue
// BREAK
// END
//END
//
//
Is it better? Well, it avoid a loop with different places where one has to break it
It avoids a double call to TableSearch, but replaces it with a recursive call
Other really good suggestions:
function to avoid a double in a two dimensional array
You can use a loop to iterate over the elements in the two-dimensional array and check if a given value already exists. Here’s an example implementation in C#:
csharpCopy codepublic bool CheckIfValueExistsInArray(int[,] array, int value)
{
for (int i = 0; i < array.GetLength(0); i++)
{
for (int j = 0; j < array.GetLength(1); j++)
{
if (array[i, j] == value)
{
return true;
}
}
}
return false;
}
In this example, the CheckIfValueExistsInArray
method takes in a two-dimensional integer array and a value to check for. It then iterates over each element in the array using two nested loops, comparing each element to the given value. If a match is found, the method returns true
. If the loop completes without finding a match, the method returns false
.
You can call this method to check if a value already exists in a two-dimensional array before inserting a new value. You can then decide whether or not to insert the new value based on the return value of the method.
And:
How can I avoid the double loop in the suggested code?
If you want to avoid using nested loops, you can use the Array.IndexOf
method to search for the value in a flattened version of the two-dimensional array. Here’s an example implementation:
csharpCopy codepublic bool CheckIfValueExistsInArray(int[,] array, int value)
{
int[] flattenedArray = new int[array.GetLength(0) * array.GetLength(1)];
Buffer.BlockCopy(array, 0, flattenedArray, 0, flattenedArray.Length * sizeof(int));
return Array.IndexOf(flattenedArray, value) != -1;
}
In this example, the CheckIfValueExistsInArray
method takes in a two-dimensional integer array and a value to check for. It creates a new one-dimensional integer array with the same number of elements as the two-dimensional array by using Buffer.BlockCopy
to copy the elements from the two-dimensional array to the new array. It then uses the Array.IndexOf
method to search for the value in the flattened array. If the value is found, the method returns true
. If the value is not found, the method returns false
.
Note that this approach has some overhead because of the need to create a new flattened array, so it may not be faster than using nested loops for very small arrays. However, it can be more concise and easier to read for larger arrays.