Function Pointers in VB Script (revised)

Posted by admin - Dec 9, 2008 Articles, Meir Bar-Tal 0 3 Views : 1527 Receive Updates For This Category

Article Tools

Print this page
Add Comment
Send to Friend
Share This
Last Updated on :
Aug 28, 2011

Abstract

Function pointers are used in C and C++ to enable callbacks and as a result, more generic and parsimonious coding. This article shows how to implement function pointers in VB Script using the Scripting.Dictionary object and the Command Wrapper design pattern. It is also shown how to implement “constructor” functions, callbacks land event handlers.

Keywords: function pointer, callback, delegate, scripting dictionary, hash table, design pattern, command wrapper, event handler.

Introduction

In the following sections I shall explain several basic concepts that are essential to understand the rationale behind the suggested method. The list might be non-exhaustive and the reader is hereby encouraged to recur to complementary sources to fill-in any eventual knowledge gaps.

Function Pointers

A function pointer is a variable that stores the memory address of a block of code that is programmed to fulfill a specific function. Function pointers are useful to avoid complex switch case structures; instead, they support direct access in run-time to previously loaded functions or class methods. This enables the construction of callback functions. A callback is, in essence, executable code that is passed as argument to a function. This enables more generic coding, by having lower-level modules calling higher-level functions or subroutines.

Function pointers are supported by programming languages like C and C++. A recent good introductory text on the subject with implementation examples is Lars Haendel (2005).

This article shows how to implement function pointers in VB script.

Design Patterns

Design patterns are well established generic design techniques whose aim is to make software design and the derived code more parsimonious, scalable, and reusable, as well as more easily maintainable. This article will delve only into the command wrapper design pattern, which is important for its purpose. For a more extensive explanation of design patterns, the reader is encouraged to read the literature in the field (e.g., Gamma, Helm, Johnson, & Vlissides, 1997).

The command-wrapper design pattern enables to load blocks of code dynamically to memory as well as other uses as will be reviewed below. The singleton design pattern is used to restrict instantiation of a class to one object. This is useful when there is no need for more than one object within a system (e.g., a reporter/logger object). For example, the factory design pattern usually implements the singleton design pattern to have a single interface from which to retrieve references to a specific class object or to a variety of class objects.

The Command Wrapper Design Pattern

The command wrapper design pattern is a technique that implements a function as a class, usually with a single public method. During run-time, it is possible to instantiate the class and thus to get a reference (or pointer) to the object. This way, the code embodied in such methods can be dynamically loaded, a feature that can be of great value in systems that are poor in resources. This is especially true when the to-be called function is rarely used. After creating the object, it is possible to execute its method according to need. For example, let us assume a function that adds numbers (note: this example is, of course, trivial. It is done just to illustrate the point.)

Public Function Sum(ByVal arrNumbers)
    Dim ix

    'Check if an array was passed. If so, there's nothing to do – exit function
    If (Not IsArray(arrNumbers)) Then
        'Add your error handling code here
        Exit Function
    End If

    Sum = 0
    For ix = LBound(arrNumbers) To UBound(arrNumbers)
        If (IsNumeric(arrNumbers(ix))) Then
            Sum = Sum + arrNumbers(ix)
        Else
            'Add your error handling code here
        End If
    Next
End Function

'Test the function and display result returned by the Sum function
MsgBox Sum(Array(23, 56, 78, 95, 114)), vbOKOnly, "Result from simple function"


'Now, let us convert this function into an object using the Command Wrapper design pattern:
Class Sum
    Private m_arrVarNumbers
    Private m_varResult

    Private Sub Class_Initialize()
        'Initialize the Numbers member as an empty array
        ReDim m_arrVarNumbers(-1)
    End Sub

    Public Function Init(ByVal arrVarNumbers)
        Numbers = arrVarNumbers
    End Function

    Public Default Function Exec()
        Dim ix, arrNumbers

        'Check if an array was passed. If so, there's nothing to do – exit function
        If (Not IsArray(Numbers)) Then
            'Add your error handling code here
            Exec = "Invalid data type was supplied to perform the operation."
            Exit Function
        ElseIf (UBound(Numbers) - LBound(Numbers) + 1 <= 1) Then
                'Array is empty or has single item - Add your error handling code here
                Exec = "Not enough data was supplied to perform the operation."
                Exit Function
        Else
            arrNumbers = Numbers
        End If

        Result = 0
        For ix = LBound(arrNumbers) To UBound(arrNumbers)
            If (IsNumeric(arrNumbers(ix))) Then
                Result = Result + arrNumbers(ix)
            Else
                'Add your error handling code here
            End If
        Next
        Exec = Result
    End Function

    Public Property Get Numbers()
        Numbers = m_arrVarNumbers
    End Property

    Private Property Let Numbers(ByVal arrVarNumbers)
        m_arrVarNumbers = arrVarNumbers
    End Property

    Public Property Get Result()
        Result = m_varResult
    End Property

    Private Property Let Result(ByVal varResult)
        m_varResult = varResult
    End Property
End Class

'This function behaves as a constructor and returns an initialized instance of the class
Public Function GetSum(ByVal arrNumbers)
    Set GetSum = New Sum
    GetSum.Init(arrNumbers)
End Function

'Test the class
Dim objSum, arrNumbers

'Assign an array of numbers
arrNumbers = Array(23, 56, 78, 95, 114)

'Get an instance of class Sum and initialize it with numbers array
Set objSum = GetSum(arrNumbers)

'Execute Sum (Exec method)
objSum.Exec()

'Display result stored in Result property
MsgBox objSum.Result, vbOKOnly, "Result from Result Property"

'Alternatively, display the result returned by the Exec method:
MsgBox GetSum(Array(23, 56, 78, 95, 114)).Exec, vbOKOnly, "Result from Exec method"

The Scripting Dictionary

In VB Script, the scripting dictionary is an object that stores key-item pairs using a hashing algorithm. The items can be accessed using their corresponding keys. Basically, the dictionary is useful to store variant type, non-structured data, such as the catalog number of an item in an inventory list, or the authors of a list of books, and to retrieve the data using the unique keys supplied, as in the following example:

Dim dicBooksAuthors

'Create an instance of the scripting dictionary class
Set dicBookAuthors = CreateObject("Scripting.Dictionary")

With dicBookAuthors
    'Add some books (keys) and authors (items)
    .Add "The Selfish Gene", "Richard Dawkins"
    .Add "The Mismeasure of Man", "Stephen J. Gould"
    .Add "The Da Vinci Code", "Dan Brown"

    'Answer the question: who wrote "The Selfish Gene"?
    strBook = "The Selfish Gene"
    MsgBox .item(strBook), vbOKOnly+vbInformation, "Author query result for book: " & strBook
End With

The example above demonstrates the power of a dictionary as a data storage and data retrieval device. For instance, it eliminates the need for item search functions (direct access) and avoids duplicate key creation.

However, the dictionary can be much more than just a data storage and retrieval device. Thanks to its capacity to store variant data types, it is actually possible to store references to objects of different types. For instance, it is possible to store complex data structures by using nested dictionaries (this issue, however, is out of the scope of the current paper). In the next chapter, we shall delve into a method to exploit this feature of the scripting dictionary object to implement function pointers in VBScript.

Implementing Function Pointers in VB Script

Earlier in this article, we have shown that it is possible to encapsulate any function as a class by using the command wrapper design pattern. In addition, it has been indicated that the VBScript Scripting Dictionary object is equipped with the capacity of storing variant data types, including references to objects. In what follows a method will be described to combine these two features into a powerful design and programming technique.

Recall that a pointer is a variable that stores the memory address of a function or instantiated class object. Following the example given above in the Command Wrapper section, we shall now show how it is possible to build function pointers using a Scripting Dictionary. Here below, we shall demonstrate the case of the four basic arithmetic operations.

The Addition Operation

Class Sum
    Private m_arrVarNumbers
    Private m_varResult

    Private Sub Class_Initialize()
        'Initialize the Numbers member as an empty array
        ReDim m_arrVarNumbers(-1)
    End Sub

    Public Function Init(ByVal arrVarNumbers)
        Numbers = arrVarNumbers
    End Function

    Public Default Function Exec()
        Dim ix, arrNumbers

        If (Not IsArray(Numbers)) Then 'Not an array, so nothing to do – exit function
            'Add your error handling code here
            Exec = "Invalid data type was supplied to perform the operation."
            Exit Function
        ElseIf (UBound(Numbers) - LBound(Numbers) + 1 <= 1) Then
            'Array is empty or has single item - Add your error handling code here
            Exec = "Not enough data was supplied to perform the operation."
            Exit Function
        Else
            arrNumbers = Numbers
        End If

        Result = 0
        For ix = LBound(arrNumbers) To UBound(arrNumbers)
            If (IsNumeric(arrNumbers(ix))) Then
                Result = Result + arrNumbers(ix)
            Else
                'Add your error handling code here
            End If
        Next
        Exec = Result
    End Function

    Public Property Get Numbers()
        Numbers = m_arrVarNumbers
    End Property

    Private Property Let Numbers(ByVal arrVarNumbers)
        m_arrVarNumbers = arrVarNumbers
    End Property

    Public Property Get Result()
        Result = m_varResult
    End Property

    Private Property Let Result(ByVal varResult)
        m_varResult = varResult
    End Property
End Class

'This function behaves as a constructor and returns an initialized instance of the class
Public Function GetSum(ByVal arrNumbers)
    Set GetSum = New Sum
    GetSum.Init(arrNumbers)
End Function

The Subtraction Operation

Class Subtract
    Private m_arrVarNumbers
    Private m_varResult

    Private Sub Class_Initialize()
        'Initialize the Numbers member as an empty array
        ReDim m_arrVarNumbers(-1)
    End Sub

    Public Function Init(ByVal arrVarNumbers)
        Numbers = arrVarNumbers
    End Function

    Public Default Function Exec()
        Dim ix, arrNumbers

        If (Not IsArray(Numbers)) Then 'Not an array, so nothing to do – exit function
            'Add your error handling code here
            Exec = "Invalid data type was supplied to perform the operation."
            Exit Function
        ElseIf (UBound(Numbers) - LBound(Numbers) + 1 <= 1) Then
            'Array is empty or has single item - Add your error handling code here
            Exec = "Not enough data was supplied to perform the operation."
            Exit Function
        Else
            arrNumbers = Numbers
        End If

        Result = arrNumbers(LBound(arrNumbers))- arrNumbers(LBound(arrNumbers)+1)
        For ix = LBound(arrNumbers)+2 To UBound(arrNumbers)
            If (IsNumeric(arrNumbers(ix))) Then
                Result = Result - arrNumbers(ix)
            Else
                'Add your error handling code here
            End If
        Next
        Exec = Result
    End Function

    Public Property Get Numbers()
        Numbers = m_arrVarNumbers
    End Property

    Private Property Let Numbers(ByVal arrVarNumbers)
        m_arrVarNumbers = arrVarNumbers
    End Property

    Public Property Get Result()
        Result = m_varResult
    End Property

    Private Property Let Result(ByVal varResult)
        m_varResult = varResult
    End Property
End Class

'This function behaves as a constructor and returns an initialized instance of the class
Public Function GetSubtract(ByVal arrNumbers)
    Set GetSubtract = New Subtract
    GetSubtract.Init(arrNumbers)
End Function

The Multiplication Operation

Class Multiply
    Private m_arrVarNumbers
    Private m_varResult

    Private Sub Class_Initialize()
        'Initialize the Numbers member as an empty array
        ReDim m_arrVarNumbers(-1)
    End Sub

    Public Function Init(ByVal arrVarNumbers)
        Numbers = arrVarNumbers
    End Function

    Public Default Function Exec()
        Dim ix, arrNumbers

        If (Not IsArray(Numbers)) Then 'Not an array, so nothing to do – exit function
            'Add your error handling code here
            Exec = "Invalid data type was supplied to perform the operation."
            Exit Function
        ElseIf (UBound(Numbers) - LBound(Numbers) + 1 <= 1) Then
            'Array is empty or has single item - Add your error handling code here
            Exec = "Not enough data was supplied to perform the operation."
            Exit Function
        Else
            arrNumbers = Numbers
        End If

        Result = arrNumbers(LBound(arrNumbers)) * arrNumbers(LBound(arrNumbers)+1)
        For ix = LBound(arrNumbers)+2 To UBound(arrNumbers)
            If (IsNumeric(arrNumbers(ix))) Then
                Result = Result * arrNumbers(ix)
            Else
                'Add your error handling code here
            End If
        Next
        Exec = Result
    End Function

    Public Property Get Numbers()
        Numbers = m_arrVarNumbers
    End Property

    Private Property Let Numbers(ByVal arrVarNumbers)
        m_arrVarNumbers = arrVarNumbers
    End Property

    Public Property Get Result()
        Result = m_varResult
    End Property

    Private Property Let Result(ByVal varResult)
        m_varResult = varResult
    End Property
End Class

'This function behaves as a constructor and returns an initialized instance of the class
Public Function GetMultiply(ByVal arrNumbers)
    Set GetMultiply = New Multiply
    GetMultiply.Init(arrNumbers)
End Function

The Division Operation

Class Divide
    Private m_arrVarNumbers
    Private m_varResult

    Private Sub Class_Initialize()
        'Initialize the Numbers member as an empty array
        ReDim m_arrVarNumbers(-1)
    End Sub

    Public Function Init(ByVal arrVarNumbers)
        Numbers = arrVarNumbers
    End Function

    Public Default Function Exec()
        Dim ix, arrNumbers

        If (Not IsArray(Numbers)) Then 'Not an array, so nothing to do – exit function
            'Add your error handling code here
            Exec = "Invalid data type was supplied to perform the operation."
            Exit Function
        ElseIf (UBound(Numbers) - LBound(Numbers) + 1 <= 1) Then
            'Array is empty or has single item - Add your error handling code here
            Exec = "Not enough data was supplied to perform the operation."
            Exit Function
        Else
            arrNumbers = Numbers
        End If

        If (IsNumeric(arrNumbers(LBound(arrNumbers))) And IsNumeric(arrNumbers(LBound(arrNumbers)+1)) And (arrNumbers(LBound(arrNumbers)+1) <> 0)) Then
            Result = arrNumbers(LBound(arrNumbers)) / arrNumbers(LBound(arrNumbers)+1)
        Else
            'Add your error handling code here
            Exec = "Invalid data was supplied to perform the operation."
            Exit Function
        End If

        For ix = LBound(arrNumbers)+2 To UBound(arrNumbers)
            If (IsNumeric(arrNumbers(ix)) And (arrNumbers(ix) <> 0)) Then
                Result = Result / arrNumbers(ix)
            Else
                'Add your error handling code here
            End If
        Next
        Exec = Result
    End Function

    Public Property Get Numbers()
        Numbers = m_arrVarNumbers
    End Property

    Private Property Let Numbers(ByVal arrVarNumbers)
        m_arrVarNumbers = arrVarNumbers
    End Property

    Public Property Get Result()
        Result = m_varResult
    End Property

    Private Property Let Result(ByVal varResult)
        m_varResult = varResult
    End Property
End Class

'This function behaves as a constructor and returns an initialized instance of the class
Public Function GetDivide(ByVal arrNumbers)
    Set GetDivide = New Divide
    GetDivide.Init(arrNumbers)
End Function

Using the Function Pointers to Perform the basic Arithmetic Operations

 1: Dim dicFunctionHandler

2:

 3: 'Create an instance of the scripting dictionary class

 4: Set dicFunctionHandler = CreateObject("Scripting.Dictionary")

5:

 6: 'Load some functions

 7: With dicFunctionHandler

 8:     .Add "+", New Sum

 9:     .Add "-", New Subtract

 10:     .Add "*", New Multiply

 11:     .Add "/", New Divide

 12: End With

13:

 14: 'Execute the functions using the Function Handler

 15: With dicFunctionHandler

 16:     With .item("+")

 17:         Call .Init(Array(23, 56, 78, 95, 114))

 18:         MsgBox .Exec(), vbOKOnly+vbInformation, "Result (+)" 'Display result returned by the Exec method

 19:     End With

 20:     With .item("-")

 21:         Call .Init(Array(117, 23))

 22:         MsgBox .Exec(), vbOKOnly+vbInformation, "Result (-)" 'Display result returned by the Exec method

 23:     End With

 24:     With .item("*")

 25:             Call .Init(Array(7, 5))

 26:             MsgBox .Exec(), vbOKOnly+vbInformation, "Result (*)" 'Display result returned by the Exec method

 27:     End With

 28:     With .item("/")

 29:         Call .Init(Array(84, 12))

 30:         MsgBox .Exec(), vbOKOnly+vbInformation, "Result (/)" 'Display result returned by the Exec method

 31:     End With

 32: End With

33:

 34: 'Or, using the "constructors":

 35: 'First, load some functions

 36: With dicFunctionHandler

 37:     .RemoveAll

 38:     .Add "+", GetSum(Array(23, 56, 78, 95, 114))

 39:     .Add "-", GetSubtract(Array(117, 23))

 40:     .Add "*", GetMultiply(Array(7, 5))

 41:     .Add "/", GetDivide(Array(84, 12))

 42: End With

43:

 44: 'Second, execute the functions using the Function Handler

 45: With dicFunctionHandler

 46:     MsgBox .item("+").Exec(), vbOKOnly+vbInformation, "Result (+)" 'Display result returned by the Exec method

 47:     MsgBox .item("-").Exec(), vbOKOnly+vbInformation, "Result (-)" 'Display result returned by the Exec method

 48:     MsgBox .item("*").Exec(), vbOKOnly+vbInformation, "Result (*)" 'Display result returned by the Exec method

 49:     MsgBox .item("/").Exec(), vbOKOnly+vbInformation, "Result (/)" 'Display result returned by the Exec method

 50: End With

In the above example we have shown how to:

Implement the Command Wrapper design pattern in VBScript;
Implement a “constructor” for a class in VBScript;
Implement a function handler using a scripting dictionary;
Instantiate such custom classes and load them to a scripting dictionary;
Call the loaded function via the dictionary key and retrieve the result.

This is the method suggested in this paper to implement a function pointer in VBScript.

There is also another possible way to call a function implemented with this method, as follows:

 1: 'Execute the functions using the Function Handler

 2: MsgBox dicFunctionHandler(“+”).Exec(), vbOKOnly+vbInformation, "Result (+)"

 3: MsgBox dicFunctionHandler(“-”).Exec(), vbOKOnly+vbInformation, "Result (-)"

 4: MsgBox dicFunctionHandler(“*”).Exec(), vbOKOnly+vbInformation, "Result (*)"

 5: MsgBox dicFunctionHandler(“/”).Exec(), vbOKOnly+vbInformation, "Result (/)"

and this is because the item property is the scripting dictionary’s default property.

In a similar fashion, it is possible to define the Exec methods of the above mentioned classes as Default (by declaring it: Public Default Function) and then the code above can be further reduced to:

 1: 'Execute the functions using the Function Handler

 2: MsgBox dicFunctionHandler(“+”), vbOKOnly+vbInformation, "Result (+)"

 3: MsgBox dicFunctionHandler(“-”), vbOKOnly+vbInformation, "Result (-)"

 4: MsgBox dicFunctionHandler(“*”), vbOKOnly+vbInformation, "Result (*)"

 5: MsgBox dicFunctionHandler(“/”), vbOKOnly+vbInformation, "Result (/)"

6:

The readers are encouraged to try to execute the sample code shown in this paper, as well as to try the method to implement their own functionality.

Performance of Function Pointers

A small case study comparing the performance of regular function calls with that of function pointers shows that the more a function is used, the more worthwhile it is to use function pointers.

Number of Calls	Single	10	20	50	100
Regular calls	0.0943	0.5630	1.0635	2.5806	5.0674
Function Pointers	0.1561	0.5308	0.9212	2.0922	4.1219

Discussion

We have seen so far how to implement the Command Wrapper design pattern in VBScript and a “constructor” for a class in VBScript, as well as a function handler using a scripting dictionary. We have also shown how to instantiate such custom classes and load them to a scripting dictionary, together with different ways to call the loaded function via the dictionary key and to retrieve the result. We have also indicated that this method is, in fact, equivalent to the implementation of a function pointer in C or C++.

The general uses and benefits of function pointers are explained elsewhere (e.g., Lars Haendel, 2005), and hence they will not be covered here. In what remains I shall attempt to convey in which cases the implementation of this design pattern in VBScript in general, and with Quicktest Pro (QTP) in particular, might be of benefit.

First, the method presented in this paper should be of great value when the basic hardware configuration is poor, i.e., when the system is low in RAM, by means of dynamic loading of code blocks. Recall that common QTP usage requires the automation developer to add every single function library to the test resources.

Second, by implementing a function handler as illustrated above, it would be possible to build a generic controller component that would enable execution of real keyword-driven scripts. With such a component it would be possible, for example, to define the flow of the different code blocks in an external file, such as an XML file.

Third, the method can be used to emulate callbacks, which is a central feature of function pointers. This can be easily done by passing the function handler entry (dictionary item) to another function.

Fourth, the method can be used to emulate event handling. This can be achieved by returning a string with the name of the function to be called. Please notice that this technique would yield a highly parsimonious coding style, for it makes the need for decision structures to analyze the return code of a function obsolete. An example for this can be found in Appendix 2.

Conclusion

This paper attempted to demonstrate how to implement function pointers in VBScript, and pinpointed the possible uses and advantages of the method in general and particularly for QTP. It is concluded that the technique can help developers to achieve more efficient and generic design and code, and better run-time resources management. Future forthcoming articles will further expand on several topics mentioned throughout this paper.

References

Haendel, L. (2005). The Function Pointer Tutorials. Introduction to C and C++ Function Pointers, Callbacks and Functors. Source: http://www.newty.de/fpt/zip/e_fpt.pdf

Gamma, E., Helm, R., Johnson, R., & Vlissides, J. (1997). Design Patterns: Elements of Reusable Object Oriented Software. Addison-Wesley Publishing.

Appendix 1: Event Handling Example

We shall show here how to implement an event handler in VBScript for a typical login flow in QTP. The flow includes three functions: Login, FirstTest and Logout. In addition, two additional functions (AbortTest and Cleanup) are included for error handling and orderly exiting the test flow. Within the TestFlow Sub, the functions are loaded using a generic function (class) loader function (GetFunction), and then called according to their order in the arrRunActions, with their corresponding arguments from arrActionArgs. As can be seen in the code, in case of error the Login.Exec function returns the name of the action to be performed (AbortTest). This action is then performed by means of the statement: strNextAction = dicFunctionHandler(strNextAction)(arrArgs), and since the for loop continues to advance, the normal course of the test flow is altered such that the FirstTest action is never executed.

 1: Class Login

 2:     Public Default Function Exec(ByVal arrArgs)

 3:         'Add your code here

 4:         If (Not IsArray(arrArgs)) Then

 5:             MsgBox "Error: username & password are mandatory parameters.", _

 6:                     vbOKOnly+vbCritical, "Login"

 7:             Exec = "AbortTest"

 8:         Else

 9:             MsgBox Join(arrArgs, ";"), vbOKOnly+vbInformation, "Login"

 10:             Exec = ""

 11:         End If

 12:     End Function

 13: End Class

14:

 15: Class Logout

 16:     Public Default Function Exec(ByVal arrArgs)

 17:         MsgBox "Exec", vbOKOnly+vbInformation, "Logout"

 18:         'Add your code here

 19:     End Function

 20: End Class

21:

 22: Class AbortTest

 23:     Public Default Function Exec(ByVal arrArgs)

 24:         MsgBox "Exec", vbOKOnly+vbCritical, "AbortTest"

 25:         Exec = "Cleanup"

 26:         'Add your code here

 27:     End Function

 28: End Class

29:

 30: Class FirstTest

 31:     Public Default Function Exec(ByVal arrArgs)

 32:         MsgBox "Exec", vbOKOnly+vbInformation, "FirstTest"

 33:         'Add your code here

 34:     End Function

 35: End Class

36:

 37: Class Cleanup

 38:     Public Default Function Exec(ByVal arrArgs)

 39:         MsgBox "Exec", vbOKOnly+vbInformation, "Cleanup"

 40:         'Add your code here

 41:     End Function

 42: End Class

43:

 44: 'This generic function will load any class

 45: Public Function GetFunction(ByVal strFunctionName)

 46:     Execute "Set GetFunction = New " & strFunctionName

 47: End Function

48:

 49: 'This sub will run the flow

 50: Public Sub TestFlow(ByVal arrLoadActions, ByVal arrRunActions, ByVal arrActionArgs)

 51:     Dim dicFunctionHandler, ix, arrArgs, strNextAction

52:

 53:     Set dicFunctionHandler = CreateObject("Scripting.Dictionary")

 54:     Set arrArgs = CreateObject("Scripting.Dictionary")

55:

 56:     'Load the required functions

 57:     With dicFunctionHandler

 58:         For ix = LBound(arrLoadActions) To UBound(arrLoadActions)

 59:             .Add arrLoadActions (ix), GetFunction(arrLoadActions (ix))

 60:         Next

 61:     End With

62:

 63:     'Run the required flow

 64:     strNextAction = ""

 65:     For ix = LBound(arrRunActions) To UBound(arrRunActions)

 66:         'Get the action arguments

 67:         arrArgs = split(arrActionArgs(ix), ";")

 68:         If (UBound(arrArgs) - LBound(arrArgs) + 1 = 0) Then

 69:             'If no args are found, pass an empty string

 70:             arrArgs = ""

 71:         End If

 72:         'If the next command is empty

 73:         If (strNextAction = "") Then

 74:             'Run the next planned action

 75:             strNextAction = dicFunctionHandler(arrRunActions(ix))(arrArgs)

 76:         Else

 77:             'Run the action returned by the previously call action

 78:             strNextAction = dicFunctionHandler(strNextAction)(arrArgs)

 79:         End If

 80:     Next

 81: End Sub

82:

 83: Call TestFlow(Array("Login", "FirstTest", "Logout", "AbortTest", "Cleanup"), _

 84:               Array("Login", "FirstTest", "Logout"), Array("User;123456", "", ""))

Appendix 2: Implementing a Callback with Function Pointers

We shall show here how to implement a callback with the classes defined in Appendix 1 and used in this paper. The example used here will be the calculation of the total amount plus the tax on the sum of several items prices.

 1: 'Define a constant with the tax value multiplier

 2: Const CONST_DBL_VAT = 1.155

3:

 4: 'Now, by dynamically loading the functions without the function handler (as shown earlier in this article):

 5: 'Execute the (*) function on the result of the (+) function to calculate the tax on an item

 6: MsgBox GetMultiply(Array(GetSum(Array(23, 56, 78, 95, 114)), CONST_DBL_VAT)), _

 7:                 vbOKOnly, "Result (Tax)"

8:

True, the syntax looks complicated, but it is very useful.