unit uROServerIntf;

{----------------------------------------------------------------------------}
{ RemObjects SDK Library - Core Library                                      }
{                                                                            }
{ compiler: Delphi 5 and up, Kylix 2 and up                                  }
{ platform: Win32, Linux                                                     }
{                                                                            }
{ (c)opyright RemObjects Software. all rights reserved.                      }
{                                                                            }
{ Using this code requires a valid license of the RemObjects SDK             }
{ which can be obtained at http://www.remobjects.com.                        }
{----------------------------------------------------------------------------}

{$I RemObjects.inc}

interface

uses
  {$IFDEF REMOBJECTS_TRIAL}uROTrial,{$ENDIF}
  {$IFDEF WIN32}Windows, {$ENDIF}
  uRORes, uROClientIntf, uROTypes, Classes, SysUtils;

type
  {$IFDEF DELPHI5}
  { IInterface }
  IInterface = IUnknown;
  {$ENDIF}

  IROClassFactory = interface;

  TROResponseOption = (roNoResponse, roDontEncrypt);
  TROResponseOptions = set of TROResponseOption;

  { IROInvoker }
  IROInvoker = interface
  ['{6BF28A4D-1511-4FD0-83C0-0F0A23322ACC}']
    function HandleMessage(const aFactory : IROClassFactory;
                            const aMessage : IROMessage;
                            const aTransport : IROTransport;
                            out oResponseOptions: TROResponseOptions) : boolean;
  end;

  { IROClassFactory }
  IROClassFactory = interface
  ['{87580688-9994-4EB3-BDB9-E621ED52C3E9}']
    procedure CreateInstance(const aClientID : TGUID; out anInstance : IInterface);
    procedure ReleaseInstance(const aClientID: TGUID; var anInstance : IInterface);

    function GetInterfaceName : string;
    function GetInvoker : IROInvoker;

    property InterfaceName : string read GetInterfaceName;
    property Invoker : IROInvoker read GetInvoker;
  end;

  IROPooledClassFactory = interface(IROClassFactory)
  ['{DB0C4A2B-CA2C-4CDA-A02C-289918B29FA3}']
    procedure ClearPool;
  end;

  { IRODispatchNotifier }
  IRODispatchNotifier = interface
  ['{C3359706-83B8-4285-866C-D4DD5960B183}']
    procedure GetDispatchInfo(const aTransport : IROTransport; const aMessage : IROMessage);
  end;

  { IRODestructorController }
  IRODestructorController = interface
  ['{D590AF9A-1029-450B-A8B7-0EC8A93DF7DC}']
    function CanBeDestroyed : boolean;
  end;

  { IRODestructorControllerEx }
  IRODestructorControllerEx = interface(IRODestructorController)
  ['{2897DFAE-A466-4886-ADC3-9F0D7DD393A8}']
    procedure SetCanBeDestroyed(Value : boolean);
  end;

  { IROObjectActivation }
  IROObjectActivation = interface
  ['{071ECDF1-A4B0-4333-93B4-EE1B8609FF80}']
    procedure OnActivate(aClientID: TGUID; const aMessage : IROMessage);
    procedure OnDeactivate(aClientID: TGUID);
  end;

  { IROObjectTimeout }
  IROObjectTimeout = interface
  ['{DC7FC0CB-D3C6-4CA7-8F71-57ECE1392594}']
    procedure OnTimeout;
  end;

  { IROServerEventsBroker }
  IROServerEventsBroker = interface
    ['{5B6A3449-3B13-4B0A-B1FF-B2FAA18D57B1}']
    procedure RegisterEventClient(const ClientID, EventTypes : string);
    procedure UnregisterEventClient(const ClientID, EventTypes : string);

    function GetEventsData(const ClientID : string; out EventsData : Binary) : integer;
  end;

  TROEventData = class;

  IROActiveEventServer = interface
    ['{DD0B0C09-2D17-46EA-8110-E7BEE9B8AB7B}']
    procedure EventsRegistered(aSender : TObject; aClient: TGUID);
    procedure DispatchEvent(anEventDataItem : TROEventData; aSessionReference : TGUID; aSender: TObject); // asender is TROEventRepository
  end;

  { TROEventData }
  TROEventData = class
  private
    fData: TStream;
    fRefCount: integer;
//    fShouldRemoveFromOwner: Boolean;
  protected
  public
    constructor Create(anEventDataStream : TMemoryStream);
    destructor Destroy; override;

    function AddRef : integer;
    function RemoveRef : integer;
//    property ShouldRemoveFromOwner: Boolean read fShouldRemoveFromOwner write fShouldRemoveFromOwner;

    property Data : TStream read fData;
  end;



implementation
uses
  uROClasses;

{ TROEventData }

function TROEventData.AddRef : integer;
begin
  result := InterlockedIncrement(fRefCount);
end;

constructor TROEventData.Create(anEventDataStream : TMemoryStream);
begin
  inherited Create;
  fRefCount := 1;
//  fShouldRemoveFromOwner := true;
  fData := TMemoryStream.Create;
  anEventDataStream.Position := 0;
  fData.CopyFrom(anEventDataStream, anEventDataStream.Size);
end;

destructor TROEventData.Destroy;
begin
  FreeAndNIL(fData);
  inherited;
end;

function TROEventData.RemoveRef : integer;
begin
  result := InterlockedDecrement(fRefCount);
end;


end.