unit uDAMemDataTable;

{----------------------------------------------------------------------------}
{ 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,DB, uDAInterfaces,
  uDADataTable, uDAMemDataset;

type
  { TDAADODataset }
  TDAMemDataset = class(TDAMemoryDataset, IDADataTableDataset)
  private
    FRecIDOffset: cardinal;
  protected
    function GetDataTable: TDADataTable; safecall;
    procedure InternalRefresh; override;
    procedure InternalInitFieldDefs; override;
    procedure InternalOpen; override;
  public
    constructor Create(AOwner: TComponent); override;
  end;

  TDAMemDataTable = class(TDADataTable,IDAMemDatasetBatchAdding)
  private
    fMemDataset: TDAMemDataset;
  protected
    // IDAMemDatasetBatchAdding
    function AllocRecordBuffer: PChar;
    procedure FreeRecordBuffer(var Buffer: PChar);
    function GetFieldNativeBuffer(Buffer: PChar; Field: TField): Pointer;
    function MakeBlobFromString(Blob:String):pointer;
    procedure AppendBuffer(Buffer: Pchar);
    procedure SetNullMask(Buffer: PChar; Field: TField; const Value: boolean);
    procedure SetAnsiString(NativeBuf: Pointer; Field: TField; const Value: Ansistring);
    procedure SetWideString(NativeBuf: Pointer; Field: TField; const Value: Widestring);
    procedure FinalizeBatchAdding;
  protected
    function GetDatasetClass: TDatasetClass; override;
    //    procedure CreateInternalFields(aDataset: TDataset; someFieldDefinitions: TDAFieldCollection); override;
    //    procedure DoAfterCloseDataset; override;
    procedure DoSort(const FieldNames: array of string; const Directions: array of TDASortDirection); override;

    procedure SetMasterSource(const Value: TDADataSource); override;
    function GetMasterSource: TDADataSource; override;
    procedure SetDetailsFields(const Value: string); override;
    procedure SetMasterFields(const Value: string); override;
    function GetDetailFields: string; override;
    function GetMasterFields: string; override;

    function GetFilter: string; override;
    function GetFiltered: boolean; override;
    procedure SetFilter(const Value: string); override;
    procedure SetFiltered(const Value: boolean); override;
  public
    constructor Create(aOwner: TComponent); override;
    procedure EnableConstraints; override; safecall;
    procedure DisableConstraints; override; safecall;
  end;


implementation

{ TDAMemDataset }


constructor TDAMemDataset.Create(AOwner: TComponent);
begin
  inherited;
  FRecIDOffset := 0;
end;

function TDAMemDataset.GetDataTable: TDADataTable;
begin
  result := TDADataTable(Owner);
end;

procedure TDAMemDataset.InternalInitFieldDefs;
begin
  inherited;

end;

procedure TDAMemDataset.InternalOpen;
begin
  inherited;
  FRecIDOffset := GetFieldOffset(0);
end;

procedure TDAMemDataset.InternalRefresh;
begin
  inherited;
end;

{ TDAMemDataTable }

function TDAMemDataTable.AllocRecordBuffer: PChar;
begin
  Result:= fMemDataset.IntCreateBuffer(True);
end;

procedure TDAMemDataTable.AppendBuffer(Buffer: Pchar);
begin
  PCardinal(Buffer+fMemDataset.FRecIDOffset)^:=CurrRecId;
  fMemDataset.SetNullMask(Buffer,0,False);  //RECID 
  CurrRecId:=CurrRecId+1;
  fMemDataset.IntInsertBuffer(Buffer);
end;

constructor TDAMemDataTable.Create(aOwner: TComponent);
begin
  inherited;
  fMemDataset := TDAMemDataset(Dataset);
end;

procedure TDAMemDataTable.DisableConstraints;
begin
  //
end;

procedure TDAMemDataTable.DoSort(const FieldNames: array of string;
  const Directions: array of TDASortDirection);
var
  i: integer;
  s: string;
begin
  s := '';
  for i := Low(FieldNames) to High(FieldNames) do
    s := s + FieldNames[i] + ';';
  { TODO :
  very simple implementation of sorting.
  sorting for each field is not supported! }
  fMemDataset.SortOnFields(s);
end;

procedure TDAMemDataTable.EnableConstraints;
begin
  //
end;

procedure TDAMemDataTable.FinalizeBatchAdding;
begin
  fMemDataset.ProcessFilter;
end;

procedure TDAMemDataTable.FreeRecordBuffer(var Buffer: PChar);
begin
   fMemDataset.FreeRecordBuffer(Buffer);
end;

function TDAMemDataTable.GetDatasetClass: TDatasetClass;
begin
  Result := TDAMemDataset;
end;

function TDAMemDataTable.GetDetailFields: string;
begin
  result := fMemDataset.IndexFieldNames
end;

function TDAMemDataTable.GetFieldNativeBuffer(Buffer: PChar;
  Field: TField): Pointer;
begin
  Result:= fMemDataset.IntFindFieldData(Buffer,Field);
end;

function TDAMemDataTable.GetFilter: string;
begin
  Result := fMemDataset.Filter;
end;

function TDAMemDataTable.GetFiltered: boolean;
begin
  Result := fMemDataset.Filtered;
end;

function TDAMemDataTable.GetMasterFields: string;
begin
  result := fMemDataset.MasterFields
end;

function TDAMemDataTable.GetMasterSource: TDADataSource;
begin
  result := TDADataSource(fMemDataset.DataSource);
end;

function TDAMemDataTable.MakeBlobFromString(Blob: String): pointer;
begin
  Result:= fMemDataset.MakeBlobFromString(Blob);
end;

procedure TDAMemDataTable.SetAnsiString(NativeBuf: Pointer; Field: TField;
  const Value: Ansistring);
begin
  fMemDataset.SetAnsiString(NativeBuf,Field, Value);
end;

procedure TDAMemDataTable.SetDetailsFields(const Value: string);
begin
  fMemDataset.IndexFieldNames := Value
end;

procedure TDAMemDataTable.SetFilter(const Value: string);
begin
  fMemDataset.Filter := Value;
end;

procedure TDAMemDataTable.SetFiltered(const Value: boolean);
begin
  fMemDataset.Filtered := Value;
end;

procedure TDAMemDataTable.SetMasterFields(const Value: string);
begin
  inherited;
  fMemDataset.MasterFields := Value
end;

procedure TDAMemDataTable.SetMasterSource(const Value: TDADataSource);
begin
  inherited;
  fMemDataset.MasterSource := Value
end;

procedure TDAMemDataTable.SetNullMask(Buffer: PChar; Field: TField;
  const Value: boolean);
begin
  fMemDataset.SetNullMask(Buffer,Field.Index,Value);
end;

procedure TDAMemDataTable.SetWideString(NativeBuf: Pointer; Field: TField;
  const Value: Widestring);
begin
  fMemDataset.SetWideString(NativeBuf,Field, Value);
end;

end.