unit ucursorfila;

{$mode delphi}

interface

uses
  Classes, SysUtils,
  {$IFDEF CRONVAR_PAGINADAS}
  uvectorpaginado,
  {$ENDIF}
  math,
  matreal,
  xmatdefs;

type
    { TCronVarCursorFila }
  {$IFDEF CRONVAR_PAGINADAS}
  TCronVarCursorFila = class( TCursorMatOfPaginado  )
  {$ELSE}
  TModoCursor = ( CMC_ReadWrite, CMC_Read, CMC_Write );

  TCronVarCursorFila = class
  {$ENDIF}
  private

    function GetVal( jCronica: integer): NReal;
    procedure SetVal( jCronica: integer; aValor: NReal);

  public
  {$IFNDEF CRONVAR_PAGINADAS}
     vector: TMatOfNReal;
     elemento: TDAofNReal;
   {$ENDIF}

    Modo: TModoCursor;
    NFils, NCols: integer;
  {$IFNDEF CRONVAR_PAGINADAS}
    constructor Create( vector: TMatOfNReal; modo: TModoCursor );

    procedure Enter( kPaso: integer );
    procedure Leave;
    procedure LeaveModificado;

    {$ELSE}
   constructor Create( vector: TVectorPaginado; modo: TModoCursor );
   {$ENDIF}
    procedure CopyToDA( var a: TDAofNReal );
    procedure CopyFromDA( const a: TDAOfNReal );

    procedure CopyToVectR(var a: TVectR);
    procedure CopyFromVectR(const a: TVectR);


    // comprueba si la matriz es El CERO
    function isnull: boolean;
    // verifica si elemento k es CERO
    function isnull_elemento( k: integer ): boolean;

    procedure CopyToDM( var a: TMatOfNReal );
    procedure CopyFromDM( const a: TMatOfNReal );

    procedure CopyToMatR( var a: TMatR );
    procedure CopyFromMatR( const a: TMatR );

    function Serialize: string;

    function pdatos_: PLAOfNReal;

    property valores[ jCronica: integer]: NReal read GetVal write SetVal;
      default;

  end;




implementation


{ TCronVarCursorFila }

{$IFNDEF CRONVAR_PAGINADAS}
constructor TCronVarCursorFila.Create( vector: TMatOfNReal; modo: TModoCursor
  );
{$ELSE}
constructor TCronVarCursorFila.Create(vector: TVectorPaginado; modo: TModoCursor
  );
{$ENDIF}
begin
  {$IFDEF CRONVAR_PAGINADAS}
  inherited Create( vector, modo );
  NFils:= vector.Count;
  NCols:= vector.DimElemento div sizeOf( NReal );
  {$ELSE}
  self.vector:= vector;
  NFils:= length( vector ) ;
  if NFils > 0 then
     NCols:= length( vector[0] );
  {$ENDIF}
end;

{$IFNDEF CRONVAR_PAGINADAS}
procedure TCronVarCursorFila.Enter(kPaso: integer);
begin
  elemento:= vector[kPaso];
end;

procedure TCronVarCursorFila.Leave;
begin
  elemento:= nil;
end;

procedure TCronVarCursorFila.LeaveModificado;
begin
  Leave;
end;

{$ENDIF}

function TCronVarCursorFila.GetVal(jCronica: integer): NReal;
var
  kCronica: integer;
begin
  {$IFDEF CRONVAR_PAGINADAS}
  kCronica:= min( jCronica, high( ??elemento ) );
  {$ELSE}
  kCronica:= min( jCronica, high( elemento ) );
  {$ENDIF}
  result:= pdatos_^[kCronica];
end;

procedure TCronVarCursorFila.SetVal(jCronica: integer; aValor: NReal);
var
  kCronica: integer;
begin
  {$IFDEF CRONVAR_PAGINADAS}
  kCronica:= min( jCronica, high( ??elemento ) );
  {$ELSE}
  kCronica:= min( jCronica, high( elemento ) );
  {$ENDIF}
  pdatos_^[kCronica]:= aValor;
end;

function TCronVarCursorFila.pdatos_: PLAOfNReal;
begin
  {$IFDEF CRONVAR_PAGINADAS}
  result:= elemento.pdata;
  {$ELSE}
  if elemento<> nil then
     result:= @elemento[0]
  else
      raise Exception.Create('Error en Cursor Fila, puede que se' +
            'haya llamado a Leave antes de tiempo');
  {$ENDIF}
end;

procedure TCronVarCursorFila.CopyToDA(var a: TDAofNReal);
var
  k: integer;
begin
  setlength( a, NCols );
  for k:= 0 to NCols-1 do
    a[k]:= pdatos_^[k];
end;

procedure TCronVarCursorFila.CopyFromDA(const a: TDAOfNReal);
var
  k: integer;
begin
  if length( a ) <> NCols then
    raise Exception.Create( 'TCronVarCursorFila.CopyFromDA length(a) <> nCols ' );

  for k:= 0 to high( a ) do
    pdatos_^[k]:= a[k];
end;

procedure TCronVarCursorFila.CopyToVectR(var a: TVectR );
var
  k: integer;
begin
  if a = nil then
    a:= TVectR.Create_init( NCols )
  else
    a.resize( NCols );
  for k:= 0 to NCols-1 do
    a.pon_e( k+1, pdatos_^[k] );
end;

procedure TCronVarCursorFila.CopyFromVectR(const a: TVectR );
var
  k: integer;
begin
  if a.n <> NCols then
    raise Exception.Create( 'TCronVarCursorFila.CopyFromDA a.n <> nCols ' );

  for k:= 0 to a.n-1 do
    pdatos_^[k]:= a.e( k+1 );
end;

function TCronVarCursorFila.isnull: boolean;
var
  k: integer;
begin
  result:= true;
  for k:= 0 to NFils -1 do
    if not isnull_elemento( k ) then
    begin
      result:= false;
      break;
    end;
end;

function TCronVarCursorFila.isnull_elemento(k: integer): boolean;
var
  j: integer;
begin
  enter( k );
  result:= true;
  for j:= 0 to NCols-1 do
     if self[j] <> 0 then
     begin
       result:= false;
       break;
     end;
  leave;
end;


procedure TCronVarCursorFila.CopyToDM(var a: TMatOfNReal);
var
  k: integer;
begin
  setlength( a, NFils );
  for k:= 0 to  high( a ) do
  begin
    enter( k );
    CopyToDA( a[k ] );
    leave;
  end;
end;

procedure TCronVarCursorFila.CopyFromDM(const a: TMatOfNReal);
var
  k: integer;
begin
  if length( a ) <> NFils then
    raise Exception.Create( 'TCronVarCursorFila.CopyFromDA length(a) <> nFils ' );

  for k:= 0 to  high( a ) do
  begin
    enter( k );
    CopyFromDA( a[k ] );
    LeaveModificado;
  end;

end;

procedure TCronVarCursorFila.CopyToMatR(var a: TMatR);
var
  k: integer;
begin
  if a = nil then
    a:= TMatR.Create_Init( NFils, NCols )
  else
    a.resize( NFils, NCols );

  for k:= 0 to  NFils-1 do
  begin
    enter( k );
    CopyToVectR( a.pm[ k+1 ] );
    leave;
  end;
end;

procedure TCronVarCursorFila.CopyFromMatR(const a: TMatR);
var
  k: integer;
begin
  if a.nf <> NFils then
    raise Exception.Create( 'TCronVarCursorFila.CopyFromMatR a.nf <> nFils ' );

  for k:= 0 to  NFils -1  do
  begin
    enter( k );
    CopyFromVectR( a.pm[ k+1 ] );
    LeaveModificado;
  end;
end;

function TCronVarCursorFila.Serialize: string;
var
  a: TMatR;
begin
  a:= nil;
  CopyToMatR( a );
  result:= a.serialize;
  a.Free;
end;




end.

