The Factory method pattern defines an interface for creating and objects, but lets subclasses to decide which class they will create.

Huh?

I will try to present this pattern on a simple example. Imagine you work in a company that sales software. However, this software is, due to different laws, different for each country/region it is sold in (in our case EU and USA). You have two types of software (Pro and Basic that differ by price and package). You will need to create a single store that will allow users to only buy products from their country.

First, you can create an abstract class that will represent a product.

Class CSoftware
	m_strName As String

	Property Get ProductName As String
		ProductName = Me.m_strName
	End Property

	Sub New
	End Sub

	Sub PreparePackage ()
	End Sub

	Sub PrintPrice ()
	End Sub
End Class

As you can see, the class itself is pretty simple. It contains a member variable for product name and has two methods that will prepare a package and print it’s price.
Now (as you need two product types for two countries) you need to create 4 product classes that will inherit from CSoftware class. I will only show you both EU classes as others are pretty self explanatory.

Class CEUSoftwareBasic As CSoftware
	Sub New
		Me.m_strName = "EU Basic"
	End Sub

	Sub PreparePackage ()
		'TODO: put your code here
	End Sub

	Sub PrintPrice ()
		'TODO: put your code here
	End Sub
End Class

Class CEUSoftwarePro As CSoftware
	Sub New
		Me.m_strName = "EU Pro"
	End Sub

	Sub PreparePackage ()
		'TODO: put your code here
	End Sub

	Sub PrintPrice ()
		'TODO: put your code here
	End Sub
End Class

There. You are done with products. Now, you need two stores, that will create desired products. But first, you should create an abstract store class.

Class CSoftwareStore
	Function orderSoftware (swtype As String) As CSoftware
		Dim sw As CSoftware

		Set sw = createSoftwarePackage (swtype)
		Call sw.PreparePackage ()
		Call sw.PrintPrice ()

		Set orderSoftware = sw
	End Function

	Function createSoftwarePackage (swtype As String) As CSoftware
	End Function
End Class

As you can see, createSoftwarePackage method is empty. This is because createSoftwarePackage differs from store to store. Method orderSoftware, though, is the same for all stores and can be implemented in abstract class.
Now, a source of both stores that inherit from CSoftwareStore.

Class CEUSoftwareStore As CSoftwareStore
	Function createSoftwarePackage (swtype As String) As CSoftware
		Dim sw As CSoftware

		Select Case (Lcase (swtype))
		Case "basic": Set sw = New CEUSoftwareBasic ()
		Case "pro": Set sw = New CEUSoftwarePro ()
		End Select

		Set createSoftwarePackage = sw
	End Function
End Class

Class CUSASoftwareStore As CSoftwareStore
	Function createSoftwarePackage (swtype As String) As CSoftware
		Dim sw As CSoftware

		Select Case (Lcase (swtype))
		Case "basic": Set sw = New CUSASoftwareBasic ()
		Case "pro": Set sw = New CUSASoftwarePro ()
		End Select

		Set createSoftwarePackage = sw
	End Function
End Class

Each store creates and returns an object depending on the type we wanted.

But what will that bring me?

You will only have to know which store you need to use and not care about the product returned. That is a job of each separate store. Thus, your code will be easier to read and to maintain.
Pasted below is a sample execution code.

Sub Initialize
	Dim storeEU As CEUSoftwareStore
	Dim storeUSA As CUSASoftwareStore
	Dim sw As CSoftware

	Set storeEU = New CEUSoftwareStore ()
	Set storeUSA = New CUSASoftwareStore ()

	Set sw = storeEU.orderSoftware ("basic")
	Print "Package: " & sw.ProductName

	Set sw = storeUSA.orderSoftware ("pro")
	Print "Package: " & sw.ProductName
End Sub

The agent creates both stores and then for each store orders a software. Printed results should be:

Package: EU Basic
Package: USA Pro

The Singleton Pattern ensures a class has only one instance, and provides a point of access to it.

So why would you need that? Well, there are many objects you only need one of in your application (e.g. Logging, text trimming, for loading strings from a view, etc.). It assures you that you only have one instance of the class and that no one can create another instance on its own. Thus, you need a global access point to deliver the handle to the class.

How do we do that?

I will use my text-trimming class (called CLimitedString) for this presentation.  The class is pretty simple. It’s basic task is to trim text after n characters and append “…” afterwards. Default limit is set to 30, but user can set other value via Limit property.

Private Class CLimitedString
    Private m_nLimit As Integer

    Public Sub New ()
        'setting default value
        Me.m_nLimit = 30
    End Sub

    Public Property Get Limit As Integer
        Limit = Me.m_nLimit
    End Property

    Public Property Set Limit As Integer
        Me.m_nLimit = Limit
    End Property

    Public Function Process (source As String) As String
        If (Len (source) < Me.Limit) Then
            Process = source
            Exit Function
        End If

        Process = Strleftback (Left (source, Me.Limit), " ") &_
        "..."
    End Function
End Class

As LotusScript does not support private constructors, we will have to create a private class instead. This means that you won’t be able to access this class from anywhere else but this ScriptLibrary. Thus, we need to create a global variable to store class instance and a script library function as a global point of access.
Variable:

Private currLimitedString As CLimitedString

Script library function:

Function GetLimitedStringInstance As Variant
    If (currLimitedString Is Nothing) Then
        Set currLimitedString = New CLimitedString
    End If

    Set GetLimitedStringInstance = currLimitedString
End Function

As your class is private, this function must return Variant, as code using this class isn’t aware of class’ existence. The usage of the object remains the same.

How do I call my class?

It is quite simple. All you need to do is include your library into an agent for example and then do the following where needed:

...
Dim vLimitedString As Variant
...
vLimitedString = GetLimitedStringInstance
vLimitedString.Limit = 10
Messagebox vLimitedString.Process ("My very first singleton class")