unit DataAbstract3_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 DataAbstract.inc}

interface

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

const
  { Library ID }
  LibraryUID = '{2966A4BF-569C-45AA-8F34-CF1E155FD77A}';
  TargetNamespace = '';

  { Service Interface ID's }
  IDARemoteService_IID : TGUID = '{C532E842-0AA9-4253-A9BF-AFCF22885B97}';
  IDALoginService_IID : TGUID = '{58550AA0-B64F-495A-B2F8-C981D4C39180}';

  { Event ID's }

type
  { Forward declarations }
  IDARemoteService = interface;
  IDALoginService = interface;

  TDADatasetParamArray = class;
  TDADatasetRequestInfoArray = class;
  TDAStringArray = class;

  TDADatasetParam = class;
  TDADatasetRequestInfo = class;
  TDALoginInfo = class;


  { TDADatasetParam }
  TDADatasetParam = class(TROComplexType)
  private
    fName: AnsiString;
    fValue: Variant;
  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 Value:Variant read fValue write fValue;
  end;

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

  { TDADatasetRequestInfo }
  TDADatasetRequestInfo = class(TROComplexType)
  private
    fDatasetName: AnsiString;
    fIncludeSchema: Boolean;
    fMaxRecords: Integer;
    fParams: TDADatasetParamArray;
    function GetParams: TDADatasetParamArray;
  public
    procedure Assign(iSource: TPersistent); override;
    procedure ReadComplex(ASerializer: TObject); override;
    procedure WriteComplex(ASerializer: TObject); override;
  published
    property DatasetName:AnsiString read fDatasetName write fDatasetName;
    property IncludeSchema:Boolean read fIncludeSchema write fIncludeSchema;
    property MaxRecords:Integer read fMaxRecords write fMaxRecords;
    property Params:TDADatasetParamArray read GetParams write fParams;
  end;

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

  { TDALoginInfo }
  TDALoginInfo = class(TROComplexType)
  private
    fSessionID: AnsiString;
    fUserID: AnsiString;
    fPrivileges: TDAStringArray;
    fAttributes: TDAStringArray;
    fData: Binary;
    function GetPrivileges: TDAStringArray;
    function GetAttributes: TDAStringArray;
    function GetData: Binary;
  public
    procedure Assign(iSource: TPersistent); override;
    procedure ReadComplex(ASerializer: TObject); override;
    procedure WriteComplex(ASerializer: TObject); override;
  published
    property SessionID:AnsiString read fSessionID write fSessionID;
    property UserID:AnsiString read fUserID write fUserID;
    property Privileges:TDAStringArray read GetPrivileges write fPrivileges;
    property Attributes:TDAStringArray read GetAttributes write fAttributes;
    property Data:Binary read GetData write fData;
  end;

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

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

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

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

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

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

    function GetItemRef(aIndex: integer): 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(const Value:AnsiString): integer;
    function GetIndex(const aPropertyName : string;
                      const aPropertyValue : Variant;
                      StartFrom : integer = 0;
                      Options : TROSearchOptions = [soIgnoreCase]) : integer; override;

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

  { IDARemoteService }
  IDARemoteService = interface
    ['{C532E842-0AA9-4253-A9BF-AFCF22885B97}']
    function GetDatasetSchema(const aDatasetName: AnsiString): Binary;
    function GetDatasetScripts(const DatasetNames: AnsiString): AnsiString;
    function GetDatasetData(const DatasetName: AnsiString; const Params: AnsiString; const IncludeSchema: Boolean; const MaxRecords: Integer): Binary;
    function GetDatasetDataEx(const DatasetName: AnsiString; const Params: TDADatasetParamArray; const UserFilter: AnsiString; const IncludeSchema: Boolean; 
                              const MaxRecords: Integer): Binary;
    function UpdateData(const Delta: Binary): Binary;
    function ExecuteSQLCommand(const SQL: AnsiString): Integer;
    function GetSchemaAsXML: AnsiString;
    function GetMultipleDatasets(const DatasetRequestInfoArray: TDADatasetRequestInfoArray): Binary;
    function ExecuteSQLCommandEx(const CommandName: AnsiString; const Params: TDADatasetParamArray): Integer;
  end;

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

  { TDARemoteService_Proxy }
  TDARemoteService_Proxy = class(TROProxy, IDARemoteService)
  protected
    function __GetInterfaceName:string; override;

    function GetDatasetSchema(const aDatasetName: AnsiString): Binary;
    function GetDatasetScripts(const DatasetNames: AnsiString): AnsiString;
    function GetDatasetData(const DatasetName: AnsiString; const Params: AnsiString; const IncludeSchema: Boolean; const MaxRecords: Integer): Binary;
    function GetDatasetDataEx(const DatasetName: AnsiString; const Params: TDADatasetParamArray; const UserFilter: AnsiString; const IncludeSchema: Boolean; 
                              const MaxRecords: Integer): Binary;
    function UpdateData(const Delta: Binary): Binary;
    function ExecuteSQLCommand(const SQL: AnsiString): Integer;
    function GetSchemaAsXML: AnsiString;
    function GetMultipleDatasets(const DatasetRequestInfoArray: TDADatasetRequestInfoArray): Binary;
    function ExecuteSQLCommandEx(const CommandName: AnsiString; const Params: TDADatasetParamArray): Integer;
  end;

  { IDALoginService }
  IDALoginService = interface(IDARemoteService)
    ['{58550AA0-B64F-495A-B2F8-C981D4C39180}']
    function Login(const UserID: AnsiString; const Password: AnsiString; out LoginInfo: TDALoginInfo): Boolean;
    procedure Logout;
  end;

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

  { TDALoginService_Proxy }
  TDALoginService_Proxy = class(TDARemoteService_Proxy, IDALoginService)
  protected
    function __GetInterfaceName:string; override;

    function Login(const UserID: AnsiString; const Password: AnsiString; out LoginInfo: TDALoginInfo): Boolean;
    procedure Logout;
  end;

implementation

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

{ TDADatasetParamArray }

procedure TDADatasetParamArray.Assign(iSource: TPersistent);
var lSource:TDADatasetParamArray;
    i:integer;
begin
  if (iSource is TDADatasetParamArray) then begin
    lSource := TDADatasetParamArray(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 TDADatasetParamArray.GetItemType: PTypeInfo;
begin
  result := TypeInfo(TDADatasetParam);
end;

class function TDADatasetParamArray.GetItemClass: TClass;
begin
  result := TDADatasetParam;
end;

class function TDADatasetParamArray.GetItemSize: integer;
begin
  result := SizeOf(TDADatasetParam);
end;

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

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

procedure TDADatasetParamArray.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 TDADatasetParamArray.Clear;
var i: integer;
begin
  for i := 0 to (Count-1) do fItems[i].Free();
  SetLength(fItems, 0);
  FCount := 0;
end;

procedure TDADatasetParamArray.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 TDADatasetParamArray.SetItems(aIndex: integer; const Value: TDADatasetParam);
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 TDADatasetParamArray.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] := TDADatasetParam.Create;
  FCount := ElementCount;
end;

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

procedure TDADatasetParamArray.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 TDADatasetParamArray.Add: TDADatasetParam;
begin
  result := TDADatasetParam.Create;
  Add(Result);
end;

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

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

procedure TDADatasetParamArray.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], TDADatasetParam, i);
end;

{ TDADatasetRequestInfoArray }

procedure TDADatasetRequestInfoArray.Assign(iSource: TPersistent);
var lSource:TDADatasetRequestInfoArray;
    i:integer;
begin
  if (iSource is TDADatasetRequestInfoArray) then begin
    lSource := TDADatasetRequestInfoArray(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 TDADatasetRequestInfoArray.GetItemType: PTypeInfo;
begin
  result := TypeInfo(TDADatasetRequestInfo);
end;

class function TDADatasetRequestInfoArray.GetItemClass: TClass;
begin
  result := TDADatasetRequestInfo;
end;

class function TDADatasetRequestInfoArray.GetItemSize: integer;
begin
  result := SizeOf(TDADatasetRequestInfo);
end;

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

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

procedure TDADatasetRequestInfoArray.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 TDADatasetRequestInfoArray.Clear;
var i: integer;
begin
  for i := 0 to (Count-1) do fItems[i].Free();
  SetLength(fItems, 0);
  FCount := 0;
end;

procedure TDADatasetRequestInfoArray.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 TDADatasetRequestInfoArray.SetItems(aIndex: integer; const Value: TDADatasetRequestInfo);
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 TDADatasetRequestInfoArray.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] := TDADatasetRequestInfo.Create;
  FCount := ElementCount;
end;

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

procedure TDADatasetRequestInfoArray.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 TDADatasetRequestInfoArray.Add: TDADatasetRequestInfo;
begin
  result := TDADatasetRequestInfo.Create;
  Add(Result);
end;

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

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

procedure TDADatasetRequestInfoArray.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], TDADatasetRequestInfo, i);
end;

{ TDAStringArray }

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

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

class function TDAStringArray.GetItemType: PTypeInfo;
begin
  result := TypeInfo(AnsiString);
end;

class function TDAStringArray.GetItemSize: integer;
begin
  result := SizeOf(AnsiString);
end;

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

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

procedure TDAStringArray.Clear;
begin
  SetLength(fItems, 0);
  FCount := 0;
end;

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

  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 TDAStringArray.SetItems(aIndex: integer; const Value: AnsiString);
begin
  if (aIndex < 0) or (aIndex >= Count) then RaiseError(err_ArrayIndexOutOfBounds,[aIndex]);
  fItems[aIndex] := Value;
end;

procedure TDAStringArray.Resize(ElementCount: integer);
begin
  if fCount = ElementCount then Exit;
  SetLength(fItems, ElementCount);
  FCount := ElementCount;
end;

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

procedure TDAStringArray.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 TDAStringArray.Add(const Value: AnsiString): integer;
begin
  Result := Count;
  if Length(fItems) = Result then
    Grow;
  fItems[result] := Value;
  Inc(fCount);
end;

function TDAStringArray.GetIndex(const aPropertyName: string;
  const aPropertyValue: Variant; StartFrom: integer;
  Options: TROSearchOptions): integer;
begin
  result := -1;
end;

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

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

{ TDADatasetParam }

procedure TDADatasetParam.Assign(iSource: TPersistent); 
var lSource: DataAbstract3_Intf.TDADatasetParam;
begin
  inherited Assign(iSource);
  if (iSource is DataAbstract3_Intf.TDADatasetParam) then begin
    lSource := DataAbstract3_Intf.TDADatasetParam(iSource);
    Name := lSource.Name;
    Value := lSource.Value;
  end;
end;

procedure TDADatasetParam.ReadComplex(ASerializer: TObject);
var
  l_Name: AnsiString;
  l_Value: Variant;
begin
  if TROSerializer(ASerializer).RecordStrictOrder then begin
    l_Name := Name;
    TROSerializer(ASerializer).ReadUTF8String('Name', l_Name);
    Name := l_Name;
    l_Value := Value;
    TROSerializer(ASerializer).ReadVariant('Value', l_Value);
    Value := l_Value;
  end
  else begin
    l_Name := Name;
    TROSerializer(ASerializer).ReadUTF8String('Name', l_Name);
    Name := l_Name;
    l_Value := Value;
    TROSerializer(ASerializer).ReadVariant('Value', l_Value);
    Value := l_Value;
  end;
end;

procedure TDADatasetParam.WriteComplex(ASerializer: TObject);
var
  l_Name: AnsiString;
  l_Value: Variant;
begin
  if TROSerializer(ASerializer).RecordStrictOrder then begin
    TROSerializer(ASerializer).ChangeClass(TDADatasetParam);
    l_Name := Name;
    TROSerializer(ASerializer).WriteUTF8String('Name', l_Name);
    l_Value := Value;
    TROSerializer(ASerializer).WriteVariant('Value', l_Value);
  end
  else begin
    l_Name := Name;
    TROSerializer(ASerializer).WriteUTF8String('Name', l_Name);
    l_Value := Value;
    TROSerializer(ASerializer).WriteVariant('Value', l_Value);
  end;
end;

{ TDADatasetParamCollection }
constructor TDADatasetParamCollection.Create;
begin
  inherited Create(TDADatasetParam);
end;

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

function TDADatasetParamCollection.Add: TDADatasetParam;
begin
  result := TDADatasetParam(inherited Add);
end;

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

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

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

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

{ TDADatasetRequestInfo }

procedure TDADatasetRequestInfo.Assign(iSource: TPersistent); 
var lSource: DataAbstract3_Intf.TDADatasetRequestInfo;
begin
  inherited Assign(iSource);
  if (iSource is DataAbstract3_Intf.TDADatasetRequestInfo) then begin
    lSource := DataAbstract3_Intf.TDADatasetRequestInfo(iSource);
    DatasetName := lSource.DatasetName;
    IncludeSchema := lSource.IncludeSchema;
    MaxRecords := lSource.MaxRecords;
    Params.Assign(lSource.Params);
  end;
end;

function TDADatasetRequestInfo.GetParams: TDADatasetParamArray;
begin
  if (fParams = nil) then fParams := TDADatasetParamArray.Create();
  result := fParams;
end;

procedure TDADatasetRequestInfo.ReadComplex(ASerializer: TObject);
var
  l_DatasetName: AnsiString;
  l_IncludeSchema: Boolean;
  l_MaxRecords: Integer;
  l_Params: TDADatasetParamArray;
begin
  if TROSerializer(ASerializer).RecordStrictOrder then begin
    l_DatasetName := DatasetName;
    TROSerializer(ASerializer).ReadUTF8String('DatasetName', l_DatasetName);
    DatasetName := l_DatasetName;
    l_IncludeSchema := IncludeSchema;
    TROSerializer(ASerializer).ReadEnumerated('IncludeSchema',TypeInfo(boolean), l_IncludeSchema);
    IncludeSchema := l_IncludeSchema;
    l_MaxRecords := MaxRecords;
    TROSerializer(ASerializer).ReadInteger('MaxRecords', otSLong, l_MaxRecords);
    MaxRecords := l_MaxRecords;
    l_Params := Params;
    TROSerializer(ASerializer).ReadArray('Params', TDADatasetParamArray, l_Params);
    if Params <> l_Params then Params.Free;
    Params := l_Params;
  end
  else begin
    l_DatasetName := DatasetName;
    TROSerializer(ASerializer).ReadUTF8String('DatasetName', l_DatasetName);
    DatasetName := l_DatasetName;
    l_IncludeSchema := IncludeSchema;
    TROSerializer(ASerializer).ReadEnumerated('IncludeSchema',TypeInfo(boolean), l_IncludeSchema);
    IncludeSchema := l_IncludeSchema;
    l_MaxRecords := MaxRecords;
    TROSerializer(ASerializer).ReadInteger('MaxRecords', otSLong, l_MaxRecords);
    MaxRecords := l_MaxRecords;
    l_Params := Params;
    TROSerializer(ASerializer).ReadArray('Params', TDADatasetParamArray, l_Params);
    if Params <> l_Params then Params.Free;
    Params := l_Params;
  end;
end;

procedure TDADatasetRequestInfo.WriteComplex(ASerializer: TObject);
var
  l_DatasetName: AnsiString;
  l_IncludeSchema: Boolean;
  l_MaxRecords: Integer;
  l_Params: TDADatasetParamArray;
begin
  if TROSerializer(ASerializer).RecordStrictOrder then begin
    TROSerializer(ASerializer).ChangeClass(TDADatasetRequestInfo);
    l_DatasetName := DatasetName;
    TROSerializer(ASerializer).WriteUTF8String('DatasetName', l_DatasetName);
    l_IncludeSchema := IncludeSchema;
    TROSerializer(ASerializer).WriteEnumerated('IncludeSchema',TypeInfo(boolean), l_IncludeSchema);
    l_MaxRecords := MaxRecords;
    TROSerializer(ASerializer).WriteInteger('MaxRecords', otSLong, l_MaxRecords);
    l_Params := Params;
    TROSerializer(ASerializer).WriteArray('Params', l_Params, TDADatasetParamArray);
  end
  else begin
    l_DatasetName := DatasetName;
    TROSerializer(ASerializer).WriteUTF8String('DatasetName', l_DatasetName);
    l_IncludeSchema := IncludeSchema;
    TROSerializer(ASerializer).WriteEnumerated('IncludeSchema',TypeInfo(boolean), l_IncludeSchema);
    l_MaxRecords := MaxRecords;
    TROSerializer(ASerializer).WriteInteger('MaxRecords', otSLong, l_MaxRecords);
    l_Params := Params;
    TROSerializer(ASerializer).WriteArray('Params', l_Params, TDADatasetParamArray);
  end;
end;

{ TDADatasetRequestInfoCollection }
constructor TDADatasetRequestInfoCollection.Create;
begin
  inherited Create(TDADatasetRequestInfo);
end;

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

function TDADatasetRequestInfoCollection.Add: TDADatasetRequestInfo;
begin
  result := TDADatasetRequestInfo(inherited Add);
end;

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

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

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

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

{ TDALoginInfo }

procedure TDALoginInfo.Assign(iSource: TPersistent); 
var lSource: DataAbstract3_Intf.TDALoginInfo;
begin
  inherited Assign(iSource);
  if (iSource is DataAbstract3_Intf.TDALoginInfo) then begin
    lSource := DataAbstract3_Intf.TDALoginInfo(iSource);
    SessionID := lSource.SessionID;
    UserID := lSource.UserID;
    Privileges.Assign(lSource.Privileges);
    Attributes.Assign(lSource.Attributes);
    Data.Assign(lSource.Data);
  end;
end;

function TDALoginInfo.GetPrivileges: TDAStringArray;
begin
  if (fPrivileges = nil) then fPrivileges := TDAStringArray.Create();
  result := fPrivileges;
end;

function TDALoginInfo.GetAttributes: TDAStringArray;
begin
  if (fAttributes = nil) then fAttributes := TDAStringArray.Create();
  result := fAttributes;
end;

function TDALoginInfo.GetData: Binary;
begin
  if (fData = nil) then fData := Binary.Create();
  result := fData;
end;

procedure TDALoginInfo.ReadComplex(ASerializer: TObject);
var
  l_Attributes: TDAStringArray;
  l_Data: Binary;
  l_Privileges: TDAStringArray;
  l_SessionID: AnsiString;
  l_UserID: AnsiString;
begin
  if TROSerializer(ASerializer).RecordStrictOrder then begin
    l_SessionID := SessionID;
    TROSerializer(ASerializer).ReadUTF8String('SessionID', l_SessionID);
    SessionID := l_SessionID;
    l_UserID := UserID;
    TROSerializer(ASerializer).ReadUTF8String('UserID', l_UserID);
    UserID := l_UserID;
    l_Privileges := Privileges;
    TROSerializer(ASerializer).ReadArray('Privileges', TDAStringArray, l_Privileges);
    if Privileges <> l_Privileges then Privileges.Free;
    Privileges := l_Privileges;
    l_Attributes := Attributes;
    TROSerializer(ASerializer).ReadArray('Attributes', TDAStringArray, l_Attributes);
    if Attributes <> l_Attributes then Attributes.Free;
    Attributes := l_Attributes;
    l_Data := Data;
    TROSerializer(ASerializer).ReadBinary('Data', l_Data);
    if Data <> l_Data then Data.Free;
    Data := l_Data;
  end
  else begin
    l_Attributes := Attributes;
    TROSerializer(ASerializer).ReadArray('Attributes', TDAStringArray, l_Attributes);
    if Attributes <> l_Attributes then Attributes.Free;
    Attributes := l_Attributes;
    l_Data := Data;
    TROSerializer(ASerializer).ReadBinary('Data', l_Data);
    if Data <> l_Data then Data.Free;
    Data := l_Data;
    l_Privileges := Privileges;
    TROSerializer(ASerializer).ReadArray('Privileges', TDAStringArray, l_Privileges);
    if Privileges <> l_Privileges then Privileges.Free;
    Privileges := l_Privileges;
    l_SessionID := SessionID;
    TROSerializer(ASerializer).ReadUTF8String('SessionID', l_SessionID);
    SessionID := l_SessionID;
    l_UserID := UserID;
    TROSerializer(ASerializer).ReadUTF8String('UserID', l_UserID);
    UserID := l_UserID;
  end;
end;

procedure TDALoginInfo.WriteComplex(ASerializer: TObject);
var
  l_Attributes: TDAStringArray;
  l_Data: Binary;
  l_Privileges: TDAStringArray;
  l_SessionID: AnsiString;
  l_UserID: AnsiString;
begin
  if TROSerializer(ASerializer).RecordStrictOrder then begin
    TROSerializer(ASerializer).ChangeClass(TDALoginInfo);
    l_SessionID := SessionID;
    TROSerializer(ASerializer).WriteUTF8String('SessionID', l_SessionID);
    l_UserID := UserID;
    TROSerializer(ASerializer).WriteUTF8String('UserID', l_UserID);
    l_Privileges := Privileges;
    TROSerializer(ASerializer).WriteArray('Privileges', l_Privileges, TDAStringArray);
    l_Attributes := Attributes;
    TROSerializer(ASerializer).WriteArray('Attributes', l_Attributes, TDAStringArray);
    l_Data := Data;
    TROSerializer(ASerializer).WriteBinary('Data', l_Data);
  end
  else begin
    l_Attributes := Attributes;
    TROSerializer(ASerializer).WriteArray('Attributes', l_Attributes, TDAStringArray);
    l_Data := Data;
    TROSerializer(ASerializer).WriteBinary('Data', l_Data);
    l_Privileges := Privileges;
    TROSerializer(ASerializer).WriteArray('Privileges', l_Privileges, TDAStringArray);
    l_SessionID := SessionID;
    TROSerializer(ASerializer).WriteUTF8String('SessionID', l_SessionID);
    l_UserID := UserID;
    TROSerializer(ASerializer).WriteUTF8String('UserID', l_UserID);
  end;
end;

{ TDALoginInfoCollection }
constructor TDALoginInfoCollection.Create;
begin
  inherited Create(TDALoginInfo);
end;

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

function TDALoginInfoCollection.Add: TDALoginInfo;
begin
  result := TDALoginInfo(inherited Add);
end;

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

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

{ CoDARemoteService }

class function CoDARemoteService.Create(const aMessage: IROMessage; aTransportChannel: IROTransportChannel): IDARemoteService;
begin
  result := TDARemoteService_Proxy.Create(aMessage, aTransportChannel);
end;

{ TDARemoteService_Proxy }

function TDARemoteService_Proxy.__GetInterfaceName:string;
begin
  result := 'DARemoteService';
end;

function TDARemoteService_Proxy.GetDatasetSchema(const aDatasetName: AnsiString): Binary;
begin
  try
    result := nil;
    __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract3', __InterfaceName, 'GetDatasetSchema');
    __Message.Write('aDatasetName', TypeInfo(AnsiString), aDatasetName, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

function TDARemoteService_Proxy.GetDatasetScripts(const DatasetNames: AnsiString): AnsiString;
begin
  try
    __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract3', __InterfaceName, 'GetDatasetScripts');
    __Message.Write('DatasetNames', TypeInfo(AnsiString), DatasetNames, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

function TDARemoteService_Proxy.GetDatasetData(const DatasetName: AnsiString; const Params: AnsiString; const IncludeSchema: Boolean; const MaxRecords: Integer): Binary;
begin
  try
    result := nil;
    __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract3', __InterfaceName, 'GetDatasetData');
    __Message.Write('DatasetName', TypeInfo(AnsiString), DatasetName, []);
    __Message.Write('Params', TypeInfo(AnsiString), Params, []);
    __Message.Write('IncludeSchema', TypeInfo(Boolean), IncludeSchema, []);
    __Message.Write('MaxRecords', TypeInfo(Integer), MaxRecords, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

function TDARemoteService_Proxy.GetDatasetDataEx(const DatasetName: AnsiString; const Params: TDADatasetParamArray; const UserFilter: AnsiString; const IncludeSchema: Boolean; 
                                                 const MaxRecords: Integer): Binary;
begin
  try
    result := nil;
    __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract3', __InterfaceName, 'GetDatasetDataEx');
    __Message.Write('DatasetName', TypeInfo(AnsiString), DatasetName, []);
    __Message.Write('Params', TypeInfo(DataAbstract3_Intf.TDADatasetParamArray), Params, []);
    __Message.Write('UserFilter', TypeInfo(AnsiString), UserFilter, []);
    __Message.Write('IncludeSchema', TypeInfo(Boolean), IncludeSchema, []);
    __Message.Write('MaxRecords', TypeInfo(Integer), MaxRecords, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

function TDARemoteService_Proxy.UpdateData(const Delta: Binary): Binary;
begin
  try
    result := nil;
    __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract3', __InterfaceName, 'UpdateData');
    __Message.Write('Delta', TypeInfo(Binary), Delta, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

function TDARemoteService_Proxy.ExecuteSQLCommand(const SQL: AnsiString): Integer;
begin
  try
    __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract3', __InterfaceName, 'ExecuteSQLCommand');
    __Message.Write('SQL', TypeInfo(AnsiString), SQL, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

function TDARemoteService_Proxy.GetSchemaAsXML: AnsiString;
begin
  try
    __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract3', __InterfaceName, 'GetSchemaAsXML');
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

function TDARemoteService_Proxy.GetMultipleDatasets(const DatasetRequestInfoArray: TDADatasetRequestInfoArray): Binary;
begin
  try
    result := nil;
    __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract3', __InterfaceName, 'GetMultipleDatasets');
    __Message.Write('DatasetRequestInfoArray', TypeInfo(DataAbstract3_Intf.TDADatasetRequestInfoArray), DatasetRequestInfoArray, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

function TDARemoteService_Proxy.ExecuteSQLCommandEx(const CommandName: AnsiString; const Params: TDADatasetParamArray): Integer;
begin
  try
    __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract3', __InterfaceName, 'ExecuteSQLCommandEx');
    __Message.Write('CommandName', TypeInfo(AnsiString), CommandName, []);
    __Message.Write('Params', TypeInfo(DataAbstract3_Intf.TDADatasetParamArray), Params, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

{ CoDALoginService }

class function CoDALoginService.Create(const aMessage: IROMessage; aTransportChannel: IROTransportChannel): IDALoginService;
begin
  result := TDALoginService_Proxy.Create(aMessage, aTransportChannel);
end;

{ TDALoginService_Proxy }

function TDALoginService_Proxy.__GetInterfaceName:string;
begin
  result := 'DALoginService';
end;

function TDALoginService_Proxy.Login(const UserID: AnsiString; const Password: AnsiString; out LoginInfo: TDALoginInfo): Boolean;
begin
  try
    LoginInfo := nil;
    __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract3', __InterfaceName, 'Login');
    __Message.Write('UserID', TypeInfo(AnsiString), UserID, []);
    __Message.Write('Password', TypeInfo(AnsiString), Password, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

procedure TDALoginService_Proxy.Logout;
begin
  try
    __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract3', __InterfaceName, 'Logout');
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

  finally
    __Message.FreeStream;
  end
end;

initialization
  RegisterROClass(TDADatasetParam);
  RegisterROClass(TDADatasetRequestInfo);
  RegisterROClass(TDALoginInfo);
  RegisterROClass(TDADatasetParamArray);
  RegisterROClass(TDADatasetRequestInfoArray);
  RegisterROClass(TDAStringArray);
  RegisterProxyClass(IDARemoteService_IID, TDARemoteService_Proxy);
  RegisterProxyClass(IDALoginService_IID, TDALoginService_Proxy);


finalization
  UnregisterROClass(TDADatasetParam);
  UnregisterROClass(TDADatasetRequestInfo);
  UnregisterROClass(TDALoginInfo);
  UnregisterROClass(TDADatasetParamArray);
  UnregisterROClass(TDADatasetRequestInfoArray);
  UnregisterROClass(TDAStringArray);
  UnregisterProxyClass(IDARemoteService_IID);
  UnregisterProxyClass(IDALoginService_IID);

end.