unit SyncServerLibrary_Intf;

{----------------------------------------------------------------------------}
{ This unit was automatically generated by the RemObjects SDK after reading  }
{ the RODL file associated with this project .                               }
{                                                                            }
{ Do not modify this unit manually, or your changes will be lost when this   }
{ unit is regenerated the next time you compile the project.                 }
{----------------------------------------------------------------------------}

{$I RemObjects.inc}

interface

uses
  {vcl:} Classes, TypInfo,
  {RemObjects:} uROXMLIntf, uROClasses, uROClient, uROTypes, uROClientIntf;

const
  { Library ID }
  LibraryUID = '{C04AE0F2-540E-434F-96FA-08B8A7810005}';
  TargetNamespace = '';

  { Service Interface ID's }
  ISyncServerService_IID : TGUID = '{7941D2C3-63AE-4559-BB62-3443C5B3EB3F}';
  IPairingService_IID : TGUID = '{CBA27400-AE3F-4945-8520-0EA97EC5DE41}';

  { Event ID's }

type
  TSeekOrigin = Classes.TSeekOrigin; // fake declaration
  { Forward declarations }
  ISyncServerService = interface;
  IPairingService = interface;

  FileInfoArray = class;

  FileInfoStruct = class;

  FileTransferException = class;


  { Enumerateds }
  PairingStatus = (PairingStatus_Successfull,PairingStatus_PairingRequired,PairingStatus_PairingBusy);

  { FileInfoStruct }
  FileInfoStruct = class(TROComplexType)
  private
    fName: AnsiString;
    fDate: DateTime;
    fFileSize: Integer;
  public
    procedure Assign(iSource: TPersistent); override;
    procedure ReadComplex(ASerializer: TObject); override;
    procedure WriteComplex(ASerializer: TObject); override;
  published
    property Name:AnsiString read fName write fName;
    property Date:DateTime read fDate write fDate;
    property FileSize:Integer read fFileSize write fFileSize;
  end;

  { FileInfoStructCollection }
  FileInfoStructCollection = class(TROCollection)
  protected
    constructor Create(aItemClass: TCollectionItemClass); overload;
    function GetItems(aIndex: integer): FileInfoStruct;
    procedure SetItems(aIndex: integer; const Value: FileInfoStruct);
  public
    constructor Create; overload;
    function Add: FileInfoStruct; reintroduce;
    procedure SaveToArray(anArray: FileInfoArray);
    procedure LoadFromArray(anArray: FileInfoArray);
    property Items[Index: integer]:FileInfoStruct read GetItems write SetItems; default;
  end;

  { FileInfoArray }
  FileInfoArray_FileInfoStruct = array of FileInfoStruct;
  FileInfoArray = class(TROArray)
  private
    fCount: Integer;
    fItems : FileInfoArray_FileInfoStruct;
  protected
    procedure Grow; virtual;
    function GetItems(aIndex: integer): FileInfoStruct;
    procedure SetItems(aIndex: integer; const Value: FileInfoStruct);
    function GetCount: integer; override;
  public
    class function GetItemType: PTypeInfo; override;
    class function GetItemClass: TClass; override;
    class function GetItemSize: integer; override;

    function GetItemRef(aIndex: integer): pointer; override;
    procedure SetItemRef(aIndex: integer; Ref: pointer); override;
    procedure Clear; override;
    procedure Delete(aIndex: integer); override;
    procedure Resize(ElementCount: integer); override;

    procedure Assign(iSource:TPersistent); override;
    procedure ReadComplex(ASerializer: TObject); override;
    procedure WriteComplex(ASerializer: TObject); override;
    function Add: FileInfoStruct; overload;
    function Add(const Value: FileInfoStruct):integer; overload;

    property Count : integer read GetCount;
    property Items[Index: integer]:FileInfoStruct read GetItems write SetItems; default;
    property InnerArray: FileInfoArray_FileInfoStruct read fItems;
  end;

  { Exceptions }
  FileTransferException = class(EROException)
  private
    fFileName: AnsiString;
    fMessage: AnsiString;
  public
    constructor Create(anExceptionMessage : string; aFileName: AnsiString; aMessage: AnsiString);
    procedure ReadException(ASerializer: TObject); override;
    procedure WriteException(ASerializer: TObject); override;
  published
    property FileName: AnsiString read fFileName write fFileName;
    property Message: AnsiString read fMessage write fMessage;
  end;


  { ISyncServerService }
  ISyncServerService = interface
    ['{7941D2C3-63AE-4559-BB62-3443C5B3EB3F}']
    function GetRemoteFiles: FileInfoArray;
    function DeclareLocalFiles(const FilesList: FileInfoArray): FileInfoArray;
    procedure SetChunkSize(const Size: Integer);
    function GetFile(const FileName: AnsiString; const ChunkNo: Integer): Binary;
    procedure SendFile(const FileName: AnsiString; const ChunkNo: Integer; const FileData: Binary);
  end;

  { CoSyncServerService }
  CoSyncServerService = class
    class function Create(const aMessage: IROMessage; aTransportChannel: IROTransportChannel): ISyncServerService;
  end;

  { TSyncServerService_Proxy }
  TSyncServerService_Proxy = class(TROProxy, ISyncServerService)
  protected
    function __GetInterfaceName:string; override;

    function GetRemoteFiles: FileInfoArray;
    function DeclareLocalFiles(const FilesList: FileInfoArray): FileInfoArray;
    procedure SetChunkSize(const Size: Integer);
    function GetFile(const FileName: AnsiString; const ChunkNo: Integer): Binary;
    procedure SendFile(const FileName: AnsiString; const ChunkNo: Integer; const FileData: Binary);
  end;

  { IPairingService }
  IPairingService = interface
    ['{CBA27400-AE3F-4945-8520-0EA97EC5DE41}']
    function LoginAttempt(const ClientGuid: Guid): Integer;
    function ConfirmCode(const Code: AnsiString; const ClientGuid: Guid): Boolean;
  end;

  { CoPairingService }
  CoPairingService = class
    class function Create(const aMessage: IROMessage; aTransportChannel: IROTransportChannel): IPairingService;
  end;

  { TPairingService_Proxy }
  TPairingService_Proxy = class(TROProxy, IPairingService)
  protected
    function __GetInterfaceName:string; override;

    function LoginAttempt(const ClientGuid: Guid): Integer;
    function ConfirmCode(const Code: AnsiString; const ClientGuid: Guid): Boolean;
  end;

implementation

uses
  {vcl:} SysUtils,
  {RemObjects:} uROEventRepository, uROSerializer, uRORes;

{ FileTransferException }

constructor FileTransferException.Create(anExceptionMessage : string; aFileName: AnsiString;
  aMessage: AnsiString);
begin
  inherited Create(anExceptionMessage);

  fFileName := aFileName;
  fMessage := aMessage;
end;

procedure FileTransferException.ReadException(ASerializer: TObject);
var
  l_FileName: AnsiString;
  l_Message: AnsiString;
begin
  if TROSerializer(ASerializer).RecordStrictOrder then begin
    l_FileName := FileName;
    TROSerializer(ASerializer).ReadAnsiString('FileName', l_FileName);
    FileName := l_FileName;
    l_Message := Message;
    TROSerializer(ASerializer).ReadAnsiString('Message', l_Message);
    Message := l_Message;
  end
  else begin
    l_FileName := FileName;
    TROSerializer(ASerializer).ReadAnsiString('FileName', l_FileName);
    FileName := l_FileName;
    l_Message := Message;
    TROSerializer(ASerializer).ReadAnsiString('Message', l_Message);
    Message := l_Message;
  end;
end;

procedure FileTransferException.WriteException(ASerializer: TObject);
var
  l_FileName: AnsiString;
  l_Message: AnsiString;
begin
  if TROSerializer(ASerializer).RecordStrictOrder then begin
    TROSerializer(ASerializer).ChangeClass(FileTransferException);
    l_FileName := FileName;
    TROSerializer(ASerializer).WriteAnsiString('FileName', l_FileName);
    l_Message := Message;
    TROSerializer(ASerializer).WriteAnsiString('Message', l_Message);
  end
  else begin
    l_FileName := FileName;
    TROSerializer(ASerializer).WriteAnsiString('FileName', l_FileName);
    l_Message := Message;
    TROSerializer(ASerializer).WriteAnsiString('Message', l_Message);
  end;
end;

{ FileInfoArray }

procedure FileInfoArray.Assign(iSource: TPersistent);
var lSource:FileInfoArray;
    i:integer;
    lItem:FileInfoStruct;
begin
  if (iSource is FileInfoArray) then begin
    lSource := FileInfoArray(iSource);
    Clear();

    for i := 0 to lSource.Count-1 do
      if Assigned(lSource.Items[i]) then begin
        lItem := FileInfoStruct(lSource.Items[i].ClassType.Create);
        lItem.Assign(lSource.Items[i]);
        Add(lItem);
      end
      else begin
        Add(nil);
      end;
  end
  else begin
    inherited Assign(iSource);
  end;
end;

class function FileInfoArray.GetItemType: PTypeInfo;
begin
  result := TypeInfo(FileInfoStruct);
end;

class function FileInfoArray.GetItemClass: TClass;
begin
  result := FileInfoStruct;
end;

class function FileInfoArray.GetItemSize: integer;
begin
  result := SizeOf(FileInfoStruct);
end;

function FileInfoArray.GetItems(aIndex: integer): FileInfoStruct;
begin
  if (aIndex < 0) or (aIndex >= Count) then RaiseError(err_ArrayIndexOutOfBounds,[aIndex]);
  result := fItems[aIndex];
end;

function FileInfoArray.GetItemRef(aIndex: integer): pointer;
begin
  if (aIndex < 0) or (aIndex >= Count) then RaiseError(err_ArrayIndexOutOfBounds,[aIndex]);
  result := fItems[aIndex];
end;

procedure FileInfoArray.SetItemRef(aIndex: integer; Ref: pointer);
begin
  if (aIndex < 0) or (aIndex >= Count) then RaiseError(err_ArrayIndexOutOfBounds,[aIndex]);
  if Ref <> fItems[aIndex] then begin
    if fItems[aIndex] <> nil then fItems[aIndex].Free;
    fItems[aIndex] := Ref;
  end;
end;

procedure FileInfoArray.Clear;
var i: integer;
begin
  for i := 0 to (Count-1) do fItems[i].Free();
  SetLength(fItems, 0);
  FCount := 0;
end;

procedure FileInfoArray.Delete(aIndex: integer);
var i: integer;
begin
  if (aIndex>=Count) then RaiseError(err_InvalidIndex, [aIndex]);

  fItems[aIndex].Free();

  if (aIndex<Count-1) then
    for i := aIndex to Count-2 do fItems[i] := fItems[i+1];

  SetLength(fItems, Count-1);
  Dec(FCount);
end;

procedure FileInfoArray.SetItems(aIndex: integer; const Value: FileInfoStruct);
begin
  if (aIndex < 0) or (aIndex >= Count) then RaiseError(err_ArrayIndexOutOfBounds,[aIndex]);
  if fItems[aIndex] <> Value then begin
    fItems[aIndex].Free;
    fItems[aIndex] := Value;
  end;
end;

procedure FileInfoArray.Resize(ElementCount: integer);
var i: Integer;
begin
  if fCount = ElementCount then Exit;
  for i := FCount -1 downto ElementCount do
    FItems[i].Free;
  SetLength(fItems, ElementCount);
  for i := FCount to ElementCount -1 do
    FItems[i] := FileInfoStruct.Create;
  FCount := ElementCount;
end;

function FileInfoArray.GetCount: integer;
begin
  result := FCount;
end;

procedure FileInfoArray.Grow;
var
  Delta, Capacity: Integer;
begin
  Capacity := Length(fItems);
  if Capacity > 64 then
    Delta := Capacity div 4
  else
    if Capacity > 8 then
      Delta := 16
   else
      Delta := 4;
  SetLength(fItems, Capacity + Delta);
end;

function FileInfoArray.Add: FileInfoStruct;
begin
  result := FileInfoStruct.Create;
  Add(Result);
end;

function FileInfoArray.Add(const Value:FileInfoStruct): integer;
begin
  Result := Count;
  if Length(fItems) = Result then
    Grow;
  fItems[result] := Value;
  Inc(fCount);
end;

procedure FileInfoArray.ReadComplex(ASerializer: TObject);
var
  lval: FileInfoStruct;
  i: integer;
begin
  for i := 0 to Count-1 do begin
    with TROSerializer(ASerializer) do begin
      ReadStruct(GetArrayElementName(GetItemType, GetItemRef(i)), FileInfoStruct, lval, i);
    end;
    Items[i] := lval;
  end;
end;

procedure FileInfoArray.WriteComplex(ASerializer: TObject);
var
  i: integer;
begin
  for i := 0 to Count-1 do
    with TROSerializer(ASerializer) do
      WriteStruct(GetArrayElementName(GetItemType, GetItemRef(i)), fItems[i], FileInfoStruct, i);
end;

{ FileInfoStruct }

procedure FileInfoStruct.Assign(iSource: TPersistent); 
var lSource: SyncServerLibrary_Intf.FileInfoStruct;
begin
  inherited Assign(iSource);
  if (iSource is SyncServerLibrary_Intf.FileInfoStruct) then begin
    lSource := SyncServerLibrary_Intf.FileInfoStruct(iSource);
    Name := lSource.Name;
    Date := lSource.Date;
    FileSize := lSource.FileSize;
  end;
end;

procedure FileInfoStruct.ReadComplex(ASerializer: TObject);
var
  l_Date: DateTime;
  l_FileSize: Integer;
  l_Name: AnsiString;
begin
  if TROSerializer(ASerializer).RecordStrictOrder then begin
    l_Name := Name;
    TROSerializer(ASerializer).ReadAnsiString('Name', l_Name);
    Name := l_Name;
    l_Date := Date;
    TROSerializer(ASerializer).ReadDateTime('Date', l_Date);
    Date := l_Date;
    l_FileSize := FileSize;
    TROSerializer(ASerializer).ReadInteger('FileSize', otSLong, l_FileSize);
    FileSize := l_FileSize;
  end
  else begin
    l_Date := Date;
    TROSerializer(ASerializer).ReadDateTime('Date', l_Date);
    Date := l_Date;
    l_FileSize := FileSize;
    TROSerializer(ASerializer).ReadInteger('FileSize', otSLong, l_FileSize);
    FileSize := l_FileSize;
    l_Name := Name;
    TROSerializer(ASerializer).ReadAnsiString('Name', l_Name);
    Name := l_Name;
  end;
end;

procedure FileInfoStruct.WriteComplex(ASerializer: TObject);
var
  l_Date: DateTime;
  l_FileSize: Integer;
  l_Name: AnsiString;
begin
  if TROSerializer(ASerializer).RecordStrictOrder then begin
    TROSerializer(ASerializer).ChangeClass(FileInfoStruct);
    l_Name := Name;
    TROSerializer(ASerializer).WriteAnsiString('Name', l_Name);
    l_Date := Date;
    TROSerializer(ASerializer).WriteDateTime('Date', l_Date);
    l_FileSize := FileSize;
    TROSerializer(ASerializer).WriteInteger('FileSize', otSLong, l_FileSize);
  end
  else begin
    l_Date := Date;
    TROSerializer(ASerializer).WriteDateTime('Date', l_Date);
    l_FileSize := FileSize;
    TROSerializer(ASerializer).WriteInteger('FileSize', otSLong, l_FileSize);
    l_Name := Name;
    TROSerializer(ASerializer).WriteAnsiString('Name', l_Name);
  end;
end;

{ FileInfoStructCollection }
constructor FileInfoStructCollection.Create;
begin
  inherited Create(FileInfoStruct);
end;

constructor FileInfoStructCollection.Create(aItemClass: TCollectionItemClass);
begin
  inherited Create(aItemClass);
end;

function FileInfoStructCollection.Add: FileInfoStruct;
begin
  result := FileInfoStruct(inherited Add);
end;

function FileInfoStructCollection.GetItems(aIndex: integer): FileInfoStruct;
begin
  result := FileInfoStruct(inherited Items[aIndex]);
end;

procedure FileInfoStructCollection.LoadFromArray(anArray: FileInfoArray);
var i : integer;
begin
  Clear;
  for i := 0 to (anArray.Count-1) do
    anArray[i].Clone.Collection := Self;
end;

procedure FileInfoStructCollection.SaveToArray(anArray: FileInfoArray);
var i : integer;
begin
  anArray.Clear;
  for i := 0 to (Count-1) do begin
    if Assigned(Items[i]) then
      anArray.Add(FileInfoStruct(Items[i].Clone))
    else
      anArray.Add(nil);
  end;
end;

procedure FileInfoStructCollection.SetItems(aIndex: integer; const Value: FileInfoStruct);
begin
  FileInfoStruct(inherited Items[aIndex]).Assign(Value);
end;

{ CoSyncServerService }

class function CoSyncServerService.Create(const aMessage: IROMessage; aTransportChannel: IROTransportChannel): ISyncServerService;
begin
  result := TSyncServerService_Proxy.Create(aMessage, aTransportChannel);
end;

{ TSyncServerService_Proxy }

function TSyncServerService_Proxy.__GetInterfaceName:string;
begin
  result := 'SyncServerService';
end;

function TSyncServerService_Proxy.GetRemoteFiles: FileInfoArray;
begin
  try
    result := nil;
    __Message.InitializeRequestMessage(__TransportChannel, 'SyncServerLibrary', __InterfaceName, 'GetRemoteFiles');
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

    __Message.Read('Result', TypeInfo(SyncServerLibrary_Intf.FileInfoArray), result, []);
  finally
    __Message.UnsetAttributes(__TransportChannel);
    __Message.FreeStream;
  end
end;

function TSyncServerService_Proxy.DeclareLocalFiles(const FilesList: FileInfoArray): FileInfoArray;
begin
  try
    result := nil;
    __Message.InitializeRequestMessage(__TransportChannel, 'SyncServerLibrary', __InterfaceName, 'DeclareLocalFiles');
    __Message.Write('FilesList', TypeInfo(SyncServerLibrary_Intf.FileInfoArray), FilesList, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

    __Message.Read('Result', TypeInfo(SyncServerLibrary_Intf.FileInfoArray), result, []);
  finally
    __Message.UnsetAttributes(__TransportChannel);
    __Message.FreeStream;
  end
end;

procedure TSyncServerService_Proxy.SetChunkSize(const Size: Integer);
begin
  try
    __Message.InitializeRequestMessage(__TransportChannel, 'SyncServerLibrary', __InterfaceName, 'SetChunkSize');
    __Message.Write('Size', TypeInfo(Integer), Size, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

  finally
    __Message.UnsetAttributes(__TransportChannel);
    __Message.FreeStream;
  end
end;

function TSyncServerService_Proxy.GetFile(const FileName: AnsiString; const ChunkNo: Integer): Binary;
begin
  try
    result := nil;
    __Message.InitializeRequestMessage(__TransportChannel, 'SyncServerLibrary', __InterfaceName, 'GetFile');
    __Message.Write('FileName', TypeInfo(AnsiString), FileName, []);
    __Message.Write('ChunkNo', TypeInfo(Integer), ChunkNo, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

    __Message.Read('Result', TypeInfo(Binary), result, []);
  finally
    __Message.UnsetAttributes(__TransportChannel);
    __Message.FreeStream;
  end
end;

procedure TSyncServerService_Proxy.SendFile(const FileName: AnsiString; const ChunkNo: Integer; const FileData: Binary);
begin
  try
    __Message.InitializeRequestMessage(__TransportChannel, 'SyncServerLibrary', __InterfaceName, 'SendFile');
    __Message.Write('FileName', TypeInfo(AnsiString), FileName, []);
    __Message.Write('ChunkNo', TypeInfo(Integer), ChunkNo, []);
    __Message.Write('FileData', TypeInfo(Binary), FileData, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

  finally
    __Message.UnsetAttributes(__TransportChannel);
    __Message.FreeStream;
  end
end;

{ CoPairingService }

class function CoPairingService.Create(const aMessage: IROMessage; aTransportChannel: IROTransportChannel): IPairingService;
begin
  result := TPairingService_Proxy.Create(aMessage, aTransportChannel);
end;

{ TPairingService_Proxy }

function TPairingService_Proxy.__GetInterfaceName:string;
begin
  result := 'PairingService';
end;

function TPairingService_Proxy.LoginAttempt(const ClientGuid: Guid): Integer;
begin
  try
    __Message.InitializeRequestMessage(__TransportChannel, 'SyncServerLibrary', __InterfaceName, 'LoginAttempt');
    __Message.Write('ClientGuid', TypeInfo(Guid), ClientGuid, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

    __Message.Read('Result', TypeInfo(Integer), result, []);
  finally
    __Message.UnsetAttributes(__TransportChannel);
    __Message.FreeStream;
  end
end;

function TPairingService_Proxy.ConfirmCode(const Code: AnsiString; const ClientGuid: Guid): Boolean;
begin
  try
    __Message.InitializeRequestMessage(__TransportChannel, 'SyncServerLibrary', __InterfaceName, 'ConfirmCode');
    __Message.Write('Code', TypeInfo(AnsiString), Code, []);
    __Message.Write('ClientGuid', TypeInfo(Guid), ClientGuid, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

    __Message.Read('Result', TypeInfo(Boolean), result, []);
  finally
    __Message.UnsetAttributes(__TransportChannel);
    __Message.FreeStream;
  end
end;

initialization
  RegisterROClass(FileInfoStruct);
  RegisterROClass(FileInfoArray);
  RegisterExceptionClass(FileTransferException);
  RegisterProxyClass(ISyncServerService_IID, TSyncServerService_Proxy);
  RegisterProxyClass(IPairingService_IID, TPairingService_Proxy);

  RegisterEnumMapping(TROEnumMapping.Create('PairingStatus', 'Successfull', 'Successfull'));
  RegisterEnumMapping(TROEnumMapping.Create('PairingStatus', 'PairingRequired', 'PairingRequired'));
  RegisterEnumMapping(TROEnumMapping.Create('PairingStatus', 'PairingBusy', 'PairingBusy'));

finalization
  UnregisterROClass(FileInfoStruct);
  UnregisterROClass(FileInfoArray);
  UnregisterExceptionClass(FileTransferException);
  UnregisterProxyClass(ISyncServerService_IID);
  UnregisterProxyClass(IPairingService_IID);


  UnRegisterEnumMappings();
end.