Vichingo455-RePacks
/
xtool
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity
xtool/contrib/fundamentals/Utils/Templates/flcDynArrays.inc

2209 lines
85 KiB
PHP
Raw Blame History

{*******************************************************************************}
{ }
{ Library: Fundamentals 5.00 }
{ File name: flcDynArrays.pas }
{ File version: 5.34 }
{ Description: Utility functions for dynamic arrays }
{ }
{ Copyright: Copyright (c) 2000-2020, David J Butler }
{ All rights reserved. }
{ Redistribution and use in source and binary forms, with }
{ or without modification, are permitted provided that }
{ the following conditions are met: }
{ Redistributions of source code must retain the above }
{ copyright notice, this list of conditions and the }
{ following disclaimer. }
{ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND }
{ CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED }
{ WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED }
{ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A }
{ PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL }
{ THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, }
{ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR }
{ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, }
{ PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF }
{ USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) }
{ HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER }
{ IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING }
{ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE }
{ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE }
{ POSSIBILITY OF SUCH DAMAGE. }
{ }
{ Github: https://github.com/fundamentalslib }
{ E-mail: fundamentals.library at gmail.com }
{ }
{ Revision history: }
{ }
{ 2000/03/08 1.01 Initial verison: array functions. }
{ 2000/04/10 1.02 Added Append, Renamed Delete to Remove and added }
{ StringArrays. }
{ 2000/06/01 1.03 Added Range and Dup constructors for dynamic arrays. }
{ 2000/06/03 1.04 Added ArrayInsert functions. }
{ 2000/06/14 1.05 Unit now generated from a template using a source }
{ pre-processor. }
{ 2000/07/04 1.06 Revision for first Fundamentals release. }
{ 2000/07/24 1.07 Added TrimArray functions. }
{ 2000/07/26 1.08 Added Difference functions. }
{ 2000/09/02 1.09 Added RemoveDuplicates functions. }
{ Added Count functions. }
{ Fixed bug in Sort. }
{ 2000/09/27 1.10 Fixed bug in ArrayInsert. }
{ 2001/11/11 2.11 Revision. }
{ 2002/05/31 3.12 Refactored for Fundamentals 3. }
{ 2003/09/11 3.13 Added InterfaceArray functions. }
{ 2004/01/18 3.14 Added WideStringArray functions. }
{ 2004/07/24 3.15 Optimizations of Sort functions. }
{ 2004/08/22 3.16 Compilable with Delphi 8. }
{ 2005/06/10 4.17 Compilable with FreePascal 2 Win32 i386. }
{ 2005/08/19 4.18 Compilable with FreePascal 2 Linux i386. }
{ 2005/09/21 4.19 Revised for Fundamentals 4. }
{ 2006/03/04 4.20 Compilable with Delphi 2006 Win32/.NET. }
{ 2007/06/08 4.21 Compilable with FreePascal 2.04 Win32 i386 }
{ 2009/10/09 4.22 Compilable with Delphi 2009 Win32/.NET. }
{ 2010/06/27 4.23 Compilable with FreePascal 2.4.0 OSX x86-64. }
{ 2011/04/03 4.24 Support for Delphi XE string and integer types. }
{ 2011/04/04 4.25 Split dynamic array functions from Utils unit. }
{ 2012/08/26 4.26 UnicodeString functions. }
{ 2015/03/13 4.27 RawByteString functions. }
{ 2016/01/09 5.28 Revised for Fundamentals 5. }
{ 2016/04/16 5.29 Changes for FreePascal 3.0.0. }
{ 2018/07/17 5.30 Int32/Word32 functions. }
{ 2018/08/12 5.31 String type changes. }
{ 2019/03/22 5.32 FreePascal 3.04 Win64 changes. }
{ 2019/04/02 5.33 Integer/Cardinal functions. }
{ 2020/03/31 5.34 Word64 functions. }
{ }
{ Supported compilers: }
{ }
{ Delphi 2010-10.4 Win32/Win64 5.34 2020/06/02 }
{ Delphi 10.2-10.4 Linux64 5.34 2020/06/02 }
{ FreePascal 3.0.4 Win64 5.34 2020/06/02 }
{ }
{*******************************************************************************}
{$INCLUDE ..\flcInclude.inc}
{$IFDEF FREEPASCAL}
{$WARNINGS OFF}
{$HINTS OFF}
{$ENDIF}
{$IFDEF DEBUG}
{$IFDEF TEST}
{$DEFINE DYNARRAYS_TEST}
{$ENDIF}
{$ENDIF}
unit flcDynArrays;
interface
uses
{ System }
SysUtils,
{ Fundamentals }
flcStdTypes,
flcUtils;
{ }
{ Dynamic arrays }
{ }
{%DEFINE DynArrayAppend}
function DynArrayAppend%1%(var V: %2%Array; const R: %3%): Integer; overload; {$IFDEF UseInline}inline;{$ENDIF}{%ENDDEF}
{%TEMPLATE DynArrayAppend '' 'Byte' 'Byte'}
{%TEMPLATE DynArrayAppend '' 'Word16' 'Word16'}
{%TEMPLATE DynArrayAppend '' 'Word32' 'Word32'}
{%TEMPLATE DynArrayAppend '' 'Word64' 'Word64'}
{%TEMPLATE DynArrayAppend '' 'LongWord' 'LongWord'}
{%TEMPLATE DynArrayAppend '' 'Cardinal' 'Cardinal'}
{%TEMPLATE DynArrayAppend '' 'NativeUInt' 'NativeUInt'}
{%TEMPLATE DynArrayAppend '' 'ShortInt' 'ShortInt'}
{%TEMPLATE DynArrayAppend '' 'SmallInt' 'SmallInt'}
{%TEMPLATE DynArrayAppend '' 'LongInt' 'LongInt'}
{%TEMPLATE DynArrayAppend '' 'Integer' 'Integer'}
{%TEMPLATE DynArrayAppend '' 'Int32' 'Int32'}
{%TEMPLATE DynArrayAppend '' 'Int64' 'Int64'}
{%TEMPLATE DynArrayAppend '' 'NativeInt' 'NativeInt'}
{%TEMPLATE DynArrayAppend '' 'Single' 'Single'}
{%TEMPLATE DynArrayAppend '' 'Double' 'Double'}
{%TEMPLATE DynArrayAppend '' 'Extended' 'Extended'}
{%TEMPLATE DynArrayAppend '' 'Currency' 'Currency'}
{%TEMPLATE DynArrayAppend '' 'Boolean' 'Boolean'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayAppend 'A' 'AnsiString' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayAppend 'B' 'RawByteString' 'RawByteString'}
{%TEMPLATE DynArrayAppend 'U' 'UnicodeString' 'UnicodeString'}
{%TEMPLATE DynArrayAppend '' 'String' 'String'}
{%TEMPLATE DynArrayAppend '' 'Pointer' 'Pointer'}
{%TEMPLATE DynArrayAppend '' 'Object' 'TObject'}
{%TEMPLATE DynArrayAppend '' 'Interface' 'IInterface'}
{%TEMPLATE DynArrayAppend '' 'ByteSet' 'ByteSet'}
{%TEMPLATE DynArrayAppend '' 'ByteCharSet' 'ByteCharSet'}
{%DEFINE DynArrayAppendArray}
function DynArrayAppend%1%Array(var V: %1%Array; const R: %2%): Integer; overload;{%ENDDEF}
{%TEMPLATE DynArrayAppendArray 'Byte' 'array of Byte'}
{%TEMPLATE DynArrayAppendArray 'Word16' 'array of Word16'}
{%TEMPLATE DynArrayAppendArray 'Word32' 'array of Word32'}
{%TEMPLATE DynArrayAppendArray 'Word64' 'array of Word64'}
{%TEMPLATE DynArrayAppendArray 'Cardinal' 'array of Cardinal'}
{%TEMPLATE DynArrayAppendArray 'NativeUInt' 'array of NativeUInt'}
{%TEMPLATE DynArrayAppendArray 'ShortInt' 'array of ShortInt'}
{%TEMPLATE DynArrayAppendArray 'SmallInt' 'array of SmallInt'}
{%TEMPLATE DynArrayAppendArray 'LongInt' 'array of LongInt'}
{%TEMPLATE DynArrayAppendArray 'Integer' 'array of Integer'}
{%TEMPLATE DynArrayAppendArray 'Int32' 'array of Int32'}
{%TEMPLATE DynArrayAppendArray 'Int64' 'array of Int64'}
{%TEMPLATE DynArrayAppendArray 'NativeInt' 'array of NativeInt'}
{%TEMPLATE DynArrayAppendArray 'Single' 'array of Single'}
{%TEMPLATE DynArrayAppendArray 'Double' 'array of Double'}
{%TEMPLATE DynArrayAppendArray 'Extended' 'array of Extended'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayAppendArray 'AnsiString' 'array of AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayAppendArray 'RawByteString' 'array of RawByteString'}
{%TEMPLATE DynArrayAppendArray 'UnicodeString' 'array of UnicodeString'}
{%TEMPLATE DynArrayAppendArray 'String' 'array of String'}
{%TEMPLATE DynArrayAppendArray 'Currency' 'array of Currency'}
{%TEMPLATE DynArrayAppendArray 'Pointer' 'array of Pointer'}
{%TEMPLATE DynArrayAppendArray 'ByteCharSet' 'array of ByteCharSet'}
{%TEMPLATE DynArrayAppendArray 'ByteSet' 'array of ByteSet'}
{%TEMPLATE DynArrayAppendArray 'Object' 'ObjectArray'}
{%DEFINE DynArrayRemove}
function DynArrayRemove%1%(var V: %2%Array; const Idx: Integer; const Count: Integer = 1): Integer; overload;{%ENDDEF}
{%TEMPLATE DynArrayRemove '' 'Byte'}
{%TEMPLATE DynArrayRemove '' 'Word16'}
{%TEMPLATE DynArrayRemove '' 'Word32'}
{%TEMPLATE DynArrayRemove '' 'Word64'}
{%TEMPLATE DynArrayRemove '' 'LongWord'}
{%TEMPLATE DynArrayRemove '' 'Cardinal'}
{%TEMPLATE DynArrayRemove '' 'NativeUInt'}
{%TEMPLATE DynArrayRemove '' 'ShortInt'}
{%TEMPLATE DynArrayRemove '' 'SmallInt'}
{%TEMPLATE DynArrayRemove '' 'LongInt'}
{%TEMPLATE DynArrayRemove '' 'Integer'}
{%TEMPLATE DynArrayRemove '' 'Int32'}
{%TEMPLATE DynArrayRemove '' 'Int64'}
{%TEMPLATE DynArrayRemove '' 'NativeInt'}
{%TEMPLATE DynArrayRemove '' 'Single'}
{%TEMPLATE DynArrayRemove '' 'Double'}
{%TEMPLATE DynArrayRemove '' 'Extended'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayRemove 'A' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayRemove 'B' 'RawByteString'}
{%TEMPLATE DynArrayRemove 'U' 'UnicodeString'}
{%TEMPLATE DynArrayRemove '' 'String'}
{%TEMPLATE DynArrayRemove '' 'Pointer'}
{%TEMPLATE DynArrayRemove '' 'Currency'}
function DynArrayRemove(var V: ObjectArray; const Idx: Integer; const Count: Integer = 1;
const FreeObjects: Boolean = False): Integer; overload;
{%TEMPLATE DynArrayRemove '' 'Interface'}
{%DEFINE DynArrayRemoveDuplicates}
procedure DynArrayRemoveDuplicates%1%(var V: %2%Array; const IsSorted: Boolean); overload;{%ENDDEF}
{%TEMPLATE DynArrayRemoveDuplicates '' 'Byte'}
{%TEMPLATE DynArrayRemoveDuplicates '' 'Word16'}
{%TEMPLATE DynArrayRemoveDuplicates '' 'LongWord'}
{%TEMPLATE DynArrayRemoveDuplicates '' 'ShortInt'}
{%TEMPLATE DynArrayRemoveDuplicates '' 'SmallInt'}
{%TEMPLATE DynArrayRemoveDuplicates '' 'LongInt'}
{%TEMPLATE DynArrayRemoveDuplicates '' 'Int64'}
{%TEMPLATE DynArrayRemoveDuplicates '' 'Single'}
{%TEMPLATE DynArrayRemoveDuplicates '' 'Double'}
{%TEMPLATE DynArrayRemoveDuplicates '' 'Extended'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayRemoveDuplicates 'A' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayRemoveDuplicates 'U' 'UnicodeString'}
{%TEMPLATE DynArrayRemoveDuplicates '' 'String'}
{%TEMPLATE DynArrayRemoveDuplicates '' 'Pointer'}
{%DEFINE DynArrayTrimLeft}
procedure DynArrayTrimLeft%1%(var S: %2%Array; const TrimList: array of %3%); overload;{%ENDDEF}
{%TEMPLATE DynArrayTrimLeft '' 'Byte' 'Byte'}
{%TEMPLATE DynArrayTrimLeft '' 'Word16' 'Word16'}
{%TEMPLATE DynArrayTrimLeft '' 'LongWord' 'LongWord'}
{%TEMPLATE DynArrayTrimLeft '' 'ShortInt' 'ShortInt'}
{%TEMPLATE DynArrayTrimLeft '' 'SmallInt' 'SmallInt'}
{%TEMPLATE DynArrayTrimLeft '' 'LongInt' 'LongInt'}
{%TEMPLATE DynArrayTrimLeft '' 'Int64' 'Int64'}
{%TEMPLATE DynArrayTrimLeft '' 'Single' 'Single'}
{%TEMPLATE DynArrayTrimLeft '' 'Double' 'Double'}
{%TEMPLATE DynArrayTrimLeft '' 'Extended' 'Extended'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayTrimLeft 'A' 'AnsiString' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayTrimLeft 'U' 'UnicodeString' 'UnicodeString'}
{%TEMPLATE DynArrayTrimLeft '' 'Pointer' 'Pointer'}
{%DEFINE DynArrayTrimRight}
procedure DynArrayTrimRight%1%(var S: %2%Array; const TrimList: array of %3%); overload;{%ENDDEF}
{%TEMPLATE DynArrayTrimRight '' 'Byte' 'Byte'}
{%TEMPLATE DynArrayTrimRight '' 'Word16' 'Word16'}
{%TEMPLATE DynArrayTrimRight '' 'LongWord' 'LongWord'}
{%TEMPLATE DynArrayTrimRight '' 'ShortInt' 'ShortInt'}
{%TEMPLATE DynArrayTrimRight '' 'SmallInt' 'SmallInt'}
{%TEMPLATE DynArrayTrimRight '' 'LongInt' 'LongInt'}
{%TEMPLATE DynArrayTrimRight '' 'Int64' 'Int64'}
{%TEMPLATE DynArrayTrimRight '' 'Single' 'Single'}
{%TEMPLATE DynArrayTrimRight '' 'Double' 'Double'}
{%TEMPLATE DynArrayTrimRight '' 'Extended' 'Extended'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayTrimRight 'A' 'AnsiString' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayTrimRight 'U' 'UnicodeString' 'UnicodeString'}
{%TEMPLATE DynArrayTrimRight '' 'String' 'String'}
{%TEMPLATE DynArrayTrimRight '' 'Pointer' 'Pointer'}
{%DEFINE DynArrayInsert}
function DynArrayInsert%1%(var V: %2%Array; const Idx: Integer; const Count: Integer): Integer; overload;{%ENDDEF}
{%TEMPLATE DynArrayInsert '' 'Byte'}
{%TEMPLATE DynArrayInsert '' 'Word16'}
{%TEMPLATE DynArrayInsert '' 'Word32'}
{%TEMPLATE DynArrayInsert '' 'Word64'}
{%TEMPLATE DynArrayInsert '' 'LongWord'}
{%TEMPLATE DynArrayInsert '' 'NativeUInt'}
{%TEMPLATE DynArrayInsert '' 'ShortInt'}
{%TEMPLATE DynArrayInsert '' 'SmallInt'}
{%TEMPLATE DynArrayInsert '' 'LongInt'}
{%TEMPLATE DynArrayInsert '' 'Int32'}
{%TEMPLATE DynArrayInsert '' 'Int64'}
{%TEMPLATE DynArrayInsert '' 'NativeInt'}
{%TEMPLATE DynArrayInsert '' 'Single'}
{%TEMPLATE DynArrayInsert '' 'Double'}
{%TEMPLATE DynArrayInsert '' 'Extended'}
{%TEMPLATE DynArrayInsert '' 'Currency'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayInsert 'A' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayInsert 'B' 'RawByteString'}
{%TEMPLATE DynArrayInsert 'U' 'UnicodeString'}
{%TEMPLATE DynArrayInsert '' 'String'}
{%TEMPLATE DynArrayInsert '' 'Pointer'}
{%TEMPLATE DynArrayInsert '' 'Object'}
{%TEMPLATE DynArrayInsert '' 'Interface'}
{%DEFINE DynArrayPosNext}
function DynArrayPosNext%1%(const Find: %3%; const V: %2%Array; const PrevPos: Integer = -1;
const IsSortedAscending: Boolean = False): Integer; overload;{%ENDDEF}
{%TEMPLATE DynArrayPosNext '' 'Byte' 'Byte'}
{%TEMPLATE DynArrayPosNext '' 'Word16' 'Word16'}
{%TEMPLATE DynArrayPosNext '' 'Word32' 'Word32'}
{%TEMPLATE DynArrayPosNext '' 'Word64' 'Word64'}
{%TEMPLATE DynArrayPosNext '' 'LongWord' 'LongWord'}
{%TEMPLATE DynArrayPosNext '' 'Cardinal' 'Cardinal'}
{%TEMPLATE DynArrayPosNext '' 'NativeUInt' 'NativeUInt'}
{%TEMPLATE DynArrayPosNext '' 'ShortInt' 'ShortInt'}
{%TEMPLATE DynArrayPosNext '' 'SmallInt' 'SmallInt'}
{%TEMPLATE DynArrayPosNext '' 'LongInt' 'LongInt'}
{%TEMPLATE DynArrayPosNext '' 'Integer' 'Integer'}
{%TEMPLATE DynArrayPosNext '' 'Int32' 'Int32'}
{%TEMPLATE DynArrayPosNext '' 'Int64' 'Int64'}
{%TEMPLATE DynArrayPosNext '' 'NativeInt' 'NativeInt'}
{%TEMPLATE DynArrayPosNext '' 'Single' 'Single'}
{%TEMPLATE DynArrayPosNext '' 'Double' 'Double'}
{%TEMPLATE DynArrayPosNext '' 'Extended' 'Extended'}
{%TEMPLATE DynArrayPosNext '' 'Boolean' 'Boolean'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayPosNext 'A' 'AnsiString' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayPosNext 'B' 'RawByteString' 'RawByteString'}
{%TEMPLATE DynArrayPosNext 'U' 'UnicodeString' 'UnicodeString'}
{%TEMPLATE DynArrayPosNext '' 'String' 'String'}
function DynArrayPosNext(const Find: Pointer; const V: PointerArray;
const PrevPos: Integer = -1): Integer; overload;
function DynArrayPosNext(const Find: TObject; const V: ObjectArray;
const PrevPos: Integer = -1): Integer; overload;
function DynArrayPosNext(const ClassType: TClass; const V: ObjectArray;
const PrevPos: Integer = -1): Integer; overload;
function DynArrayPosNext(const ClassName: String; const V: ObjectArray;
const PrevPos: Integer = -1): Integer; overload;
{%DEFINE DynArrayCount}
function DynArrayCount%1%(const Find: %3%; const V: %2%Array;
const IsSortedAscending: Boolean = False): Integer; overload;{%ENDDEF}
{%TEMPLATE DynArrayCount '' 'Byte' 'Byte'}
{%TEMPLATE DynArrayCount '' 'Word16' 'Word16'}
{%TEMPLATE DynArrayCount '' 'LongWord' 'LongWord'}
{%TEMPLATE DynArrayCount '' 'ShortInt' 'ShortInt'}
{%TEMPLATE DynArrayCount '' 'SmallInt' 'SmallInt'}
{%TEMPLATE DynArrayCount '' 'LongInt' 'LongInt'}
{%TEMPLATE DynArrayCount '' 'Int64' 'Int64'}
{%TEMPLATE DynArrayCount '' 'Single' 'Single'}
{%TEMPLATE DynArrayCount '' 'Double' 'Double'}
{%TEMPLATE DynArrayCount '' 'Extended' 'Extended'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayCount 'A' 'AnsiString' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayCount 'B' 'RawByteString' 'RawByteString'}
{%TEMPLATE DynArrayCount 'U' 'UnicodeString' 'UnicodeString'}
{%TEMPLATE DynArrayCount '' 'String' 'String'}
{%TEMPLATE DynArrayCount '' 'Boolean' 'Boolean'}
{%DEFINE DynArrayRemoveAll}
procedure DynArrayRemoveAll%1%(const Find: %3%; var V: %2%Array;
const IsSortedAscending: Boolean = False); overload; {%ENDDEF}
{%TEMPLATE DynArrayRemoveAll '' 'Byte' 'Byte'}
{%TEMPLATE DynArrayRemoveAll '' 'Word16' 'Word16'}
{%TEMPLATE DynArrayRemoveAll '' 'LongWord' 'LongWord'}
{%TEMPLATE DynArrayRemoveAll '' 'ShortInt' 'ShortInt'}
{%TEMPLATE DynArrayRemoveAll '' 'SmallInt' 'SmallInt'}
{%TEMPLATE DynArrayRemoveAll '' 'LongInt' 'LongInt'}
{%TEMPLATE DynArrayRemoveAll '' 'Int64' 'Int64'}
{%TEMPLATE DynArrayRemoveAll '' 'Single' 'Single'}
{%TEMPLATE DynArrayRemoveAll '' 'Double' 'Double'}
{%TEMPLATE DynArrayRemoveAll '' 'Extended' 'Extended'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayRemoveAll 'A' 'AnsiString' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayRemoveAll 'U' 'UnicodeString' 'UnicodeString'}
{%TEMPLATE DynArrayRemoveAll '' 'String' 'String'}
{%DEFINE DynArrayIntersection}
function DynArrayIntersection%1%(const V1, V2: %2%Array;
const IsSortedAscending: Boolean = False): %2%Array; overload;{%ENDDEF}
{%TEMPLATE DynArrayIntersection '' 'Byte'}
{%TEMPLATE DynArrayIntersection '' 'Word16'}
{%TEMPLATE DynArrayIntersection '' 'LongWord'}
{%TEMPLATE DynArrayIntersection '' 'ShortInt'}
{%TEMPLATE DynArrayIntersection '' 'SmallInt'}
{%TEMPLATE DynArrayIntersection '' 'LongInt'}
{%TEMPLATE DynArrayIntersection '' 'Int64'}
{%TEMPLATE DynArrayIntersection '' 'Single'}
{%TEMPLATE DynArrayIntersection '' 'Double'}
{%TEMPLATE DynArrayIntersection '' 'Extended'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayIntersection 'A' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayIntersection 'U' 'UnicodeString'}
{%TEMPLATE DynArrayIntersection '' 'String'}
{%DEFINE DynArrayDifference}
function DynArrayDifference%1%(const V1, V2: %2%Array;
const IsSortedAscending: Boolean = False): %2%Array; overload;{%ENDDEF}
{%TEMPLATE DynArrayDifference '' 'Byte'}
{%TEMPLATE DynArrayDifference '' 'Word16'}
{%TEMPLATE DynArrayDifference '' 'LongWord'}
{%TEMPLATE DynArrayDifference '' 'ShortInt'}
{%TEMPLATE DynArrayDifference '' 'SmallInt'}
{%TEMPLATE DynArrayDifference '' 'LongInt'}
{%TEMPLATE DynArrayDifference '' 'Int64'}
{%TEMPLATE DynArrayDifference '' 'Single'}
{%TEMPLATE DynArrayDifference '' 'Double'}
{%TEMPLATE DynArrayDifference '' 'Extended'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayDifference 'A' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayDifference 'U' 'UnicodeString'}
{%TEMPLATE DynArrayDifference '' 'String'}
{%DEFINE DynArrayReverse}
procedure DynArrayReverse%1%(var V: %2%Array); overload;{%ENDDEF}
{%TEMPLATE DynArrayReverse '' 'Byte'}
{%TEMPLATE DynArrayReverse '' 'Word16'}
{%TEMPLATE DynArrayReverse '' 'LongWord'}
{%TEMPLATE DynArrayReverse '' 'ShortInt'}
{%TEMPLATE DynArrayReverse '' 'SmallInt'}
{%TEMPLATE DynArrayReverse '' 'LongInt'}
{%TEMPLATE DynArrayReverse '' 'Int64'}
{%TEMPLATE DynArrayReverse '' 'Single'}
{%TEMPLATE DynArrayReverse '' 'Double'}
{%TEMPLATE DynArrayReverse '' 'Extended'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayReverse 'A' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayReverse 'U' 'UnicodeString'}
{%TEMPLATE DynArrayReverse '' 'String'}
{%TEMPLATE DynArrayReverse '' 'Pointer'}
{%TEMPLATE DynArrayReverse '' 'Object'}
{%DEFINE OpenArrayAsDynArray}
function As%1%Array(const V: array of %2%): %1%Array; overload;{%ENDDEF}
{%TEMPLATE OpenArrayAsDynArray 'Boolean' 'Boolean'}
{%TEMPLATE OpenArrayAsDynArray 'Byte' 'Byte'}
{%TEMPLATE OpenArrayAsDynArray 'Word16' 'Word16'}
{%TEMPLATE OpenArrayAsDynArray 'Word32' 'Word32'}
{%TEMPLATE OpenArrayAsDynArray 'Word64' 'Word64'}
{%TEMPLATE OpenArrayAsDynArray 'LongWord' 'LongWord'}
{%TEMPLATE OpenArrayAsDynArray 'Cardinal' 'Cardinal'}
{%TEMPLATE OpenArrayAsDynArray 'NativeUInt' 'NativeUInt'}
{%TEMPLATE OpenArrayAsDynArray 'ShortInt' 'ShortInt'}
{%TEMPLATE OpenArrayAsDynArray 'SmallInt' 'SmallInt'}
{%TEMPLATE OpenArrayAsDynArray 'LongInt' 'LongInt'}
{%TEMPLATE OpenArrayAsDynArray 'Integer' 'Integer'}
{%TEMPLATE OpenArrayAsDynArray 'Int32' 'Int32'}
{%TEMPLATE OpenArrayAsDynArray 'Int64' 'Int64'}
{%TEMPLATE OpenArrayAsDynArray 'NativeInt' 'NativeInt'}
{%TEMPLATE OpenArrayAsDynArray 'Single' 'Single'}
{%TEMPLATE OpenArrayAsDynArray 'Double' 'Double'}
{%TEMPLATE OpenArrayAsDynArray 'Extended' 'Extended'}
{%TEMPLATE OpenArrayAsDynArray 'Currency' 'Currency'}
{$IFDEF SupportAnsiString}
{%TEMPLATE OpenArrayAsDynArray 'AnsiString' 'AnsiString'}
{$ENDIF}
{%TEMPLATE OpenArrayAsDynArray 'RawByteString' 'RawByteString'}
{%TEMPLATE OpenArrayAsDynArray 'UnicodeString' 'UnicodeString'}
{%TEMPLATE OpenArrayAsDynArray 'String' 'String'}
{%TEMPLATE OpenArrayAsDynArray 'Pointer' 'Pointer'}
{%TEMPLATE OpenArrayAsDynArray 'ByteCharSet' 'ByteCharSet'}
function AsObjectArray(const V: array of TObject): ObjectArray; overload;
function AsInterfaceArray(const V: array of IInterface): InterfaceArray; overload;
{%DEFINE DynArrayRange}
function DynArrayRange%1%(const First: %1%; const Count: Integer;
const Increment: %1% = 1): %1%Array;{%ENDDEF}
{%TEMPLATE DynArrayRange 'Byte'}
{%TEMPLATE DynArrayRange 'Word16'}
{%TEMPLATE DynArrayRange 'LongWord'}
{%TEMPLATE DynArrayRange 'Cardinal'}
{%TEMPLATE DynArrayRange 'ShortInt'}
{%TEMPLATE DynArrayRange 'SmallInt'}
{%TEMPLATE DynArrayRange 'LongInt'}
{%TEMPLATE DynArrayRange 'Integer'}
{%TEMPLATE DynArrayRange 'Int64'}
{%TEMPLATE DynArrayRange 'Single'}
{%TEMPLATE DynArrayRange 'Double'}
{%TEMPLATE DynArrayRange 'Extended'}
{%DEFINE DynArrayDup}
function DynArrayDup%1%(const V: %2%; const Count: Integer): %1%Array;{%ENDDEF}
{%TEMPLATE DynArrayDup 'Byte' 'Byte' }
{%TEMPLATE DynArrayDup 'Word16' 'Word16' }
{%TEMPLATE DynArrayDup 'LongWord' 'LongWord' }
{%TEMPLATE DynArrayDup 'Cardinal' 'Cardinal' }
{%TEMPLATE DynArrayDup 'NativeUInt' 'NativeUInt' }
{%TEMPLATE DynArrayDup 'ShortInt' 'ShortInt' }
{%TEMPLATE DynArrayDup 'SmallInt' 'SmallInt' }
{%TEMPLATE DynArrayDup 'LongInt' 'LongInt' }
{%TEMPLATE DynArrayDup 'Integer' 'Integer' }
{%TEMPLATE DynArrayDup 'Int64' 'Int64' }
{%TEMPLATE DynArrayDup 'NativeInt' 'NativeInt' }
{%TEMPLATE DynArrayDup 'Single' 'Single' }
{%TEMPLATE DynArrayDup 'Double' 'Double' }
{%TEMPLATE DynArrayDup 'Extended' 'Extended' }
{%TEMPLATE DynArrayDup 'Currency' 'Currency' }
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayDup 'AnsiString' 'AnsiString' }
{$ENDIF}
{%TEMPLATE DynArrayDup 'UnicodeString' 'UnicodeString' }
{%TEMPLATE DynArrayDup 'String' 'String' }
{%TEMPLATE DynArrayDup 'ByteCharSet' 'ByteCharSet' }
{%TEMPLATE DynArrayDup 'Object' 'TObject' }
{%DEFINE SetLengthAndZero}
procedure SetLengthAndZero(var V: %1%Array; const NewLength: Integer); overload;{%ENDDEF}
{%TEMPLATE SetLengthAndZero 'Byte' }
{%TEMPLATE SetLengthAndZero 'Word16' }
{%TEMPLATE SetLengthAndZero 'Word32' }
{%TEMPLATE SetLengthAndZero 'Word64' }
{%TEMPLATE SetLengthAndZero 'LongWord' }
{%TEMPLATE SetLengthAndZero 'Cardinal' }
{%TEMPLATE SetLengthAndZero 'NativeUInt' }
{%TEMPLATE SetLengthAndZero 'ShortInt' }
{%TEMPLATE SetLengthAndZero 'SmallInt' }
{%TEMPLATE SetLengthAndZero 'LongInt' }
{%TEMPLATE SetLengthAndZero 'Integer' }
{%TEMPLATE SetLengthAndZero 'Int32' }
{%TEMPLATE SetLengthAndZero 'Int64' }
{%TEMPLATE SetLengthAndZero 'NativeInt' }
{%TEMPLATE SetLengthAndZero 'Single' }
{%TEMPLATE SetLengthAndZero 'Double' }
{%TEMPLATE SetLengthAndZero 'Extended' }
{%TEMPLATE SetLengthAndZero 'Currency' }
{%TEMPLATE SetLengthAndZero 'ByteCharSet'}
{%TEMPLATE SetLengthAndZero 'Boolean' }
{%TEMPLATE SetLengthAndZero 'Pointer' }
procedure SetLengthAndZero(var V: ObjectArray; const NewLength: Integer;
const FreeObjects: Boolean = False); overload;
{%DEFINE DynArrayIsEqual}
function DynArrayIsEqual%1%(const V1, V2: %2%Array): Boolean; overload;{%ENDDEF}
{%TEMPLATE DynArrayIsEqual '' 'Byte'}
{%TEMPLATE DynArrayIsEqual '' 'Word16'}
{%TEMPLATE DynArrayIsEqual '' 'LongWord'}
{%TEMPLATE DynArrayIsEqual '' 'ShortInt'}
{%TEMPLATE DynArrayIsEqual '' 'SmallInt'}
{%TEMPLATE DynArrayIsEqual '' 'LongInt'}
{%TEMPLATE DynArrayIsEqual '' 'Int64'}
{%TEMPLATE DynArrayIsEqual '' 'Single'}
{%TEMPLATE DynArrayIsEqual '' 'Double'}
{%TEMPLATE DynArrayIsEqual '' 'Extended'}
{%TEMPLATE DynArrayIsEqual '' 'Currency'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayIsEqual 'A' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayIsEqual 'B' 'RawByteString'}
{%TEMPLATE DynArrayIsEqual 'U' 'UnicodeString'}
{%TEMPLATE DynArrayIsEqual '' 'String'}
{%TEMPLATE DynArrayIsEqual '' 'ByteCharSet'}
{%DEFINE DynArrayToDynArray}
function %1%ArrayTo%2%Array(const V: %1%Array): %2%Array;{%ENDDEF}
{%TEMPLATE DynArrayToDynArray 'Byte' 'LongInt'}
{%TEMPLATE DynArrayToDynArray 'Word16' 'LongInt'}
{%TEMPLATE DynArrayToDynArray 'ShortInt' 'LongInt'}
{%TEMPLATE DynArrayToDynArray 'SmallInt' 'LongInt'}
{%TEMPLATE DynArrayToDynArray 'LongInt' 'Int64'}
{%TEMPLATE DynArrayToDynArray 'LongInt' 'Single'}
{%TEMPLATE DynArrayToDynArray 'LongInt' 'Double'}
{%TEMPLATE DynArrayToDynArray 'LongInt' 'Extended'}
{%TEMPLATE DynArrayToDynArray 'Single' 'Double'}
{%TEMPLATE DynArrayToDynArray 'Single' 'Extended'}
{%TEMPLATE DynArrayToDynArray 'Single' 'Currency'}
{%TEMPLATE DynArrayToDynArray 'Single' 'LongInt'}
{%TEMPLATE DynArrayToDynArray 'Single' 'Int64'}
{%TEMPLATE DynArrayToDynArray 'Double' 'Extended'}
{%TEMPLATE DynArrayToDynArray 'Double' 'Currency'}
{%TEMPLATE DynArrayToDynArray 'Double' 'LongInt'}
{%TEMPLATE DynArrayToDynArray 'Double' 'Int64'}
{%TEMPLATE DynArrayToDynArray 'Extended' 'Currency'}
{%TEMPLATE DynArrayToDynArray 'Extended' 'LongInt'}
{%TEMPLATE DynArrayToDynArray 'Extended' 'Int64'}
{%DEFINE DynArrayFromIndexes}
function %1%ArrayFromIndexes(const V: %1%Array;
const Indexes: IntegerArray): %1%Array;{%ENDDEF}
{%TEMPLATE DynArrayFromIndexes 'Byte'}
{%TEMPLATE DynArrayFromIndexes 'Word16'}
{%TEMPLATE DynArrayFromIndexes 'LongWord'}
{%TEMPLATE DynArrayFromIndexes 'Cardinal'}
{%TEMPLATE DynArrayFromIndexes 'ShortInt'}
{%TEMPLATE DynArrayFromIndexes 'SmallInt'}
{%TEMPLATE DynArrayFromIndexes 'LongInt'}
{%TEMPLATE DynArrayFromIndexes 'Integer'}
{%TEMPLATE DynArrayFromIndexes 'Int64'}
{%TEMPLATE DynArrayFromIndexes 'Single'}
{%TEMPLATE DynArrayFromIndexes 'Double'}
{%TEMPLATE DynArrayFromIndexes 'Extended'}
{%TEMPLATE DynArrayFromIndexes 'String'}
{%DEFINE DynArraySort}
procedure DynArraySort%1%(const V: %2%Array); overload;{%ENDDEF}
{%TEMPLATE DynArraySort '' 'Byte'}
{%TEMPLATE DynArraySort '' 'Word16'}
{%TEMPLATE DynArraySort '' 'LongWord'}
{%TEMPLATE DynArraySort '' 'Cardinal'}
{%TEMPLATE DynArraySort '' 'NativeUInt'}
{%TEMPLATE DynArraySort '' 'ShortInt'}
{%TEMPLATE DynArraySort '' 'SmallInt'}
{%TEMPLATE DynArraySort '' 'LongInt'}
{%TEMPLATE DynArraySort '' 'Integer'}
{%TEMPLATE DynArraySort '' 'Int64'}
{%TEMPLATE DynArraySort '' 'NativeInt'}
{%TEMPLATE DynArraySort '' 'Single'}
{%TEMPLATE DynArraySort '' 'Double'}
{%TEMPLATE DynArraySort '' 'Extended'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArraySort 'A' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArraySort 'B' 'RawByteString'}
{%TEMPLATE DynArraySort 'U' 'UnicodeString'}
{%TEMPLATE DynArraySort '' 'String'}
{%DEFINE DynArrayPairSort}
procedure DynArraySort(const Key: %1%Array; const Data: %2%Array); overload;{%ENDDEF}
{%TEMPLATE DynArrayPairSort 'Integer' 'Integer'}
{%TEMPLATE DynArrayPairSort 'Integer' 'Int64'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayPairSort 'Integer' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayPairSort 'Integer' 'Extended'}
{%TEMPLATE DynArrayPairSort 'Integer' 'Pointer'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayPairSort 'AnsiString' 'Integer'}
{%TEMPLATE DynArrayPairSort 'AnsiString' 'Int64'}
{%TEMPLATE DynArrayPairSort 'AnsiString' 'AnsiString'}
{%TEMPLATE DynArrayPairSort 'AnsiString' 'Extended'}
{%TEMPLATE DynArrayPairSort 'AnsiString' 'Pointer'}
{$ENDIF}
{%TEMPLATE DynArrayPairSort 'Extended' 'Integer'}
{%TEMPLATE DynArrayPairSort 'Extended' 'Int64'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayPairSort 'Extended' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayPairSort 'Extended' 'Extended'}
{%TEMPLATE DynArrayPairSort 'Extended' 'Pointer'}
{ }
{ Test cases }
{ }
{$IFDEF DYNARRAYS_TEST}
procedure Test;
{$ENDIF}
implementation
{ }
{ DynArrayAppend }
{ }
{%DEFINE DynArrayAppendImpl}
function DynArrayAppend%1%(var V: %2%Array; const R: %3%): Integer;
begin
Result := Length(V);
SetLength(V, Result + 1);
V[Result] := R;
end;
{%ENDDEF}
{%TEMPLATE DynArrayAppendImpl '' 'Byte' 'Byte'}
{%TEMPLATE DynArrayAppendImpl '' 'Word16' 'Word16'}
{%TEMPLATE DynArrayAppendImpl '' 'Word32' 'Word32'}
{%TEMPLATE DynArrayAppendImpl '' 'Word64' 'Word64'}
{%TEMPLATE DynArrayAppendImpl '' 'LongWord' 'LongWord'}
{%TEMPLATE DynArrayAppendImpl '' 'Cardinal' 'Cardinal'}
{%TEMPLATE DynArrayAppendImpl '' 'NativeUInt' 'NativeUInt'}
{%TEMPLATE DynArrayAppendImpl '' 'ShortInt' 'ShortInt'}
{%TEMPLATE DynArrayAppendImpl '' 'SmallInt' 'SmallInt'}
{%TEMPLATE DynArrayAppendImpl '' 'Int32' 'Int32'}
{%TEMPLATE DynArrayAppendImpl '' 'LongInt' 'LongInt'}
{%TEMPLATE DynArrayAppendImpl '' 'Integer' 'Integer'}
{%TEMPLATE DynArrayAppendImpl '' 'Int64' 'Int64'}
{%TEMPLATE DynArrayAppendImpl '' 'NativeInt' 'NativeInt'}
{%TEMPLATE DynArrayAppendImpl '' 'Single' 'Single'}
{%TEMPLATE DynArrayAppendImpl '' 'Double' 'Double'}
{%TEMPLATE DynArrayAppendImpl '' 'Extended' 'Extended'}
{%TEMPLATE DynArrayAppendImpl '' 'Currency' 'Currency'}
{%TEMPLATE DynArrayAppendImpl '' 'Boolean' 'Boolean'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayAppendImpl 'A' 'AnsiString' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayAppendImpl 'B' 'RawByteString' 'RawByteString'}
{%TEMPLATE DynArrayAppendImpl 'U' 'UnicodeString' 'UnicodeString'}
{%TEMPLATE DynArrayAppendImpl '' 'String' 'String'}
{%TEMPLATE DynArrayAppendImpl '' 'Pointer' 'Pointer'}
{%TEMPLATE DynArrayAppendImpl '' 'Object' 'TObject'}
{%TEMPLATE DynArrayAppendImpl '' 'Interface' 'IInterface'}
{%TEMPLATE DynArrayAppendImpl '' 'ByteSet' 'ByteSet'}
{%TEMPLATE DynArrayAppendImpl '' 'ByteCharSet' 'ByteCharSet'}
{%DEFINE DynArrayAppendArrayImpl}
function DynArrayAppend%2%Array(var V: %2%Array; const R: array of %1%): Integer;
var L : Integer;
begin
Result := Length(V);
L := Length(R);
if L > 0 then
begin
SetLength(V, Result + L);
Move(R[0], V[Result], Sizeof(%1%) * L);
end;
end;
{%ENDDEF}
{%TEMPLATE DynArrayAppendArrayImpl 'Byte' 'Byte'}
{%TEMPLATE DynArrayAppendArrayImpl 'Word16' 'Word16'}
{%TEMPLATE DynArrayAppendArrayImpl 'Word32' 'Word32'}
{%TEMPLATE DynArrayAppendArrayImpl 'Word64' 'Word64'}
{%TEMPLATE DynArrayAppendArrayImpl 'Cardinal' 'Cardinal'}
{%TEMPLATE DynArrayAppendArrayImpl 'NativeUInt' 'NativeUInt'}
{%TEMPLATE DynArrayAppendArrayImpl 'ShortInt' 'ShortInt'}
{%TEMPLATE DynArrayAppendArrayImpl 'SmallInt' 'SmallInt'}
{%TEMPLATE DynArrayAppendArrayImpl 'LongInt' 'LongInt'}
{%TEMPLATE DynArrayAppendArrayImpl 'Int32' 'Int32'}
{%TEMPLATE DynArrayAppendArrayImpl 'Integer' 'Integer'}
{%TEMPLATE DynArrayAppendArrayImpl 'Int64' 'Int64'}
{%TEMPLATE DynArrayAppendArrayImpl 'NativeInt' 'NativeInt'}
{%TEMPLATE DynArrayAppendArrayImpl 'Single' 'Single'}
{%TEMPLATE DynArrayAppendArrayImpl 'Double' 'Double'}
{%TEMPLATE DynArrayAppendArrayImpl 'Extended' 'Extended'}
{%TEMPLATE DynArrayAppendArrayImpl 'Currency' 'Currency'}
{%TEMPLATE DynArrayAppendArrayImpl 'Pointer' 'Pointer'}
{%TEMPLATE DynArrayAppendArrayImpl 'ByteCharSet' 'ByteCharSet'}
{%TEMPLATE DynArrayAppendArrayImpl 'ByteSet' 'ByteSet'}
function DynArrayAppendObjectArray(var V: ObjectArray; const R: ObjectArray): Integer;
var I, LR : Integer;
begin
Result := Length(V);
LR := Length(R);
if LR > 0 then
begin
SetLength(V, Result + LR);
for I := 0 to LR - 1 do
V[Result + I] := R[I];
end;
end;
{$IFDEF SupportAnsiString}
function DynArrayAppendAnsiStringArray(var V: AnsiStringArray; const R: array of AnsiString): Integer;
var I, LR : Integer;
begin
Result := Length(V);
LR := Length(R);
if LR > 0 then
begin
SetLength(V, Result + LR);
for I := 0 to LR - 1 do
V[Result + I] := R[I];
end;
end;
{$ENDIF}
function DynArrayAppendRawByteStringArray(var V: RawByteStringArray; const R: array of RawByteString): Integer;
var I, LR : Integer;
begin
Result := Length(V);
LR := Length(R);
if LR > 0 then
begin
SetLength(V, Result + LR);
for I := 0 to LR - 1 do
V[Result + I] := R[I];
end;
end;
function DynArrayAppendUnicodeStringArray(var V: UnicodeStringArray; const R: array of UnicodeString): Integer;
var I, LR : Integer;
begin
Result := Length(V);
LR := Length(R);
if LR > 0 then
begin
SetLength(V, Result + LR);
for I := 0 to LR - 1 do
V[Result + I] := R[I];
end;
end;
function DynArrayAppendStringArray(var V: StringArray; const R: array of String): Integer;
var I, LR : Integer;
begin
Result := Length(V);
LR := Length(R);
if LR > 0 then
begin
SetLength(V, Result + LR);
for I := 0 to LR - 1 do
V[Result + I] := R[I];
end;
end;
{ }
{ DynArrayRemove }
{ }
{%DEFINE DynArrayRemoveMemImpl}
function DynArrayRemove(var V: %1%Array; const Idx: Integer; const Count: Integer): Integer;
var I, J, L, M: Integer;
begin
L := Length(V);
if (Idx >= L) or (Idx + Count <= 0) or (L = 0) or (Count = 0) then
begin
Result := 0;
exit;
end;
I := MaxInt(Idx, 0);
J := MinInt(Count, L - I);
M := L - J - I;
if M > 0 then
Move(V[I + J], V[I], M * SizeOf(%2%));
SetLength(V, L - J);
Result := J;
end;
{%ENDDEF}
{%TEMPLATE DynArrayRemoveMemImpl 'Byte' 'Byte'}
{%TEMPLATE DynArrayRemoveMemImpl 'Word16' 'Word16'}
{%TEMPLATE DynArrayRemoveMemImpl 'Word32' 'Word32'}
{%TEMPLATE DynArrayRemoveMemImpl 'Word64' 'Word64'}
{%TEMPLATE DynArrayRemoveMemImpl 'LongWord' 'LongWord'}
{%TEMPLATE DynArrayRemoveMemImpl 'Cardinal' 'Cardinal'}
{%TEMPLATE DynArrayRemoveMemImpl 'NativeUInt' 'NativeUInt'}
{%TEMPLATE DynArrayRemoveMemImpl 'ShortInt' 'ShortInt'}
{%TEMPLATE DynArrayRemoveMemImpl 'SmallInt' 'SmallInt'}
{%TEMPLATE DynArrayRemoveMemImpl 'LongInt' 'LongInt'}
{%TEMPLATE DynArrayRemoveMemImpl 'Integer' 'Integer'}
{%TEMPLATE DynArrayRemoveMemImpl 'Int32' 'Int32'}
{%TEMPLATE DynArrayRemoveMemImpl 'Int64' 'Int64'}
{%TEMPLATE DynArrayRemoveMemImpl 'NativeInt' 'NativeInt'}
{%TEMPLATE DynArrayRemoveMemImpl 'Single' 'Single'}
{%TEMPLATE DynArrayRemoveMemImpl 'Double' 'Double'}
{%TEMPLATE DynArrayRemoveMemImpl 'Extended' 'Extended'}
{%TEMPLATE DynArrayRemoveMemImpl 'Currency' 'Currency'}
{%TEMPLATE DynArrayRemoveMemImpl 'Pointer' 'Pointer'}
function DynArrayRemove(var V: ObjectArray; const Idx: Integer; const Count: Integer;
const FreeObjects: Boolean): Integer;
var I, J, K, L, M, F : Integer;
begin
L := Length(V);
if (Idx >= L) or (Idx + Count <= 0) or (L = 0) or (Count = 0) then
begin
Result := 0;
exit;
end;
I := MaxInt(Idx, 0);
J := MinInt(Count, L - I);
if FreeObjects then
for K := I to I + J - 1 do
FreeAndNil(V[K]);
M := L - J - I;
for F := I to I + M - 1 do
V[F] := V[F + J];
SetLength(V, L - J);
Result := J;
end;
{$IFDEF SupportAnsiString}
function DynArrayRemoveA(var V: AnsiStringArray; const Idx: Integer; const Count: Integer): Integer;
var I, J, K, L : Integer;
begin
L := Length(V);
if (Idx >= L) or (Idx + Count <= 0) or (L = 0) or (Count = 0) then
begin
Result := 0;
exit;
end;
I := MaxInt(Idx, 0);
J := MinInt(Count, L - I);
for K := I to L - J - 1 do
V[K] := V[K + J];
SetLength(V, L - J);
Result := J;
end;
{$ENDIF}
function DynArrayRemoveB(var V: RawByteStringArray; const Idx: Integer; const Count: Integer): Integer;
var I, J, K, L : Integer;
begin
L := Length(V);
if (Idx >= L) or (Idx + Count <= 0) or (L = 0) or (Count = 0) then
begin
Result := 0;
exit;
end;
I := MaxInt(Idx, 0);
J := MinInt(Count, L - I);
for K := I to L - J - 1 do
V[K] := V[K + J];
SetLength(V, L - J);
Result := J;
end;
function DynArrayRemoveU(var V: UnicodeStringArray; const Idx: Integer; const Count: Integer): Integer;
var I, J, K, L : Integer;
begin
L := Length(V);
if (Idx >= L) or (Idx + Count <= 0) or (L = 0) or (Count = 0) then
begin
Result := 0;
exit;
end;
I := MaxInt(Idx, 0);
J := MinInt(Count, L - I);
for K := I to L - J - 1 do
V[K] := V[K + J];
SetLength(V, L - J);
Result := J;
end;
function DynArrayRemove(var V: StringArray; const Idx: Integer; const Count: Integer): Integer;
var I, J, K, L : Integer;
begin
L := Length(V);
if (Idx >= L) or (Idx + Count <= 0) or (L = 0) or (Count = 0) then
begin
Result := 0;
exit;
end;
I := MaxInt(Idx, 0);
J := MinInt(Count, L - I);
for K := I to L - J - 1 do
V[K] := V[K + J];
SetLength(V, L - J);
Result := J;
end;
function DynArrayRemove(var V: InterfaceArray; const Idx: Integer; const Count: Integer): Integer;
var I, J, K, L, M : Integer;
begin
L := Length(V);
if (Idx >= L) or (Idx + Count <= 0) or (L = 0) or (Count = 0) then
begin
Result := 0;
exit;
end;
I := MaxInt(Idx, 0);
J := MinInt(Count, L - I);
for K := I to I + J - 1 do
V[K] := nil;
M := L - J - I;
if M > 0 then
Move(V[I + J], V[I], M * SizeOf(IInterface));
FillChar(V[L - J], J * SizeOf(IInterface), #0);
SetLength(V, L - J);
Result := J;
end;
{ }
{ DynArrayRemoveDuplicates }
{ }
{%DEFINE DynArrayRemoveDuplicatesImpl}
procedure DynArrayRemoveDuplicates%1%(var V: %2%Array; const IsSorted: Boolean);
var I, C, J, L : Integer;
F : %3%;
begin
L := Length(V);
if L = 0 then
exit;
if IsSorted then
begin
J := 0;
repeat
F := V[J];
I := J + 1;
while (I < L) and (V[I] = F) do
Inc(I);
C := I - J;
if C > 1 then
begin
DynArrayRemove%1%(V, J + 1, C - 1);
Dec(L, C - 1);
Inc(J);
end
else
J := I;
until J >= L;
end else
begin
J := 0;
repeat
repeat
I := DynArrayPosNext%1%(V[J], V, J);
if I >= 0 then
DynArrayRemove%1%(V, I, 1);
until I < 0;
Inc(J);
until J >= Length(V);
end;
end;
{%ENDDEF}
{%TEMPLATE DynArrayRemoveDuplicatesImpl '' 'Byte' 'Byte' }
{%TEMPLATE DynArrayRemoveDuplicatesImpl '' 'Word16' 'Word16' }
{%TEMPLATE DynArrayRemoveDuplicatesImpl '' 'LongWord' 'LongWord' }
{%TEMPLATE DynArrayRemoveDuplicatesImpl '' 'ShortInt' 'ShortInt' }
{%TEMPLATE DynArrayRemoveDuplicatesImpl '' 'SmallInt' 'SmallInt' }
{%TEMPLATE DynArrayRemoveDuplicatesImpl '' 'LongInt' 'LongInt' }
{%TEMPLATE DynArrayRemoveDuplicatesImpl '' 'Int64' 'Int64' }
{%TEMPLATE DynArrayRemoveDuplicatesImpl '' 'Single' 'Single' }
{%TEMPLATE DynArrayRemoveDuplicatesImpl '' 'Double' 'Double' }
{%TEMPLATE DynArrayRemoveDuplicatesImpl '' 'Extended' 'Extended' }
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayRemoveDuplicatesImpl 'A' 'AnsiString' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayRemoveDuplicatesImpl 'U' 'UnicodeString' 'UnicodeString'}
{%TEMPLATE DynArrayRemoveDuplicatesImpl '' 'String' 'String' }
{%TEMPLATE DynArrayRemoveDuplicatesImpl '' 'Pointer' 'Pointer' }
{%DEFINE DynArrayTrimLeftImpl}
procedure DynArrayTrimLeft%1%(var S: %2%Array; const TrimList: array of %3%); overload;
var I, J : Integer;
R : Boolean;
begin
I := 0;
R := True;
while R and (I < Length(S)) do
begin
R := False;
for J := 0 to High(TrimList) do
if S[I] = TrimList[J] then
begin
R := True;
Inc(I);
break;
end;
end;
if I > 0 then
DynArrayRemove%1%(S, 0, I - 1);
end;
{%ENDDEF}
{%TEMPLATE DynArrayTrimLeftImpl '' 'Byte' 'Byte'}
{%TEMPLATE DynArrayTrimLeftImpl '' 'Word16' 'Word16'}
{%TEMPLATE DynArrayTrimLeftImpl '' 'LongWord' 'LongWord'}
{%TEMPLATE DynArrayTrimLeftImpl '' 'ShortInt' 'ShortInt'}
{%TEMPLATE DynArrayTrimLeftImpl '' 'SmallInt' 'SmallInt'}
{%TEMPLATE DynArrayTrimLeftImpl '' 'LongInt' 'LongInt'}
{%TEMPLATE DynArrayTrimLeftImpl '' 'Int64' 'Int64'}
{%TEMPLATE DynArrayTrimLeftImpl '' 'Single' 'Single'}
{%TEMPLATE DynArrayTrimLeftImpl '' 'Double' 'Double'}
{%TEMPLATE DynArrayTrimLeftImpl '' 'Extended' 'Extended'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayTrimLeftImpl 'A' 'AnsiString' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayTrimLeftImpl 'U' 'UnicodeString' 'UnicodeString'}
{%TEMPLATE DynArrayTrimLeftImpl '' 'String' 'String'}
{%TEMPLATE DynArrayTrimLeftImpl '' 'Pointer' 'Pointer'}
{%DEFINE DynArrayTrimRightImpl}
procedure DynArrayTrimRight%1%(var S: %2%Array; const TrimList: array of %3%); overload;
var I, J : Integer;
R : Boolean;
begin
I := Length(S) - 1;
R := True;
while R and (I >= 0) do
begin
R := False;
for J := 0 to High(TrimList) do
if S[I] = TrimList[J] then
begin
R := True;
Dec(I);
break;
end;
end;
if I < Length(S) - 1 then
SetLength(S, I + 1);
end;
{%ENDDEF}
{%TEMPLATE DynArrayTrimRightImpl '' 'Byte' 'Byte'}
{%TEMPLATE DynArrayTrimRightImpl '' 'Word16' 'Word16'}
{%TEMPLATE DynArrayTrimRightImpl '' 'LongWord' 'LongWord'}
{%TEMPLATE DynArrayTrimRightImpl '' 'ShortInt' 'ShortInt'}
{%TEMPLATE DynArrayTrimRightImpl '' 'SmallInt' 'SmallInt'}
{%TEMPLATE DynArrayTrimRightImpl '' 'LongInt' 'LongInt'}
{%TEMPLATE DynArrayTrimRightImpl '' 'Int64' 'Int64'}
{%TEMPLATE DynArrayTrimRightImpl '' 'Single' 'Single'}
{%TEMPLATE DynArrayTrimRightImpl '' 'Double' 'Double'}
{%TEMPLATE DynArrayTrimRightImpl '' 'Extended' 'Extended'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayTrimRightImpl 'A' 'AnsiString' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayTrimRightImpl 'U' 'UnicodeString' 'UnicodeString'}
{%TEMPLATE DynArrayTrimRightImpl '' 'String' 'String'}
{%TEMPLATE DynArrayTrimRightImpl '' 'Pointer' 'Pointer'}
{ }
{ DynArrayInsert }
{ }
{%DEFINE DynArrayInsertImpl}
function DynArrayInsert%1%(var V: %2%Array; const Idx: Integer; const Count: Integer): Integer;
var I, L : Integer;
P : Pointer;
begin
L := Length(V);
if (Idx > L) or (Idx + Count <= 0) or (Count <= 0) then
begin
Result := -1;
exit;
end;
SetLength(V, L + Count);
I := Idx;
if I < 0 then
I := 0;
P := @V[I];
if I < L then
Move(P^, V[I + Count], (L - I) * Sizeof(%3%));
FillChar(P^, Count * Sizeof(%3%), #0);
Result := I;
end;
{%ENDDEF}
{%TEMPLATE DynArrayInsertImpl '' 'Byte' 'Byte' '0'}
{%TEMPLATE DynArrayInsertImpl '' 'Word16' 'Word16' '0'}
{%TEMPLATE DynArrayInsertImpl '' 'Word32' 'Word32' '0'}
{%TEMPLATE DynArrayInsertImpl '' 'Word64' 'Word64' '0'}
{%TEMPLATE DynArrayInsertImpl '' 'LongWord' 'LongWord' '0'}
{%TEMPLATE DynArrayInsertImpl '' 'NativeUInt' 'NativeUInt' '0'}
{%TEMPLATE DynArrayInsertImpl '' 'ShortInt' 'ShortInt' '0'}
{%TEMPLATE DynArrayInsertImpl '' 'SmallInt' 'SmallInt' '0'}
{%TEMPLATE DynArrayInsertImpl '' 'LongInt' 'LongInt' '0'}
{%TEMPLATE DynArrayInsertImpl '' 'Int32' 'Int32' '0'}
{%TEMPLATE DynArrayInsertImpl '' 'Int64' 'Int64' '0'}
{%TEMPLATE DynArrayInsertImpl '' 'NativeInt' 'NativeInt' '0'}
{%TEMPLATE DynArrayInsertImpl '' 'Single' 'Single' '0.0'}
{%TEMPLATE DynArrayInsertImpl '' 'Double' 'Double' '0.0'}
{%TEMPLATE DynArrayInsertImpl '' 'Extended' 'Extended' '0.0'}
{%TEMPLATE DynArrayInsertImpl '' 'Currency' 'Currency' '0.0'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayInsertImpl 'A' 'AnsiString' 'AnsiString' ''''''}
{$ENDIF}
{%TEMPLATE DynArrayInsertImpl 'B' 'RawByteString' 'RawByteString' ''''''}
{%TEMPLATE DynArrayInsertImpl 'U' 'UnicodeString' 'UnicodeString' ''''''}
{%TEMPLATE DynArrayInsertImpl '' 'String' 'String' ''''''}
{%TEMPLATE DynArrayInsertImpl '' 'Pointer' 'Pointer' 'nil'}
{%TEMPLATE DynArrayInsertImpl '' 'Object' 'Pointer' 'nil'}
{%TEMPLATE DynArrayInsertImpl '' 'Interface' 'IInterface' 'nil'}
{%DEFINE ArrayValue}%1%{%ENDDEF}
{ }
{ DynArrayPosNext }
{ PosNext finds the next occurance of Find in V, -1 if it was not found. }
{ Searches from Item[PrevPos + 1], ie PrevPos = -1 to find first }
{ occurance. }
{ }
{%DEFINE DynArrayPosNextImpl}
function DynArrayPosNext%5%(const %4%: %2%; const V: %1%Array; const PrevPos: Integer;
const IsSortedAscending: Boolean): Integer;
var I, L, H : Integer;
D : %2%;
begin
if IsSortedAscending then // binary search
begin
if MaxInt(PrevPos + 1, 0) = 0 then // find first
begin
L := 0;
H := Length(V) - 1;
while L <= H do
begin
I := (L + H) div 2;
D := {%TEMPLATE %3% 'V[I]'};
if %4% = D then
begin
while (I > 0) and ({%TEMPLATE %3% 'V[I - 1]'} = %4%) do
Dec(I);
Result := I;
exit;
end else
if D > %4% then
H := I - 1
else
L := I + 1;
end;
Result := -1;
end
else // find next
if PrevPos >= Length(V) - 1 then
Result := -1
else
if {%TEMPLATE %3% 'V[PrevPos + 1]'} = %4% then
Result := PrevPos + 1
else
Result := -1;
end
else
begin // linear search
for I := MaxInt(PrevPos + 1, 0) to Length(V) - 1 do
if {%TEMPLATE %3% 'V[I]'} = %4% then
begin
Result := I;
exit;
end;
Result := -1;
end;
end;
{%ENDDEF}
{%DEFINE DynArrayPosNextArrayImpl}{%TEMPLATE DynArrayPosNextImpl '%2%' '%3%' 'ArrayValue' 'Find' '%1%'}{%ENDDEF}
{%TEMPLATE DynArrayPosNextArrayImpl '' 'Byte' 'Byte' }
{%TEMPLATE DynArrayPosNextArrayImpl '' 'Word16' 'Word16' }
{%TEMPLATE DynArrayPosNextArrayImpl '' 'Word32' 'Word32' }
{%TEMPLATE DynArrayPosNextArrayImpl '' 'Word64' 'Word64' }
{%TEMPLATE DynArrayPosNextArrayImpl '' 'LongWord' 'LongWord' }
{%TEMPLATE DynArrayPosNextArrayImpl '' 'Cardinal' 'Cardinal' }
{%TEMPLATE DynArrayPosNextArrayImpl '' 'NativeUInt' 'NativeUInt' }
{%TEMPLATE DynArrayPosNextArrayImpl '' 'ShortInt' 'ShortInt' }
{%TEMPLATE DynArrayPosNextArrayImpl '' 'SmallInt' 'SmallInt' }
{%TEMPLATE DynArrayPosNextArrayImpl '' 'LongInt' 'LongInt' }
{%TEMPLATE DynArrayPosNextArrayImpl '' 'Integer' 'Integer' }
{%TEMPLATE DynArrayPosNextArrayImpl '' 'Int32' 'Int32' }
{%TEMPLATE DynArrayPosNextArrayImpl '' 'Int64' 'Int64' }
{%TEMPLATE DynArrayPosNextArrayImpl '' 'NativeInt' 'NativeInt' }
{%TEMPLATE DynArrayPosNextArrayImpl '' 'Single' 'Single' }
{%TEMPLATE DynArrayPosNextArrayImpl '' 'Double' 'Double' }
{%TEMPLATE DynArrayPosNextArrayImpl '' 'Extended' 'Extended' }
{%TEMPLATE DynArrayPosNextArrayImpl '' 'Boolean' 'Boolean' }
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayPosNextArrayImpl 'A' 'AnsiString' 'AnsiString' }
{$ENDIF}
{%TEMPLATE DynArrayPosNextArrayImpl 'B' 'RawByteString' 'RawByteString' }
{%TEMPLATE DynArrayPosNextArrayImpl 'U' 'UnicodeString' 'UnicodeString' }
{%TEMPLATE DynArrayPosNextArrayImpl '' 'String' 'String' }
function DynArrayPosNext(const Find: TObject; const V: ObjectArray; const PrevPos: Integer): Integer;
var I : Integer;
begin
for I := MaxInt(PrevPos + 1, 0) to Length(V) - 1 do
if V[I] = Find then
begin
Result := I;
exit;
end;
Result := -1;
end;
function DynArrayPosNext(const ClassType: TClass; const V: ObjectArray; const PrevPos: Integer): Integer;
var I : Integer;
begin
for I := MaxInt(PrevPos + 1, 0) to Length(V) - 1 do
if V[I] is ClassType then
begin
Result := I;
exit;
end;
Result := -1;
end;
function DynArrayPosNext(const ClassName: String; const V: ObjectArray; const PrevPos: Integer): Integer;
var I : Integer;
T : TObject;
begin
for I := MaxInt(PrevPos + 1, 0) to Length(V) - 1 do
begin
T := V[I];
if Assigned(T) and (T.ClassName = ClassName) then
begin
Result := I;
exit;
end;
end;
Result := -1;
end;
function DynArrayPosNext(const Find: Pointer; const V: PointerArray; const PrevPos: Integer): Integer;
var I : Integer;
begin
for I := MaxInt(PrevPos + 1, 0) to Length(V) - 1 do
if V[I] = Find then
begin
Result := I;
exit;
end;
Result := -1;
end;
{ }
{ DynArrayCount }
{ }
{%DEFINE DynArrayCountImpl}
function DynArrayCount%1%(const Find: %3%; const V: %2%Array; const IsSortedAscending: Boolean = False): Integer;
var I, J : Integer;
begin
if IsSortedAscending then
begin
I := DynArrayPosNext%1%(Find, V, -1, True);
if I = -1 then
Result := 0 else
begin
Result := 1;
J := Length(V);
while (I + Result < J) and (V[I + Result] = Find) do
Inc(Result);
end;
end
else
begin
J := -1;
Result := 0;
repeat
I := DynArrayPosNext%1%(Find, V, J, False);
if I >= 0 then
begin
Inc(Result);
J := I;
end;
until I < 0;
end;
end;
{%ENDDEF}
{%TEMPLATE DynArrayCountImpl '' 'Byte' 'Byte'}
{%TEMPLATE DynArrayCountImpl '' 'Word16' 'Word16'}
{%TEMPLATE DynArrayCountImpl '' 'LongWord' 'LongWord'}
{%TEMPLATE DynArrayCountImpl '' 'ShortInt' 'ShortInt'}
{%TEMPLATE DynArrayCountImpl '' 'SmallInt' 'SmallInt'}
{%TEMPLATE DynArrayCountImpl '' 'LongInt' 'LongInt'}
{%TEMPLATE DynArrayCountImpl '' 'Int64' 'Int64'}
{%TEMPLATE DynArrayCountImpl '' 'Single' 'Single'}
{%TEMPLATE DynArrayCountImpl '' 'Double' 'Double'}
{%TEMPLATE DynArrayCountImpl '' 'Extended' 'Extended'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayCountImpl 'A' 'AnsiString' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayCountImpl 'B' 'RawByteString' 'RawByteString'}
{%TEMPLATE DynArrayCountImpl 'U' 'UnicodeString' 'UnicodeString'}
{%TEMPLATE DynArrayCountImpl '' 'String' 'String'}
{%TEMPLATE DynArrayCountImpl '' 'Boolean' 'Boolean'}
{ }
{ DynArrayRemoveAll }
{ }
{%DEFINE DynArrayRemoveAllImpl}
procedure DynArrayRemoveAll%1%(const Find: %3%; var V: %2%Array; const IsSortedAscending: Boolean = False);
var I, J : Integer;
begin
I := DynArrayPosNext%1%(Find, V, -1, IsSortedAscending);
while I >= 0 do
begin
J := 1;
while (I + J < Length(V)) and (V[I + J] = Find) do
Inc(J);
DynArrayRemove%1%(V, I, J);
I := DynArrayPosNext%1%(Find, V, I, IsSortedAscending);
end;
end;
{%ENDDEF}
{%TEMPLATE DynArrayRemoveAllImpl '' 'Byte' 'Byte'}
{%TEMPLATE DynArrayRemoveAllImpl '' 'Word16' 'Word16'}
{%TEMPLATE DynArrayRemoveAllImpl '' 'LongWord' 'LongWord'}
{%TEMPLATE DynArrayRemoveAllImpl '' 'ShortInt' 'ShortInt'}
{%TEMPLATE DynArrayRemoveAllImpl '' 'SmallInt' 'SmallInt'}
{%TEMPLATE DynArrayRemoveAllImpl '' 'LongInt' 'LongInt'}
{%TEMPLATE DynArrayRemoveAllImpl '' 'Int64' 'Int64'}
{%TEMPLATE DynArrayRemoveAllImpl '' 'Single' 'Single'}
{%TEMPLATE DynArrayRemoveAllImpl '' 'Double' 'Double'}
{%TEMPLATE DynArrayRemoveAllImpl '' 'Extended' 'Extended'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayRemoveAllImpl 'A' 'AnsiString' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayRemoveAllImpl 'U' 'UnicodeString' 'UnicodeString'}
{%TEMPLATE DynArrayRemoveAllImpl '' 'String' 'String'}
{ }
{ DynArrayIntersection }
{ If both arrays are sorted ascending then time is o(n) instead of o(n^2). }
{ }
{%DEFINE DynArrayIntersectionFloatImpl}
function DynArrayIntersection(const V1, V2: %1%Array; const IsSortedAscending: Boolean): %1%Array;
var I, J, L, LV : Integer;
begin
SetLength(Result, 0);
if IsSortedAscending then
begin
I := 0;
J := 0;
L := Length(V1);
LV := Length(V2);
while (I < L) and (J < LV) do
begin
while (I < L) and (V1[I] < V2[J]) do
Inc(I);
if I < L then
begin
if V1[I] = V2[J] then
DynArrayAppend(Result, V1[I]);
while (J < LV) and (V2[J] <= V1[I]) do
Inc(J);
end;
end;
end
else
for I := 0 to Length(V1) - 1 do
if (DynArrayPosNext(V1[I], V2) >= 0) and (DynArrayPosNext(V1[I], Result) = -1) then
DynArrayAppend(Result, V1[I]);
end;
{%ENDDEF}
{%TEMPLATE DynArrayIntersectionFloatImpl 'Single'}
{%TEMPLATE DynArrayIntersectionFloatImpl 'Double'}
{%TEMPLATE DynArrayIntersectionFloatImpl 'Extended'}
{%DEFINE DynArrayIntersectionImpl}
function DynArrayIntersection%1%(const V1, V2: %2%Array; const IsSortedAscending: Boolean): %2%Array;
var I, J, L, LV : Integer;
begin
SetLength(Result, 0);
if IsSortedAscending then
begin
I := 0;
J := 0;
L := Length(V1);
LV := Length(V2);
while (I < L) and (J < LV) do
begin
while (I < L) and (V1[I] < V2[J]) do
Inc(I);
if I < L then
begin
if V1[I] = V2[J] then
DynArrayAppend%1%(Result, V1[I]);
while (J < LV) and (V2[J] <= V1[I]) do
Inc(J);
end;
end;
end
else
for I := 0 to Length(V1) - 1 do
if (DynArrayPosNext%1%(V1[I], V2) >= 0) and (DynArrayPosNext%1%(V1[I], Result) = -1) then
DynArrayAppend%1%(Result, V1[I]);
end;
{%ENDDEF}
{%TEMPLATE DynArrayIntersectionImpl '' 'Byte'}
{%TEMPLATE DynArrayIntersectionImpl '' 'Word16'}
{%TEMPLATE DynArrayIntersectionImpl '' 'LongWord'}
{%TEMPLATE DynArrayIntersectionImpl '' 'ShortInt'}
{%TEMPLATE DynArrayIntersectionImpl '' 'SmallInt'}
{%TEMPLATE DynArrayIntersectionImpl '' 'LongInt'}
{%TEMPLATE DynArrayIntersectionImpl '' 'Int64'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayIntersectionImpl 'A' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayIntersectionImpl 'U' 'UnicodeString'}
{%TEMPLATE DynArrayIntersectionImpl '' 'String'}
{ }
{ DynArrayDifference }
{ Returns elements in V1 but not in V2. }
{ If both arrays are sorted ascending then time is o(n) instead of o(n^2). }
{ }
{%DEFINE DynArrayDifferenceFloatImpl}
function DynArrayDifference(const V1, V2: %1%Array; const IsSortedAscending: Boolean): %1%Array;
var I, J, L, LV : Integer;
begin
SetLength(Result, 0);
if IsSortedAscending then
begin
I := 0;
J := 0;
L := Length(V1);
LV := Length(V2);
while (I < L) and (J < LV) do
begin
while (I < L) and (V1[I] < V2[J]) do
Inc(I);
if I < L then
begin
if V1[I] <> V2[J] then
DynArrayAppend(Result, V1[I]);
while (J < LV) and (V2[J] <= V1[I]) do
Inc(J);
end;
end;
end
else
for I := 0 to Length(V1) - 1 do
if (DynArrayPosNext(V1[I], V2) = -1) and (DynArrayPosNext(V1[I], Result) = -1) then
DynArrayAppend(Result, V1[I]);
end;
{%ENDDEF}
{%TEMPLATE DynArrayDifferenceFloatImpl 'Single'}
{%TEMPLATE DynArrayDifferenceFloatImpl 'Double'}
{%TEMPLATE DynArrayDifferenceFloatImpl 'Extended'}
{%DEFINE DynArrayDifferenceImpl}
function DynArrayDifference%1%(const V1, V2: %2%Array; const IsSortedAscending: Boolean): %2%Array;
var I, J, L, LV : Integer;
begin
SetLength(Result, 0);
if IsSortedAscending then
begin
I := 0;
J := 0;
L := Length(V1);
LV := Length(V2);
while (I < L) and (J < LV) do
begin
while (I < L) and (V1[I] < V2[J]) do
Inc(I);
if I < L then
begin
if V1[I] <> V2[J] then
DynArrayAppend%1%(Result, V1[I]);
while (J < LV) and (V2[J] <= V1[I]) do
Inc(J);
end;
end;
end
else
for I := 0 to Length(V1) - 1 do
if (DynArrayPosNext%1%(V1[I], V2) = -1) and (DynArrayPosNext%1%(V1[I], Result) = -1) then
DynArrayAppend%1%(Result, V1[I]);
end;
{%ENDDEF}
{%TEMPLATE DynArrayDifferenceImpl '' 'Byte'}
{%TEMPLATE DynArrayDifferenceImpl '' 'Word16'}
{%TEMPLATE DynArrayDifferenceImpl '' 'LongWord'}
{%TEMPLATE DynArrayDifferenceImpl '' 'ShortInt'}
{%TEMPLATE DynArrayDifferenceImpl '' 'SmallInt'}
{%TEMPLATE DynArrayDifferenceImpl '' 'LongInt'}
{%TEMPLATE DynArrayDifferenceImpl '' 'Int64'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayDifferenceImpl 'A' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayDifferenceImpl 'U' 'UnicodeString'}
{%TEMPLATE DynArrayDifferenceImpl '' 'String'}
{ }
{ DynArrayReverse }
{ }
{%DEFINE DynArrayReverseImpl}
procedure DynArrayReverse%1%(var V: %2%Array);
var I, L : Integer;
begin
L := Length(V);
for I := 1 to L div 2 do
Swap%3%(V[I - 1], V[L - I]);
end;
{%ENDDEF}
{%TEMPLATE DynArrayReverseImpl '' 'Byte' ''}
{%TEMPLATE DynArrayReverseImpl '' 'Word16' ''}
{%TEMPLATE DynArrayReverseImpl '' 'LongWord' 'LW'}
{%TEMPLATE DynArrayReverseImpl '' 'ShortInt' ''}
{%TEMPLATE DynArrayReverseImpl '' 'SmallInt' ''}
{%TEMPLATE DynArrayReverseImpl '' 'LongInt' 'LI'}
{%TEMPLATE DynArrayReverseImpl '' 'Int64' ''}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayReverseImpl 'A' 'AnsiString' 'A'}
{$ENDIF}
{%TEMPLATE DynArrayReverseImpl 'U' 'UnicodeString' 'U'}
{%TEMPLATE DynArrayReverseImpl '' 'String' ''}
{%TEMPLATE DynArrayReverseImpl '' 'Pointer' ''}
{%TEMPLATE DynArrayReverseImpl '' 'Object' ''}
{%TEMPLATE DynArrayReverseImpl '' 'Single' ''}
{%TEMPLATE DynArrayReverseImpl '' 'Double' ''}
{%TEMPLATE DynArrayReverseImpl '' 'Extended' 'Ext'}
{ }
{ Returns an open array (V) as a dynamic array. }
{ }
{%DEFINE OpenArrayAsDynArrayImpl}
function As%1%Array(const V: array of %2%): %1%Array;
var I : Integer;
begin
SetLength(Result, High(V) + 1);
for I := 0 to High(V) do
Result[I] := V[I];
end;
{%ENDDEF}
{%TEMPLATE OpenArrayAsDynArrayImpl 'Boolean' 'Boolean'}
{%TEMPLATE OpenArrayAsDynArrayImpl 'Byte' 'Byte'}
{%TEMPLATE OpenArrayAsDynArrayImpl 'Word16' 'Word16'}
{%TEMPLATE OpenArrayAsDynArrayImpl 'Word32' 'Word32'}
{%TEMPLATE OpenArrayAsDynArrayImpl 'Word64' 'Word64'}
{%TEMPLATE OpenArrayAsDynArrayImpl 'LongWord' 'LongWord'}
{%TEMPLATE OpenArrayAsDynArrayImpl 'Cardinal' 'Cardinal'}
{%TEMPLATE OpenArrayAsDynArrayImpl 'NativeUInt' 'NativeUInt'}
{%TEMPLATE OpenArrayAsDynArrayImpl 'ShortInt' 'ShortInt'}
{%TEMPLATE OpenArrayAsDynArrayImpl 'SmallInt' 'SmallInt'}
{%TEMPLATE OpenArrayAsDynArrayImpl 'LongInt' 'LongInt'}
{%TEMPLATE OpenArrayAsDynArrayImpl 'Integer' 'Integer'}
{%TEMPLATE OpenArrayAsDynArrayImpl 'Int32' 'Int32'}
{%TEMPLATE OpenArrayAsDynArrayImpl 'Int64' 'Int64'}
{%TEMPLATE OpenArrayAsDynArrayImpl 'NativeInt' 'NativeInt'}
{%TEMPLATE OpenArrayAsDynArrayImpl 'Single' 'Single'}
{%TEMPLATE OpenArrayAsDynArrayImpl 'Double' 'Double'}
{%TEMPLATE OpenArrayAsDynArrayImpl 'Extended' 'Extended'}
{%TEMPLATE OpenArrayAsDynArrayImpl 'Currency' 'Currency'}
{$IFDEF SupportAnsiString}
{%TEMPLATE OpenArrayAsDynArrayImpl 'AnsiString' 'AnsiString'}
{$ENDIF}
{%TEMPLATE OpenArrayAsDynArrayImpl 'RawByteString' 'RawByteString'}
{%TEMPLATE OpenArrayAsDynArrayImpl 'UnicodeString' 'UnicodeString'}
{%TEMPLATE OpenArrayAsDynArrayImpl 'String' 'String'}
{%TEMPLATE OpenArrayAsDynArrayImpl 'Pointer' 'Pointer'}
{%TEMPLATE OpenArrayAsDynArrayImpl 'ByteCharSet' 'ByteCharSet'}
{%TEMPLATE OpenArrayAsDynArrayImpl 'Object' 'TObject'}
{%TEMPLATE OpenArrayAsDynArrayImpl 'Interface' 'IInterface'}
{%DEFINE DynArrayRangeImpl}
function DynArrayRange%1%(const First: %1%; const Count: Integer; const Increment: %1%): %1%Array;
var I : Integer;
J : %1%;
begin
SetLength(Result, Count);
J := First;
for I := 0 to Count - 1 do
begin
Result[I] := J;
J := J + Increment;
end;
end;
{%ENDDEF}
{%TEMPLATE DynArrayRangeImpl 'Byte'}
{%TEMPLATE DynArrayRangeImpl 'Word16'}
{%TEMPLATE DynArrayRangeImpl 'LongWord'}
{%TEMPLATE DynArrayRangeImpl 'Cardinal'}
{%TEMPLATE DynArrayRangeImpl 'ShortInt'}
{%TEMPLATE DynArrayRangeImpl 'SmallInt'}
{%TEMPLATE DynArrayRangeImpl 'LongInt'}
{%TEMPLATE DynArrayRangeImpl 'Integer'}
{%TEMPLATE DynArrayRangeImpl 'Int64'}
{%TEMPLATE DynArrayRangeImpl 'Single'}
{%TEMPLATE DynArrayRangeImpl 'Double'}
{%TEMPLATE DynArrayRangeImpl 'Extended'}
{ }
{ DynArrayDup }
{ }
function DynArrayDupByte(const V: Byte; const Count: Integer): ByteArray;
begin
if Count <= 0 then
begin
SetLength(Result, 0);
exit;
end;
SetLength(Result, Count);
FillChar(Result[0], Count, V);
end;
{%DEFINE DynArrayDupImpl}
function DynArrayDup%1%(const V: %2%; const Count: Integer): %1%Array;
var I : Integer;
begin
if Count <= 0 then
begin
SetLength(Result, 0);
exit;
end;
SetLength(Result, Count);
for I := 0 to Count - 1 do
Result[I] := V;
end;
{%ENDDEF}
{%TEMPLATE DynArrayDupImpl 'Word16' 'Word16'}
{%TEMPLATE DynArrayDupImpl 'LongWord' 'LongWord'}
{%TEMPLATE DynArrayDupImpl 'Cardinal' 'Cardinal'}
{%TEMPLATE DynArrayDupImpl 'NativeUInt' 'NativeUInt'}
{%TEMPLATE DynArrayDupImpl 'ShortInt' 'ShortInt'}
{%TEMPLATE DynArrayDupImpl 'SmallInt' 'SmallInt'}
{%TEMPLATE DynArrayDupImpl 'LongInt' 'LongInt'}
{%TEMPLATE DynArrayDupImpl 'Integer' 'Integer'}
{%TEMPLATE DynArrayDupImpl 'Int64' 'Int64'}
{%TEMPLATE DynArrayDupImpl 'NativeInt' 'NativeInt'}
{%TEMPLATE DynArrayDupImpl 'Single' 'Single'}
{%TEMPLATE DynArrayDupImpl 'Double' 'Double'}
{%TEMPLATE DynArrayDupImpl 'Extended' 'Extended'}
{%TEMPLATE DynArrayDupImpl 'Currency' 'Currency'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayDupImpl 'AnsiString' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayDupImpl 'UnicodeString' 'UnicodeString'}
{%TEMPLATE DynArrayDupImpl 'String' 'String'}
{%TEMPLATE DynArrayDupImpl 'ByteCharSet' 'ByteCharSet'}
{%TEMPLATE DynArrayDupImpl 'Object' 'TObject'}
{ }
{ SetLengthAndZero }
{ }
{%DEFINE SetLengthAndZeroImpl}
procedure SetLengthAndZero(var V: %1%Array; const NewLength: Integer);
var OldLen, NewLen : Integer;
begin
NewLen := NewLength;
if NewLen < 0 then
NewLen := 0;
OldLen := Length(V);
if OldLen = NewLen then
exit;
SetLength(V, NewLen);
if OldLen > NewLen then
exit;
FillChar(Pointer(@V[OldLen])^, Sizeof(%2%) * (NewLen - OldLen), #0);
end;
{%ENDDEF}
{%TEMPLATE SetLengthAndZeroImpl 'Byte' 'Byte' '0'}
{%TEMPLATE SetLengthAndZeroImpl 'Word16' 'Word16' '0'}
{%TEMPLATE SetLengthAndZeroImpl 'Word32' 'Word32' '0'}
{%TEMPLATE SetLengthAndZeroImpl 'Word64' 'Word64' '0'}
{%TEMPLATE SetLengthAndZeroImpl 'LongWord' 'LongWord' '0'}
{%TEMPLATE SetLengthAndZeroImpl 'Cardinal' 'Cardinal' '0'}
{%TEMPLATE SetLengthAndZeroImpl 'NativeUInt' 'NativeUInt' '0'}
{%TEMPLATE SetLengthAndZeroImpl 'ShortInt' 'ShortInt' '0'}
{%TEMPLATE SetLengthAndZeroImpl 'SmallInt' 'SmallInt' '0'}
{%TEMPLATE SetLengthAndZeroImpl 'LongInt' 'LongInt' '0'}
{%TEMPLATE SetLengthAndZeroImpl 'Integer' 'Integer' '0'}
{%TEMPLATE SetLengthAndZeroImpl 'Int32' 'Int32' '0'}
{%TEMPLATE SetLengthAndZeroImpl 'Int64' 'Int64' '0'}
{%TEMPLATE SetLengthAndZeroImpl 'NativeInt' 'NativeInt' '0'}
{%TEMPLATE SetLengthAndZeroImpl 'Single' 'Single' '0.0'}
{%TEMPLATE SetLengthAndZeroImpl 'Double' 'Double' '0.0'}
{%TEMPLATE SetLengthAndZeroImpl 'Extended' 'Extended' '0.0'}
{%TEMPLATE SetLengthAndZeroImpl 'Currency' 'Currency' '0.0'}
{%TEMPLATE SetLengthAndZeroImpl 'ByteCharSet' 'ByteCharSet' '[]'}
{%TEMPLATE SetLengthAndZeroImpl 'Boolean' 'Boolean' 'False'}
{%TEMPLATE SetLengthAndZeroImpl 'Pointer' 'Pointer' 'nil'}
procedure SetLengthAndZero(var V: ObjectArray; const NewLength: Integer;
const FreeObjects: Boolean);
var I, L : Integer;
begin
L := Length(V);
if L = NewLength then
exit;
if (L > NewLength) and FreeObjects then
for I := NewLength to L - 1 do
FreeAndNil(V[I]);
SetLength(V, NewLength);
if L > NewLength then
exit;
FillChar(V[L], Sizeof(Pointer) * (NewLength - L), #0);
end;
{ }
{ DynArrayIsEqual }
{ }
{%DEFINE DynArrayIsEqualMemImpl}
function DynArrayIsEqual(const V1, V2: %1%Array): Boolean;
var L : Integer;
begin
L := Length(V1);
if L <> Length(V2) then
begin
Result := False;
exit;
end;
Result := EqualMem(Pointer(V1)^, Pointer(V2)^, Sizeof(%1%) * L);
end;
{%ENDDEF}
{%DEFINE DynArrayIsEqualBruteImpl}
function DynArrayIsEqual%1%(const V1, V2: %2%Array): Boolean;
var I, L : Integer;
begin
L := Length(V1);
if L <> Length(V2) then
begin
Result := False;
exit;
end;
for I := 0 to L - 1 do
if V1[I] <> V2[I] then
begin
Result := False;
exit;
end;
Result := True;
end;
{%ENDDEF}
{%TEMPLATE DynArrayIsEqualMemImpl 'Byte'}
{%TEMPLATE DynArrayIsEqualMemImpl 'Word16'}
{%TEMPLATE DynArrayIsEqualMemImpl 'LongWord'}
{%TEMPLATE DynArrayIsEqualMemImpl 'ShortInt'}
{%TEMPLATE DynArrayIsEqualMemImpl 'SmallInt'}
{%TEMPLATE DynArrayIsEqualMemImpl 'LongInt'}
{%TEMPLATE DynArrayIsEqualMemImpl 'Int64'}
{%TEMPLATE DynArrayIsEqualMemImpl 'Single'}
{%TEMPLATE DynArrayIsEqualMemImpl 'Double'}
{%TEMPLATE DynArrayIsEqualMemImpl 'Extended'}
{%TEMPLATE DynArrayIsEqualMemImpl 'Currency'}
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayIsEqualBruteImpl 'A' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayIsEqualBruteImpl 'B' 'RawByteString'}
{%TEMPLATE DynArrayIsEqualBruteImpl 'U' 'UnicodeString'}
{%TEMPLATE DynArrayIsEqualBruteImpl '' 'String'}
{%TEMPLATE DynArrayIsEqualBruteImpl '' 'ByteCharSet'}
{ }
{ Dynamic array to Dynamic array }
{ }
{%DEFINE DynArrayToDynArrayImpl}
function %1%ArrayTo%2%Array(const V: %1%Array): %2%Array;
var I, L : Integer;
begin
L := Length(V);
SetLength(Result, L);
for I := 0 to L - 1 do
Result[I] := %3%V[I]%4%;
end;
{%ENDDEF}
{%TEMPLATE DynArrayToDynArrayImpl 'Byte' 'LongInt' '' ''}
{%TEMPLATE DynArrayToDynArrayImpl 'Word16' 'LongInt' '' ''}
{%TEMPLATE DynArrayToDynArrayImpl 'ShortInt' 'LongInt' '' ''}
{%TEMPLATE DynArrayToDynArrayImpl 'SmallInt' 'LongInt' '' ''}
{%TEMPLATE DynArrayToDynArrayImpl 'LongInt' 'Int64' '' ''}
{%TEMPLATE DynArrayToDynArrayImpl 'LongInt' 'Single' '' ''}
{%TEMPLATE DynArrayToDynArrayImpl 'LongInt' 'Double' '' ''}
{%TEMPLATE DynArrayToDynArrayImpl 'LongInt' 'Extended' '' ''}
{%TEMPLATE DynArrayToDynArrayImpl 'Single' 'Double' '' ''}
{%TEMPLATE DynArrayToDynArrayImpl 'Single' 'Extended' '' ''}
{%TEMPLATE DynArrayToDynArrayImpl 'Single' 'Currency' '' ''}
{%TEMPLATE DynArrayToDynArrayImpl 'Single' 'LongInt' 'LongInt(Trunc(' '))'}
{%TEMPLATE DynArrayToDynArrayImpl 'Single' 'Int64' 'Trunc(' ')'}
{%TEMPLATE DynArrayToDynArrayImpl 'Double' 'Extended' '' ''}
{%TEMPLATE DynArrayToDynArrayImpl 'Double' 'Currency' '' ''}
{%TEMPLATE DynArrayToDynArrayImpl 'Double' 'LongInt' 'LongInt(Trunc(' '))'}
{%TEMPLATE DynArrayToDynArrayImpl 'Double' 'Int64' 'Trunc(' ')'}
{%TEMPLATE DynArrayToDynArrayImpl 'Extended' 'Currency' '' ''}
{%TEMPLATE DynArrayToDynArrayImpl 'Extended' 'LongInt' 'LongInt(Trunc(' '))'}
{%TEMPLATE DynArrayToDynArrayImpl 'Extended' 'Int64' 'Trunc(' ')'}
{ }
{ Array from indexes }
{ }
{%DEFINE DynArrayFromIndexesImpl}
function %1%ArrayFromIndexes(const V: %1%Array; const Indexes: IntegerArray): %1%Array;
var I, L : Integer;
begin
L := Length(Indexes);
SetLength(Result, L);
for I := 0 to L - 1 do
Result[I] := V[Indexes[I]];
end;
{%ENDDEF}
{%TEMPLATE DynArrayFromIndexesImpl 'Byte'}
{%TEMPLATE DynArrayFromIndexesImpl 'Word16'}
{%TEMPLATE DynArrayFromIndexesImpl 'LongWord'}
{%TEMPLATE DynArrayFromIndexesImpl 'Cardinal'}
{%TEMPLATE DynArrayFromIndexesImpl 'ShortInt'}
{%TEMPLATE DynArrayFromIndexesImpl 'SmallInt'}
{%TEMPLATE DynArrayFromIndexesImpl 'LongInt'}
{%TEMPLATE DynArrayFromIndexesImpl 'Integer'}
{%TEMPLATE DynArrayFromIndexesImpl 'Int64'}
{%TEMPLATE DynArrayFromIndexesImpl 'Single'}
{%TEMPLATE DynArrayFromIndexesImpl 'Double'}
{%TEMPLATE DynArrayFromIndexesImpl 'Extended'}
{%TEMPLATE DynArrayFromIndexesImpl 'String'}
{ }
{ Dynamic array sort }
{ }
{%DEFINE DynArraySortImpl}
procedure DynArraySort%1%(const V: %2%Array);
procedure QuickSort(L, R: Integer);
var I, J, M : Integer;
W, T : %3%;
begin
repeat
I := L;
J := R;
M := (L + R) shr 1;
W := V[M];
repeat
while V[I] < W do
Inc(I);
while V[J] > W do
Dec(J);
if I <= J then
begin
T := V[I];
V[I] := V[J];
V[J] := T;
if M = I then
begin
M := J;
W := V[J];
end else
if M = J then
begin
M := I;
W := V[I];
end;
Inc(I);
Dec(J);
end;
until I > J;
if L < J then
QuickSort(L, J);
L := I;
until I >= R;
end;
var I : Integer;
begin
I := Length(V);
if I > 0 then
QuickSort(0, I - 1);
end;
{%ENDDEF}
{%TEMPLATE DynArraySortImpl '' 'Byte' 'Byte' }
{%TEMPLATE DynArraySortImpl '' 'Word16' 'Word16' }
{%TEMPLATE DynArraySortImpl '' 'LongWord' 'LongWord' }
{%TEMPLATE DynArraySortImpl '' 'Cardinal' 'Cardinal' }
{%TEMPLATE DynArraySortImpl '' 'NativeUInt' 'NativeUInt' }
{%TEMPLATE DynArraySortImpl '' 'ShortInt' 'ShortInt' }
{%TEMPLATE DynArraySortImpl '' 'SmallInt' 'SmallInt' }
{%TEMPLATE DynArraySortImpl '' 'LongInt' 'LongInt' }
{%TEMPLATE DynArraySortImpl '' 'Integer' 'Integer' }
{%TEMPLATE DynArraySortImpl '' 'Int64' 'Int64' }
{%TEMPLATE DynArraySortImpl '' 'NativeInt' 'NativeInt' }
{%TEMPLATE DynArraySortImpl '' 'Single' 'Single' }
{%TEMPLATE DynArraySortImpl '' 'Double' 'Double' }
{%TEMPLATE DynArraySortImpl '' 'Extended' 'Extended' }
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArraySortImpl 'A' 'AnsiString' 'AnsiString' }
{$ENDIF}
{%TEMPLATE DynArraySortImpl 'B' 'RawByteString' 'RawByteString' }
{%TEMPLATE DynArraySortImpl 'U' 'UnicodeString' 'UnicodeString' }
{%TEMPLATE DynArraySortImpl '' 'String' 'String' }
{%DEFINE DynArrayPairSortImpl}
procedure DynArraySort(const Key: %1%Array; const Data: %2%Array);
procedure QuickSort(L, R: Integer);
var I, J, M : Integer;
W, T : %3%;
P, Q : P%3%;
A : %4%;
begin
repeat
I := L;
P := @Key[I];
J := R;
Q := @Key[J];
M := (L + R) shr 1;
W := Key[M];
repeat
while P^ < W do
begin
Inc(P);
Inc(I);
end;
while Q^ > W do
begin
Dec(Q);
Dec(J);
end;
if I <= J then
begin
T := P^;
P^ := Q^;
Q^ := T;
A := Data[I];
Data[I] := Data[J];
Data[J] := A;
if M = I then
begin
M := J;
W := Q^;
end else
if M = J then
begin
M := I;
W := P^;
end;
Inc(P);
Inc(I);
Dec(Q);
Dec(J);
end;
until I > J;
if L < J then
QuickSort(L, J);
L := I;
until I >= R;
end;
var I : Integer;
begin
Assert(Length(Key) = Length(Data));
I := Length(Key);
if I > 0 then
QuickSort(0, I - 1);
end;
{%ENDDEF}
{%TEMPLATE DynArrayPairSortImpl 'Integer' 'Integer' 'Integer' 'Integer' }
{%TEMPLATE DynArrayPairSortImpl 'Integer' 'Int64' 'Integer' 'Int64' }
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayPairSortImpl 'Integer' 'AnsiString' 'Integer' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayPairSortImpl 'Integer' 'Extended' 'Integer' 'Extended' }
{%TEMPLATE DynArrayPairSortImpl 'Integer' 'Pointer' 'Integer' 'Pointer' }
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayPairSortImpl 'AnsiString' 'Integer' 'AnsiString' 'Integer' }
{%TEMPLATE DynArrayPairSortImpl 'AnsiString' 'Int64' 'AnsiString' 'Int64' }
{%TEMPLATE DynArrayPairSortImpl 'AnsiString' 'AnsiString' 'AnsiString' 'AnsiString'}
{%TEMPLATE DynArrayPairSortImpl 'AnsiString' 'Extended' 'AnsiString' 'Extended' }
{%TEMPLATE DynArrayPairSortImpl 'AnsiString' 'Pointer' 'AnsiString' 'Pointer' }
{$ENDIF}
{%TEMPLATE DynArrayPairSortImpl 'Extended' 'Integer' 'Extended' 'Integer' }
{%TEMPLATE DynArrayPairSortImpl 'Extended' 'Int64' 'Extended' 'Int64' }
{$IFDEF SupportAnsiString}
{%TEMPLATE DynArrayPairSortImpl 'Extended' 'AnsiString' 'Extended' 'AnsiString'}
{$ENDIF}
{%TEMPLATE DynArrayPairSortImpl 'Extended' 'Extended' 'Extended' 'Extended' }
{%TEMPLATE DynArrayPairSortImpl 'Extended' 'Pointer' 'Extended' 'Pointer' }
{ }
{ Test cases }
{ }
{$IFDEF DYNARRAYS_TEST}
{$ASSERTIONS ON}
procedure Test_IntegerArray;
var S, T : IntegerArray;
F : Integer;
begin
S := nil;
for F := 1 to 100 do
begin
DynArrayAppend(S, F);
Assert(Length(S) = F, 'Append');
Assert(S[F - 1] = F, 'Append');
end;
T := Copy(S);
DynArrayAppendIntegerArray(S, T);
for F := 1 to 100 do
Assert(S[F + 99] = F, 'Append');
Assert(DynArrayPosNext(60, S) = 59, 'PosNext');
Assert(DynArrayPosNext(60, T) = 59, 'PosNext');
Assert(DynArrayPosNext(60, S, 59) = 159, 'PosNext');
Assert(DynArrayPosNext(60, T, 59) = -1, 'PosNext');
Assert(DynArrayPosNext(60, T, -1, True) = 59, 'PosNext');
Assert(DynArrayPosNext(60, T, 59, True) = -1, 'PosNext');
for F := 1 to 100 do
begin
DynArrayRemove(S, DynArrayPosNext(F, S), 1);
Assert(Length(S) = 200 - F, 'Remove');
end;
for F := 99 downto 0 do
begin
DynArrayRemove(S, DynArrayPosNext(F xor 3 + 1, S), 1);
Assert(Length(S) = F, 'Remove');
end;
S := AsIntegerArray([3, 1, 2, 5, 4]);
DynArraySort(S);
Assert(S[0] = 1, 'Sort');
Assert(S[1] = 2, 'Sort');
Assert(S[2] = 3, 'Sort');
Assert(S[3] = 4, 'Sort');
Assert(S[4] = 5, 'Sort');
S := AsIntegerArray([3, 5, 5, 2, 5, 5, 1]);
DynArraySort(S);
Assert(S[0] = 1, 'Sort');
Assert(S[1] = 2, 'Sort');
Assert(S[2] = 3, 'Sort');
Assert(S[3] = 5, 'Sort');
Assert(S[4] = 5, 'Sort');
Assert(S[5] = 5, 'Sort');
Assert(S[6] = 5, 'Sort');
SetLength(S, 1000);
for F := 0 to 999 do
S[F] := F mod 5;
DynArraySort(S);
for F := 0 to 999 do
Assert(S[F] = F div 200, 'Sort');
S := AsIntegerArray([6, 3, 5, 1]);
T := AsIntegerArray([1, 2, 3, 4]);
DynArraySort(S, T);
Assert(S[0] = 1, 'Sort');
Assert(S[1] = 3, 'Sort');
Assert(S[2] = 5, 'Sort');
Assert(S[3] = 6, 'Sort');
Assert(T[0] = 4, 'Sort');
Assert(T[1] = 2, 'Sort');
Assert(T[2] = 3, 'Sort');
Assert(T[3] = 1, 'Sort');
end;
procedure Test_ObjectArray;
var S, T : ObjectArray;
F : Integer;
V : TObject;
begin
S := nil;
V := TObject.Create;
try
for F := 1 to 100 do
begin
DynArrayAppend(S, V);
Assert(Length(S) = F, 'Append');
Assert(S[F - 1] = V, 'Append');
end;
T := Copy(S);
for F := 1 to 10 do
begin
DynArrayRemove(S, F - 1, 1, False);
Assert(Length(S) = 100 - F, 'Remove');
end;
DynArrayRemove(S, 89, 1, False);
Assert(Length(S) = 89, 'Remove');
DynArrayRemove(S, 87, 1, False);
Assert(Length(S) = 88, 'Remove');
DynArrayAppendObjectArray(S, T);
Assert(Length(S) = 188, 'AppendObjectArray');
DynArrayRemove(S, 10, 88, False);
Assert(Length(S) = 100, 'Remove');
DynArrayRemove(S, 0, 100, False);
Assert(Length(S) = 0, 'Remove');
finally
V.Free;
end;
end;
procedure Test_StringArray;
var S, T : StringArray;
U : String;
F : Integer;
begin
S := nil;
for F := 1 to 100 do
begin
U := IntToStr(F);
DynArrayAppend(S, U);
Assert(Length(S) = F, 'Append');
Assert(S[F - 1] = U, 'Append');
end;
T := Copy(S);
DynArrayAppendStringArray(S, T);
for F := 1 to 100 do
Assert(S[F + 99] = IntToStr(F), 'Append');
Assert(DynArrayPosNext('60', S) = 59, 'PosNext');
Assert(DynArrayPosNext('60', T) = 59, 'PosNext');
Assert(DynArrayPosNext('60', S, 59) = 159, 'PosNext');
Assert(DynArrayPosNext('60', T, 59) = -1, 'PosNext');
Assert(DynArrayPosNext('60', T, -1, True) = 59, 'PosNext');
Assert(DynArrayPosNext('60', T, 59, True) = -1, 'PosNext');
for F := 1 to 100 do
begin
DynArrayRemove(S, DynArrayPosNext(IntToStr(F), S), 1);
Assert(Length(S) = 200 - F, 'Remove');
end;
for F := 99 downto 0 do
begin
DynArrayRemove(S, DynArrayPosNext(IntToStr(F xor 3 + 1), S), 1);
Assert(Length(S) = F, 'Remove');
end;
S := AsStringArray(['3', '1', '2', '5', '4']);
DynArraySort(S);
Assert(S[0] = '1', 'Sort');
Assert(S[1] = '2', 'Sort');
Assert(S[2] = '3', 'Sort');
Assert(S[3] = '4', 'Sort');
Assert(S[4] = '5', 'Sort');
S := AsStringArray(['3', '5', '5', '2', '5', '5', '1']);
DynArraySort(S);
Assert(S[0] = '1', 'Sort');
Assert(S[1] = '2', 'Sort');
Assert(S[2] = '3', 'Sort');
Assert(S[3] = '5', 'Sort');
Assert(S[4] = '5', 'Sort');
Assert(S[5] = '5', 'Sort');
Assert(S[6] = '5', 'Sort');
SetLength(S, 1000);
for F := 0 to 999 do
S[F] := IntToStr(F mod 5);
DynArraySort(S);
for F := 0 to 999 do
Assert(S[F] = IntToStr(F div 200), 'Sort');
end;
procedure Test;
begin
Test_IntegerArray;
Test_ObjectArray;
Test_StringArray;
end;
{$ENDIF}
end.
Reference in New Issue View Git Blame Copy Permalink