Re: Factories, handles, and handle wrappers

On 16/12/09 13:50, Michael Mol wrote:
 > Let's say you have a factory which returns handles to objects that it
 > allocates. You pass these handles to the factory whenever you want to
 > use the object or destroy it. The factory's "OperateOnObject" class
 > verifies that the handle is within its object collection, and then
 > marshals the OperateOnObject call to the class's internal
 > OperateOnObject method. All external operations on the object
 > instance are required to pass through the Factory in order to
 > guarantee that the object instance is still valid at the time of call.
 >
 > This leads to code roughly like this. (Not using exceptions here, but
 > rather return error codes.)
 >
 > // For the sake of scope, consider this as a global singleton factory.
 > // For the sake of concerns over initialization and destruction,
 > assume that's dealt with in code not shown.
 > class SomeFactory
 > {
 > public:
 > OBJHANDLE CreateObject();
 > ERRCODE DestroyObject(OBJHANDLE);
 > ERRCODE OperateOnObject(OBJHANDLE objHandle, int someArgument);
 > protected:
 > OBJCOLLECTION objCollection;
 > } factoryObj;
 >
 > // In some function, somewhere
 > OBJHANDLE objHandle = factoryObj.CreateObject();
 > factoryObj.OperateOnObject(objHandle, 42);
 > factoryObj.DestroyObject(objHandle);

In other words, you've got:

1) A factory that creates objects.
2) Those objects implement an interface, which is currently belongs to
factory class.
3) You'd also like for the factory to check whether the object reference
is valid.

You can refactor this to simply things.

1) Extract object interface from the factory.

   struct SomeObject {
       // former SomeFactory::OperateOnObject
       virtual ERRCODE Operate(int someArgument) = 0;
       virtual ~SomeObject() = 0;
   };

Using such object now does not require a factory object, i.e. you can
call Operare() directly on the object.

2) Make factory return smart-pointers to SomeObject. The objects it
creates implement SomeObject interface.

   typedef boost::shared_ptr<SomeObject> SomeObjectPtr;

   class SomeFactory {
   public:
        SomeObjectPtr createSomeObject();
        ...
   };

Now the factory function returns a smart-pointer. This smart-pointer
takes care of destroying the object when it is no longer used. No manual
object destruction required.

3) Using a smart-pointer makes the possibility of using an already
destroyed object highly unlikely. Checking whether the object reference
is valid may be not necessary any more.

New usage:

   SomeFactory factory;

   // later in some function or scope
   {
     SomeObjectPtr object = factory.createSomeObject();
     object->Operate(123);
   } // now object goes out of scope and gets destroyed automatically

This looks to be simpler and more intuitive, isn't it?

--
Max