unit uDADataTableReferenceCollection;

{----------------------------------------------------------------------------}
{ Data Abstract Library - Core Library                                       }
{                                                                            }
{ compiler: Delphi 6 and up, Kylix 3 and up                                  }
{ platform: Win32, Linux                                                     }
{                                                                            }
{ (c)opyright RemObjects Software. all rights reserved.                      }
{                                                                            }
{ Using this code requires a valid license of the Data Abstract              }
{ which can be obtained at http://www.remobjects.com.                        }
{----------------------------------------------------------------------------}

{$I DataAbstract.inc}

interface

uses
  Classes,
  uDAInterfaces,uDADataTable;

type
  { TDADataTableReference }
  TDADataTableReferenceCollection = class;
  TDADataTableReference = class(TCollectionItem)
  private
    fDataTable: TComponent;
    FDataset: IDADataset;
    FLogicalName: string; // fro Tdataset
    function GetIsValidReference: boolean;
    procedure SetDataTable(const Value: TComponent);
    function GetReferenceCollection: TDADataTableReferenceCollection;
    function GetDataset: IDADataset;
    function GetLogicalName: string;
    procedure SetLogicalName(const Value: string);

  protected
    function GetDisplayName : string; override;
  public
    constructor Create(aCollection : TDADataTableReferenceCollection); reintroduce;
    property IsValidReference : boolean read GetIsValidReference;
    property ReferenceCollection : TDADataTableReferenceCollection read GetReferenceCollection;
    property Dataset: IDADataset read GetDataset;
    destructor Destroy; override;
  published
    property DataTable : TComponent read fDataTable write SetDataTable;
    property LogicalName: string read GetLogicalName write SetLogicalName;
  end;

  { TDADataTableReferenceCollection }
  TDADataTableReferenceCollection = class(TCollection)
  private
    fOwner: TComponent;

    function GetItems(Index: integer): TDADataTableReference;
  protected
  public
    constructor Create(aOwner: TComponent);
    destructor Destroy; override;

    function FindByDataTable(aDataTable : TComponent) : TDADataTableReference;
    function FindByName(const aLogicalName : string) : TDADataTableReference;

    property Items[Index : integer] : TDADataTableReference read GetItems; default;

    property OwnerService: TComponent read fOwner;
  end;

implementation

uses
  SysUtils,DB,
  uROClasses, uDADatasetWrapper;

{ TDADataTableReferenceCollection }

constructor TDADataTableReferenceCollection.Create(aOwner: TComponent);
begin
  inherited Create(TDADataTableReference);

  fOwner := aOwner;
end;

destructor TDADataTableReferenceCollection.Destroy;
begin

  inherited;
end;

function TDADataTableReferenceCollection.FindByDataTable(aDataTable: TComponent): TDADataTableReference;
var i : integer;
begin
  result := NIL;
  if (aDataTable=NIL) then Exit;

  for i := 0 to (Count-1) do
    if (Items[i].DataTable=aDataTable) then begin
      result := Items[i];
      Exit;
    end;
end;

function TDADataTableReferenceCollection.FindByName(const aLogicalName: string): TDADataTableReference;
var i : integer;
begin
  result := NIL;

  for i := 0 to (Count-1) do
    if Items[i].IsValidReference and SameText(Items[i].Dataset.LogicalName, aLogicalName) then begin
      result := Items[i];
      Exit;
    end;
end;

function TDADataTableReferenceCollection.GetItems(
  Index: integer): TDADataTableReference;
begin
  result := TDADataTableReference(inherited Items[Index]);
end;

{ TDADataTableReference }

constructor TDADataTableReference.Create(aCollection : TDADataTableReferenceCollection);
begin
  inherited Create(aCollection);
end;

function TDADataTableReference.GetDataset: IDADataset;
begin
  Result := FDataset;
  if (Result = nil) and (fDataTable is TDADataTable) then
    Result := fDataTable as IDADataset;
end;

procedure TDADataTableReference.SetDataTable(const Value: TComponent);
begin
  if (fDataTable=Value) then Exit;

  if Value is TDataSet then begin
    FDataset := TDatasetWrapper.Create(TDataSet(Value));
    FDataset.LogicalName := FLogicalName;
  end
  else
    FDataset := nil;

  if (Value is TDataSet) or (Value is TDADataTable) then
    fDataTable := Value
  else
    // don't supported other types
    fDataTable := nil;

  if (fDataTable<>NIL)
    then fDataTable.FreeNotification(ReferenceCollection.OwnerService);
end;

function TDADataTableReference.GetDisplayName: string;
var F_logicalname : string;
begin
  if (fDataTable<>NIL) then begin
    F_logicalname := LogicalName;
    if (F_logicalname='') then F_logicalname := '???';
    result := Format('%s (%s)', [F_logicalname, fDataTable.Name])
  end
  else result := '<No Reference>';
end;

function TDADataTableReference.GetIsValidReference: boolean;
begin
  result := fDataTable<>NIL
end;

function TDADataTableReference.GetReferenceCollection: TDADataTableReferenceCollection;
begin
  result := TDADataTableReferenceCollection(inherited Collection);
end;

function TDADataTableReference.GetLogicalName: string;
begin
  if (fDataTable<>NIL) then begin
    Result := Dataset.LogicalName;
    if fDataTable is TDataset then Result:= FLogicalName;
  end
  else
    result := '';
end;

procedure TDADataTableReference.SetLogicalName(const Value: string);
begin
  FLogicalName := Value;
  if (Dataset <> nil) then Dataset.LogicalName := Value;
end;


destructor TDADataTableReference.Destroy;
begin
  FDataset:=nil;
  inherited;
end;

end.