The Goal

We want to:

1. Search through subfolders automatically.
2. Add a maxDepth parameter so we don’t accidentally crawl the entire hard drive.
3. Keep the simple version working using method overloading.

Step 1: Move File Reading to its own Method

The original FindInFiles function did everything: validated the folder, looped through children, read file content, and matched text. Adding recursion to that would make the code look ugly, so let’s refactor our code.

We’ll start by moving the file-reading logic into its own private method: SearchFile. This keeps the “search” logic separate from the “looping” logic.

Private Sub SearchFile(file As FolderItem, searchTerm As String, hits() As SearchHit)
  Try
    Var input As TextInputStream = TextInputStream.Open(file)
    input.Encoding = Encodings.UTF8
    Var lineNumber As Integer = 0
    While Not input.EndOfFile
      Var line As String = input.ReadLine
      lineNumber = lineNumber + 1
      If line.Contains(searchTerm, ComparisonOptions.CaseInsensitive) Then
        hits.Add(New SearchHit(file.NativePath, lineNumber, line))
      End If
    Wend
    input.Close
  Catch error As IOException
    // Skip unreadable files
  End Try
End Sub

Step 2: Recursive Folder Traversal

Now we create SearchFolder. This method loops through a folder. If it finds a file, it calls SearchFile. If it finds a folder, it calls itself.

To keep this safe, we Use maxDepth:

• maxDepth = 0: Search only this folder.
• maxDepth > 0: Search this folder and N levels of subfolders.
• maxDepth = -1: Search everything (unlimited).

Private Sub SearchFolder(folder As FolderItem, searchTerm As String, hits() As SearchHit, maxDepth As Integer)
   Try
    For Each item As FolderItem In folder.Children
      If item Is Nil Or Not item.Exists Or Not item.IsReadable Then Continue
      If item.IsFolder Then
        If maxDepth <> 0 Then
          Var nextDepth As Integer = If(maxDepth > 0, maxDepth - 1, maxDepth)
          SearchFolder(item, searchTerm, hits, nextDepth)
        End If
      Else
        SearchFile(item, searchTerm, hits)
      End If
    Next
  Catch error As IOException
    // Skip inaccessible folders
  End Try
End Sub

The logic in nextDepth lets us count down if there’s a limit, or stay at -1 if there isn’t.

Step 3: Support Both Versions with Method Overloading

Overloading is a feature that lets you have multiple methods with the same name, as long as they have different parameters. In our case, it allows us to provide a simple version for one folder, and a recursive version with a depth limit. Xojo will automatically pick the right one based on the arguments you pass. You can read more about it in the Xojo Documentation.

The default version (depth 0):

Public Function FindInFiles(targetFolder As FolderItem, searchTerm As String) As SearchHit()
  Return FindInFiles(targetFolder, searchTerm, 0)
End Function

The recursive version:

Public Function FindInFiles(targetFolder As FolderItem, searchTerm As String, maxDepth As Integer) As SearchHit()
  Var hits() As SearchHit
  If targetFolder Is Nil Or Not targetFolder.Exists Or Not targetFolder.IsFolder Or searchTerm.IsEmpty Then
    Return hits
  End If
  Try
    SearchFolder(targetFolder, searchTerm, hits, maxDepth)
  Catch error As IOException
    // Skip inaccessible folders
  End Try
  Return hits
End Function

By separating the validation, traversal, and processing, the code is much easier to modify. If you want to add Regex support, you only change SearchFile. If you want to filter by file extension, you only change SearchFolder.

Summary

Now, you can search a single folder just like before, or crawl a directory tree with one extra parameter:

// Search up to 3 levels deep
Var results() As SearchUtils.SearchHit = SearchUtils.FindInFiles(myFolder, "TODO", 3)

The Complete Recursive Code

The SearchUtils Module

Module SearchUtils

  Class SearchHit
    Public Property FilePath As String
    Public Property LineNumber As Integer
    Public Property LineText As String

    Public Sub Constructor(filePath As String, lineNumber As Integer, lineText As String)
      Self.FilePath = filePath
      Self.LineNumber = lineNumber
      Self.LineText = lineText
    End Sub
  End Class

  Public Function FindInFiles(targetFolder As FolderItem, searchTerm As String) As SearchHit()
    // Simple usage: depth = 0
    Return FindInFiles(targetFolder, searchTerm, 0)
  End Function

  Public Function FindInFiles(targetFolder As FolderItem, searchTerm As String, maxDepth As Integer) As SearchHit()
    // Recursive usage: maxDepth ( -1 is unlimited )

    Var hits() As SearchHit

    If targetFolder Is Nil Or Not targetFolder.Exists Or Not targetFolder.IsFolder Or searchTerm.IsEmpty Then
      Return hits
    End If

    Try
      SearchFolder(targetFolder, searchTerm, hits, maxDepth)
    Catch error As IOException
      // Skip inaccessible folders
    End Try

    Return hits
  End Function

  Private Sub SearchFolder(folder As FolderItem, searchTerm As String, hits() As SearchHit, maxDepth As Integer)
    Try
      For Each item As FolderItem In folder.Children
        If item Is Nil Or Not item.Exists Or Not item.IsReadable Then Continue

        If item.IsFolder Then
          If maxDepth <> 0 Then
            Var nextDepth As Integer = If(maxDepth > 0, maxDepth - 1, maxDepth)
            SearchFolder(item, searchTerm, hits, nextDepth)
          End If
        Else
          SearchFile(item, searchTerm, hits)
        End If
      Next
    Catch error As IOException
      // Skip inaccessible folders
    End Try
  End Sub

  Private Sub SearchFile(file As FolderItem, searchTerm As String, hits() As SearchHit)
    Try
      Var input As TextInputStream = TextInputStream.Open(file)
      input.Encoding = Encodings.UTF8
      Var lineNumber As Integer = 0

      While Not input.EndOfFile
        Var line As String = input.ReadLine
        lineNumber = lineNumber + 1

        If line.Contains(searchTerm, ComparisonOptions.CaseInsensitive) Then
          hits.Add(New SearchHit(file.NativePath, lineNumber, line))
        End If
      Wend

      input.Close
    Catch error As IOException
      // Skip unreadable files
    End Try
  End Sub
End Module

Happy coding!

Gabriel is a digital marketing enthusiast who loves coding with Xojo to create cool software tools for any platform. He is always eager to learn and share new ideas!

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

The Basics of the Number Class

Let’s start with the bare bones of this Number class. Add a new Class to a Xojo project and name it Number in the Inspector Panel.

The value of the Number class is going to be backed by a primitive double property. So add a new Property to the Number class and use the Inspector Panel with the following values:

• Name: Value
• Type: Double
• Scope: Protected

We also want to know when a value is set to any of the Number instances, so go ahead and add a new Property to the Class using the following values in the Inspector Panel:

• Name: IsSet
• Type: Boolean
• Scope: Protected

And of course we want to have the ability to enable or disable any Number instance, so its assigned value may or may not be taken into account when used in any mathematical operation, for example. Add the third of the properties required by our Number class:

• Name: Enabled
• Type: Boolean
• Scope: Public

The next step is to add some constructor Methods to our class, so we can create new instances of it covering several common cases:

• Creating a new instance with no value provided: IsSet property will be set to False, and the Enabled property will be set to True.
• Creating a new instance with the Integer/Double provided: IsSet property will be set to True, and the Enabled property will be set to True.
• Creating a new instance with the numeric value from the provided String: IsSet property will be set to True and the Enabled property will be set to True too.

The default constructor for the class will be the one with no parameters. So add a new method to the Number class using the following values in the Inspector Panel:

• Method Name: Constructor
• Scope: Public

And type the following line of code in the associated Code Editor:

Self.Enabled = True

Add a second method to the class and use the following values in the Inspector Panel (this constructor will create a new instance from the received Integer/Double value):

• Method Name: Constructor
• Parameters: value As Double
• Scope: Public

And type the following lines of code in the associated Code Editor:

Self.Constructor
Self.Value = value
Self.IsSet = True

Let’s add the third constructor, the one taking a String as the parameter. Add a third method to the class using the following values in the Inspector Panel:

• Method Name: Constructor
• Parameters: value As String
• Scope: Public

And type the following lines of code in the associated Code Editor:

Self.Constructor

Self.Value = Double.FromString(value, Locale.Raw)
Self.IsSet = True

But, wait! Wouldn’t it be great if we could create new Number instances from another Number instance received as the parameter? Of course it would! So add a new Method again using the following values in the Inspector Panel:

• Method Name: Constructor
• Parameters: value As Number
• Scope: Public

And type the following lines of code in the associated Code Editor:

Self.Constructor

If value <> Nil and value.IsSet And value.Enabled Then
  Self.Value = value.Value
  Self.IsSet = True
End If

By now our class has four special methods, all of them with the same name: Constructor. If defined in any of your classes, this is the method that will be called/executed every time your code uses the New keyword in combination with the class data type. For example:

Var n As New Number // This calls the by default Constructor.
Var i As New Number(10) // This calls the Constructor taking an Integer/Double as the parameter.
Var s As New Number("120.20") // This calls the Constructor taking a String as the parameter.
Var objNumber As New Number(n) // This calls the Constructor taking a Number instance as the parameter.

When several methods are added to a class using the same method name but with different number of arguments or arguments data types (or returned values), that is called Method Overloading and you will find it in any object-oriented programming language. So our constructor method is overloaded to cover all the expected cases.

As you see, there is nothing fancy in the previous examples. I mean, creating a new instance from the received value in the constructor method is ok, but it would be even better and more simple if we could do something like:

Var i As Number = 10
Var s As Number = "120.20"
Var objNumber = n

Overloading the Assignment Operator

The good news is that we can do that! The Xojo programming language has the ability to overload operators too, just like we did with the constructor method! And when it is about to overload the assignment operator we implement the Operator_Convert method. This one will be called every time our class receives a value from another data type or needs to convert itself to the expected data type; for example:

Var i As Number = 10 // 10 Integer value needs to be converted to a Number instance.
Var intValue As Integer = i // The variable "i" (Number data type) needs to be converted to an Integer data type.

The most important thing to remember is that when Operator_Convert gets into play, the class Constructor is never called! So the code in the Operator_Convert method implementation needs to take care of properly initialising the instance as you expect.

So let’s start implementing the Operator_Convert that will be called every time a Number instance needs to be converted to an Integer or Double value.

Add a new method to the Number class using the following values:

• Method Name: Operator_Convert
• Return Type: Double
• Scope: Public

And type the following line of code in the associated Code Editor:

Return If(Self.Enabled, Self.Value, 0)

Add a second Operator_Convert method, this time change the returned value to a String so our Number instances internal values can be easily assigned to a String variable (or used in other operations with Strings) like this:

Var i As Number = 10
Var s As String = i

Use the following values in the associated Inspector Panel and type the line of code in the associated Code Editor:

• Method Name: Operator_Convert
• Return Type: String
• Scope: Public

Return If(Self.Enabled, Self.Value.ToString(Locale.Raw), "")

We need to overload the Operator_Convert method two more times so it can handle the assignment operation when the received value is at the right of the equal operator instead of the left.

Use the following values in the Inspector Panel for every one of the new two overloaded methods (typing the line(s) of code following each of these):

• Method Name: Operator_Convert
• Parameters: value As Double
• Scope: Public

Self.Enabled = True
Self.Value = value
Self.IsSet = True

• Method Name: Operator_Convert
• Parameters: value As String
• Scope: Public

Self.Enabled = True
Self.Value = Double.FromString(value, locale.Raw)
Self.IsSet = True

Overloading the Add Operator

Assigning values to Number variables or properties or Number instances to Integer / Double or String variables and properties is fine, but not so useful now. So the next step is adding Number instances with another Number instances, Integer / Double data types and also even with all the values from an array. To do this we need to overload the “+” (Add) operator implementing the Operator_Add method in the Number class.

This will allow us to write code like this:

Var n2 As Number = i + 10

Here the “10” value is first converted to a Number instance that is going to be added to the “i” Number instance and then assigned to the “n2” variable.

Var n3 As Integer = i + 10

Here the “10” value is first converted to a Number instance that is added to the “i” number instance and, then, the result converted to an integer value assigned to the “n3” variable.

So we need to implement the Operator_Add taking a Number parameter and returning also a Number data type.

Add a new method to the Number class using the following values in the Inspector Panel, and typing the lines of code following them in the associated Inspector Panel:

• Method Name: Operator_Add
• Parameters: Value As Number
• Return Type: Number
• Scope: Public

If value <> Nil Then
  Var no As New Number(If(Self.Enabled, Self.Value, 0) + value.Value)
  Return no
End If

That one works well when we have a Number instance to the left of the add operation, but not when the Number instance is to the right. For that scenarios we need to overload another method: Operator_AddRight.

Add another method to the Number class using the following values in the associated Inspector Panel:

• Method Name: Operator_AddRight
• Parameters: value As Double
• Return Type: Double
• Scope: Public

And type this line of code in the associated Code Editor:

Return If(Self.Enabled, Self.Value, 0) + value

Adding Number Instances to an Array of Integers

It would be also really helpful if we could add a Number to an array of integer values or even a Number instance to an array containing other array instances. For example, it would look like this in code:

Var arrayNumbers() As Number
Var arrayIntegers() As Integer

For z As Integer = 0 To 10
  arrayNumbers.Add(System.Random.InRange(10, 200))
  arrayIntegers.Add(System.Random.InRange(10, 200))
Next

Var z1 As Number = i + arrayNumbers
Var z3 As Integer = i + arrayIntegers

Of course this implies implementing new overloaded methods both for Convert_Add and Convert_AddRight. These are the implementations for overloading Convert_Add taking an Array of Doubles and also taking an Array of Number instances. I will let the Convert_AddRight implementation to you as exercice:

• Method Name: Operator_AddRight
• Parameters: value() As Integer
• Return Type: Double
• Scope: Public

Var sum As Double

For Each item As Double In values
  sum = sum + item
Next

Return sum + If(Self.Enabled, Self.Value, 0)

• Method Name: Operator_AddRight
• Parameters: value() As Number
• Return Type: Number
• Scope: Public

Var sum As Double

For Each item As Number In values
  If item <> Nil And item.Enabled Then sum = sum + item.Value
Next

Return sum + If(Self.Enabled, Self.Value, 0)

Unset Number Instances

The last step in this Number class is to implement the Method that will take care of Unset the instance; that is, kind of “reset” state where the value is still not defined.

Add a new Method to the Number class using the following values:

• Method Name: Unset
• Scope: Public

And adding the following lines of code to the associated Code Editor:

Self.IsSet = False
Self.Value = 0

Conclusion

As you see, method overloading is a powerful technique as we have done with the constructor method and also with the Operator_Convert, Operator_Add and Operator_AddRight methods. This Number class, with a little work, can be made to to cover other scenarios like the subtract, multiply or divide operations, among others. That wouldn’t be too difficult based on the implementations already exposed for the overloaded Operator_Add and Operator_AddRight methods. Download the Numbers class project.

Further Reading from the Xojo Blog Archives

Methods Overloading: Computed Properties, Setters and Getters

More on Object-Oriented Programming from the Xojo Blog and Xojo Documentation

Javier Menendez is an engineer at Xojo and has been using Xojo since 1998. He lives in Castellón, Spain and hosts regular Xojo hangouts en español. Ask Javier questions on Twitter at @XojoES or on the Xojo Forum.

• Facebook
• X
• LinkedIn
• GitHub
• YouTube

When we define and implement the Operator_Lookup method in our classes, we will be able to use the dot notation to access and assign a value to a class member that has not been defined for the class! That is, it will be the code implemented in this method that will decide how it will act, not the Xojo Compiler. Among other possibilities, this will bring us the flexibility to create a Preferences class that is not attached to a particular project, and that is multiplatform, of course, backed by as many pairs of Keys/Values in a Dictionary as we need to store our apps preferences. This way we can use the simple dot notation both to store and assign the stored values. Let’s put this into practice.

The first step is adding a new Class item to the project without assigning a Super class; that is, this will be a base class. For this example, we will use MyPreferences as the name of the class. Then, we will add a property with Data as the Name and Xojo.Core.Dictionary as the data type, setting its scope to Private (this means that the property will be accessible only from the own class). This property will act as the storage for the Key/Value pairs used for our Preference Class.

Add now a new Constructor method in charge of initializing the just defined Dictionary property:

• Name: Constructor
• Scope: Public

And put this line of code in the Code Editor for the Constructor method:

Data = New Xojo.Core.Dictionary

Now we will add the method that we are really interested in. This is, the overload for the Operator_Lookup method:

• Name: Operator_Lookup
• Parameters: key as string, assigns value as auto
• Scope: Public

Writing the following line of code in the resulting Code Editor:

data.Value( key ) = value

Once implemented, we can take advantage of the feature. If we add the Open Event to the project and write the below snippet of code, we will see how we can use the dot notation to use and access class members that have never been added to the class. These members are captured by the Operator_Lookup method, adding the member as the key for a new entry in the dictionary (this is the text we write after the dot) and assigning to it the value we put after the equal symbol (the assignation operator); thanks to the use of the assigns keyword in the parameters declaration for the Operator_Lookup method.

Dim pr As New MyPreferences
pr.page = 10
pr.index = "20"
pr.baseColor = &c204060

As you can see, Page, Index and BaseColor are not members of our class; these are captured as Keys for the Dictionary thanks to the Operator_Lookup operator. In addition, you can see how we can assign several types of values to these: an Integer, a String and a Color value.

Retrieving data with Operator_Lookup

Now, how can we retrieve values for these not existing members using the dot notation? As you probably guessed, we need to add an additional method that overloads Operator_Lookup. In this case the method signature will accept as the parameter the Key we want to retrieve (the class member put after the dot), returning always a String, in order to simplify this example. Thus, add a new method for the class using the following signature:

• Name: Operator_Lookup
• Parameters: Key As String
• Return Type: String
• Scope: Public

Writing the following code in the associated Code Editor:

Dim a As Auto
Dim s As String
If data.HasKey(key) Then
  a = data.Value(key)
  Dim info As Xojo.Introspection.TypeInfo
  info = xojo.Introspection.GetType(a)
  If info = GetTypeInfo(Text) Or info = GetTypeInfo(String) Then
    s = a
  Elseif info = GetTypeInfo(Integer) Then
    s = CType(a, Integer).totext
  Elseif info= GetTypeInfo(Color) Then
    Dim c As Color = a
    s = Str(c)
  End If
End If
Return s

As you can see, and after verifying that the Dictionary has the Key, we use the Introspection mechanisms provided by the language in order to see what type is associated with the key. Once we have its type, we will convert the value to a String using the appropriate approach for each case: an Integer, a Text/String or a Color. Of course, for brevity, this example doesn’t take into account other possible value types; but that is something you can implement yourself!

Let’s go back to the Open Event for the project and add the following line of code at the end:

MsgBox pr.page + EndOfLine + pr.index + EndOfLine + pr.baseColor

Run it and observe how we can assign values and retrieve them (always as a String) simply using the dot notation. We can take this class from one project to other and use the dot notation to reference the elements we want to save and retrieve as preferences.

Final Word

If you decide to use this approach for your projects, there are some considerations you have to take into account. For example, you will not be able to take advantage of the Autocompletion feature provided by the IDE. In addition, we will have to pay special attention to write exactly the same “member” in all the cases we want refer to it; otherwise we will be using a different key with unexpected results. After all, once implemented, Operator_Lookup for the class the Compiler will not complain about the undefined members you are trying to access!

It would also be very easy to expand the class so it can work with other data types; adding an additional method to serialize the Key/Values pairs so they can be stored on file/database for a later retrieval and reconstruction via an additional Constructor. Finally, it is very probable that you only want to use a MyPreferences instance in your app, so you could implement this class as a Singleton. Do you dare? If you do, tell me about it!

Javier Rodri­guez has been the Xojo Spanish Evangelist since 2008, he’s also a Developer, Consultant and Trainer who has be using Xojo since 1998. He manages AprendeXojo.com and is the developer behind the GuancheMOS plug-in for Xojo Developers, Markdown Parser for Xojo, HTMLColorizer for Xojo and the Snippery app, among others

*Read this post in Spanish