unit ExtendedFileTransferLibrary_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 = '{02F3ADBC-D8AD-476D-A885-54E6B61AA7A1}';
  TargetNamespace = '';

  { Service Interface ID's }
  IExtendedFileTransferService_IID : TGUID = '{50F60F48-A35C-43AD-93AE-9A027E2ED4B0}';

  { Event ID's }

type
  { Forward declarations }
  IExtendedFileTransferService = interface;

  FileInfoArray = class;

  TFileInfo = class;


  { TFileInfo }
  TFileInfo = class(TROComplexType)
  private
    fFileName: AnsiString;
    fSize: Integer;
    fTypeName: AnsiString;
  public
    procedure Assign(iSource: TPersistent); override;
    procedure ReadComplex(ASerializer: TObject); override;
    procedure WriteComplex(ASerializer: TObject); override;
  published
    property FileName:AnsiString read fFileName write fFileName;
    property Size:Integer read fSize write fSize;
    property TypeName:AnsiString read fTypeName write fTypeName;
  end;

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

  { FileInfoArray }
  FileInfoArray_TFileInfo = array of TFileInfo;
  FileInfoArray = class(TROArray)
  private
    fCount: Integer;
    fItems : FileInfoArray_TFileInfo;
  protected
    procedure Grow; virtual;
    function GetItems(aIndex: integer): TFileInfo;
    procedure SetItems(aIndex: integer; const Value: TFileInfo);
    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: TFileInfo; overload;
    function Add(const Value: TFileInfo):integer; overload;

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

  { IExtendedFileTransferService }
  IExtendedFileTransferService = interface
    ['{50F60F48-A35C-43AD-93AE-9A027E2ED4B0}']
    function GetFilesList: FileInfoArray;
    function DownloadFilePart(const FileName: AnsiString; const PartNo: Integer; const PartSize: Integer): Binary;
  end;

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

  { TExtendedFileTransferService_Proxy }
  TExtendedFileTransferService_Proxy = class(TROProxy, IExtendedFileTransferService)
  protected
    function __GetInterfaceName:string; override;

    function GetFilesList: FileInfoArray;
    function DownloadFilePart(const FileName: AnsiString; const PartNo: Integer; const PartSize: Integer): Binary;
  end;

implementation

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

{ FileInfoArray }

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

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

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

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

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

function FileInfoArray.GetItems(aIndex: integer): TFileInfo;
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: TFileInfo);
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] := TFileInfo.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: TFileInfo;
begin
  result := TFileInfo.Create;
  Add(Result);
end;

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

procedure FileInfoArray.ReadComplex(ASerializer: TObject);
var
  lval: TFileInfo;
  i: integer;
begin
  for i := 0 to Count-1 do begin
    with TROSerializer(ASerializer) do
      ReadStruct(GetArrayElementName(GetItemType, GetItemRef(i)), TFileInfo, lval, i);
    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], TFileInfo, i);
end;

{ TFileInfo }

procedure TFileInfo.Assign(iSource: TPersistent); 
var lSource: ExtendedFileTransferLibrary_Intf.TFileInfo;
begin
  inherited Assign(iSource);
  if (iSource is ExtendedFileTransferLibrary_Intf.TFileInfo) then begin
    lSource := ExtendedFileTransferLibrary_Intf.TFileInfo(iSource);
    FileName := lSource.FileName;
    Size := lSource.Size;
    TypeName := lSource.TypeName;
  end;
end;

procedure TFileInfo.ReadComplex(ASerializer: TObject);
var
  l_FileName: AnsiString;
  l_Size: Integer;
  l_TypeName: AnsiString;
begin
  if TROSerializer(ASerializer).RecordStrictOrder then begin
    l_FileName := FileName;
    TROSerializer(ASerializer).ReadAnsiString('FileName', l_FileName);
    FileName := l_FileName;
    l_Size := Size;
    TROSerializer(ASerializer).ReadInteger('Size', otSLong, l_Size);
    Size := l_Size;
    l_TypeName := TypeName;
    TROSerializer(ASerializer).ReadAnsiString('TypeName', l_TypeName);
    TypeName := l_TypeName;
  end
  else begin
    l_FileName := FileName;
    TROSerializer(ASerializer).ReadAnsiString('FileName', l_FileName);
    FileName := l_FileName;
    l_Size := Size;
    TROSerializer(ASerializer).ReadInteger('Size', otSLong, l_Size);
    Size := l_Size;
    l_TypeName := TypeName;
    TROSerializer(ASerializer).ReadAnsiString('TypeName', l_TypeName);
    TypeName := l_TypeName;
  end;
end;

procedure TFileInfo.WriteComplex(ASerializer: TObject);
var
  l_FileName: AnsiString;
  l_Size: Integer;
  l_TypeName: AnsiString;
begin
  if TROSerializer(ASerializer).RecordStrictOrder then begin
    TROSerializer(ASerializer).ChangeClass(TFileInfo);
    l_FileName := FileName;
    TROSerializer(ASerializer).WriteAnsiString('FileName', l_FileName);
    l_Size := Size;
    TROSerializer(ASerializer).WriteInteger('Size', otSLong, l_Size);
    l_TypeName := TypeName;
    TROSerializer(ASerializer).WriteAnsiString('TypeName', l_TypeName);
  end
  else begin
    l_FileName := FileName;
    TROSerializer(ASerializer).WriteAnsiString('FileName', l_FileName);
    l_Size := Size;
    TROSerializer(ASerializer).WriteInteger('Size', otSLong, l_Size);
    l_TypeName := TypeName;
    TROSerializer(ASerializer).WriteAnsiString('TypeName', l_TypeName);
  end;
end;

{ TFileInfoCollection }
constructor TFileInfoCollection.Create;
begin
  inherited Create(TFileInfo);
end;

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

function TFileInfoCollection.Add: TFileInfo;
begin
  result := TFileInfo(inherited Add);
end;

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

procedure TFileInfoCollection.LoadFromArray(anArray: FileInfoArray);
var i : integer;
begin
  Clear;
  for i := 0 to (anArray.Count-1) do
    Add.Assign(anArray[i]);
end;

procedure TFileInfoCollection.SaveToArray(anArray: FileInfoArray);
var i : integer;
begin
  anArray.Clear;
  anArray.Resize(Count);
  for i := 0 to (Count-1) do begin
    anArray[i] := TFileInfo.Create;
    anArray[i].Assign(Items[i]);
  end;
end;

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

{ CoExtendedFileTransferService }

class function CoExtendedFileTransferService.Create(const aMessage: IROMessage; aTransportChannel: IROTransportChannel): IExtendedFileTransferService;
begin
  result := TExtendedFileTransferService_Proxy.Create(aMessage, aTransportChannel);
end;

{ TExtendedFileTransferService_Proxy }

function TExtendedFileTransferService_Proxy.__GetInterfaceName:string;
begin
  result := 'ExtendedFileTransferService';
end;

function TExtendedFileTransferService_Proxy.GetFilesList: FileInfoArray;
begin
  try
    result := nil;
    __Message.InitializeRequestMessage(__TransportChannel, 'ExtendedFileTransferLibrary', __InterfaceName, 'GetFilesList');
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

function TExtendedFileTransferService_Proxy.DownloadFilePart(const FileName: AnsiString; const PartNo: Integer; const PartSize: Integer): Binary;
begin
  try
    result := nil;
    __Message.InitializeRequestMessage(__TransportChannel, 'ExtendedFileTransferLibrary', __InterfaceName, 'DownloadFilePart');
    __Message.Write('FileName', TypeInfo(AnsiString), FileName, []);
    __Message.Write('PartNo', TypeInfo(Integer), PartNo, []);
    __Message.Write('PartSize', TypeInfo(Integer), PartSize, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

initialization
  RegisterROClass(TFileInfo);
  RegisterROClass(FileInfoArray);
  RegisterProxyClass(IExtendedFileTransferService_IID, TExtendedFileTransferService_Proxy);


finalization
  UnregisterROClass(TFileInfo);
  UnregisterROClass(FileInfoArray);
  UnregisterProxyClass(IExtendedFileTransferService_IID);

end.