JWSCL provides access to auto pointers or objects. It means that allocated space or objects are automtically destroyed/freed as soon as the auto object runs out of scope. What is a scope? A scope exists as long as the (I say) parent object exists. Parent objects can be:

  1. The process. The auto pointer and thus the object exist as long as the process runs. The object will be destroyed when the process is destroyed.
  2. A class or record. The auto pointer exists as long as the class instance exists. If the instance is freed the managed auto pointer object will be freed as well.

What is not a parent object?

  1. begin end. In contrast to C++, a begin/end construct does not allow to create a variable scope. You have to create a new function do achieve the same effect.
  2. A pointer to an object. Auto pointer to any object (class, record, variable) will not be automatically destroyed. You have to free the memory manually (Dispose, FreeMem) to let the auto pointer take effect.

The current release only allows to create or wrap objects. It is done by the methods of TJwAutoPointer.

The following sample shows how to avoid to manually call free. It uses the Wrap method of TJwAutoPointer to activate the managed pointer mechanism. There is no method to undo this call.

  1. procedure X;
  2. var
  3.   ManagedObject : TJwSecurityID;
  4.   AutoPtr : IJwAutoPointer;
  5. begin
  6.   ManagedObject := TJwSecurityID.Create(…);
  7.   AutoPtr := TJwAutoPointer.Wrap(ManagedObject);
  8. …
  9. //no need to free ManagedObject
  10. end;

The advantage of the auto pointer approach is that we do not need to call Free for every possible exit. Even exceptions cannot avoid that the managed object is destroyed.
The next sample demonstrates this fact.

  1. procedure X;
  2. var
  3.   ManagedObject : TJwSecurityID;
  4.   AutoPtr : IJwAutoPointer;
  5. begin
  6.   ManagedObject := TJwSecurityID.Create(…);
  7.   AutoPtr := TJwAutoPointer.Wrap(ManagedObject);
  8.  
  9.   if DoExit then
  10.    exit;
  11.  
  12.   if Error then
  13.    raise Exception.Create(…);
  14.   …
  15.   //no need to free ManagedObject
  16. end;

The same way can be used to add the IJwAutoPointer variable into classes and records.

  1. uses
  2.   SysUtils,
  3.   JwsclComUtils;
  4. type
  5.   TMyClass = class
  6.   public
  7.     N : String;
  8.     x : IJwAutoPointer;
  9.     constructor Create(Name : String);
  10.     destructor Destroy; override;
  11.   end;
  12.  
  13. TMyRecord = record
  14.   x : IJwAutoPointer;
  15. end;
  16.  
  17. constructor TMyClass.Create(Name: String);
  18. begin
  19.   inherited Create;
  20.   Writeln(‘Create :’,Name);
  21.   N := Name;
  22. end;
  23.  
  24. destructor TMyClass.Destroy;
  25. begin
  26.   Writeln(‘DesTMyRecordoy: ‘,N);
  27.   inherited;
  28. end;
  29.  
  30. procedure X;
  31. var Y,Z : TMyClass;
  32. begin
  33.   Y := TMyClass.Create(‘1′);
  34.   Z := TMyClass.Create(‘2′);
  35.   Y.x := TJwAutoPointer.Wrap(Z);
  36.  
  37.   Y.Free;
  38. end;
  39.  
  40. procedure Y(UseDispose : Boolean);
  41. var
  42.   L : TMyRecord;
  43.   pL : ^TMyRecord;
  44.   Y : TMyClass;
  45. begin
  46.   new(pL);
  47.   Y := TMyClass.Create(‘1′);
  48.   PL.x := TJwAutoPointer.Wrap(Y);
  49.  
  50.   writeln;
  51.   if UseDispose  then
  52.    dispose(PL);
  53. end;

A call to X returns:

Create :1
Create :2
Destroy: 1
Destroy: 2

As you can see, the managed object (Name : “2″) is shortly destroyed after the parent object is destroyed. You should know about this fact, because accessing the parent object will fail (if you are luck) in an exception.

A call to Y(false) returns

Create :1

A call to Y(true) returns

Create :1
Destroy: 1

The next release of JWSCL will bring support for pointers created by New and GetMem as well as LocalAlloc. It will also implement thread safe locking mechanisms.

[Update]

There is no need to save the COM object if you want to keep the object only alive in a single function.
Just wrap it.

  1. procedure X;
  2. var Y,Z : TMyClass;
  3. begin
  4.   Y := TMyClass.Create(‘1′);
  5.   TJwAutoPointer.Wrap(Y);
  6. end;

You even can wrap it several times. All wrapped up instances will be freed, regardeless of the variable’s name.

  1. procedure X;
  2. var Y,Z : TMyClass;
  3. begin
  4.   Y := TMyClass.Create(‘1′);
  5.   TJwAutoPointer.Wrap(Y);
  6.  
  7.   Y := TMyClass.Create(‘2′);
  8.   TJwAutoPointer.Wrap(Y);
  9. end;

Of course you can’t access the first object anymore. But sometimes it comes quite handy.

Send post as PDF to www.pdf24.org
convert this post to pdf.