Курсовой проект групп 3341 и 3382 / DMCore / FastVector

unit FastVector;

interface

uses
Classes,
DmmConstants,
DmmTypes,
StandardObject,
StandardSerializableObject,
SysUtils;

type
{Класс итератор, для перебора объетов TDMFastVector}
TDMFastVectorEnumeration = class;
{Класс, который позволяет хранить динамический массив объектов
типа TObject}
TDMFastVector = class( TDMStandardSerializableObject )
protected
m_Objects : TDMObjectArray;
m_Size : Integer;
m_Capacity : Integer;
m_ElementMemoryManagement : Boolean;

procedure freeRange( const index1, index2 : Integer );
procedure insertAtHead( element : TObject );

public
constructor Create; overload;
constructor Create( const capacity : Integer ); overload;

function elementMemoryManagement : Boolean; overload;
procedure elementMemoryManagement( flagValue : Boolean ); overload;

procedure addElement( element : TObject );
procedure insertElementAt( element : TObject; const index : Integer );
procedure appendElements( toappend : TDMFastVector );
procedure setElementAt( const index : Integer; element : TObject );
procedure removeElementAt( const index : Integer );
procedure removeAndClearElementAt( const index : Integer );
procedure removeAllElements;
procedure removeAndClearAllElements;

function elementAt( const index : Integer ) : TObject;
function firstElement : TObject;
function lastElement : TObject;
function contains( element : TObject ) : Boolean;
function indexOf( element : TObject ) : Integer;

function capacity : Integer;
procedure setCapacity( const capacity : Integer );
function size : Integer;

function copyObject : TObject; override;
function cloneObject : TObject; override;
function equals( otherObject : TObject ) : Boolean; override;

procedure trimToSize( const size : Integer ); overload;
procedure trimToSize(); overload;

function toArray : TDMObjectArray;

procedure swap( const index1, index2 : Integer );

procedure serializeObject( ostream : TStream ); override;
procedure deserializeObject( istream : TStream ); override;

function toString : AnsiString; override;

destructor Destroy; override;
end;

TDMFastVectorEnumeration = class( TDMStandardSerializableObject )
protected

m_Counter : Integer;
m_FastVector : TDMFastVector;
m_SpecialElement : Integer;

public
constructor Create( fastVector : TDMFastVector ); overload;
constructor Create( fastVector : TDMFastVector; const specialElement : Integer ); overload;

function hasMoreElements : Boolean; virtual;
function nextElement : TObject; virtual;

function cloneObject : TObject; override;
function copyObject : TObject; override;

procedure serializeObject( ostream : TStream ); override;
procedure deserializeObject( istream : TStream ); override;

destructor Destroy; override;
end;

TDMFastVectorArray = array of TDMFastVector;

implementation

constructor TDMFastVector.Create;
begin
SetLength( m_Objects, 0 );
m_Capacity := 0;
m_Size := 0;
m_ElementMemoryManagement := true;
end;

constructor TDMFastVector.Create( const capacity : Integer );
begin
if capacity >= 0 then
begin
SetLength( m_Objects, capacity );
m_Capacity := capacity;
m_Size := 0;
m_ElementMemoryManagement := true;
end;
end;

function TDMFastVector.elementMemoryManagement : Boolean;
begin
Result := m_ElementMemoryManagement;
end;

procedure TDMFastVector.elementMemoryManagement( flagValue : Boolean );
begin
m_ElementMemoryManagement := flagValue;
end;

procedure TDMFastVector.freeRange( const index1, index2 : Integer );
var
i : Integer;
begin
for i := index1 to index2 do
begin
if ( m_Objects[ i ] <> nil ) then m_Objects[ i ].Free;
end;
end;

procedure TDMFastVector.insertAtHead( element : TObject );
var
i,n1 : Integer;
begin
n1 := m_Size - 1;
for i := n1 downto 0 do
m_Objects[ i + 1 ] := m_Objects[ i ];
m_Objects[ 0 ] := element;
end;

function TDMFastVector.capacity : Integer;
begin
Result := m_Capacity;
end;

function TDMFastVector.size : Integer;
begin
Result := m_Size;
end;

function TDMFastVector.cloneObject : TObject;
var
rvector : TDMFastVector;
begin
rvector := TDMFastVector.Create;
rvector.m_Capacity := m_Capacity;
rvector.m_Objects := Copy( m_Objects );
rvector.m_Size := m_Size;
rvector.m_ElementMemoryManagement := m_ElementMemoryManagement;
Result := rvector;
end;

function TDMFastVector.copyObject : TObject;
var
i, n1 : Integer;
rvector : TDMFastVector;
cobject : TObject;
cstdobject : TDMStandardObject;
begin
rvector := TDMFastVector.Create;
rvector.m_Capacity := m_Capacity;
SetLength( rvector.m_Objects, m_Capacity );
n1 := m_Size - 1;
for i := 0 to n1 do
begin
cobject := Self.m_Objects[ i ];
if ( cobject <> nil ) then
if ( cobject is TDMStandardObject ) then
begin
cstdobject := cobject as TDMStandardObject;
rvector.m_Objects[ i ] := cstdobject.copyObject;
end;
end;
rvector.m_Size := m_Size;
rvector.m_ElementMemoryManagement := m_ElementMemoryManagement;
Result := rvector;
end;

procedure TDMFastVector.swap( const index1, index2 : Integer );
var
cobject : TObject;
begin
if ( index1 >= 0 ) and ( index1 < m_Size )
and ( index2 >= 0 ) and ( index2 < m_Size ) then
begin
cobject := m_Objects[ index1 ];
m_Objects[ index1 ] := m_Objects[ index2 ];
m_Objects[ index2 ] := cobject;
end;
end;

procedure TDMFastVector.setElementAt( const index : Integer; element : TObject );
begin
if ( index >= 0 ) and ( index < m_Size ) then
begin
if ( m_ElementMemoryManagement ) and ( m_Objects[ index ] <> nil ) then
m_Objects[ index ].Free;

m_Objects[ index ] := element;
end;
end;

procedure TDMFastVector.addElement( element : TObject );
begin
if ( m_Size = m_Capacity ) then
begin
m_Capacity := FAST_VECTOR_CAPACITY_MULTIPLIER *
( m_Capacity + FAST_VECTOR_CAPACITY_INCREMENT );

SetLength( m_Objects, m_Capacity );
end;
m_Objects[ m_Size ] := element;
m_Size := m_Size + 1;
end;

procedure TDMFastVector.insertElementAt( element : TObject; const index : Integer );
var
i, n1 : Integer;
begin
if ( m_Size = m_Capacity ) then
begin
m_Capacity := FAST_VECTOR_CAPACITY_MULTIPLIER *
( m_Capacity + FAST_VECTOR_CAPACITY_INCREMENT );
SetLength( m_Objects, m_Capacity );
end;
if ( index >= 0 ) then
begin
if ( index < m_Size ) then
begin
n1 := m_Size - 1;
for i := n1 downto index do
begin
m_Objects[ i + 1 ] := m_Objects[ i ];
end;
m_Objects[ index ] := element;
end
else m_Objects[ m_Size ] := element;
end
else insertAtHead( element );
m_Size := m_Size + 1;
end;

function TDMFastVector.indexOf( element : TObject ) : Integer;
var
i, n1 : Integer;
ielem : TObject;
celem : TDMStandardObject;
begin
Result := -1;
if ( element <> nil ) then
begin
n1 := m_Size - 1;
for i := 0 to n1 do
begin
ielem := m_Objects[ i ];
if ( ielem <> nil ) then
if ( ielem is TDMStandardObject ) then
begin
celem := ielem as TDMStandardObject;
if ( celem.equals( element ) ) then
begin
Result := i;
Break;
end;
end
else
if ( ielem = element ) then
begin
Result := i;
Break;
end;
end;
end;
end;

function TDMFastVector.firstElement : TObject;
begin
Result := m_Objects[ 0 ];
end;

function TDMFastVector.lastElement : TObject;
begin
Result := m_Objects[ m_Size - 1 ];
end;

procedure TDMFastVector.appendElements( toappend : TDMFastVector );
var
i, j, n1, s1, s11 : Integer;
begin
s1 := m_Size + toappend.m_Size;
s11 := s1 - 1;
setCapacity( s1 );
n1 := m_Size - 1;
j := 0;
for i := n1 to s11 do
begin
m_Objects[ i ] := toappend.m_Objects[ j ];
j := j + 1;
end;
m_Size := s1;
end;

procedure TDMFastVector.removeElementAt( const index : Integer );
var
i, n1 : Integer;
begin
if ( index >= 0 ) and ( index < m_Size ) and ( m_Size > 0 ) then
begin
if index = m_Size - 1 then m_Size := m_Size - 1
else
begin
n1 := m_Size - 1;
for i := index + 1 to n1 do
begin
m_Objects[ i - 1 ] := m_Objects[ i ];
end;
m_Size := m_Size - 1;
end;
end;
end;

procedure TDMFastVector.removeAndClearElementAt( const index : Integer );
var
i, n1 : Integer;
begin
if ( index >= 0 ) and ( index < m_Size ) and ( m_Size > 0 ) then
begin
if index = m_Size - 1 then m_Size := m_Size - 1
else
begin
if ( m_ElementMemoryManagement ) and ( m_Objects[ index ] <> nil ) then
m_Objects[ index ].Free;
n1 := m_Size - 1;
for i := index + 1 to n1 do
begin
m_Objects[ i - 1 ] := m_Objects[ i ];
end;
m_Size := m_Size - 1;
end;
end;
end;

procedure TDMFastVector.removeAllElements;
begin
SetLength( m_Objects, 0 );
m_Capacity := 0;
m_Size := 0;
end;

procedure TDMFastVector.removeAndClearAllElements;
begin
if ( m_ElementMemoryManagement ) then freeRange( 0, m_Size - 1 );
SetLength( m_Objects, 0 );
m_Capacity := 0;
m_Size := 0;
end;

function TDMFastVector.toArray : TDMObjectArray;
var
rarray : TDMObjectArray;
begin
rarray := Copy( m_Objects, 0, m_Size );
Result := rarray;
end;

function TDMFastVector.contains( element : TObject ) : Boolean;
var
i, n1 : Integer;
cobject : TObject;
cstdobject : TDMStandardObject;
begin
Result := false;
if ( element <> nil ) and ( m_Size > 0 ) then
begin
n1 := m_Size - 1;
for i := 0 to n1 do
begin
cobject := m_Objects[ i ];
if ( cobject is TDMStandardObject ) then
begin
cstdobject := cobject as TDMStandardObject;
if ( cstdobject.equals( element ) ) then
begin
Result := true;
Break;
end;
end;
end;
end;
end;

function TDMFastVector.elementAt( const index : Integer ) : TObject;
begin
Result := nil;
if ( index >= 0 ) and ( index < m_Size ) then Result := m_Objects[ index ];
end;

procedure TDMFastVector.trimToSize( const size : Integer );
var
n1 : Integer;
begin
n1 := m_Size - size;
if ( size > 0 ) and ( n1 > 0 ) then
begin
if ( m_ElementMemoryManagement ) then freeRange( size, n1 );
SetLength( m_Objects, size );
m_Capacity := size;
m_Size := size;
end;
end;

procedure TDMFastVector.trimToSize();
var
newObjects : TDMObjectArray;
begin
SetLength(newObjects, m_Size);

newObjects := Copy(m_Objects, 0, m_Size);
m_Objects := newObjects;
end;

procedure TDMFastVector.setCapacity( const capacity : Integer );
var
n1 : Integer;
begin
if capacity >= 0 then
begin
if ( m_ElementMemoryManagement ) then
begin
n1 := m_Size - capacity;
if ( n1 > 0 ) then
freeRange( capacity, n1 );
end;
SetLength( m_Objects, capacity );
m_Capacity := capacity;
if m_Size > m_Capacity then
m_Size := m_Capacity;
end;
end;

function TDMFastVector.equals( otherObject : TObject ) : Boolean;
var
otherFastVector : TDMFastVector;
thisElement, otherElement : TObject;
thisStdObject, otherStdObject : TDMStandardObject;
i, n1 : Integer;
objectsNotComparableNil, thisIsStandard, otherIsStandard : Boolean;
begin
Result := false;
if ( otherObject <> nil ) then
if ( otherObject is TDMFastVector ) then
begin
otherFastVector := otherObject as TDMFastVector;
if ( otherFastVector.m_Size = m_Size ) then
begin
n1 := m_Size - 1;
Result := true;
for i := 0 to n1 do
begin
thisElement := m_Objects[ i ];
otherElement := otherFastVector.m_Objects[ i ];
objectsNotComparableNil := ( thisElement = nil ) xor ( otherElement = nil );

if ( objectsNotComparableNil ) then
begin
Result := false;
Break;
end;

if ( thisElement = nil ) and ( otherElement = nil ) then Continue;

thisIsStandard := thisElement is TDMStandardObject;
otherIsStandard := otherElement is TDMStandardObject;

if ( thisIsStandard xor otherIsStandard ) then
begin
Result := false;
Break;
end;

if ( not thisIsStandard ) and ( not otherIsStandard ) then
if ( thisElement <> otherElement ) then
begin
Result := false;
Break;
end
else Continue;

thisStdObject := thisElement as TDMStandardObject;
otherStdObject := otherElement as TDMStandardObject;

if ( thisStdObject.equals( otherStdObject ) ) then Continue
else
begin
Result := false;
Break;
end;
end;
end;
end;
end;

procedure TDMFastVector.serializeObject( ostream : TStream );
begin
end;

procedure TDMFastVector.deserializeObject( istream : TStream );
begin
end;

function TDMFastVector.toString : AnsiString;
var
i, n1 : Integer;
rstring : AnsiString;
selem : TDMStandardObject;
begin
rstring := 'FastVector ( m_Size = ' + IntToStr( m_Size ) + ' m_Capacity = ';
rstring := rstring + IntToStr( capacity ) + ' )'#10#13'';
n1 := m_Size - 1;
for i := 0 to n1 do
begin
if ( m_Objects[ i ] <> nil ) then
if ( m_Objects[ i ] is TDMStandardObject ) then
begin
selem := m_Objects[ i ] as TDMStandardObject;
rstring := rstring + ' ' + selem.toString + ''#10#13'';
end;
end;
Result := rstring;
end;

destructor TDMFastVector.Destroy;
begin
if ( m_ElementMemoryManagement ) then
begin
freeRange( 0, m_Size - 1 );
end;
SetLength( m_Objects, 0 );
end;

constructor TDMFastVectorEnumeration.Create( fastVector : TDMFastVector );
begin
m_Counter := 0;
m_FastVector := fastVector;
m_SpecialElement := -1;
end;

constructor TDMFastVectorEnumeration.Create( fastVector : TDMFastVector; const specialElement : Integer );
begin
if ( specialElement = 0 ) then m_Counter := 1
else m_Counter := 0;
m_FastVector := fastVector;
m_SpecialElement := specialElement;
end;

function TDMFastVectorEnumeration.hasMoreElements : Boolean;
begin
Result := false;
if ( m_Counter < m_FastVector.size ) then Result := true;
end;

function TDMFastVectorEnumeration.nextElement : TObject;
begin
Result := m_FastVector.elementAt( m_Counter );
m_Counter := m_Counter + 1;
if ( m_Counter = m_SpecialElement ) then m_Counter := m_Counter + 1;
end;

function TDMFastVectorEnumeration.cloneObject : TObject;
var
renumeration : TDMFastVectorEnumeration;
begin
renumeration := TDMFastVectorEnumeration.Create;
renumeration.m_FastVector := m_FastVector;
renumeration.m_Counter := m_Counter;
renumeration.m_SpecialElement := m_SpecialElement;
Result := renumeration;
end;

function TDMFastVectorEnumeration.copyObject : TObject;
begin
Result := cloneObject;
end;

procedure TDMFastVectorEnumeration.serializeObject( ostream : TStream );
begin
end;

procedure TDMFastVectorEnumeration.deserializeObject( istream : TStream );
begin
end;

destructor TDMFastVectorEnumeration.Destroy;
begin
m_Counter := 0;
m_FastVector := nil;
m_SpecialElement := 0;
end;

end.