vector.inc_pas

Delphi Generic Algorytms library - Maps, Lists, Hashmaps, Datastructures.

(*
 * DGL(The Delphi Generic Library)
 *
 * Copyright (c) 2004
 * [e-mail]
 *
 * This material is provided "as is", with absolutely no warranty expressed
 * or implied. Any use is at your own risk.
 *
 * Permission to use or copy this software for any purpose is hereby granted
 * without fee, provided the above notices are retained on all copies.
 * Permission to modify the code and to distribute modified code is granted,
 * provided the above notices are retained, and a notice that the code was
 * modified is included with the above copyright notice.
 *
 *)

//------------------------------------------------------------------------------
// _TVector的实现
// Create by HouSisong, 2004.09.01
//------------------------------------------------------------------------------
// Vector.inc_pas; Vector.inc_h;

{$ifndef  __Vector_inc_pas_}
{$define  __Vector_inc_pas_}

{$I DGLIntf.inc_pas}
{$I PointerItBox.inc_pas}


{ _TVector }

function  _TVector.GetSelfObj():TObject;
begin
  result:=self;
end;

function  _TVector.IsEmpty(): Boolean;
begin
  result:=FCount=0;
end;

function _TVector.GetBackValue(): _ValueType;
begin
  Assert(FCount>0);
  result:=self.FDataArray[FCount-1];
end;

procedure _TVector.SetBackValue(const aValue:_ValueType);
begin
  Assert(FCount>0);
  {$ifdef _DGL_ObjValue}
    _Assign(self.FDataArray[FCount-1],aValue);
  {$else}
    self.FDataArray[FCount-1]:=aValue;
  {$endif}
end;

procedure _TVector.AlwaysReserve(const aAlwaysReserveSize: integer);
begin
  self.Reserve(aAlwaysReserveSize);
  self.FAlwaysReserveSize:=aAlwaysReserveSize;
end;

procedure _TVector.Clear;
var
  i,L : integer;
begin
{$ifdef _DGL_ObjValue}
  for i:=0 to self.FCount-1 do
    _Free(self.FDataArray[i]);
{$endif}
  self.FCount:=0;
  self.FArrayLength:=0;
  if FAlwaysReserveSize<=0 then
    self.FDataArray:=nil
  else
  begin
    L:=length(FDataArray);
    if FAlwaysReserveSize<L then
      L:=FAlwaysReserveSize;
    setlength(FDataArray,FAlwaysReserveSize);
    for i:=0 to L-1 do
      FDataArray[i]:=_NULL_Value;
  end;
end;

procedure _TVector.Swap(AVector:_TVector);
var
    tmpInt        : Integer;
    tmpDataArray  : _TValueDArray;
begin
  if self=AVector then exit;
  
  //tmpInt:=FAlwaysReserveSize; FAlwaysReserveSize:=AVector.FAlwaysReserveSize; AVector.FAlwaysReserveSize:=tmpInt;
  
  tmpInt:=FCount;  FCount:=AVector.FCount;  AVector.FCount:=tmpInt;
  tmpInt:=FArrayLength;  FArrayLength:=AVector.FArrayLength;  AVector.FArrayLength:=tmpInt;
  tmpDataArray:=FDataArray;  FDataArray:=AVector.FDataArray;  AVector.FDataArray:=tmpDataArray;

end;

constructor _TVector.Create;
begin
  inherited;
end;

destructor _TVector.Destroy;
begin
  Clear();
  inherited;
end;

function _TVector.ItBegin: _IIterator;
begin
  _TVectorIterator.ItCreate(result,self.UnSafe_GetVectorBufPointer(0));
end;

function  _TVector.NewIterator(const Index: Integer):_IIterator;
begin
  _TVectorIterator.ItCreate(result,self.UnSafe_GetVectorBufPointer(Index));
end;


function _TVector.GetItemValue(const Index: Integer): _ValueType;
begin
  Assert(Index>=0);
  Assert(Index<FCount);
  result:=self.FDataArray[Index];
end;

procedure _TVector.SetItemValue(const Index: Integer; const Value: _ValueType);
begin
  Assert(Index>=0);
  Assert(Index<FCount);
  {$ifdef _DGL_ObjValue}
  _Assign(self.FDataArray[Index],Value);
  {$else}
  self.FDataArray[Index]:=Value;
  {$endif}
end;

function _TVector.IndexOf(const Value: _ValueType): Integer;
var
  i : integer;
begin
  for i:=0 to self.FCount-1 do
  begin
    {$ifdef  _DGL_Compare}
    if (_IsEqual(FDataArray[i],Value)) then
    {$else}
    if FDataArray[i]=Value then
    {$endif}
    begin
      result:=i;
      exit;
    end;
  end;
  result:=-1;
end;

function _TVector.IsEquals(const AContainer: _IContainer): Boolean;
var
  i : integer;
  it : _IIterator;
begin
  if self.Size()<>AContainer.Size() then
  begin
    result:=false;
    exit;
  end;

  it:=AContainer.ItBegin();
  for i:=0 to FCount-1 do
  begin
    {$ifdef  _DGL_Compare}
    if (not _IsEqual(FDataArray[i],it.Value)) then
    {$else}
    if not(FDataArray[i]=it.Value) then
    {$endif}
    begin
      result:=false;
      exit;
    end
    else
      it.Next();
  end;
  result:=true;
end;


function _TVector.IsLess(const AContainer: _IContainer): Boolean;
var
  i : integer;
  ACSize,MinSize : integer;
  it : _IIterator;
begin
  ACSize:=AContainer.Size();
  MinSize:=ACSize;
  if FCount<MinSize then MinSize:=FCount;

  it:=AContainer.ItBegin();
  for i:=0 to MinSize-1 do
  begin
    {$ifdef  _DGL_Compare}
    if (_IsLess(it.Value,FDataArray[i])) then
    {$else}
    if it.Value<FDataArray[i] then
    {$endif}
    begin
      result:=false;
      exit;
    end
    else
      it.Next();
  end;
  result:=(FCount<ACSize);
end;

function _TVector.ItEnd: _IIterator;
begin
  _TVectorIterator.ItCreate(result,self.UnSafe_GetVectorBufPointer(FCount));
end;

procedure _TVector.PushBack(const Value: _ValueType);
begin
  if FCount>=FArrayLength then
  begin
    SetNewCapability(FCount+1);
  end;
  {$ifdef _DGL_ObjValue}
  self.FDataArray[FCount]:=_CopyCreateNew(Value);
  {$else}
  self.FDataArray[FCount]:=Value;
  {$endif}
  inc(FCount);
end;

procedure _TVector.PopBack;
begin
  Assert(FCount>0);
  {$ifdef _DGL_ObjValue}
  _Free(self.FDataArray[FCount-1]);
  {$endif}
  self.FDataArray[FCount-1]:=_NULL_Value;
  dec(self.FCount);
end;

procedure _TVector.PushBack(const ItBegin, ItEnd: _IIterator);
begin
  self.Insert(self.ItEnd,ItBegin,ItEnd);
end;

procedure  _TVector.PushBack(const ItBegin,ItEnd:_PValueType);
begin
  self.Insert(self.ItEnd,ItBegin, ItEnd);
end;

procedure _TVector.PushBack(const num:integer;Value: _ValueType); 
var
  i : integer;
begin
  for i:=0 to num-1 do
    self.PushBack(Value);
end;

function _TVector.EraseValue(const Value: _ValueType): integer;
var
  iRead  : integer;
  iWrite : integer;
  fIndex : integer;
begin
  fIndex:=IndexOf(Value);
  if fIndex<0 then
  begin
    result:=0;
    exit;
  end;

  result:=0;
  iWrite:= fIndex;
  for iRead:=fIndex to FCount-1 do
  begin
    {$ifdef  _DGL_Compare}
    if (_IsEqual(self.FDataArray[iRead],Value)) then
    {$else}
    if self.FDataArray[iRead]=Value then
    {$endif}
    begin
      {$ifdef _DGL_ObjValue}
      _Free(self.FDataArray[iRead]);
      {$endif}
      inc(result);
    end
    else
    begin
      FDataArray[iWrite]:=self.FDataArray[iRead];
      inc(iWrite);
    end;
  end;
  fill(@FDataArray[FCount-result],@FDataArray[FCount],_NULL_Value);
  dec(self.FCount,result);
end;

function _TVector.Size: Integer;
begin
  result:=self.FCount;
end;

procedure _TVector.Insert(const ItPos:_IIterator; const Value: _ValueType);
begin
  self.InsertByIndex((ItPos._Data0-integer(UnSafe_GetVectorBufPointer(0))) div sizeof(_ValueType),Value);
end;


procedure _TVector.InsertByIndex(const Index: Integer;const Value: _ValueType);
var
  IndexPos : integer;
begin
  IndexPos:=Index;
  Assert(IndexPos>=0);
  Assert(IndexPos<=FCount);
  self.SetNewCapability(FCount+1);
  ReCopy(@FDataArray[IndexPos],@FDataArray[FCount],@FDataArray[IndexPos+1]);
  {$ifdef _DGL_ObjValue}
  FDataArray[IndexPos]:=_CopyCreateNew(Value);
  {$else}
  FDataArray[IndexPos]:=Value;
  {$endif}
  inc(FCount);
end;

procedure _TVector.Insert(const ItPos:_IIterator; const ItBegin,ItEnd: _IIterator);
var
  i : integer;
  _ItBegin : _IIterator;
  CopyCount : integer;
  IndexPos : integer;
begin
  //todo: Check safe

  IndexPos:=(ItPos._Data0-integer(UnSafe_GetVectorBufPointer(0))) div sizeof(_ValueType);
  Assert(IndexPos>=0);
  Assert(IndexPos<=FCount);
  CopyCount:=ItBegin.Distance(ItEnd);
  if CopyCount<=0 then exit;

  self.SetNewCapability(FCount+CopyCount);
  ReCopy(@FDataArray[IndexPos],@FDataArray[FCount],@FDataArray[IndexPos+CopyCount]);

  _ItBegin:=ItBegin.Clone();
  for i:=IndexPos+0 to IndexPos+CopyCount-1 do
  begin
    {$ifdef _DGL_ObjValue}
    FDataArray[i]:=_CopyCreateNew(_ItBegin.Value);
    {$else}
    FDataArray[i]:=_ItBegin.Value;
    {$endif}