Componentes.Terceros.RemObjects/internal/5.0.35.741/1/RemObjects SDK for Delphi/Samples/Arrays/ArraysLibrary_Intf.pas

unit ArraysLibrary_Intf;

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

{$I Remobjects.inc}

interface

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

const
  { Library ID }
  LibraryUID = '{7BFDF035-4BE8-4255-9337-E112A2F30DA0}';
  TargetNamespace = '';

  { Service Interface ID's }
  IArraysService_IID : TGUID = '{426D1A36-4EBF-4241-8E63-A26D303AA90E}';

  { Event ID's }

type
  { Forward declarations }
  IArraysService = interface;

  CustomersArray = class;
  OrdersArray = class;

  Customers = class;
  Orders = class;
  Tables = class;


  { Customers }
  Customers = class(TROComplexType)
  private
    fCustomerID: WideString;
    fCompanyName: WideString;
    fContactName: WideString;
    fContactTitle: WideString;
    fAddress: WideString;
    fCity: WideString;
    fRegion: WideString;
    fPostalcode: WideString;
    fCountry: WideString;
    fPhone: WideString;
    fFax: WideString;
  public
    procedure Assign(iSource: TPersistent); override;
    procedure ReadComplex(ASerializer: TObject); override;
    procedure WriteComplex(ASerializer: TObject); override;
  published
    property CustomerID:WideString read fCustomerID write fCustomerID;
    property CompanyName:WideString read fCompanyName write fCompanyName;
    property ContactName:WideString read fContactName write fContactName;
    property ContactTitle:WideString read fContactTitle write fContactTitle;
    property Address:WideString read fAddress write fAddress;
    property City:WideString read fCity write fCity;
    property Region:WideString read fRegion write fRegion;
    property Postalcode:WideString read fPostalcode write fPostalcode;
    property Country:WideString read fCountry write fCountry;
    property Phone:WideString read fPhone write fPhone;
    property Fax:WideString read fFax write fFax;
  end;

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

  { Orders }
  Orders = class(TROComplexType)
  private
    fOrderID: Integer;
    fCustomerID: WideString;
    fEmployeeID: Integer;
    fOrderDate: DateTime;
    fRequiredDate: DateTime;
    fShippedDate: DateTime;
    fShipVia: Integer;
    fFreight: Currency;
    fShipName: WideString;
    fShipAddress: WideString;
    fShipCity: WideString;
    fShipRegion: WideString;
    fShipPostalCode: WideString;
    fShipCountry: WideString;
  public
    procedure Assign(iSource: TPersistent); override;
    procedure ReadComplex(ASerializer: TObject); override;
    procedure WriteComplex(ASerializer: TObject); override;
  published
    property OrderID:Integer read fOrderID write fOrderID;
    property CustomerID:WideString read fCustomerID write fCustomerID;
    property EmployeeID:Integer read fEmployeeID write fEmployeeID;
    property OrderDate:DateTime read fOrderDate write fOrderDate;
    property RequiredDate:DateTime read fRequiredDate write fRequiredDate;
    property ShippedDate:DateTime read fShippedDate write fShippedDate;
    property ShipVia:Integer read fShipVia write fShipVia;
    property Freight:Currency read fFreight write fFreight;
    property ShipName:WideString read fShipName write fShipName;
    property ShipAddress:WideString read fShipAddress write fShipAddress;
    property ShipCity:WideString read fShipCity write fShipCity;
    property ShipRegion:WideString read fShipRegion write fShipRegion;
    property ShipPostalCode:WideString read fShipPostalCode write fShipPostalCode;
    property ShipCountry:WideString read fShipCountry write fShipCountry;
  end;

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

  { Tables }
  Tables = class(TROComplexType)
  private
    faCustomers: CustomersArray;
    faOrders: OrdersArray;
    function GetaCustomers: CustomersArray;
    function GetaOrders: OrdersArray;
  public
    procedure Assign(iSource: TPersistent); override;
    procedure ReadComplex(ASerializer: TObject); override;
    procedure WriteComplex(ASerializer: TObject); override;
  published
    property aCustomers:CustomersArray read GetaCustomers write faCustomers;
    property aOrders:OrdersArray read GetaOrders write faOrders;
  end;

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

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

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

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

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

  { IArraysService }
  IArraysService = interface
    ['{426D1A36-4EBF-4241-8E63-A26D303AA90E}']
    function GetTables: Tables;
  end;

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

  { TArraysService_Proxy }
  TArraysService_Proxy = class(TROProxy, IArraysService)
  protected
    function __GetInterfaceName:string; override;

    function GetTables: Tables;
  end;

implementation

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

{ CustomersArray }

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

class function CustomersArray.GetItemClass: TClass;
begin
  result := Customers;
end;

class function CustomersArray.GetItemSize: integer;
begin
  result := SizeOf(Customers);
end;

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

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

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

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

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

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

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

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

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

{ OrdersArray }

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

class function OrdersArray.GetItemClass: TClass;
begin
  result := Orders;
end;

class function OrdersArray.GetItemSize: integer;
begin
  result := SizeOf(Orders);
end;

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

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

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

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

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

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

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

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

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

{ Customers }

procedure Customers.Assign(iSource: TPersistent);
var lSource: ArraysLibrary_Intf.Customers;
begin
  inherited Assign(iSource);
  if (iSource is ArraysLibrary_Intf.Customers) then begin
    lSource := ArraysLibrary_Intf.Customers(iSource);
    CustomerID := lSource.CustomerID;
    CompanyName := lSource.CompanyName;
    ContactName := lSource.ContactName;
    ContactTitle := lSource.ContactTitle;
    Address := lSource.Address;
    City := lSource.City;
    Region := lSource.Region;
    Postalcode := lSource.Postalcode;
    Country := lSource.Country;
    Phone := lSource.Phone;
    Fax := lSource.Fax;
  end;
end;

procedure Customers.ReadComplex(ASerializer: TObject);
var
  l_Address: WideString;
  l_City: WideString;
  l_CompanyName: WideString;
  l_ContactName: WideString;
  l_ContactTitle: WideString;
  l_Country: WideString;
  l_CustomerID: WideString;
  l_Fax: WideString;
  l_Phone: WideString;
  l_Postalcode: WideString;
  l_Region: WideString;
begin
  if TROSerializer(ASerializer).RecordStrictOrder then begin
    l_CustomerID := CustomerID;
    TROSerializer(ASerializer).ReadWideString('CustomerID', l_CustomerID);
    CustomerID := l_CustomerID;
    l_CompanyName := CompanyName;
    TROSerializer(ASerializer).ReadWideString('CompanyName', l_CompanyName);
    CompanyName := l_CompanyName;
    l_ContactName := ContactName;
    TROSerializer(ASerializer).ReadWideString('ContactName', l_ContactName);
    ContactName := l_ContactName;
    l_ContactTitle := ContactTitle;
    TROSerializer(ASerializer).ReadWideString('ContactTitle', l_ContactTitle);
    ContactTitle := l_ContactTitle;
    l_Address := Address;
    TROSerializer(ASerializer).ReadWideString('Address', l_Address);
    Address := l_Address;
    l_City := City;
    TROSerializer(ASerializer).ReadWideString('City', l_City);
    City := l_City;
    l_Region := Region;
    TROSerializer(ASerializer).ReadWideString('Region', l_Region);
    Region := l_Region;
    l_Postalcode := Postalcode;
    TROSerializer(ASerializer).ReadWideString('Postalcode', l_Postalcode);
    Postalcode := l_Postalcode;
    l_Country := Country;
    TROSerializer(ASerializer).ReadWideString('Country', l_Country);
    Country := l_Country;
    l_Phone := Phone;
    TROSerializer(ASerializer).ReadWideString('Phone', l_Phone);
    Phone := l_Phone;
    l_Fax := Fax;
    TROSerializer(ASerializer).ReadWideString('Fax', l_Fax);
    Fax := l_Fax;
  end
  else begin
    l_Address := Address;
    TROSerializer(ASerializer).ReadWideString('Address', l_Address);
    Address := l_Address;
    l_City := City;
    TROSerializer(ASerializer).ReadWideString('City', l_City);
    City := l_City;
    l_CompanyName := CompanyName;
    TROSerializer(ASerializer).ReadWideString('CompanyName', l_CompanyName);
    CompanyName := l_CompanyName;
    l_ContactName := ContactName;
    TROSerializer(ASerializer).ReadWideString('ContactName', l_ContactName);
    ContactName := l_ContactName;
    l_ContactTitle := ContactTitle;
    TROSerializer(ASerializer).ReadWideString('ContactTitle', l_ContactTitle);
    ContactTitle := l_ContactTitle;
    l_Country := Country;
    TROSerializer(ASerializer).ReadWideString('Country', l_Country);
    Country := l_Country;
    l_CustomerID := CustomerID;
    TROSerializer(ASerializer).ReadWideString('CustomerID', l_CustomerID);
    CustomerID := l_CustomerID;
    l_Fax := Fax;
    TROSerializer(ASerializer).ReadWideString('Fax', l_Fax);
    Fax := l_Fax;
    l_Phone := Phone;
    TROSerializer(ASerializer).ReadWideString('Phone', l_Phone);
    Phone := l_Phone;
    l_Postalcode := Postalcode;
    TROSerializer(ASerializer).ReadWideString('Postalcode', l_Postalcode);
    Postalcode := l_Postalcode;
    l_Region := Region;
    TROSerializer(ASerializer).ReadWideString('Region', l_Region);
    Region := l_Region;
  end;
end;

procedure Customers.WriteComplex(ASerializer: TObject);
var
  l_Address: WideString;
  l_City: WideString;
  l_CompanyName: WideString;
  l_ContactName: WideString;
  l_ContactTitle: WideString;
  l_Country: WideString;
  l_CustomerID: WideString;
  l_Fax: WideString;
  l_Phone: WideString;
  l_Postalcode: WideString;
  l_Region: WideString;
begin
  if TROSerializer(ASerializer).RecordStrictOrder then begin
    TROSerializer(ASerializer).ChangeClass(Customers);
    l_CustomerID := CustomerID;
    TROSerializer(ASerializer).WriteWideString('CustomerID', l_CustomerID);
    l_CompanyName := CompanyName;
    TROSerializer(ASerializer).WriteWideString('CompanyName', l_CompanyName);
    l_ContactName := ContactName;
    TROSerializer(ASerializer).WriteWideString('ContactName', l_ContactName);
    l_ContactTitle := ContactTitle;
    TROSerializer(ASerializer).WriteWideString('ContactTitle', l_ContactTitle);
    l_Address := Address;
    TROSerializer(ASerializer).WriteWideString('Address', l_Address);
    l_City := City;
    TROSerializer(ASerializer).WriteWideString('City', l_City);
    l_Region := Region;
    TROSerializer(ASerializer).WriteWideString('Region', l_Region);
    l_Postalcode := Postalcode;
    TROSerializer(ASerializer).WriteWideString('Postalcode', l_Postalcode);
    l_Country := Country;
    TROSerializer(ASerializer).WriteWideString('Country', l_Country);
    l_Phone := Phone;
    TROSerializer(ASerializer).WriteWideString('Phone', l_Phone);
    l_Fax := Fax;
    TROSerializer(ASerializer).WriteWideString('Fax', l_Fax);
  end
  else begin
    l_Address := Address;
    TROSerializer(ASerializer).WriteWideString('Address', l_Address);
    l_City := City;
    TROSerializer(ASerializer).WriteWideString('City', l_City);
    l_CompanyName := CompanyName;
    TROSerializer(ASerializer).WriteWideString('CompanyName', l_CompanyName);
    l_ContactName := ContactName;
    TROSerializer(ASerializer).WriteWideString('ContactName', l_ContactName);
    l_ContactTitle := ContactTitle;
    TROSerializer(ASerializer).WriteWideString('ContactTitle', l_ContactTitle);
    l_Country := Country;
    TROSerializer(ASerializer).WriteWideString('Country', l_Country);
    l_CustomerID := CustomerID;
    TROSerializer(ASerializer).WriteWideString('CustomerID', l_CustomerID);
    l_Fax := Fax;
    TROSerializer(ASerializer).WriteWideString('Fax', l_Fax);
    l_Phone := Phone;
    TROSerializer(ASerializer).WriteWideString('Phone', l_Phone);
    l_Postalcode := Postalcode;
    TROSerializer(ASerializer).WriteWideString('Postalcode', l_Postalcode);
    l_Region := Region;
    TROSerializer(ASerializer).WriteWideString('Region', l_Region);
  end;
end;

{ CustomersCollection }
constructor CustomersCollection.Create;
begin
  inherited Create(Customers);
end;

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

function CustomersCollection.Add: Customers;
begin
  result := Customers(inherited Add);
end;

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

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

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

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

{ Orders }

procedure Orders.Assign(iSource: TPersistent);
var lSource: ArraysLibrary_Intf.Orders;
begin
  inherited Assign(iSource);
  if (iSource is ArraysLibrary_Intf.Orders) then begin
    lSource := ArraysLibrary_Intf.Orders(iSource);
    OrderID := lSource.OrderID;
    CustomerID := lSource.CustomerID;
    EmployeeID := lSource.EmployeeID;
    OrderDate := lSource.OrderDate;
    RequiredDate := lSource.RequiredDate;
    ShippedDate := lSource.ShippedDate;
    ShipVia := lSource.ShipVia;
    Freight := lSource.Freight;
    ShipName := lSource.ShipName;
    ShipAddress := lSource.ShipAddress;
    ShipCity := lSource.ShipCity;
    ShipRegion := lSource.ShipRegion;
    ShipPostalCode := lSource.ShipPostalCode;
    ShipCountry := lSource.ShipCountry;
  end;
end;

procedure Orders.ReadComplex(ASerializer: TObject);
var
  l_CustomerID: WideString;
  l_EmployeeID: Integer;
  l_Freight: Currency;
  l_OrderDate: DateTime;
  l_OrderID: Integer;
  l_RequiredDate: DateTime;
  l_ShipAddress: WideString;
  l_ShipCity: WideString;
  l_ShipCountry: WideString;
  l_ShipName: WideString;
  l_ShippedDate: DateTime;
  l_ShipPostalCode: WideString;
  l_ShipRegion: WideString;
  l_ShipVia: Integer;
begin
  if TROSerializer(ASerializer).RecordStrictOrder then begin
    l_OrderID := OrderID;
    TROSerializer(ASerializer).ReadInteger('OrderID', otSLong, l_OrderID);
    OrderID := l_OrderID;
    l_CustomerID := CustomerID;
    TROSerializer(ASerializer).ReadWideString('CustomerID', l_CustomerID);
    CustomerID := l_CustomerID;
    l_EmployeeID := EmployeeID;
    TROSerializer(ASerializer).ReadInteger('EmployeeID', otSLong, l_EmployeeID);
    EmployeeID := l_EmployeeID;
    l_OrderDate := OrderDate;
    TROSerializer(ASerializer).ReadDateTime('OrderDate', l_OrderDate);
    OrderDate := l_OrderDate;
    l_RequiredDate := RequiredDate;
    TROSerializer(ASerializer).ReadDateTime('RequiredDate', l_RequiredDate);
    RequiredDate := l_RequiredDate;
    l_ShippedDate := ShippedDate;
    TROSerializer(ASerializer).ReadDateTime('ShippedDate', l_ShippedDate);
    ShippedDate := l_ShippedDate;
    l_ShipVia := ShipVia;
    TROSerializer(ASerializer).ReadInteger('ShipVia', otSLong, l_ShipVia);
    ShipVia := l_ShipVia;
    l_Freight := Freight;
    TROSerializer(ASerializer).ReadDouble('Freight', ftCurr, l_Freight);
    Freight := l_Freight;
    l_ShipName := ShipName;
    TROSerializer(ASerializer).ReadWideString('ShipName', l_ShipName);
    ShipName := l_ShipName;
    l_ShipAddress := ShipAddress;
    TROSerializer(ASerializer).ReadWideString('ShipAddress', l_ShipAddress);
    ShipAddress := l_ShipAddress;
    l_ShipCity := ShipCity;
    TROSerializer(ASerializer).ReadWideString('ShipCity', l_ShipCity);
    ShipCity := l_ShipCity;
    l_ShipRegion := ShipRegion;
    TROSerializer(ASerializer).ReadWideString('ShipRegion', l_ShipRegion);
    ShipRegion := l_ShipRegion;
    l_ShipPostalCode := ShipPostalCode;
    TROSerializer(ASerializer).ReadWideString('ShipPostalCode', l_ShipPostalCode);
    ShipPostalCode := l_ShipPostalCode;
    l_ShipCountry := ShipCountry;
    TROSerializer(ASerializer).ReadWideString('ShipCountry', l_ShipCountry);
    ShipCountry := l_ShipCountry;
  end
  else begin
    l_CustomerID := CustomerID;
    TROSerializer(ASerializer).ReadWideString('CustomerID', l_CustomerID);
    CustomerID := l_CustomerID;
    l_EmployeeID := EmployeeID;
    TROSerializer(ASerializer).ReadInteger('EmployeeID', otSLong, l_EmployeeID);
    EmployeeID := l_EmployeeID;
    l_Freight := Freight;
    TROSerializer(ASerializer).ReadDouble('Freight', ftCurr, l_Freight);
    Freight := l_Freight;
    l_OrderDate := OrderDate;
    TROSerializer(ASerializer).ReadDateTime('OrderDate', l_OrderDate);
    OrderDate := l_OrderDate;
    l_OrderID := OrderID;
    TROSerializer(ASerializer).ReadInteger('OrderID', otSLong, l_OrderID);
    OrderID := l_OrderID;
    l_RequiredDate := RequiredDate;
    TROSerializer(ASerializer).ReadDateTime('RequiredDate', l_RequiredDate);
    RequiredDate := l_RequiredDate;
    l_ShipAddress := ShipAddress;
    TROSerializer(ASerializer).ReadWideString('ShipAddress', l_ShipAddress);
    ShipAddress := l_ShipAddress;
    l_ShipCity := ShipCity;
    TROSerializer(ASerializer).ReadWideString('ShipCity', l_ShipCity);
    ShipCity := l_ShipCity;
    l_ShipCountry := ShipCountry;
    TROSerializer(ASerializer).ReadWideString('ShipCountry', l_ShipCountry);
    ShipCountry := l_ShipCountry;
    l_ShipName := ShipName;
    TROSerializer(ASerializer).ReadWideString('ShipName', l_ShipName);
    ShipName := l_ShipName;
    l_ShippedDate := ShippedDate;
    TROSerializer(ASerializer).ReadDateTime('ShippedDate', l_ShippedDate);
    ShippedDate := l_ShippedDate;
    l_ShipPostalCode := ShipPostalCode;
    TROSerializer(ASerializer).ReadWideString('ShipPostalCode', l_ShipPostalCode);
    ShipPostalCode := l_ShipPostalCode;
    l_ShipRegion := ShipRegion;
    TROSerializer(ASerializer).ReadWideString('ShipRegion', l_ShipRegion);
    ShipRegion := l_ShipRegion;
    l_ShipVia := ShipVia;
    TROSerializer(ASerializer).ReadInteger('ShipVia', otSLong, l_ShipVia);
    ShipVia := l_ShipVia;
  end;
end;

procedure Orders.WriteComplex(ASerializer: TObject);
var
  l_CustomerID: WideString;
  l_EmployeeID: Integer;
  l_Freight: Currency;
  l_OrderDate: DateTime;
  l_OrderID: Integer;
  l_RequiredDate: DateTime;
  l_ShipAddress: WideString;
  l_ShipCity: WideString;
  l_ShipCountry: WideString;
  l_ShipName: WideString;
  l_ShippedDate: DateTime;
  l_ShipPostalCode: WideString;
  l_ShipRegion: WideString;
  l_ShipVia: Integer;
begin
  if TROSerializer(ASerializer).RecordStrictOrder then begin
    TROSerializer(ASerializer).ChangeClass(Orders);
    l_OrderID := OrderID;
    TROSerializer(ASerializer).WriteInteger('OrderID', otSLong, l_OrderID);
    l_CustomerID := CustomerID;
    TROSerializer(ASerializer).WriteWideString('CustomerID', l_CustomerID);
    l_EmployeeID := EmployeeID;
    TROSerializer(ASerializer).WriteInteger('EmployeeID', otSLong, l_EmployeeID);
    l_OrderDate := OrderDate;
    TROSerializer(ASerializer).WriteDateTime('OrderDate', l_OrderDate);
    l_RequiredDate := RequiredDate;
    TROSerializer(ASerializer).WriteDateTime('RequiredDate', l_RequiredDate);
    l_ShippedDate := ShippedDate;
    TROSerializer(ASerializer).WriteDateTime('ShippedDate', l_ShippedDate);
    l_ShipVia := ShipVia;
    TROSerializer(ASerializer).WriteInteger('ShipVia', otSLong, l_ShipVia);
    l_Freight := Freight;
    TROSerializer(ASerializer).WriteDouble('Freight', ftCurr, l_Freight);
    l_ShipName := ShipName;
    TROSerializer(ASerializer).WriteWideString('ShipName', l_ShipName);
    l_ShipAddress := ShipAddress;
    TROSerializer(ASerializer).WriteWideString('ShipAddress', l_ShipAddress);
    l_ShipCity := ShipCity;
    TROSerializer(ASerializer).WriteWideString('ShipCity', l_ShipCity);
    l_ShipRegion := ShipRegion;
    TROSerializer(ASerializer).WriteWideString('ShipRegion', l_ShipRegion);
    l_ShipPostalCode := ShipPostalCode;
    TROSerializer(ASerializer).WriteWideString('ShipPostalCode', l_ShipPostalCode);
    l_ShipCountry := ShipCountry;
    TROSerializer(ASerializer).WriteWideString('ShipCountry', l_ShipCountry);
  end
  else begin
    l_CustomerID := CustomerID;
    TROSerializer(ASerializer).WriteWideString('CustomerID', l_CustomerID);
    l_EmployeeID := EmployeeID;
    TROSerializer(ASerializer).WriteInteger('EmployeeID', otSLong, l_EmployeeID);
    l_Freight := Freight;
    TROSerializer(ASerializer).WriteDouble('Freight', ftCurr, l_Freight);
    l_OrderDate := OrderDate;
    TROSerializer(ASerializer).WriteDateTime('OrderDate', l_OrderDate);
    l_OrderID := OrderID;
    TROSerializer(ASerializer).WriteInteger('OrderID', otSLong, l_OrderID);
    l_RequiredDate := RequiredDate;
    TROSerializer(ASerializer).WriteDateTime('RequiredDate', l_RequiredDate);
    l_ShipAddress := ShipAddress;
    TROSerializer(ASerializer).WriteWideString('ShipAddress', l_ShipAddress);
    l_ShipCity := ShipCity;
    TROSerializer(ASerializer).WriteWideString('ShipCity', l_ShipCity);
    l_ShipCountry := ShipCountry;
    TROSerializer(ASerializer).WriteWideString('ShipCountry', l_ShipCountry);
    l_ShipName := ShipName;
    TROSerializer(ASerializer).WriteWideString('ShipName', l_ShipName);
    l_ShippedDate := ShippedDate;
    TROSerializer(ASerializer).WriteDateTime('ShippedDate', l_ShippedDate);
    l_ShipPostalCode := ShipPostalCode;
    TROSerializer(ASerializer).WriteWideString('ShipPostalCode', l_ShipPostalCode);
    l_ShipRegion := ShipRegion;
    TROSerializer(ASerializer).WriteWideString('ShipRegion', l_ShipRegion);
    l_ShipVia := ShipVia;
    TROSerializer(ASerializer).WriteInteger('ShipVia', otSLong, l_ShipVia);
  end;
end;

{ OrdersCollection }
constructor OrdersCollection.Create;
begin
  inherited Create(Orders);
end;

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

function OrdersCollection.Add: Orders;
begin
  result := Orders(inherited Add);
end;

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

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

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

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

{ Tables }

procedure Tables.Assign(iSource: TPersistent);
var lSource: ArraysLibrary_Intf.Tables;
begin
  inherited Assign(iSource);
  if (iSource is ArraysLibrary_Intf.Tables) then begin
    lSource := ArraysLibrary_Intf.Tables(iSource);
    aCustomers.Assign(lSource.aCustomers);
    aOrders.Assign(lSource.aOrders);
  end;
end;

function Tables.GetaCustomers: CustomersArray;
begin
  if (faCustomers = nil) then faCustomers := CustomersArray.Create();
  result := faCustomers;
end;

function Tables.GetaOrders: OrdersArray;
begin
  if (faOrders = nil) then faOrders := OrdersArray.Create();
  result := faOrders;
end;

procedure Tables.ReadComplex(ASerializer: TObject);
var
  l_aCustomers: CustomersArray;
  l_aOrders: OrdersArray;
begin
  if TROSerializer(ASerializer).RecordStrictOrder then begin
    l_aCustomers := aCustomers;
    TROSerializer(ASerializer).ReadArray('aCustomers', CustomersArray, l_aCustomers);
    if aCustomers <> l_aCustomers then aCustomers.Free;
    aCustomers := l_aCustomers;
    l_aOrders := aOrders;
    TROSerializer(ASerializer).ReadArray('aOrders', OrdersArray, l_aOrders);
    if aOrders <> l_aOrders then aOrders.Free;
    aOrders := l_aOrders;
  end
  else begin
    l_aCustomers := aCustomers;
    TROSerializer(ASerializer).ReadArray('aCustomers', CustomersArray, l_aCustomers);
    if aCustomers <> l_aCustomers then aCustomers.Free;
    aCustomers := l_aCustomers;
    l_aOrders := aOrders;
    TROSerializer(ASerializer).ReadArray('aOrders', OrdersArray, l_aOrders);
    if aOrders <> l_aOrders then aOrders.Free;
    aOrders := l_aOrders;
  end;
end;

procedure Tables.WriteComplex(ASerializer: TObject);
var
  l_aCustomers: CustomersArray;
  l_aOrders: OrdersArray;
begin
  if TROSerializer(ASerializer).RecordStrictOrder then begin
    TROSerializer(ASerializer).ChangeClass(Tables);
    l_aCustomers := aCustomers;
    TROSerializer(ASerializer).WriteArray('aCustomers', l_aCustomers, CustomersArray);
    l_aOrders := aOrders;
    TROSerializer(ASerializer).WriteArray('aOrders', l_aOrders, OrdersArray);
  end
  else begin
    l_aCustomers := aCustomers;
    TROSerializer(ASerializer).WriteArray('aCustomers', l_aCustomers, CustomersArray);
    l_aOrders := aOrders;
    TROSerializer(ASerializer).WriteArray('aOrders', l_aOrders, OrdersArray);
  end;
end;

{ TablesCollection }
constructor TablesCollection.Create;
begin
  inherited Create(Tables);
end;

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

function TablesCollection.Add: Tables;
begin
  result := Tables(inherited Add);
end;

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

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

{ CoArraysService }

class function CoArraysService.Create(const aMessage: IROMessage; aTransportChannel: IROTransportChannel): IArraysService;
begin
  result := TArraysService_Proxy.Create(aMessage, aTransportChannel);
end;

{ TArraysService_Proxy }

function TArraysService_Proxy.__GetInterfaceName:string;
begin
  result := 'ArraysService';
end;

function TArraysService_Proxy.GetTables: Tables;
begin
  try
    result := nil;
    __Message.InitializeRequestMessage(__TransportChannel, 'ArraysLibrary', __InterfaceName, 'GetTables');
    __Message.Finalize;

    __TransportChannel.Dispatch(__Message);

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

initialization
  RegisterROClass(Customers);
  RegisterROClass(Orders);
  RegisterROClass(Tables);
  RegisterROClass(CustomersArray);
  RegisterROClass(OrdersArray);
  RegisterProxyClass(IArraysService_IID, TArraysService_Proxy);


finalization
  UnregisterROClass(Customers);
  UnregisterROClass(Orders);
  UnregisterROClass(Tables);
  UnregisterROClass(CustomersArray);
  UnregisterROClass(OrdersArray);
  UnregisterProxyClass(IArraysService_IID);

end.