%REM
This is an example of how to write a pseudo-Singleton class
in LotusScript. It's not as straightforward as creating a classic
Singleton class in a fully object-oriented language because:

1. LotusScript classes can't have static methods
2. LotusScript classes can't have Private constructors

One way people try to create Singletons is by creating a global
instance of some Public class, writing a "factory" function that
returns the global instance (instantiating it if necessary), and then
hoping that anything that calls your code uses the factory function
instead of just creating a new instance of your class on its own.

What you're really doing there is creating a global instance of the
class object though, not a true single instance. If someone decides
to skip your factory function and create their own instance of your
class, suddenly you have two instances of the class running around,
acting independently.

Here's a trick to get around that. If you declare a class as PRIVATE
in a script library, it's not accessible outside the library. However, 
if you have something inside that script library (class method or 
function) that returns an instance of that Private class as a VARIANT, 
then suddenly you can call all the methods of that PRIVATE class and 
use it just like it's a regular Public class.

Since LotusScript doesn't have any kind of type-ahead for custom classes, 
you don't lose any functionality -- you still have to refer back to the 
original class to see how it works anyway. 

And it solves the problem of having to cross your fingers and hope
that developers who call your class call it the way you tell them to
(i.e. -- using a factory, or only ever referring to a single global instance).
Instead, a developer HAS to use your factory to get an instance of your
class, but they can use it just like any other class -- the only difference
being that changes to one instance of the class will affect all instances
of the class.

Another nice thing about this implementation is that it's very easy to take
an existing class and make it Singleton-like. Just turn it into a Private
class, create a Private global instance of it, and write the small Public
factory class.

An example implementation of this type of pseudo-Singleton class is
provided below. If you want to test it, save it all in the Declarations section
of a script library and write an agent like this:

================================

Option Public
Option Declare

'** obviously, use the name of your script library here
Use "ThingTest"

Sub Initialize
    Dim MyMessageThing As Variant
    Dim MyOtherMessageThing As Variant
    Dim factory As New ThingFactory
   
    '** get your MessageThings
    Set MyMessageThing = factory.getMessageThing()
    Set MyOtherMessageThing = factory.getMessageThing()
   
    '** both things act like the same object, because
    '** a modification to one also modifies the other.
    Print "Message = " & MyMessageThing.getMessage
    MyOtherMessageThing.setMessage("blah")
    Print "Message = " & MyMessageThing.getMessage
    Print "Are these things the same? " & _
    (MyMessageThing Is MyOtherMessageThing)


    '** can't do this, because singleMessage is Private
    'Print singleMessage.getMessage
    
    '** can't do this either, because MessageThing
    '** is also Private
    'Dim mt3 As New MessageThing
End Sub

================================

As with much of the other code that I write and publish, you can
use this code in any way you want, as long as you don't hold me
liable for anything, and you don't pretend you wrote it yourself
(i.e. -- please give proper attribution).

Thanks VERY MUCH to Bill Buchan ( http://www.billbuchan.com ) for
looking at my initial implementation of all this and pointing out
that I could use the factory method instead of the wrapper method
I had originally devised.

version 1.0
December 26, 2005
Julian Robichaux ( http://www.nsftools.com )

%END REM


'** This is the class we use as the basis of our pseudo-Singleton
'** class. Because it's Private, nothing outside of this script library
'** can create an instance of it. However, all the public methods
'** will be available when the class is obtained from the factory.
Private Class MessageThing
    Public msg As String
    
    Public Sub setMessage (msg As String)
        Me.msg = msg
    End Sub
    
    Public Function getMessage() As String
        getMessage = msg
    End Function
End Class


'** This is the single instance of MessageThing we'll be referencing.
'** Its methods can be called by other classes in this script
'** library, but because it's Private, other code that uses this
'** library can't access it directly -- it can only be used by other
'** classes and functions in this library (and we're making sure
'** that this library's code uses it responsibly)
Private singleMessage As MessageThing


'** Finally, this is the class that acts as our pseudo-Singleton
'** class. It instantiates the singleMessage variable above if
'** necessary, and returns a pointer to it as a Variant.
'** 
'** Note that you can actually have multiple instances of this factory
'** class, but each instance is really referring back to a single
'** instance of the Private class, which is the real point. And luckily
'** for us, LotusScript doesn't have threads so we don't have to
'** code around any weird multi-threading possibilities.
'** 
'** The entire factory class below could also just be a function, if you
'** wanted to write it that way.
Public Class ThingFactory
    Public Function getMessageThing() As Variant
        If (singleMessage Is Nothing) Then
            Set singleMessage = New MessageThing
        End If
        Set getMessageThing = singleMessage
    End Function
End Class