unit uSmartPointer;

interface

function DoSmartPointer( out Reference: TObject; Instance: TObject ): IUnknown;

implementation

type
  TSmartPointer = class( TInterfacedObject )
  private
    FInstance: TObject;
  public
    constructor Create( AInstance: TObject );
    destructor Destroy; override;
  end;

{ TSmartPointer }

function DoSmartPointer( out Reference: TObject; Instance: TObject ): IUnknown;
begin
  Result := TSmartPointer.Create( Instance );
  TObject(Reference) := Instance;
end;

constructor TSmartPointer.Create(AInstance: TObject);
begin
  FInstance := AInstance;
end;

destructor TSmartPointer.Destroy;
begin
  FInstance.Free;

  inherited;
end;

end.

procedure GetData;
var l: TList;
begin
  DoSmartPointer( TObject(l), TList.Create )
end;

unit SmartPointerClass;

interface

uses
  Generics.Defaults;

type
  TSmartPointer<T: class, constructor> = record
  strict private
    FValue: T;
    FFreeTheValue: IInterface;
    function GetValue: T;
  private
    type
      TFreeTheValue = class (TInterfacedObject)
      private
        fObjectToFree: TObject;
      public
        constructor Create(anObjectToFree: TObject);
        destructor Destroy; override;
      end;
  public
    constructor Create(AValue: T); overload;
    procedure Create; overload;
    class operator Implicit(AValue: T): TSmartPointer<T>;
    class operator Implicit(smart: TSmartPointer <T>): T;
    property Value: T read GetValue;
  end;

implementation

{ TSmartPointer<T> }

constructor TSmartPointer<T>.Create(AValue: T);
begin
  FValue := AValue;
  FFreeTheValue := TFreeTheValue.Create(FValue);
end;

procedure TSmartPointer<T>.Create;
begin
  TSmartPointer<T>.Create (T.Create);
end;

function TSmartPointer<T>.GetValue: T;
begin
  if not Assigned(FFreeTheValue) then
    self := TSmartPointer<T>.Create (T.Create);
  Result := FValue;
end;

class operator TSmartPointer<T>.Implicit(smart: TSmartPointer<T>): T;
begin
  Result := Smart.Value;
end;

class operator TSmartPointer<T>.Implicit(AValue: T): TSmartPointer<T>;
begin
  Result := TSmartPointer<T>.Create(AValue);
end;

{ TSmartPointer<T>.TFreeTheValue }

constructor TSmartPointer<T>.TFreeTheValue.Create(anObjectToFree: TObject);
begin
  fObjectToFree := anObjectToFree;
end;

destructor TSmartPointer<T>.TFreeTheValue.Destroy;
begin
  fObjectToFree.Free;
  inherited;
end;


end.

procedure TFormSmartPointers.btnImplicitCreateClick(Sender: TObject);
var
  smartP: TSmartPointer<TStringList>;
begin
//  smartP.Create;
  smartP.Value.Add('foo');
  Log ('Count: ' + IntToStr (smartP.Value.Count));
end;

procedure TFormSmartPointers.btnLeakClick(Sender: TObject);
var
  sl: TStringList;
begin
  // memory leak
  sl := TStringList.Create;
  sl.Add('foo');
  Log ('Count: ' + IntToStr (sl.Count));
end;

procedure TFormSmartPointers.btnSmartClick(Sender: TObject);
var
  sl: TStringList;
  smartP: TSmartPointer<TStringList>;
begin
  sl := TStringList.Create;
  smartP := sl;
  sl.Add('foo');
  Log ('Count: ' + IntToStr (sl.Count));
end;

procedure TFormSmartPointers.btnSmartShortClick(Sender: TObject);
var
  smartP: TSmartPointer<TStringList>;
begin
  smartP := TStringList.Create;
  smartP.Value.Add('foo');
  TStringList(smartP).Add('foo2');
  Log ('Count: ' + IntToStr (TStringList(smartP).Count));
end;

unit ObjectGuardClass

integerface

type
  IObjectGuard<T: class> = interface
    function Value: T
  end;

type
  TObjectGuard<T: class> = class(TInterfacedObject, IObjectGuard<T>)
  private
    FValue: T;
  public
    constructor Create(Obj: T);
    destructor Destroy; override;
    function Value: T;
  end;

type
  TSmartPtr<T: class> = record
  private
    FGuard: IObjectGuard<T>;
  public
    class operator Explicit(const Obj: T): TSmartPtr<T>;
    class operator Implicit(const Ptr: TSmartPtr<T>): T;
  end;

implementation

{ SmartPtr<T> }

class operator TSmartPtr<T>.Explicit(const Obj: T): TSmartPtr<T>;
begin
  Result.FGuard := TObjectGuard<T>.Create(Obj);
end;

class operator TSmartPtr<T>.Implicit(const Ptr: TSmartPtr<T>): T;
begin
  if Ptr.FGuard <> nil then
    Result := Ptr.FGuard.Value
  else
    Result := nil;
end;

{ TObjectGuard<T> }

constructor TObjectGuard<T>.Crete(Obj: T);
begin
  FValue := Obj;
end;

destructor TObjectGuard<T>.Destory;
begin
  FValue.Free;
  inherited;
end;

function TObjectGuard<T>.Value: T;
begin
  Result := FValue;
end;

end.

procedure TForm.btnSmartPtrClick(Sender: TObject);
var
  SL: TStringList;
begin
  SL := TSmartPtr<TStringList>(TStringList.Create());
  SL.Add('Foo');
end;