unit DataAbstract4_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 = '{DC8B7BE2-14AF-402D-B1F8-E1008B6FA4F6}';
  TargetNamespace = '';

  { Service Interface ID's }
  IDataAbstractService_IID : TGUID = '{4C2EC238-4FB4-434E-8CFF-ED25EEFF1525}';
  ISimpleLoginService_IID : TGUID = '{B186853B-168B-4E33-B798-467444BFC8C6}';
  IBaseLoginService_IID : TGUID = '{C349DB54-9DFB-454E-AD23-6F2166A624A6}';
  IMultiDbLoginService_IID : TGUID = '{2C6D5764-01CE-447A-8264-27210B2C7371}';
  IMultiDbLoginServiceV5_IID : TGUID = '{5A78AB01-2097-4473-A4D5-78980FFD90E4}';

  { Event ID's }
  EID_DataChangeNotification = 'DataChangeNotification';

type
  { Forward declarations }
  IDataAbstractService = interface;
  ISimpleLoginService = interface;
  IBaseLoginService = interface;
  IMultiDbLoginService = interface;
  IMultiDbLoginServiceV5 = interface;

  DataParameterArray = class;
  TableRequestInfoArray = class;
  StringArray = class;
  VariantArray = class;
  ColumnSortingArray = class;

  DataParameter = class;
  TableRequestInfo = class;
  UserInfo = class;
  TableRequestInfoV5 = class;
  ColumnSorting = class;

  IDataChangeNotification = interface;


  { Enumerateds }
  ColumnSortDirection = (ColumnSortDirection_Ascending,ColumnSortDirection_Descending);

  { DataParameter }
  DataParameter = class(TROComplexType)
  private
    fName: Utf8String;
    fValue: Variant;
  public
    procedure Assign(iSource: TPersistent); override;
    procedure ReadComplex(ASerializer: TObject); override;
    procedure WriteComplex(ASerializer: TObject); override;
  published
    property Name:Utf8String read fName write fName;
    property Value:Variant read fValue write fValue;
  end;

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

  { TableRequestInfo }
  TableRequestInfo = class(TROComplexType)
  private
    fUserFilter: Utf8String;
    fIncludeSchema: Boolean;
    fMaxRecords: Integer;
    fParameters: DataParameterArray;
    function GetParameters: DataParameterArray;
  public
    procedure Assign(iSource: TPersistent); override;
    procedure ReadComplex(ASerializer: TObject); override;
    procedure WriteComplex(ASerializer: TObject); override;
  published
    property UserFilter:Utf8String read fUserFilter write fUserFilter;
    property IncludeSchema:Boolean read fIncludeSchema write fIncludeSchema;
    property MaxRecords:Integer read fMaxRecords write fMaxRecords;
    property Parameters:DataParameterArray read GetParameters write fParameters;
  end;

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

  { TableRequestInfoV5 }
  TableRequestInfoV5 = class(TableRequestInfo)
  private
    fWhereClause: IXmlNode;
    fDynamicSelectFieldNames: StringArray;
    fSorting: ColumnSorting;
    function GetDynamicSelectFieldNames: StringArray;
    function GetSorting: ColumnSorting;
  public
    procedure Assign(iSource: TPersistent); override;
    procedure ReadComplex(ASerializer: TObject); override;
    procedure WriteComplex(ASerializer: TObject); override;
  published
    property WhereClause:IXmlNode read fWhereClause write fWhereClause;
    property DynamicSelectFieldNames:StringArray read GetDynamicSelectFieldNames write fDynamicSelectFieldNames;
    property Sorting:ColumnSorting read GetSorting write fSorting;
  end;

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

  { UserInfo }
  UserInfo = class(TROComplexType)
  private
    fSessionID: Utf8String;
    fUserID: Utf8String;
    fPrivileges: StringArray;
    fAttributes: VariantArray;
    fUserData: Binary;
    function GetPrivileges: StringArray;
    function GetAttributes: VariantArray;
    function GetUserData: Binary;
  public
    procedure Assign(iSource: TPersistent); override;
    procedure ReadComplex(ASerializer: TObject); override;
    procedure WriteComplex(ASerializer: TObject); override;
  published
    property SessionID:Utf8String read fSessionID write fSessionID;
    property UserID:Utf8String read fUserID write fUserID;
    property Privileges:StringArray read GetPrivileges write fPrivileges;
    property Attributes:VariantArray read GetAttributes write fAttributes;
    property UserData:Binary read GetUserData write fUserData;
  end;

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

  { ColumnSorting }
  ColumnSorting = class(TROComplexType)
  private
    fFieldName: Utf8String;
    fSortDirection: ColumnSortDirection;
  public
    procedure Assign(iSource: TPersistent); override;
    procedure ReadComplex(ASerializer: TObject); override;
    procedure WriteComplex(ASerializer: TObject); override;
  published
    property FieldName:Utf8String read fFieldName write fFieldName;
    property SortDirection:ColumnSortDirection read fSortDirection write fSortDirection;
  end;

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

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

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

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

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

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

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

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

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

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

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

  { IDataAbstractService }
  IDataAbstractService = interface
    ['{4C2EC238-4FB4-434E-8CFF-ED25EEFF1525}']
    function GetSchema(const aFilter: Utf8String): Utf8String;
    function GetData(const aTableNameArray: StringArray; const aTableRequestInfoArray: TableRequestInfoArray): Binary;
    function UpdateData(const aDelta: Binary): Binary;
    function ExecuteCommand(const aCommandName: Utf8String; const aParameterArray: DataParameterArray): Integer;
    function ExecuteCommandEx(const aCommandName: Utf8String; const aInputParameters: DataParameterArray; out aOutputParameters: DataParameterArray): Integer;
    function GetTableSchema(const aTableNameArray: StringArray): Utf8String;
    function GetCommandSchema(const aCommandNameArray: StringArray): Utf8String;
    function SQLGetData(const aSQLText: Utf8String; const aIncludeSchema: Boolean; const aMaxRecords: Integer): Binary;
    function SQLExecuteCommand(const aSQLText: Utf8String): Integer;
    function GetDatasetScripts(const DatasetNames: Utf8String): Utf8String;
    procedure RegisterForDataChangeNotification(const aTableName: Utf8String);
    procedure UnregisterForDataChangeNotification(const aTableName: Utf8String);
  end;

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

  { TDataAbstractService_Proxy }
  TDataAbstractService_Proxy = class(TROProxy, IDataAbstractService)
  protected
    function __GetInterfaceName:string; override;

    function GetSchema(const aFilter: Utf8String): Utf8String;
    function GetData(const aTableNameArray: StringArray; const aTableRequestInfoArray: TableRequestInfoArray): Binary;
    function UpdateData(const aDelta: Binary): Binary;
    function ExecuteCommand(const aCommandName: Utf8String; const aParameterArray: DataParameterArray): Integer;
    function ExecuteCommandEx(const aCommandName: Utf8String; const aInputParameters: DataParameterArray; out aOutputParameters: DataParameterArray): Integer;
    function GetTableSchema(const aTableNameArray: StringArray): Utf8String;
    function GetCommandSchema(const aCommandNameArray: StringArray): Utf8String;
    function SQLGetData(const aSQLText: Utf8String; const aIncludeSchema: Boolean; const aMaxRecords: Integer): Binary;
    function SQLExecuteCommand(const aSQLText: Utf8String): Integer;
    function GetDatasetScripts(const DatasetNames: Utf8String): Utf8String;
    procedure RegisterForDataChangeNotification(const aTableName: Utf8String);
    procedure UnregisterForDataChangeNotification(const aTableName: Utf8String);
  end;

  { IBaseLoginService }
  IBaseLoginService = interface
    ['{C349DB54-9DFB-454E-AD23-6F2166A624A6}']
    procedure Logout;
  end;

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

  { TBaseLoginService_Proxy }
  TBaseLoginService_Proxy = class(TROProxy, IBaseLoginService)
  protected
    function __GetInterfaceName:string; override;

    procedure Logout;
  end;

  { IMultiDbLoginService }
  IMultiDbLoginService = interface(IBaseLoginService)
    ['{2C6D5764-01CE-447A-8264-27210B2C7371}']
    function Login(const aUserID: Utf8String; const aPassword: Utf8String; const aConnectionName: Utf8String; out aUserInfo: UserInfo): Boolean;
  end;

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

  { TMultiDbLoginService_Proxy }
  TMultiDbLoginService_Proxy = class(TBaseLoginService_Proxy, IMultiDbLoginService)
  protected
    function __GetInterfaceName:string; override;

    function Login(const aUserID: Utf8String; const aPassword: Utf8String; const aConnectionName: Utf8String; out aUserInfo: UserInfo): Boolean;
  end;

  { IMultiDbLoginServiceV5 }
  IMultiDbLoginServiceV5 = interface(IMultiDbLoginService)
    ['{5A78AB01-2097-4473-A4D5-78980FFD90E4}']
    function GetConnectionNames: StringArray;
    function GetDefaultConnectionName: Utf8String;
  end;

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

  { TMultiDbLoginServiceV5_Proxy }
  TMultiDbLoginServiceV5_Proxy = class(TMultiDbLoginService_Proxy, IMultiDbLoginServiceV5)
  protected
    function __GetInterfaceName:string; override;

    function GetConnectionNames: StringArray;
    function GetDefaultConnectionName: Utf8String;
  end;

  { ISimpleLoginService }
  ISimpleLoginService = interface(IBaseLoginService)
    ['{B186853B-168B-4E33-B798-467444BFC8C6}']
    function Login(const aUserID: Utf8String; const aPassword: Utf8String; out aUserInfo: UserInfo): Boolean;
  end;

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

  { TSimpleLoginService_Proxy }
  TSimpleLoginService_Proxy = class(TBaseLoginService_Proxy, ISimpleLoginService)
  protected
    function __GetInterfaceName:string; override;

    function Login(const aUserID: Utf8String; const aPassword: Utf8String; out aUserInfo: UserInfo): Boolean;
  end;

  { IDataChangeNotification }
  IDataChangeNotification = interface
    ['{1309480C-AEF8-48E0-A27F-E6090F441B46}']
    procedure OnDataTableChanged(const aTableName: Utf8String; const aDelta: Binary);
  end;

  { IDataChangeNotification_Writer }
  IDataChangeNotification_Writer = interface(IROEventWriter)
    ['{1309480C-AEF8-48E0-A27F-E6090F441B46}']
    procedure OnDataTableChanged(const __Sender : TGUID; const aTableName: Utf8String; const aDelta: Binary);
  end;

implementation

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

{ DataParameterArray }

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

class function DataParameterArray.GetItemClass: TClass;
begin
  result := DataParameter;
end;

class function DataParameterArray.GetItemSize: integer;
begin
  result := SizeOf(DataParameter);
end;

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

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

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

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

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

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

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

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

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

{ TableRequestInfoArray }

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

class function TableRequestInfoArray.GetItemClass: TClass;
begin
  result := TableRequestInfo;
end;

class function TableRequestInfoArray.GetItemSize: integer;
begin
  result := SizeOf(TableRequestInfo);
end;

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

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

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

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

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

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

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

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

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

{ StringArray }

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

class function StringArray.GetItemSize: integer;
begin
  result := SizeOf(Utf8String);
end;

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

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

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

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

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

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

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

procedure StringArray.ReadComplex(ASerializer: TObject);
var
  lval: Utf8String;
  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 StringArray.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;

{ VariantArray }

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

class function VariantArray.GetItemSize: integer;
begin
  result := SizeOf(Variant);
end;

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

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

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

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

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

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

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

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

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

{ ColumnSortingArray }

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

class function ColumnSortingArray.GetItemClass: TClass;
begin
  result := ColumnSorting;
end;

class function ColumnSortingArray.GetItemSize: integer;
begin
  result := SizeOf(ColumnSorting);
end;

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

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

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

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

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

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

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

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

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

{ DataParameter }

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

procedure DataParameter.ReadComplex(ASerializer: TObject);
var
  l_Name: Utf8String;
  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 DataParameter.WriteComplex(ASerializer: TObject);
var
  l_Name: Utf8String;
  l_Value: Variant;
begin
  if TROSerializer(ASerializer).RecordStrictOrder then begin
    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;

{ DataParameterCollection }
constructor DataParameterCollection.Create;
begin
  inherited Create(DataParameter);
end;

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

function DataParameterCollection.Add: DataParameter;
begin
  result := DataParameter(inherited Add);
end;

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

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

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

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

{ TableRequestInfo }

procedure TableRequestInfo.Assign(iSource: TPersistent); 
var lSource: DataAbstract4_Intf.TableRequestInfo;
begin
  inherited Assign(iSource);
  if (iSource is DataAbstract4_Intf.TableRequestInfo) then begin
    lSource := DataAbstract4_Intf.TableRequestInfo(iSource);
    UserFilter := lSource.UserFilter;
    IncludeSchema := lSource.IncludeSchema;
    MaxRecords := lSource.MaxRecords;
    Parameters.Assign(lSource.Parameters);
  end;
end;

function TableRequestInfo.GetParameters: DataParameterArray;
begin
  if (fParameters = nil) then fParameters := DataParameterArray.Create();
  result := fParameters;
end;

procedure TableRequestInfo.ReadComplex(ASerializer: TObject);
var
  l_IncludeSchema: Boolean;
  l_MaxRecords: Integer;
  l_Parameters: DataParameterArray;
  l_UserFilter: Utf8String;
begin
  if TROSerializer(ASerializer).RecordStrictOrder then begin
    l_UserFilter := UserFilter;
    TROSerializer(ASerializer).ReadUTF8String('UserFilter', l_UserFilter);
    UserFilter := l_UserFilter;
    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_Parameters := Parameters;
    TROSerializer(ASerializer).ReadArray('Parameters', DataParameterArray, l_Parameters);
    if Parameters <> l_Parameters then Parameters.Free;
    Parameters := l_Parameters;
  end else begin
    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_Parameters := Parameters;
    TROSerializer(ASerializer).ReadArray('Parameters', DataParameterArray, l_Parameters);
    if Parameters <> l_Parameters then Parameters.Free;
    Parameters := l_Parameters;
    l_UserFilter := UserFilter;
    TROSerializer(ASerializer).ReadUTF8String('UserFilter', l_UserFilter);
    UserFilter := l_UserFilter;
  end;
end;

procedure TableRequestInfo.WriteComplex(ASerializer: TObject);
var
  l_IncludeSchema: Boolean;
  l_MaxRecords: Integer;
  l_Parameters: DataParameterArray;
  l_UserFilter: Utf8String;
begin
  if TROSerializer(ASerializer).RecordStrictOrder then begin
    l_UserFilter := UserFilter;
    TROSerializer(ASerializer).WriteUTF8String('UserFilter', l_UserFilter);
    l_IncludeSchema := IncludeSchema;
    TROSerializer(ASerializer).WriteEnumerated('IncludeSchema',TypeInfo(boolean), l_IncludeSchema);
    l_MaxRecords := MaxRecords;
    TROSerializer(ASerializer).WriteInteger('MaxRecords', otSLong, l_MaxRecords);
    l_Parameters := Parameters;
    TROSerializer(ASerializer).WriteArray('Parameters', l_Parameters);
  end else begin
    l_IncludeSchema := IncludeSchema;
    TROSerializer(ASerializer).WriteEnumerated('IncludeSchema',TypeInfo(boolean), l_IncludeSchema);
    l_MaxRecords := MaxRecords;
    TROSerializer(ASerializer).WriteInteger('MaxRecords', otSLong, l_MaxRecords);
    l_Parameters := Parameters;
    TROSerializer(ASerializer).WriteArray('Parameters', l_Parameters);
    l_UserFilter := UserFilter;
    TROSerializer(ASerializer).WriteUTF8String('UserFilter', l_UserFilter);
  end;
end;

{ TableRequestInfoCollection }
constructor TableRequestInfoCollection.Create;
begin
  inherited Create(TableRequestInfo);
end;

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

function TableRequestInfoCollection.Add: TableRequestInfo;
begin
  result := TableRequestInfo(inherited Add);
end;

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

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

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

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

{ UserInfo }

procedure UserInfo.Assign(iSource: TPersistent); 
var lSource: DataAbstract4_Intf.UserInfo;
begin
  inherited Assign(iSource);
  if (iSource is DataAbstract4_Intf.UserInfo) then begin
    lSource := DataAbstract4_Intf.UserInfo(iSource);
    SessionID := lSource.SessionID;
    UserID := lSource.UserID;
    Privileges.Assign(lSource.Privileges);
    Attributes.Assign(lSource.Attributes);
    UserData.Assign(lSource.UserData);
  end;
end;

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

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

function UserInfo.GetUserData: Binary;
begin
  if (fUserData = nil) then fUserData := Binary.Create();
  result := fUserData;
end;

procedure UserInfo.ReadComplex(ASerializer: TObject);
var
  l_Attributes: VariantArray;
  l_Privileges: StringArray;
  l_SessionID: Utf8String;
  l_UserData: Binary;
  l_UserID: Utf8String;
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', StringArray, l_Privileges);
    if Privileges <> l_Privileges then Privileges.Free;
    Privileges := l_Privileges;
    l_Attributes := Attributes;
    TROSerializer(ASerializer).ReadArray('Attributes', VariantArray, l_Attributes);
    if Attributes <> l_Attributes then Attributes.Free;
    Attributes := l_Attributes;
    l_UserData := UserData;
    TROSerializer(ASerializer).ReadBinary('UserData', l_UserData);
    if UserData <> l_UserData then UserData.Free;
    UserData := l_UserData;
  end else begin
    l_Attributes := Attributes;
    TROSerializer(ASerializer).ReadArray('Attributes', VariantArray, l_Attributes);
    if Attributes <> l_Attributes then Attributes.Free;
    Attributes := l_Attributes;
    l_Privileges := Privileges;
    TROSerializer(ASerializer).ReadArray('Privileges', StringArray, 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_UserData := UserData;
    TROSerializer(ASerializer).ReadBinary('UserData', l_UserData);
    if UserData <> l_UserData then UserData.Free;
    UserData := l_UserData;
    l_UserID := UserID;
    TROSerializer(ASerializer).ReadUTF8String('UserID', l_UserID);
    UserID := l_UserID;
  end;
end;

procedure UserInfo.WriteComplex(ASerializer: TObject);
var
  l_Attributes: VariantArray;
  l_Privileges: StringArray;
  l_SessionID: Utf8String;
  l_UserData: Binary;
  l_UserID: Utf8String;
begin
  if TROSerializer(ASerializer).RecordStrictOrder then begin
    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);
    l_Attributes := Attributes;
    TROSerializer(ASerializer).WriteArray('Attributes', l_Attributes);
    l_UserData := UserData;
    TROSerializer(ASerializer).WriteBinary('UserData', l_UserData);
  end else begin
    l_Attributes := Attributes;
    TROSerializer(ASerializer).WriteArray('Attributes', l_Attributes);
    l_Privileges := Privileges;
    TROSerializer(ASerializer).WriteArray('Privileges', l_Privileges);
    l_SessionID := SessionID;
    TROSerializer(ASerializer).WriteUTF8String('SessionID', l_SessionID);
    l_UserData := UserData;
    TROSerializer(ASerializer).WriteBinary('UserData', l_UserData);
    l_UserID := UserID;
    TROSerializer(ASerializer).WriteUTF8String('UserID', l_UserID);
  end;
end;

{ UserInfoCollection }
constructor UserInfoCollection.Create;
begin
  inherited Create(UserInfo);
end;

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

function UserInfoCollection.Add: UserInfo;
begin
  result := UserInfo(inherited Add);
end;

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

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

{ TableRequestInfoV5 }

procedure TableRequestInfoV5.Assign(iSource: TPersistent); 
var lSource: DataAbstract4_Intf.TableRequestInfoV5;
begin
  inherited Assign(iSource);
  if (iSource is DataAbstract4_Intf.TableRequestInfoV5) then begin
    lSource := DataAbstract4_Intf.TableRequestInfoV5(iSource);
    WhereClause := lSource.WhereClause;
    DynamicSelectFieldNames.Assign(lSource.DynamicSelectFieldNames);
    Sorting.Assign(lSource.Sorting);
  end;
end;

function TableRequestInfoV5.GetDynamicSelectFieldNames: StringArray;
begin
  if (fDynamicSelectFieldNames = nil) then fDynamicSelectFieldNames := StringArray.Create();
  result := fDynamicSelectFieldNames;
end;

function TableRequestInfoV5.GetSorting: ColumnSorting;
begin
  if (fSorting = nil) then fSorting := ColumnSorting.Create();
  result := fSorting;
end;

procedure TableRequestInfoV5.ReadComplex(ASerializer: TObject);
var
  l_DynamicSelectFieldNames: StringArray;
  l_IncludeSchema: Boolean;
  l_MaxRecords: Integer;
  l_Parameters: DataParameterArray;
  l_Sorting: ColumnSorting;
  l_UserFilter: Utf8String;
  l_WhereClause: IXmlNode;
begin
  if TROSerializer(ASerializer).RecordStrictOrder then begin
    inherited;
    l_WhereClause := WhereClause;
    TROSerializer(ASerializer).ReadXML('WhereClause', l_WhereClause);
    WhereClause := l_WhereClause;
    l_DynamicSelectFieldNames := DynamicSelectFieldNames;
    TROSerializer(ASerializer).ReadArray('DynamicSelectFieldNames', StringArray, l_DynamicSelectFieldNames);
    if DynamicSelectFieldNames <> l_DynamicSelectFieldNames then DynamicSelectFieldNames.Free;
    DynamicSelectFieldNames := l_DynamicSelectFieldNames;
    l_Sorting := Sorting;
    TROSerializer(ASerializer).ReadStruct('Sorting', ColumnSorting, l_Sorting);
    if Sorting <> l_Sorting then Sorting.Free;
    Sorting := l_Sorting;
  end else begin
    l_DynamicSelectFieldNames := DynamicSelectFieldNames;
    TROSerializer(ASerializer).ReadArray('DynamicSelectFieldNames', StringArray, l_DynamicSelectFieldNames);
    if DynamicSelectFieldNames <> l_DynamicSelectFieldNames then DynamicSelectFieldNames.Free;
    DynamicSelectFieldNames := l_DynamicSelectFieldNames;
    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_Parameters := Parameters;
    TROSerializer(ASerializer).ReadArray('Parameters', DataParameterArray, l_Parameters);
    if Parameters <> l_Parameters then Parameters.Free;
    Parameters := l_Parameters;
    l_Sorting := Sorting;
    TROSerializer(ASerializer).ReadStruct('Sorting', ColumnSorting, l_Sorting);
    if Sorting <> l_Sorting then Sorting.Free;
    Sorting := l_Sorting;
    l_UserFilter := UserFilter;
    TROSerializer(ASerializer).ReadUTF8String('UserFilter', l_UserFilter);
    UserFilter := l_UserFilter;
    l_WhereClause := WhereClause;
    TROSerializer(ASerializer).ReadXML('WhereClause', l_WhereClause);
    WhereClause := l_WhereClause;
  end;
end;

procedure TableRequestInfoV5.WriteComplex(ASerializer: TObject);
var
  l_DynamicSelectFieldNames: StringArray;
  l_IncludeSchema: Boolean;
  l_MaxRecords: Integer;
  l_Parameters: DataParameterArray;
  l_Sorting: ColumnSorting;
  l_UserFilter: Utf8String;
  l_WhereClause: IXmlNode;
begin
  if TROSerializer(ASerializer).RecordStrictOrder then begin
    inherited;
    l_WhereClause := WhereClause;
    TROSerializer(ASerializer).WriteXML('WhereClause', l_WhereClause);
    l_DynamicSelectFieldNames := DynamicSelectFieldNames;
    TROSerializer(ASerializer).WriteArray('DynamicSelectFieldNames', l_DynamicSelectFieldNames);
    l_Sorting := Sorting;
    TROSerializer(ASerializer).WriteStruct('Sorting', l_Sorting);
  end else begin
    l_DynamicSelectFieldNames := DynamicSelectFieldNames;
    TROSerializer(ASerializer).WriteArray('DynamicSelectFieldNames', l_DynamicSelectFieldNames);
    l_IncludeSchema := IncludeSchema;
    TROSerializer(ASerializer).WriteEnumerated('IncludeSchema',TypeInfo(boolean), l_IncludeSchema);
    l_MaxRecords := MaxRecords;
    TROSerializer(ASerializer).WriteInteger('MaxRecords', otSLong, l_MaxRecords);
    l_Parameters := Parameters;
    TROSerializer(ASerializer).WriteArray('Parameters', l_Parameters);
    l_Sorting := Sorting;
    TROSerializer(ASerializer).WriteStruct('Sorting', l_Sorting);
    l_UserFilter := UserFilter;
    TROSerializer(ASerializer).WriteUTF8String('UserFilter', l_UserFilter);
    l_WhereClause := WhereClause;
    TROSerializer(ASerializer).WriteXML('WhereClause', l_WhereClause);
  end;
end;

{ TableRequestInfoV5Collection }
constructor TableRequestInfoV5Collection.Create;
begin
  inherited Create(TableRequestInfoV5);
end;

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

function TableRequestInfoV5Collection.Add: TableRequestInfoV5;
begin
  result := TableRequestInfoV5(inherited Add);
end;

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

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

{ ColumnSorting }

procedure ColumnSorting.Assign(iSource: TPersistent); 
var lSource: DataAbstract4_Intf.ColumnSorting;
begin
  inherited Assign(iSource);
  if (iSource is DataAbstract4_Intf.ColumnSorting) then begin
    lSource := DataAbstract4_Intf.ColumnSorting(iSource);
    FieldName := lSource.FieldName;
    SortDirection := lSource.SortDirection;
  end;
end;

procedure ColumnSorting.ReadComplex(ASerializer: TObject);
var
  l_FieldName: Utf8String;
  l_SortDirection: ColumnSortDirection;
begin
  if TROSerializer(ASerializer).RecordStrictOrder then begin
    l_FieldName := FieldName;
    TROSerializer(ASerializer).ReadUTF8String('FieldName', l_FieldName);
    FieldName := l_FieldName;
    l_SortDirection := SortDirection;
    TROSerializer(ASerializer).ReadEnumerated('SortDirection',TypeInfo(ColumnSortDirection), l_SortDirection);
    SortDirection := l_SortDirection;
  end else begin
    l_FieldName := FieldName;
    TROSerializer(ASerializer).ReadUTF8String('FieldName', l_FieldName);
    FieldName := l_FieldName;
    l_SortDirection := SortDirection;
    TROSerializer(ASerializer).ReadEnumerated('SortDirection',TypeInfo(ColumnSortDirection), l_SortDirection);
    SortDirection := l_SortDirection;
  end;
end;

procedure ColumnSorting.WriteComplex(ASerializer: TObject);
var
  l_FieldName: Utf8String;
  l_SortDirection: ColumnSortDirection;
begin
  if TROSerializer(ASerializer).RecordStrictOrder then begin
    l_FieldName := FieldName;
    TROSerializer(ASerializer).WriteUTF8String('FieldName', l_FieldName);
    l_SortDirection := SortDirection;
    TROSerializer(ASerializer).WriteEnumerated('SortDirection',TypeInfo(ColumnSortDirection), l_SortDirection);
  end else begin
    l_FieldName := FieldName;
    TROSerializer(ASerializer).WriteUTF8String('FieldName', l_FieldName);
    l_SortDirection := SortDirection;
    TROSerializer(ASerializer).WriteEnumerated('SortDirection',TypeInfo(ColumnSortDirection), l_SortDirection);
  end;
end;

{ ColumnSortingCollection }
constructor ColumnSortingCollection.Create;
begin
  inherited Create(ColumnSorting);
end;

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

function ColumnSortingCollection.Add: ColumnSorting;
begin
  result := ColumnSorting(inherited Add);
end;

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

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

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

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

{ CoDataAbstractService }

class function CoDataAbstractService.Create(const aMessage: IROMessage; aTransportChannel: IROTransportChannel): IDataAbstractService;
begin
  result := TDataAbstractService_Proxy.Create(aMessage, aTransportChannel);
end;

{ TDataAbstractService_Proxy }

function TDataAbstractService_Proxy.__GetInterfaceName:string;
begin
  result := 'DataAbstractService';
end;

function TDataAbstractService_Proxy.GetSchema(const aFilter: Utf8String): Utf8String;
begin
  try
    __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'GetSchema');
    __Message.Write('aFilter', TypeInfo(Utf8String), aFilter, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

function TDataAbstractService_Proxy.GetData(const aTableNameArray: StringArray; const aTableRequestInfoArray: TableRequestInfoArray): Binary;
begin
  try
    result := nil;
    __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'GetData');
    __Message.Write('aTableNameArray', TypeInfo(DataAbstract4_Intf.StringArray), aTableNameArray, []);
    __Message.Write('aTableRequestInfoArray', TypeInfo(DataAbstract4_Intf.TableRequestInfoArray), aTableRequestInfoArray, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

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

    __TransportChannel.Dispatch(__Message);

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

function TDataAbstractService_Proxy.ExecuteCommand(const aCommandName: Utf8String; const aParameterArray: DataParameterArray): Integer;
begin
  try
    __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'ExecuteCommand');
    __Message.Write('aCommandName', TypeInfo(Utf8String), aCommandName, []);
    __Message.Write('aParameterArray', TypeInfo(DataAbstract4_Intf.DataParameterArray), aParameterArray, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

function TDataAbstractService_Proxy.ExecuteCommandEx(const aCommandName: Utf8String; const aInputParameters: DataParameterArray; out aOutputParameters: DataParameterArray): Integer;
begin
  try
    aOutputParameters := nil;
    __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'ExecuteCommandEx');
    __Message.Write('aCommandName', TypeInfo(Utf8String), aCommandName, []);
    __Message.Write('aInputParameters', TypeInfo(DataAbstract4_Intf.DataParameterArray), aInputParameters, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

function TDataAbstractService_Proxy.GetTableSchema(const aTableNameArray: StringArray): Utf8String;
begin
  try
    __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'GetTableSchema');
    __Message.Write('aTableNameArray', TypeInfo(DataAbstract4_Intf.StringArray), aTableNameArray, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

function TDataAbstractService_Proxy.GetCommandSchema(const aCommandNameArray: StringArray): Utf8String;
begin
  try
    __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'GetCommandSchema');
    __Message.Write('aCommandNameArray', TypeInfo(DataAbstract4_Intf.StringArray), aCommandNameArray, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

function TDataAbstractService_Proxy.SQLGetData(const aSQLText: Utf8String; const aIncludeSchema: Boolean; const aMaxRecords: Integer): Binary;
begin
  try
    result := nil;
    __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'SQLGetData');
    __Message.Write('aSQLText', TypeInfo(Utf8String), aSQLText, []);
    __Message.Write('aIncludeSchema', TypeInfo(Boolean), aIncludeSchema, []);
    __Message.Write('aMaxRecords', TypeInfo(Integer), aMaxRecords, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

function TDataAbstractService_Proxy.SQLExecuteCommand(const aSQLText: Utf8String): Integer;
begin
  try
    __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'SQLExecuteCommand');
    __Message.Write('aSQLText', TypeInfo(Utf8String), aSQLText, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

function TDataAbstractService_Proxy.GetDatasetScripts(const DatasetNames: Utf8String): Utf8String;
begin
  try
    __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'GetDatasetScripts');
    __Message.Write('DatasetNames', TypeInfo(Utf8String), DatasetNames, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

procedure TDataAbstractService_Proxy.RegisterForDataChangeNotification(const aTableName: Utf8String);
begin
  try
    __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'RegisterForDataChangeNotification');
    __Message.Write('aTableName', TypeInfo(Utf8String), aTableName, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

procedure TDataAbstractService_Proxy.UnregisterForDataChangeNotification(const aTableName: Utf8String);
begin
  try
    __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'UnregisterForDataChangeNotification');
    __Message.Write('aTableName', TypeInfo(Utf8String), aTableName, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

{ CoSimpleLoginService }

class function CoSimpleLoginService.Create(const aMessage: IROMessage; aTransportChannel: IROTransportChannel): ISimpleLoginService;
begin
  result := TSimpleLoginService_Proxy.Create(aMessage, aTransportChannel);
end;

{ TSimpleLoginService_Proxy }

function TSimpleLoginService_Proxy.__GetInterfaceName:string;
begin
  result := 'SimpleLoginService';
end;

function TSimpleLoginService_Proxy.Login(const aUserID: Utf8String; const aPassword: Utf8String; out aUserInfo: UserInfo): Boolean;
begin
  try
    aUserInfo := nil;
    __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'Login');
    __Message.Write('aUserID', TypeInfo(Utf8String), aUserID, []);
    __Message.Write('aPassword', TypeInfo(Utf8String), aPassword, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

{ CoBaseLoginService }

class function CoBaseLoginService.Create(const aMessage: IROMessage; aTransportChannel: IROTransportChannel): IBaseLoginService;
begin
  result := TBaseLoginService_Proxy.Create(aMessage, aTransportChannel);
end;

{ TBaseLoginService_Proxy }

function TBaseLoginService_Proxy.__GetInterfaceName:string;
begin
  result := 'BaseLoginService';
end;

procedure TBaseLoginService_Proxy.Logout;
begin
  try
    __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'Logout');
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

  finally
    __Message.FreeStream;
  end
end;

{ CoMultiDbLoginService }

class function CoMultiDbLoginService.Create(const aMessage: IROMessage; aTransportChannel: IROTransportChannel): IMultiDbLoginService;
begin
  result := TMultiDbLoginService_Proxy.Create(aMessage, aTransportChannel);
end;

{ TMultiDbLoginService_Proxy }

function TMultiDbLoginService_Proxy.__GetInterfaceName:string;
begin
  result := 'MultiDbLoginService';
end;

function TMultiDbLoginService_Proxy.Login(const aUserID: Utf8String; const aPassword: Utf8String; const aConnectionName: Utf8String; out aUserInfo: UserInfo): Boolean;
begin
  try
    aUserInfo := nil;
    __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'Login');
    __Message.Write('aUserID', TypeInfo(Utf8String), aUserID, []);
    __Message.Write('aPassword', TypeInfo(Utf8String), aPassword, []);
    __Message.Write('aConnectionName', TypeInfo(Utf8String), aConnectionName, []);
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

{ CoMultiDbLoginServiceV5 }

class function CoMultiDbLoginServiceV5.Create(const aMessage: IROMessage; aTransportChannel: IROTransportChannel): IMultiDbLoginServiceV5;
begin
  result := TMultiDbLoginServiceV5_Proxy.Create(aMessage, aTransportChannel);
end;

{ TMultiDbLoginServiceV5_Proxy }

function TMultiDbLoginServiceV5_Proxy.__GetInterfaceName:string;
begin
  result := 'MultiDbLoginServiceV5';
end;

function TMultiDbLoginServiceV5_Proxy.GetConnectionNames: StringArray;
begin
  try
    result := nil;
    __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'GetConnectionNames');
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

function TMultiDbLoginServiceV5_Proxy.GetDefaultConnectionName: Utf8String;
begin
  try
    __Message.InitializeRequestMessage(__TransportChannel, 'DataAbstract4', __InterfaceName, 'GetDefaultConnectionName');
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

type
  { TDataChangeNotification_Writer }
  TDataChangeNotification_Writer = class(TROEventWriter, IDataChangeNotification_Writer)
  protected
    procedure OnDataTableChanged(const __Sender : TGUID; const aTableName: Utf8String; const aDelta: Binary);
  end;

procedure TDataChangeNotification_Writer.OnDataTableChanged(const __Sender : TGUID; const aTableName: Utf8String; const aDelta: Binary);
var __eventdata : Binary;
begin
  __eventdata := Binary.Create;
  try
    __Message.InitializeEventMessage(NIL, 'DataAbstract4', EID_DataChangeNotification, 'OnDataTableChanged');
    __Message.Write('aTableName', TypeInfo(Utf8String), aTableName, []);
    __Message.Write('aDelta', TypeInfo(Binary), aDelta, []);
    __Message.Finalize;

    __Message.WriteToStream(__eventdata);

    Repository.StoreEventData(__Sender, __eventdata, ExcludeSender, ExcludeSessionList, SessionList.CommaText);
  finally
    __eventdata.Free;
  end;
end;

type
  {$M+}
  { TDataChangeNotification_Invoker }
  TDataChangeNotification_Invoker = class(TROEventInvoker)
  published
    procedure Invoke_OnDataTableChanged(__EventReceiver : TROEventReceiver; const __Message : IROMessage; const __Target : IUnknown);
  end;
  {$M-}

procedure TDataChangeNotification_Invoker.Invoke_OnDataTableChanged(__EventReceiver : TROEventReceiver; const __Message : IROMessage; const __Target : IUnknown);
var
__lObjectDisposer: TROObjectDisposer;
  aTableName: Utf8String;
  aDelta: Binary;
begin
  aDelta := NIL;

  try
    __Message.Read('aTableName', TypeInfo(Utf8String), aTableName, []);
    __Message.Read('aDelta', TypeInfo(Binary), aDelta, []);

    (__Target as IDataChangeNotification).OnDataTableChanged(aTableName, aDelta);

  finally
    __lObjectDisposer:= TROObjectDisposer.Create(__EventReceiver);
    try
      __lObjectDisposer.Add(aDelta);
    finally
      __lObjectDisposer.Free();
    end
  end
end;

initialization
  RegisterROClass(DataParameter);
  RegisterROClass(TableRequestInfo);
  RegisterROClass(UserInfo);
  RegisterROClass(TableRequestInfoV5);
  RegisterROClass(ColumnSorting);
  RegisterROClass(DataParameterArray);
  RegisterROClass(TableRequestInfoArray);
  RegisterROClass(StringArray);
  RegisterROClass(VariantArray);
  RegisterROClass(ColumnSortingArray);
  RegisterProxyClass(IDataAbstractService_IID, TDataAbstractService_Proxy);
  RegisterProxyClass(ISimpleLoginService_IID, TSimpleLoginService_Proxy);
  RegisterProxyClass(IBaseLoginService_IID, TBaseLoginService_Proxy);
  RegisterProxyClass(IMultiDbLoginService_IID, TMultiDbLoginService_Proxy);
  RegisterProxyClass(IMultiDbLoginServiceV5_IID, TMultiDbLoginServiceV5_Proxy);

  RegisterEventWriterClass(IDataChangeNotification_Writer, TDataChangeNotification_Writer);
  RegisterEventInvokerClass(EID_DataChangeNotification, TDataChangeNotification_Invoker);

finalization
  UnregisterROClass(DataParameter);
  UnregisterROClass(TableRequestInfo);
  UnregisterROClass(UserInfo);
  UnregisterROClass(TableRequestInfoV5);
  UnregisterROClass(ColumnSorting);
  UnregisterROClass(DataParameterArray);
  UnregisterROClass(TableRequestInfoArray);
  UnregisterROClass(StringArray);
  UnregisterROClass(VariantArray);
  UnregisterROClass(ColumnSortingArray);
  UnregisterProxyClass(IDataAbstractService_IID);
  UnregisterProxyClass(ISimpleLoginService_IID);
  UnregisterProxyClass(IBaseLoginService_IID);
  UnregisterProxyClass(IMultiDbLoginService_IID);
  UnregisterProxyClass(IMultiDbLoginServiceV5_IID);

  UnregisterEventWriterClass(IDataChangeNotification_Writer);
  UnregisterEventInvokerClass(EID_DataChangeNotification);
end.