Copy disabled (too large)
Download .txt
Showing preview only (45,929K chars total). Download the full file to get everything.
Repository: yavfast/dbg-spider
Branch: master
Commit: 0f3a2af24dfe
Files: 1372
Total size: 43.6 MB
Directory structure:
gitextract_1k5rhwaz/
├── ClassUtils.pas
├── CollectList.inc
├── CollectList.pas
├── CollectListIntf.inc
├── Collections/
│ ├── Collections.Bags.pas
│ ├── Collections.Base.pas
│ ├── Collections.BidiDictionaries.pas
│ ├── Collections.BidiMaps.pas
│ ├── Collections.Dictionaries.pas
│ ├── Collections.Dynamic.pas
│ ├── Collections.Lists.pas
│ ├── Collections.MultiMaps.pas
│ ├── Collections.Queues.pas
│ ├── Collections.Serialization.pas
│ ├── Collections.Sets.pas
│ ├── Collections.Stacks.pas
│ ├── Collections.dpk
│ ├── Collections.dproj
│ ├── Collections.identcache
│ ├── Collections.res
│ └── Collections_project.tvsconfig
├── DbgCodeProfiler.pas
├── DbgHook32.dpr
├── DbgHook32.dproj
├── DbgHook32.res
├── DbgHookCS.pas
├── DbgHookMemory.pas
├── DbgHookPerf.pas
├── DbgHookSyncObjs.pas
├── DbgHookThread.pas
├── DbgHookTypes.pas
├── DbgHookUtils.pas
├── DbgMemoryProfiler.pas
├── DbgSamplingProfiler.pas
├── DbgSyncObjsProfiler.pas
├── DbgWorkerThread.pas
├── DebugHook.pas
├── DebugInfo.pas
├── Debuger.pas
├── DebugerTypes.pas
├── DelphiDebugInfo.pas
├── External/
│ ├── Jedi/
│ │ ├── Jcl/
│ │ │ └── source/
│ │ │ ├── common/
│ │ │ │ ├── Jcl8087.pas
│ │ │ │ ├── JclAbstractContainers.pas
│ │ │ │ ├── JclAlgorithms.pas
│ │ │ │ ├── JclAnsiStrings.pas
│ │ │ │ ├── JclArrayLists.pas
│ │ │ │ ├── JclArraySets.pas
│ │ │ │ ├── JclBase.pas
│ │ │ │ ├── JclBinaryTrees.pas
│ │ │ │ ├── JclCharsets.pas
│ │ │ │ ├── JclCompilerUtils.pas
│ │ │ │ ├── JclComplex.pas
│ │ │ │ ├── JclCompression.pas
│ │ │ │ ├── JclContainerIntf.pas
│ │ │ │ ├── JclCounter.pas
│ │ │ │ ├── JclDateTime.pas
│ │ │ │ ├── JclDevToolsResources.pas
│ │ │ │ ├── JclExprEval.pas
│ │ │ │ ├── JclFileUtils.pas
│ │ │ │ ├── JclHashMaps.pas
│ │ │ │ ├── JclHashSets.pas
│ │ │ │ ├── JclIDEUtils.pas
│ │ │ │ ├── JclIniFiles.pas
│ │ │ │ ├── JclLinkedLists.pas
│ │ │ │ ├── JclLogic.pas
│ │ │ │ ├── JclMIDI.pas
│ │ │ │ ├── JclMath.pas
│ │ │ │ ├── JclMime.pas
│ │ │ │ ├── JclNotify.pas
│ │ │ │ ├── JclPCRE.pas
│ │ │ │ ├── JclPreProcessorAlgorithmsTemplates.pas
│ │ │ │ ├── JclPreProcessorArrayListsTemplates.pas
│ │ │ │ ├── JclPreProcessorArraySetsTemplates.pas
│ │ │ │ ├── JclPreProcessorBinaryTreesTemplates.pas
│ │ │ │ ├── JclPreProcessorContainer1DTemplates.pas
│ │ │ │ ├── JclPreProcessorContainer2DTemplates.pas
│ │ │ │ ├── JclPreProcessorContainerIntfTemplates.pas
│ │ │ │ ├── JclPreProcessorContainerKnownMaps.pas
│ │ │ │ ├── JclPreProcessorContainerKnownTypes.pas
│ │ │ │ ├── JclPreProcessorContainerTemplates.pas
│ │ │ │ ├── JclPreProcessorContainerTypes.pas
│ │ │ │ ├── JclPreProcessorExcDlgTemplates.pas
│ │ │ │ ├── JclPreProcessorHashMapsTemplates.pas
│ │ │ │ ├── JclPreProcessorHashSetsTemplates.pas
│ │ │ │ ├── JclPreProcessorLexer.pas
│ │ │ │ ├── JclPreProcessorLinkedListsTemplates.pas
│ │ │ │ ├── JclPreProcessorParser.pas
│ │ │ │ ├── JclPreProcessorQueuesTemplates.pas
│ │ │ │ ├── JclPreProcessorSortedMapsTemplates.pas
│ │ │ │ ├── JclPreProcessorStacksTemplates.pas
│ │ │ │ ├── JclPreProcessorTemplates.pas
│ │ │ │ ├── JclPreProcessorTreesTemplates.pas
│ │ │ │ ├── JclPreProcessorVectorsTemplates.pas
│ │ │ │ ├── JclQueues.pas
│ │ │ │ ├── JclRTTI.pas
│ │ │ │ ├── JclResources.pas
│ │ │ │ ├── JclSchedule.pas
│ │ │ │ ├── JclSimpleXml.pas
│ │ │ │ ├── JclSortedMaps.pas
│ │ │ │ ├── JclStacks.pas
│ │ │ │ ├── JclStatistics.pas
│ │ │ │ ├── JclStrHashMap.pas
│ │ │ │ ├── JclStreams.pas
│ │ │ │ ├── JclStringConversions.pas
│ │ │ │ ├── JclStringLists.pas
│ │ │ │ ├── JclStrings.pas
│ │ │ │ ├── JclSynch.pas
│ │ │ │ ├── JclSysInfo.pas
│ │ │ │ ├── JclSysUtils.pas
│ │ │ │ ├── JclTrees.pas
│ │ │ │ ├── JclUnicode.pas
│ │ │ │ ├── JclUnicode.rc
│ │ │ │ ├── JclUnicode.res
│ │ │ │ ├── JclUnicodeBZip2.res
│ │ │ │ ├── JclUnicodeBzip2.rc
│ │ │ │ ├── JclUnicodeZLib.rc
│ │ │ │ ├── JclUnicodeZLib.res
│ │ │ │ ├── JclUnitConv.pas
│ │ │ │ ├── JclUnitVersioning.pas
│ │ │ │ ├── JclUnitVersioningProviders.pas
│ │ │ │ ├── JclUsesUtils.pas
│ │ │ │ ├── JclValidation.pas
│ │ │ │ ├── JclVectors.pas
│ │ │ │ ├── JclWideStrings.pas
│ │ │ │ ├── bzip2.pas
│ │ │ │ ├── dirinfo.txt
│ │ │ │ ├── pcre.pas
│ │ │ │ ├── zconf.h
│ │ │ │ ├── zlib.h
│ │ │ │ └── zlibh.pas
│ │ │ ├── include/
│ │ │ │ ├── crossplatform.inc
│ │ │ │ ├── jcl.inc
│ │ │ │ ├── jcl.template.inc
│ │ │ │ ├── jcld17win32.inc
│ │ │ │ ├── jcld17win64.inc
│ │ │ │ ├── jedi/
│ │ │ │ │ ├── jedi.inc
│ │ │ │ │ └── kylix.inc
│ │ │ │ ├── unixonly.inc
│ │ │ │ └── windowsonly.inc
│ │ │ └── windows/
│ │ │ ├── Hardlinks.pas
│ │ │ ├── JclAppInst.pas
│ │ │ ├── JclCIL.pas
│ │ │ ├── JclCLR.pas
│ │ │ ├── JclCOM.pas
│ │ │ ├── JclCommCtrlAdmin.manifest
│ │ │ ├── JclCommCtrlAdmin.rc
│ │ │ ├── JclCommCtrlAdmin.res
│ │ │ ├── JclCommCtrlAsInvoker.manifest
│ │ │ ├── JclCommCtrlAsInvoker.rc
│ │ │ ├── JclCommCtrlAsInvoker.res
│ │ │ ├── JclConsole.pas
│ │ │ ├── JclCppException.pas
│ │ │ ├── JclDebug.pas
│ │ │ ├── JclDebugSerialization.pas
│ │ │ ├── JclDebugXMLDeserializer.pas
│ │ │ ├── JclDebugXMLSerializer.pas
│ │ │ ├── JclDotNet.pas
│ │ │ ├── JclHelpUtils.pas
│ │ │ ├── JclHookExcept.pas
│ │ │ ├── JclLANMan.pas
│ │ │ ├── JclLocales.pas
│ │ │ ├── JclMapi.pas
│ │ │ ├── JclMetadata.pas
│ │ │ ├── JclMiscel.pas
│ │ │ ├── JclMsBuild.pas
│ │ │ ├── JclMsdosSys.pas
│ │ │ ├── JclMultimedia.pas
│ │ │ ├── JclNTFS.pas
│ │ │ ├── JclNoDepAdmin.manifest
│ │ │ ├── JclNoDepAdmin.rc
│ │ │ ├── JclNoDepAdmin.res
│ │ │ ├── JclNoDepAsInvoker.manifest
│ │ │ ├── JclNoDepAsInvoker.rc
│ │ │ ├── JclNoDepAsInvoker.res
│ │ │ ├── JclPeImage.pas
│ │ │ ├── JclRegistry.pas
│ │ │ ├── JclSecurity.pas
│ │ │ ├── JclShell.pas
│ │ │ ├── JclStructStorage.pas
│ │ │ ├── JclSvcCtrl.pas
│ │ │ ├── JclTD32.pas
│ │ │ ├── JclTask.pas
│ │ │ ├── JclTimeZones.pas
│ │ │ ├── JclWin32.pas
│ │ │ ├── JclWin32Ex.pas
│ │ │ ├── JclWinMIDI.pas
│ │ │ ├── MSHelpServices_TLB.pas
│ │ │ ├── MSTask.pas
│ │ │ ├── Snmp.pas
│ │ │ ├── dirinfo.txt
│ │ │ ├── mscoree_TLB.pas
│ │ │ ├── mscorlib_TLB.pas
│ │ │ ├── obj/
│ │ │ │ ├── bzip2/
│ │ │ │ │ ├── win32/
│ │ │ │ │ │ ├── blocksort.obj
│ │ │ │ │ │ ├── bzlib.obj
│ │ │ │ │ │ ├── compress.obj
│ │ │ │ │ │ ├── crctable.obj
│ │ │ │ │ │ ├── decompress.obj
│ │ │ │ │ │ ├── dirinfo.txt
│ │ │ │ │ │ ├── huffman.obj
│ │ │ │ │ │ ├── makefile.mak
│ │ │ │ │ │ └── randtable.obj
│ │ │ │ │ └── win64/
│ │ │ │ │ ├── blocksort.obj
│ │ │ │ │ ├── bzlib.obj
│ │ │ │ │ ├── compress.obj
│ │ │ │ │ ├── crctable.obj
│ │ │ │ │ ├── decompress.obj
│ │ │ │ │ ├── dirinfo.txt
│ │ │ │ │ ├── huffman.obj
│ │ │ │ │ ├── makefile.mak
│ │ │ │ │ └── randtable.obj
│ │ │ │ ├── pcre/
│ │ │ │ │ ├── win32/
│ │ │ │ │ │ ├── dirinfo.txt
│ │ │ │ │ │ ├── makefile.mak
│ │ │ │ │ │ ├── pcre16_chartables.obj
│ │ │ │ │ │ ├── pcre16_compile.obj
│ │ │ │ │ │ ├── pcre16_config.obj
│ │ │ │ │ │ ├── pcre16_dfa_exec.obj
│ │ │ │ │ │ ├── pcre16_exec.obj
│ │ │ │ │ │ ├── pcre16_fullinfo.obj
│ │ │ │ │ │ ├── pcre16_get.obj
│ │ │ │ │ │ ├── pcre16_jit_compile.obj
│ │ │ │ │ │ ├── pcre16_maketables.obj
│ │ │ │ │ │ ├── pcre16_newline.obj
│ │ │ │ │ │ ├── pcre16_ord2utf16.obj
│ │ │ │ │ │ ├── pcre16_refcount.obj
│ │ │ │ │ │ ├── pcre16_string_utils.obj
│ │ │ │ │ │ ├── pcre16_study.obj
│ │ │ │ │ │ ├── pcre16_tables.obj
│ │ │ │ │ │ ├── pcre16_ucd.obj
│ │ │ │ │ │ ├── pcre16_valid_utf16.obj
│ │ │ │ │ │ ├── pcre16_version.obj
│ │ │ │ │ │ ├── pcre16_xclass.obj
│ │ │ │ │ │ ├── pcre_chartables.obj
│ │ │ │ │ │ ├── pcre_compile.obj
│ │ │ │ │ │ ├── pcre_config.obj
│ │ │ │ │ │ ├── pcre_dfa_exec.obj
│ │ │ │ │ │ ├── pcre_exec.obj
│ │ │ │ │ │ ├── pcre_fullinfo.obj
│ │ │ │ │ │ ├── pcre_get.obj
│ │ │ │ │ │ ├── pcre_jit_compile.obj
│ │ │ │ │ │ ├── pcre_maketables.obj
│ │ │ │ │ │ ├── pcre_newline.obj
│ │ │ │ │ │ ├── pcre_ord2utf8.obj
│ │ │ │ │ │ ├── pcre_refcount.obj
│ │ │ │ │ │ ├── pcre_study.obj
│ │ │ │ │ │ ├── pcre_tables.obj
│ │ │ │ │ │ ├── pcre_ucd.obj
│ │ │ │ │ │ ├── pcre_valid_utf8.obj
│ │ │ │ │ │ ├── pcre_version.obj
│ │ │ │ │ │ └── pcre_xclass.obj
│ │ │ │ │ └── win64/
│ │ │ │ │ ├── dirinfo.txt
│ │ │ │ │ ├── makefile.mak
│ │ │ │ │ ├── pcre16_chartables.obj
│ │ │ │ │ ├── pcre16_compile.obj
│ │ │ │ │ ├── pcre16_config.obj
│ │ │ │ │ ├── pcre16_dfa_exec.obj
│ │ │ │ │ ├── pcre16_exec.obj
│ │ │ │ │ ├── pcre16_fullinfo.obj
│ │ │ │ │ ├── pcre16_get.obj
│ │ │ │ │ ├── pcre16_jit_compile.obj
│ │ │ │ │ ├── pcre16_maketables.obj
│ │ │ │ │ ├── pcre16_newline.obj
│ │ │ │ │ ├── pcre16_ord2utf16.obj
│ │ │ │ │ ├── pcre16_refcount.obj
│ │ │ │ │ ├── pcre16_string_utils.obj
│ │ │ │ │ ├── pcre16_study.obj
│ │ │ │ │ ├── pcre16_tables.obj
│ │ │ │ │ ├── pcre16_ucd.obj
│ │ │ │ │ ├── pcre16_valid_utf16.obj
│ │ │ │ │ ├── pcre16_version.obj
│ │ │ │ │ ├── pcre16_xclass.obj
│ │ │ │ │ ├── pcre_chartables.obj
│ │ │ │ │ ├── pcre_compile.obj
│ │ │ │ │ ├── pcre_config.obj
│ │ │ │ │ ├── pcre_dfa_exec.obj
│ │ │ │ │ ├── pcre_exec.obj
│ │ │ │ │ ├── pcre_fullinfo.obj
│ │ │ │ │ ├── pcre_get.obj
│ │ │ │ │ ├── pcre_jit_compile.obj
│ │ │ │ │ ├── pcre_maketables.obj
│ │ │ │ │ ├── pcre_newline.obj
│ │ │ │ │ ├── pcre_ord2utf8.obj
│ │ │ │ │ ├── pcre_refcount.obj
│ │ │ │ │ ├── pcre_study.obj
│ │ │ │ │ ├── pcre_tables.obj
│ │ │ │ │ ├── pcre_ucd.obj
│ │ │ │ │ ├── pcre_valid_utf8.obj
│ │ │ │ │ ├── pcre_version.obj
│ │ │ │ │ └── pcre_xclass.obj
│ │ │ │ └── zlib/
│ │ │ │ ├── win32/
│ │ │ │ │ ├── adler32.obj
│ │ │ │ │ ├── compress.obj
│ │ │ │ │ ├── crc32.obj
│ │ │ │ │ ├── deflate.obj
│ │ │ │ │ ├── dirinfo.txt
│ │ │ │ │ ├── infback.obj
│ │ │ │ │ ├── inffast.obj
│ │ │ │ │ ├── inflate.obj
│ │ │ │ │ ├── inftrees.obj
│ │ │ │ │ ├── makefile.mak
│ │ │ │ │ ├── trees.obj
│ │ │ │ │ ├── uncompr.obj
│ │ │ │ │ └── zutil.obj
│ │ │ │ └── win64/
│ │ │ │ ├── adler32.obj
│ │ │ │ ├── compress.obj
│ │ │ │ ├── crc32.obj
│ │ │ │ ├── deflate.obj
│ │ │ │ ├── dirinfo.txt
│ │ │ │ ├── infback.obj
│ │ │ │ ├── inffast.obj
│ │ │ │ ├── inflate.obj
│ │ │ │ ├── inftrees.obj
│ │ │ │ ├── makefile.mak
│ │ │ │ ├── trees.obj
│ │ │ │ ├── uncompr.obj
│ │ │ │ └── zutil.obj
│ │ │ └── sevenzip.pas
│ │ └── Jvcl/
│ │ ├── common/
│ │ │ ├── common.txt
│ │ │ ├── crossplatform.inc
│ │ │ ├── jedi/
│ │ │ │ ├── jedi.inc
│ │ │ │ └── kylix.inc
│ │ │ ├── jvcl.inc
│ │ │ ├── jvclbase.inc
│ │ │ ├── jvclc6.inc
│ │ │ ├── jvcld10.inc
│ │ │ ├── jvcld11.inc
│ │ │ ├── jvcld12.inc
│ │ │ ├── jvcld14.inc
│ │ │ ├── jvcld15.inc
│ │ │ ├── jvcld16.inc
│ │ │ ├── jvcld16_x64.inc
│ │ │ ├── jvcld17.inc
│ │ │ ├── jvcld17_x64.inc
│ │ │ ├── jvcld6.inc
│ │ │ ├── jvcld7.inc
│ │ │ ├── jvcld9.inc
│ │ │ ├── linuxonly.inc
│ │ │ ├── windowsonly.inc
│ │ │ └── windowsversion.inc
│ │ ├── resources/
│ │ │ ├── JvAppFrmReg.dcr
│ │ │ ├── JvBDEReg.dcr
│ │ │ ├── JvBaseEdits.res
│ │ │ ├── JvCSVBase.res
│ │ │ ├── JvCalc.res
│ │ │ ├── JvCheckmarks.res
│ │ │ ├── JvCmpReg.dcr
│ │ │ ├── JvColorCombo.res
│ │ │ ├── JvComponentPanel.res
│ │ │ ├── JvConsts.res
│ │ │ ├── JvControlsReg.dcr
│ │ │ ├── JvCoreReg.dcr
│ │ │ ├── JvCryptReg.dcr
│ │ │ ├── JvCtrls.res
│ │ │ ├── JvCustomReg.dcr
│ │ │ ├── JvDBControls.res
│ │ │ ├── JvDBGrid.res
│ │ │ ├── JvDBReg.dcr
│ │ │ ├── JvDice.res
│ │ │ ├── JvDlgsReg.dcr
│ │ │ ├── JvDockingReg.dcr
│ │ │ ├── JvDotNetCtrlsReg.dcr
│ │ │ ├── JvErrorIndicator.res
│ │ │ ├── JvExplorerBar.res
│ │ │ ├── JvGammaPanel.res
│ │ │ ├── JvGlobusReg.dcr
│ │ │ ├── JvHMIReg.dcr
│ │ │ ├── JvJansReg.dcr
│ │ │ ├── JvLED.res
│ │ │ ├── JvMMReg.dcr
│ │ │ ├── JvManagedThreadsReg.dcr
│ │ │ ├── JvNetReg.dcr
│ │ │ ├── JvOutlookBar.res
│ │ │ ├── JvPageListTreeViewReg.dcr
│ │ │ ├── JvPageSetupTitled.res
│ │ │ ├── JvPascalInterpreterReg.dcr
│ │ │ ├── JvPluginSystemReg.dcr
│ │ │ ├── JvPluginWiz.res
│ │ │ ├── JvPoweredBy.res
│ │ │ ├── JvPreviewReg.dcr
│ │ │ ├── JvQConsts.res
│ │ │ ├── JvQErrorIndicator.res
│ │ │ ├── JvRegistryTreeView.res
│ │ │ ├── JvRuntimeDesign.res
│ │ │ ├── JvRuntimeDesignReg.dcr
│ │ │ ├── JvScrollMax.res
│ │ │ ├── JvSegmentedLEDDisplay.res
│ │ │ ├── JvSimImages.res
│ │ │ ├── JvSlider.res
│ │ │ ├── JvSpin.res
│ │ │ ├── JvStdCtrlsReg.dcr
│ │ │ ├── JvSwitch.res
│ │ │ ├── JvSystemReg.dcr
│ │ │ ├── JvTMTimeLine.res
│ │ │ ├── JvTimeFrameWorkReg.dcr
│ │ │ ├── JvTimeLine.res
│ │ │ ├── JvTipOfDay.res
│ │ │ ├── JvToolEdit.res
│ │ │ ├── JvWinampLabel.res
│ │ │ ├── JvWizardsReg.dcr
│ │ │ ├── JvXPBar.res
│ │ │ ├── JvXPCore.res
│ │ │ ├── JvXPCtrlsReg.dcr
│ │ │ ├── JvgButton.res
│ │ │ ├── JvgCaption.res
│ │ │ ├── JvgCheckBox.res
│ │ │ ├── JvgHint.res
│ │ │ ├── JvgLabelEditorForm.res
│ │ │ ├── JvxCheckListBox.res
│ │ │ ├── JvxSlider.res
│ │ │ └── resources.txt
│ │ └── run/
│ │ ├── Cfg.pas
│ │ ├── CfgMgr32.pas
│ │ ├── DBT.pas
│ │ ├── Hid.pas
│ │ ├── HidToken.pas
│ │ ├── HidUsage.pas
│ │ ├── JVCLVer.pas
│ │ ├── JvADOQuery.pas
│ │ ├── JvAVICapture.pas
│ │ ├── JvActions.pas
│ │ ├── JvActionsEngine.pas
│ │ ├── JvAddPrinter.pas
│ │ ├── JvAirBrush.pas
│ │ ├── JvAlarms.pas
│ │ ├── JvAni.pas
│ │ ├── JvAnimTitle.pas
│ │ ├── JvAnimate.pas
│ │ ├── JvAnimatedImage.pas
│ │ ├── JvAppAnimatedIcon.pas
│ │ ├── JvAppCommand.pas
│ │ ├── JvAppDBStorage.pas
│ │ ├── JvAppEvent.pas
│ │ ├── JvAppHotKey.pas
│ │ ├── JvAppIniStorage.pas
│ │ ├── JvAppInst.pas
│ │ ├── JvAppRegistryStorage.pas
│ │ ├── JvAppStorage.pas
│ │ ├── JvAppStoragePropertyEngineDB.pas
│ │ ├── JvAppStorageSelectList.pas
│ │ ├── JvAppXMLStorage.pas
│ │ ├── JvArrayButton.pas
│ │ ├── JvArrowButton.pas
│ │ ├── JvAutoComplete.pas
│ │ ├── JvBDECheckPasswordForm.dfm
│ │ ├── JvBDECheckPasswordForm.pas
│ │ ├── JvBDEExceptionForm.dfm
│ │ ├── JvBDEExceptionForm.pas
│ │ ├── JvBDEFilter.pas
│ │ ├── JvBDEIndex.pas
│ │ ├── JvBDELists.pas
│ │ ├── JvBDELoginDialog.pas
│ │ ├── JvBDEMemTable.pas
│ │ ├── JvBDEMove.pas
│ │ ├── JvBDEProgress.pas
│ │ ├── JvBDEQBE.pas
│ │ ├── JvBDEQuery.pas
│ │ ├── JvBDESQLScript.pas
│ │ ├── JvBDESecurity.pas
│ │ ├── JvBackgrounds.pas
│ │ ├── JvBalloonHint.pas
│ │ ├── JvBandForms.pas
│ │ ├── JvBandObject.pas
│ │ ├── JvBaseDBDialog.pas
│ │ ├── JvBaseDBLogonDialog.pas
│ │ ├── JvBaseDBPasswordDialog.pas
│ │ ├── JvBaseDBThreadedDataset.pas
│ │ ├── JvBaseDlg.pas
│ │ ├── JvBaseEdits.pas
│ │ ├── JvBaseThumbnail.pas
│ │ ├── JvBdeUtils.pas
│ │ ├── JvBehaviorLabel.pas
│ │ ├── JvBevel.pas
│ │ ├── JvBitBtn.pas
│ │ ├── JvBitmapButton.pas
│ │ ├── JvBmpAnimator.pas
│ │ ├── JvBoxProcs.pas
│ │ ├── JvBrowseFolder.pas
│ │ ├── JvButton.pas
│ │ ├── JvButtonPersistent.pas
│ │ ├── JvButtons.pas
│ │ ├── JvCSVBaseControls.pas
│ │ ├── JvCabFile.pas
│ │ ├── JvCalc.pas
│ │ ├── JvCalendar.pas
│ │ ├── JvCaptionButton.pas
│ │ ├── JvCaptionPanel.pas
│ │ ├── JvCaret.pas
│ │ ├── JvChangeNotify.pas
│ │ ├── JvCharMap.pas
│ │ ├── JvChart.pas
│ │ ├── JvCheckBox.pas
│ │ ├── JvCheckListBox.pas
│ │ ├── JvCheckTreeView.pas
│ │ ├── JvCheckedMaskEdit.pas
│ │ ├── JvCipher.pas
│ │ ├── JvClipboardMonitor.pas
│ │ ├── JvClipboardViewer.pas
│ │ ├── JvClipbrd.pas
│ │ ├── JvClock.pas
│ │ ├── JvColorBox.pas
│ │ ├── JvColorButton.pas
│ │ ├── JvColorCombo.pas
│ │ ├── JvColorForm.pas
│ │ ├── JvColorProvider.pas
│ │ ├── JvColorTrackbar.pas
│ │ ├── JvComCtrls.pas
│ │ ├── JvComboListBox.pas
│ │ ├── JvCombobox.pas
│ │ ├── JvCommStatus.pas
│ │ ├── JvCommonExecDlg.pas
│ │ ├── JvComponent.pas
│ │ ├── JvComponentBase.pas
│ │ ├── JvComponentPanel.pas
│ │ ├── JvComputerInfoEx.pas
│ │ ├── JvConnectNetwork.pas
│ │ ├── JvConsts.pas
│ │ ├── JvContentScroller.pas
│ │ ├── JvContextProvider.pas
│ │ ├── JvControlActions.pas
│ │ ├── JvControlActionsEngine.pas
│ │ ├── JvControlActionsEngineCxEditors.pas
│ │ ├── JvControlActionsEngineCxGrid.pas
│ │ ├── JvControlActionsEngineCxPivotGrid.pas
│ │ ├── JvControlActionsEngineCxTreeList.pas
│ │ ├── JvControlActionsEngineCxVerticalGrid.pas
│ │ ├── JvControlActionsEngineDBGrid.pas
│ │ ├── JvControlActionsEngineStringGrid.pas
│ │ ├── JvControlActionsEngineTreeView.pas
│ │ ├── JvControlBar.pas
│ │ ├── JvControlComponent.pas
│ │ ├── JvControlPanelButton.pas
│ │ ├── JvConverter.pas
│ │ ├── JvCoolBar.pas
│ │ ├── JvCopyError.pas
│ │ ├── JvCpuUsage.pas
│ │ ├── JvCreateProcess.pas
│ │ ├── JvCsvData.pas
│ │ ├── JvCsvParse.pas
│ │ ├── JvCtrls.pas
│ │ ├── JvCursor.pas
│ │ ├── JvCustomFileMessageDialog.pas
│ │ ├── JvCustomItemViewer.pas
│ │ ├── JvDBActions.pas
│ │ ├── JvDBActionsEngine.pas
│ │ ├── JvDBActionsEngineControlCxGrid.pas
│ │ ├── JvDBActionsEngineControlCxPivotGrid.pas
│ │ ├── JvDBActionsEngineControlCxTreeList.pas
│ │ ├── JvDBActionsEngineDatasetAdo.pas
│ │ ├── JvDBActionsEngineDatasetCSVDataset.pas
│ │ ├── JvDBActionsEngineDatasetDBExpress.pas
│ │ ├── JvDBActionsEngineDatasetDevart.pas
│ │ ├── JvDBActionsEngineDatasetDoa.pas
│ │ ├── JvDBCheckBox.pas
│ │ ├── JvDBCombobox.pas
│ │ ├── JvDBControls.pas
│ │ ├── JvDBDatePickerEdit.pas
│ │ ├── JvDBDateTimePicker.pas
│ │ ├── JvDBDotNetControls.pas
│ │ ├── JvDBFilterExpr.pas
│ │ ├── JvDBFindEdit.pas
│ │ ├── JvDBGrid.pas
│ │ ├── JvDBGridExport.pas
│ │ ├── JvDBGridFooter.pas
│ │ ├── JvDBGridSelectColumnForm.dfm
│ │ ├── JvDBGridSelectColumnForm.pas
│ │ ├── JvDBHTLabel.pas
│ │ ├── JvDBImage.pas
│ │ ├── JvDBLogonDialogBaseDevart.pas
│ │ ├── JvDBLogonDialogDoa.pas
│ │ ├── JvDBLogonDialogOdac.pas
│ │ ├── JvDBLogonDialogUniDac.pas
│ │ ├── JvDBLookup.pas
│ │ ├── JvDBLookupComboEdit.pas
│ │ ├── JvDBLookupTreeView.pas
│ │ ├── JvDBPasswordDialogDoa.pas
│ │ ├── JvDBPasswordDialogOdac.pas
│ │ ├── JvDBPasswordDialogUniDac.pas
│ │ ├── JvDBProgressBar.pas
│ │ ├── JvDBQueryParamsForm.dfm
│ │ ├── JvDBQueryParamsForm.pas
│ │ ├── JvDBRadioPanel.pas
│ │ ├── JvDBRemoteLogin.pas
│ │ ├── JvDBRichEdit.pas
│ │ ├── JvDBSearchComboBox.pas
│ │ ├── JvDBSearchEdit.pas
│ │ ├── JvDBSpinEdit.pas
│ │ ├── JvDBTreeView.pas
│ │ ├── JvDBUltimGrid.pas
│ │ ├── JvDBUtils.pas
│ │ ├── JvDSADialogs.pas
│ │ ├── JvDataEmbedded.pas
│ │ ├── JvDataProvider.pas
│ │ ├── JvDataProviderIntf.pas
│ │ ├── JvDataSource.pas
│ │ ├── JvDataSourceIntf.pas
│ │ ├── JvDatePickerEdit.pas
│ │ ├── JvDateTimePicker.pas
│ │ ├── JvDdeCmd.pas
│ │ ├── JvDebugHandler.pas
│ │ ├── JvDeleteError.pas
│ │ ├── JvDesignClip.pas
│ │ ├── JvDesignImp.pas
│ │ ├── JvDesignSurface.pas
│ │ ├── JvDesignUtils.pas
│ │ ├── JvDesktopAlert.pas
│ │ ├── JvDesktopAlertForm.pas
│ │ ├── JvDiagramShape.pas
│ │ ├── JvDialButton.pas
│ │ ├── JvDialogActns.pas
│ │ ├── JvDialogs.pas
│ │ ├── JvDice.pas
│ │ ├── JvDiskPrompt.pas
│ │ ├── JvDockAdvTree.pas
│ │ ├── JvDockConjoinHost.dfm
│ │ ├── JvDockControlForm.pas
│ │ ├── JvDockDelphiStyle.pas
│ │ ├── JvDockGlobals.pas
│ │ ├── JvDockHashTable.pas
│ │ ├── JvDockInfo.pas
│ │ ├── JvDockSupportClass.pas
│ │ ├── JvDockSupportControl.pas
│ │ ├── JvDockSupportProc.pas
│ │ ├── JvDockTabHost.dfm
│ │ ├── JvDockTree.pas
│ │ ├── JvDockVCStyle.pas
│ │ ├── JvDockVIDStyle.pas
│ │ ├── JvDockVIDVCStyle.pas
│ │ ├── JvDockVSNetStyle.pas
│ │ ├── JvDockableForm.dfm
│ │ ├── JvDotNetControls.pas
│ │ ├── JvDotNetUtils.pas
│ │ ├── JvDragDrop.pas
│ │ ├── JvDrawImage.pas
│ │ ├── JvDriveCtrls.pas
│ │ ├── JvDropDownForm.pas
│ │ ├── JvDsgnIntf.pas
│ │ ├── JvDualList.pas
│ │ ├── JvDualListForm.dfm
│ │ ├── JvDualListForm.pas
│ │ ├── JvDynControlEngine.pas
│ │ ├── JvDynControlEngineDB.pas
│ │ ├── JvDynControlEngineDBIntf.pas
│ │ ├── JvDynControlEngineDBTools.pas
│ │ ├── JvDynControlEngineDBToolscxVGrid.pas
│ │ ├── JvDynControlEngineDevExpCx.pas
│ │ ├── JvDynControlEngineDevExpCxDB.pas
│ │ ├── JvDynControlEngineIntf.pas
│ │ ├── JvDynControlEngineJVCL.pas
│ │ ├── JvDynControlEngineJVCLDB.pas
│ │ ├── JvDynControlEngineJVCLInspector.pas
│ │ ├── JvDynControlEngineTools.pas
│ │ ├── JvDynControlEngineVCL.pas
│ │ ├── JvDynControlEngineVCLDB.pas
│ │ ├── JvEasterEgg.pas
│ │ ├── JvEdit.pas
│ │ ├── JvEditor.pas
│ │ ├── JvEditorCommon.pas
│ │ ├── JvEmbeddedForms.pas
│ │ ├── JvEnterTab.pas
│ │ ├── JvErrorIndicator.pas
│ │ ├── JvExButtons.pas
│ │ ├── JvExCheckLst.pas
│ │ ├── JvExComCtrls.pas
│ │ ├── JvExControls.pas
│ │ ├── JvExDBGrids.pas
│ │ ├── JvExExtCtrls.pas
│ │ ├── JvExForms.pas
│ │ ├── JvExGrids.pas
│ │ ├── JvExMask.pas
│ │ ├── JvExStdCtrls.pas
│ │ ├── JvExceptionForm.dfm
│ │ ├── JvExceptionForm.pas
│ │ ├── JvExplorerBar.pas
│ │ ├── JvExplorerBarItems.pas
│ │ ├── JvExprParser.pas
│ │ ├── JvExtComponent.pas
│ │ ├── JvFavoritesButton.pas
│ │ ├── JvFindFiles.pas
│ │ ├── JvFindReplace.pas
│ │ ├── JvFixedEditPopUp.pas
│ │ ├── JvFooter.pas
│ │ ├── JvFormAnimatedIcon.pas
│ │ ├── JvFormAnimation.pas
│ │ ├── JvFormAutoSize.pas
│ │ ├── JvFormMagnet.pas
│ │ ├── JvFormPlacement.pas
│ │ ├── JvFormPlacementSelectList.pas
│ │ ├── JvFormToHtml.pas
│ │ ├── JvFormTransparent.pas
│ │ ├── JvFormWallpaper.pas
│ │ ├── JvForth.pas
│ │ ├── JvFullColorCircleForm.dfm
│ │ ├── JvFullColorCircleForm.pas
│ │ ├── JvFullColorCtrls.pas
│ │ ├── JvFullColorDialogs.pas
│ │ ├── JvFullColorForm.dfm
│ │ ├── JvFullColorForm.pas
│ │ ├── JvFullColorRotate.pas
│ │ ├── JvFullColorSpaces.pas
│ │ ├── JvGIF.pas
│ │ ├── JvGIFCtrl.pas
│ │ ├── JvGammaPanel.pas
│ │ ├── JvGenetic.pas
│ │ ├── JvGnugettext.pas
│ │ ├── JvGradient.pas
│ │ ├── JvGradientCaption.pas
│ │ ├── JvGradientHeaderPanel.pas
│ │ ├── JvGridFilter.pas
│ │ ├── JvGridPreviewForm.dfm
│ │ ├── JvGridPreviewForm.pas
│ │ ├── JvGridPrinter.pas
│ │ ├── JvGrids.pas
│ │ ├── JvGroupBox.pas
│ │ ├── JvGroupHeader.pas
│ │ ├── JvHLEditor.pas
│ │ ├── JvHLEditorPropertyForm.dfm
│ │ ├── JvHLEditorPropertyForm.pas
│ │ ├── JvHLParser.pas
│ │ ├── JvHeaderControl.pas
│ │ ├── JvHidControllerClass.pas
│ │ ├── JvHint.pas
│ │ ├── JvHints.pas
│ │ ├── JvHotKey.pas
│ │ ├── JvHotTrackPersistent.pas
│ │ ├── JvHtControls.pas
│ │ ├── JvHtmlParser.pas
│ │ ├── JvID3v2Base.pas
│ │ ├── JvIconList.pas
│ │ ├── JvId3v1.pas
│ │ ├── JvId3v2.pas
│ │ ├── JvId3v2Types.pas
│ │ ├── JvImage.pas
│ │ ├── JvImageDlg.pas
│ │ ├── JvImageDrawThread.pas
│ │ ├── JvImageList.pas
│ │ ├── JvImageListViewer.pas
│ │ ├── JvImageRotate.pas
│ │ ├── JvImageSquare.pas
│ │ ├── JvImageTransform.pas
│ │ ├── JvImagesViewer.pas
│ │ ├── JvInspDB.pas
│ │ ├── JvInspExtraEditors.pas
│ │ ├── JvInspXVCL.pas
│ │ ├── JvInspector.pas
│ │ ├── JvInstallLabel.pas
│ │ ├── JvInterpreter.pas
│ │ ├── JvInterpreterConst.pas
│ │ ├── JvInterpreterFm.pas
│ │ ├── JvInterpreterParser.pas
│ │ ├── JvInterpreter_Buttons.pas
│ │ ├── JvInterpreter_Classes.pas
│ │ ├── JvInterpreter_ComCtrls.pas
│ │ ├── JvInterpreter_Contnrs.pas
│ │ ├── JvInterpreter_Controls.pas
│ │ ├── JvInterpreter_DBTables.pas
│ │ ├── JvInterpreter_Db.pas
│ │ ├── JvInterpreter_DbCtrls.pas
│ │ ├── JvInterpreter_DbGrids.pas
│ │ ├── JvInterpreter_Dialogs.pas
│ │ ├── JvInterpreter_ExtCtrls.pas
│ │ ├── JvInterpreter_Forms.pas
│ │ ├── JvInterpreter_Graphics.pas
│ │ ├── JvInterpreter_Grids.pas
│ │ ├── JvInterpreter_JvEditor.pas
│ │ ├── JvInterpreter_JvInterpreter.pas
│ │ ├── JvInterpreter_JvUtils.pas
│ │ ├── JvInterpreter_Math.pas
│ │ ├── JvInterpreter_Menus.pas
│ │ ├── JvInterpreter_Quickrpt.pas
│ │ ├── JvInterpreter_StdCtrls.pas
│ │ ├── JvInterpreter_SysUtils.pas
│ │ ├── JvInterpreter_System.pas
│ │ ├── JvInterpreter_Types.pas
│ │ ├── JvInterpreter_Windows.pas
│ │ ├── JvInterpreter_all.pas
│ │ ├── JvInterpreter_httpapp.pas
│ │ ├── JvItemsPanel.pas
│ │ ├── JvItemsSearchs.pas
│ │ ├── JvJCLUtils.pas
│ │ ├── JvJVCLAboutForm.dfm
│ │ ├── JvJVCLAboutForm.pas
│ │ ├── JvJVCLUtils.pas
│ │ ├── JvJanTreeView.pas
│ │ ├── JvJclUnitVersioningBrowser.pas
│ │ ├── JvJoystick.pas
│ │ ├── JvLED.pas
│ │ ├── JvLabel.pas
│ │ ├── JvLinkLabel.pas
│ │ ├── JvLinkLabelDebug.pas
│ │ ├── JvLinkLabelParser.pas
│ │ ├── JvLinkLabelRenderer.pas
│ │ ├── JvLinkLabelTextHandler.pas
│ │ ├── JvLinkLabelTools.pas
│ │ ├── JvLinkLabelTree.pas
│ │ ├── JvLinkedControls.pas
│ │ ├── JvListBox.pas
│ │ ├── JvListComb.pas
│ │ ├── JvListView.pas
│ │ ├── JvLogClasses.pas
│ │ ├── JvLogFile.pas
│ │ ├── JvLogForm.dfm
│ │ ├── JvLogForm.pas
│ │ ├── JvLoginForm.dfm
│ │ ├── JvLoginForm.pas
│ │ ├── JvLookOut.pas
│ │ ├── JvMRUList.pas
│ │ ├── JvMRUManager.pas
│ │ ├── JvMTComponents.pas
│ │ ├── JvMTConsts.pas
│ │ ├── JvMTData.pas
│ │ ├── JvMTSync.pas
│ │ ├── JvMTSyncMon.pas
│ │ ├── JvMTThreading.pas
│ │ ├── JvMail.pas
│ │ ├── JvMailSlots.pas
│ │ ├── JvMarkupCommon.pas
│ │ ├── JvMarkupLabel.pas
│ │ ├── JvMarkupViewer.pas
│ │ ├── JvMaskEdit.pas
│ │ ├── JvMaxPixel.pas
│ │ ├── JvMemo.pas
│ │ ├── JvMemoryDataset.pas
│ │ ├── JvMenus.pas
│ │ ├── JvMergeManager.pas
│ │ ├── JvMessageControl.pas
│ │ ├── JvMonthCalendar.pas
│ │ ├── JvMouseGesture.pas
│ │ ├── JvMouseTimer.pas
│ │ ├── JvMovableBevel.pas
│ │ ├── JvNTEventLog.pas
│ │ ├── JvNavigationPane.pas
│ │ ├── JvNetscapeSplitter.pas
│ │ ├── JvObjectPickerDialog.pas
│ │ ├── JvOdacSmartQuery.pas
│ │ ├── JvOfficeColorButton.pas
│ │ ├── JvOfficeColorForm.pas
│ │ ├── JvOfficeColorPanel.pas
│ │ ├── JvOfficeDragBarForm.pas
│ │ ├── JvOracleDataSet.pas
│ │ ├── JvOutlookBar.pas
│ │ ├── JvOwnerDrawViewer.pas
│ │ ├── JvPageList.pas
│ │ ├── JvPageListTreeView.pas
│ │ ├── JvPageManager.pas
│ │ ├── JvPageScroller.pas
│ │ ├── JvPageSetup.pas
│ │ ├── JvPageSetupTitled.pas
│ │ ├── JvPaintFX.pas
│ │ ├── JvPainterEffectsForm.dfm
│ │ ├── JvPainterEffectsForm.pas
│ │ ├── JvPainterQBForm.dfm
│ │ ├── JvPainterQBForm.pas
│ │ ├── JvPanel.pas
│ │ ├── JvParameterList.pas
│ │ ├── JvParameterListParameter.pas
│ │ ├── JvParameterListTools.pas
│ │ ├── JvParserForm.dfm
│ │ ├── JvParserForm.pas
│ │ ├── JvPatchFile.pas
│ │ ├── JvPatchForm.dfm
│ │ ├── JvPatchForm.pas
│ │ ├── JvPcx.pas
│ │ ├── JvPerfMon95.pas
│ │ ├── JvPicClip.pas
│ │ ├── JvPickDate.pas
│ │ ├── JvPlaylist.pas
│ │ ├── JvPlugin.pas
│ │ ├── JvPluginManager.pas
│ │ ├── JvPoweredBy.pas
│ │ ├── JvPrint.pas
│ │ ├── JvProfilerForm.dfm
│ │ ├── JvProfilerForm.pas
│ │ ├── JvProgramVersionCheck.pas
│ │ ├── JvProgressBar.pas
│ │ ├── JvProgressComponent.pas
│ │ ├── JvProgressDialog.pas
│ │ ├── JvProgressForm.dfm
│ │ ├── JvProgressForm.pas
│ │ ├── JvProgressUtils.pas
│ │ ├── JvPropertyStorage.pas
│ │ ├── JvPropertyStore.pas
│ │ ├── JvPropertyStoreEditor.dfm
│ │ ├── JvPropertyStoreEditor.pas
│ │ ├── JvPropertyStoreEditorIntf.pas
│ │ ├── JvPrvwDoc.pas
│ │ ├── JvPrvwRender.pas
│ │ ├── JvQuickPreviewForm.dfm
│ │ ├── JvQuickPreviewForm.pas
│ │ ├── JvRadioButton.pas
│ │ ├── JvRadioGroup.pas
│ │ ├── JvRas32.pas
│ │ ├── JvRecentMenuButton.pas
│ │ ├── JvRegistryTreeview.pas
│ │ ├── JvRenameError.pas
│ │ ├── JvResample.pas
│ │ ├── JvResources.pas
│ │ ├── JvRgbToHtml.pas
│ │ ├── JvRichEdit.pas
│ │ ├── JvRichEditToHtml.pas
│ │ ├── JvRollOut.pas
│ │ ├── JvRuler.pas
│ │ ├── JvSAL.pas
│ │ ├── JvSALCore.pas
│ │ ├── JvSALHashList.pas
│ │ ├── JvSALMath.pas
│ │ ├── JvSHFileOperation.pas
│ │ ├── JvSLDMappingEditorDialog.dfm
│ │ ├── JvSLDMappingEditorDialog.pas
│ │ ├── JvSchedEvtStore.pas
│ │ ├── JvScheduledEvents.pas
│ │ ├── JvScreenResolution.pas
│ │ ├── JvScreenSaveSuppress.pas
│ │ ├── JvScreenSaver.pas
│ │ ├── JvScrollBar.pas
│ │ ├── JvScrollBox.pas
│ │ ├── JvScrollMax.pas
│ │ ├── JvScrollPanel.pas
│ │ ├── JvScrollText.pas
│ │ ├── JvSearchFiles.pas
│ │ ├── JvSecretPanel.pas
│ │ ├── JvSegmentedLEDDisplay.pas
│ │ ├── JvSegmentedLEDDisplayMapperFrame.dfm
│ │ ├── JvSegmentedLEDDisplayMapperFrame.pas
│ │ ├── JvSelectDirectory.pas
│ │ ├── JvSerialMaker.pas
│ │ ├── JvSetupApi.pas
│ │ ├── JvShape.pas
│ │ ├── JvShapedButton.pas
│ │ ├── JvShellHook.pas
│ │ ├── JvSimIndicator.pas
│ │ ├── JvSimLogic.pas
│ │ ├── JvSimPID.pas
│ │ ├── JvSimPIDLinker.pas
│ │ ├── JvSimScope.pas
│ │ ├── JvSimpleXml.pas
│ │ ├── JvSlider.pas
│ │ ├── JvSoundControl.pas
│ │ ├── JvSpacer.pas
│ │ ├── JvSpecialImage.pas
│ │ ├── JvSpecialProgress.pas
│ │ ├── JvSpeedButton.pas
│ │ ├── JvSpeedbar.pas
│ │ ├── JvSpeedbarSetupForm.dfm
│ │ ├── JvSpeedbarSetupForm.pas
│ │ ├── JvSpellChecker.pas
│ │ ├── JvSpellIntf.pas
│ │ ├── JvSpellerForm.dfm
│ │ ├── JvSpellerForm.pas
│ │ ├── JvSpin.pas
│ │ ├── JvSplashWindow.pas
│ │ ├── JvSplit.pas
│ │ ├── JvSplitter.pas
│ │ ├── JvStarfield.pas
│ │ ├── JvStartMenuButton.pas
│ │ ├── JvStaticText.pas
│ │ ├── JvStatusBar.pas
│ │ ├── JvStdEditActions.pas
│ │ ├── JvSticker.pas
│ │ ├── JvStrToHtml.pas
│ │ ├── JvStringGrid.pas
│ │ ├── JvStringHolder.pas
│ │ ├── JvStringListToHtml.pas
│ │ ├── JvStrings.pas
│ │ ├── JvSwitch.pas
│ │ ├── JvSyncSplitter.pas
│ │ ├── JvSysRequirements.pas
│ │ ├── JvSystemPopup.pas
│ │ ├── JvTFAlarm.pas
│ │ ├── JvTFDays.pas
│ │ ├── JvTFGantt.pas
│ │ ├── JvTFGlance.pas
│ │ ├── JvTFGlanceTextViewer.pas
│ │ ├── JvTFManager.pas
│ │ ├── JvTFMonths.pas
│ │ ├── JvTFSparseMatrix.pas
│ │ ├── JvTFUtils.pas
│ │ ├── JvTFWeeks.pas
│ │ ├── JvTMTimeLine.pas
│ │ ├── JvTabBar.pas
│ │ ├── JvTabBarXPPainter.pas
│ │ ├── JvTextListBox.pas
│ │ ├── JvThemes.pas
│ │ ├── JvThread.pas
│ │ ├── JvThreadDialog.pas
│ │ ├── JvThreadTimer.pas
│ │ ├── JvThumbImage.pas
│ │ ├── JvThumbViews.pas
│ │ ├── JvThumbnails.pas
│ │ ├── JvTimeLimit.pas
│ │ ├── JvTimeLine.pas
│ │ ├── JvTimer.pas
│ │ ├── JvTimerList.pas
│ │ ├── JvTipOfDay.pas
│ │ ├── JvToolBar.pas
│ │ ├── JvToolEdit.pas
│ │ ├── JvTracker.pas
│ │ ├── JvTranslateString.pas
│ │ ├── JvTranslator.pas
│ │ ├── JvTransparentButton.pas
│ │ ├── JvTrayIcon.pas
│ │ ├── JvTurtle.pas
│ │ ├── JvTypes.pas
│ │ ├── JvUniDacQuery.pas
│ │ ├── JvUnicodeCanvas.pas
│ │ ├── JvUnicodeEditor.pas
│ │ ├── JvUnicodeHLEditor.pas
│ │ ├── JvUninstallControls.pas
│ │ ├── JvUpDown.pas
│ │ ├── JvUrlGrabbers.pas
│ │ ├── JvUrlListGrabber.pas
│ │ ├── JvValidateEdit.pas
│ │ ├── JvValidators.pas
│ │ ├── JvVersionControlActions.pas
│ │ ├── JvVersionControlActionsEngine.pas
│ │ ├── JvVersionControlActionsEngineFileListBox.pas
│ │ ├── JvVersionInfo.pas
│ │ ├── JvVirtualKeySelectionFrame.dfm
│ │ ├── JvVirtualKeySelectionFrame.pas
│ │ ├── JvWaitingGradient.pas
│ │ ├── JvWaitingProgress.pas
│ │ ├── JvWallpaperEditForm.dfm
│ │ ├── JvWallpaperEditForm.pas
│ │ ├── JvWavePlayer.pas
│ │ ├── JvWin32.pas
│ │ ├── JvWinDialogs.pas
│ │ ├── JvWinHelp.pas
│ │ ├── JvWinampLabel.pas
│ │ ├── JvWizard.pas
│ │ ├── JvWizardCommon.pas
│ │ ├── JvWizardRouteMapList.pas
│ │ ├── JvWizardRouteMapNodes.pas
│ │ ├── JvWizardRouteMapSteps.pas
│ │ ├── JvWndProcHook.pas
│ │ ├── JvXPBar.pas
│ │ ├── JvXPButtons.pas
│ │ ├── JvXPCheckCtrls.pas
│ │ ├── JvXPContainer.pas
│ │ ├── JvXPCore.pas
│ │ ├── JvXPCoreUtils.pas
│ │ ├── JvXPProgressBar.pas
│ │ ├── JvXmlDatabase.pas
│ │ ├── JvXmlTree.pas
│ │ ├── JvYearGrid.pas
│ │ ├── JvYearGridEditForm.dfm
│ │ ├── JvYearGridEditForm.pas
│ │ ├── JvZlibMultiple.pas
│ │ ├── JvZoom.pas
│ │ ├── JvaScrollText.pas
│ │ ├── Jvg3DColors.pas
│ │ ├── JvgAlignFunction.pas
│ │ ├── JvgAskListBox.pas
│ │ ├── JvgButton.pas
│ │ ├── JvgCaption.pas
│ │ ├── JvgCheckBox.pas
│ │ ├── JvgCommClasses.pas
│ │ ├── JvgCrossTable.pas
│ │ ├── JvgDigits.pas
│ │ ├── JvgDrawTab.pas
│ │ ├── JvgExport.pas
│ │ ├── JvgExportComponents.pas
│ │ ├── JvgFileIterator.pas
│ │ ├── JvgGraph.pas
│ │ ├── JvgGroupBox.pas
│ │ ├── JvgHTTPVersionInfo.pas
│ │ ├── JvgHint.pas
│ │ ├── JvgHoleShape.pas
│ │ ├── JvgImage.pas
│ │ ├── JvgImageGroup.pas
│ │ ├── JvgLabel.pas
│ │ ├── JvgListBox.pas
│ │ ├── JvgLogics.pas
│ │ ├── JvgPage.pas
│ │ ├── JvgProgress.pas
│ │ ├── JvgQPrintPreviewForm.dfm
│ │ ├── JvgQPrintPreviewForm.pas
│ │ ├── JvgQPrintSetupForm.dfm
│ │ ├── JvgQPrintSetupForm.pas
│ │ ├── JvgQRLabel.pas
│ │ ├── JvgReport.pas
│ │ ├── JvgReportParamsEditor.pas
│ │ ├── JvgShade.pas
│ │ ├── JvgShadow.pas
│ │ ├── JvgSpeedButton.pas
│ │ ├── JvgStringGrid.pas
│ │ ├── JvgTab.pas
│ │ ├── JvgTabComm.pas
│ │ ├── JvgTypes.pas
│ │ ├── JvgUtils.pas
│ │ ├── JvgWebDocumentIterator.pas
│ │ ├── JvgXMLSerializer.pas
│ │ ├── JvxCheckListBox.pas
│ │ ├── JvxSlider.pas
│ │ ├── ModuleLoader.pas
│ │ ├── ObjSel.pas
│ │ ├── Ras32.pas
│ │ ├── VFW.pas
│ │ ├── WinConvTypes.pas
│ │ ├── Winamp.pas
│ │ └── run.txt
│ ├── KOLDetours.pas
│ ├── SynEdit/
│ │ └── Source/
│ │ ├── Contributors.txt
│ │ ├── QSynAutoCorrect.pas
│ │ ├── QSynAutoCorrectEditor.dfm
│ │ ├── QSynAutoCorrectEditor.pas
│ │ ├── QSynCompletionProposal.pas
│ │ ├── QSynDBEdit.pas
│ │ ├── QSynEdit.pas
│ │ ├── QSynEditAutoComplete.pas
│ │ ├── QSynEditExport.pas
│ │ ├── QSynEditHighlighter.pas
│ │ ├── QSynEditKbdHandler.pas
│ │ ├── QSynEditKeyCmdEditor.dfm
│ │ ├── QSynEditKeyCmdEditor.pas
│ │ ├── QSynEditKeyCmds.pas
│ │ ├── QSynEditKeyCmdsEditor.dfm
│ │ ├── QSynEditKeyCmdsEditor.pas
│ │ ├── QSynEditKeyConst.pas
│ │ ├── QSynEditMiscClasses.pas
│ │ ├── QSynEditMiscProcs.pas
│ │ ├── QSynEditOptionsDialog.dfm
│ │ ├── QSynEditOptionsDialog.pas
│ │ ├── QSynEditPlugins.pas
│ │ ├── QSynEditPrint.pas
│ │ ├── QSynEditPrintHeaderFooter.pas
│ │ ├── QSynEditPrintMargins.pas
│ │ ├── QSynEditPrintMarginsDialog.dfm
│ │ ├── QSynEditPrintMarginsDialog.pas
│ │ ├── QSynEditPrintPreview.pas
│ │ ├── QSynEditPrintTypes.pas
│ │ ├── QSynEditPrinterInfo.pas
│ │ ├── QSynEditPropertyReg.pas
│ │ ├── QSynEditPythonBehaviour.pas
│ │ ├── QSynEditReg.pas
│ │ ├── QSynEditRegexSearch.pas
│ │ ├── QSynEditSearch.pas
│ │ ├── QSynEditStrConst.pas
│ │ ├── QSynEditTextBuffer.pas
│ │ ├── QSynEditTypes.pas
│ │ ├── QSynEditWildcardSearch.pas
│ │ ├── QSynEditWordWrap.pas
│ │ ├── QSynExportHTML.pas
│ │ ├── QSynExportRTF.pas
│ │ ├── QSynExportTeX.pas
│ │ ├── QSynHighlighterADSP21xx.pas
│ │ ├── QSynHighlighterAWK.pas
│ │ ├── QSynHighlighterAsm.pas
│ │ ├── QSynHighlighterBaan.pas
│ │ ├── QSynHighlighterBat.pas
│ │ ├── QSynHighlighterCAC.pas
│ │ ├── QSynHighlighterCPM.pas
│ │ ├── QSynHighlighterCS.pas
│ │ ├── QSynHighlighterCache.pas
│ │ ├── QSynHighlighterCobol.pas
│ │ ├── QSynHighlighterCpp.pas
│ │ ├── QSynHighlighterCss.pas
│ │ ├── QSynHighlighterDOT.pas
│ │ ├── QSynHighlighterDfm.pas
│ │ ├── QSynHighlighterDml.pas
│ │ ├── QSynHighlighterEiffel.pas
│ │ ├── QSynHighlighterFortran.pas
│ │ ├── QSynHighlighterFoxpro.pas
│ │ ├── QSynHighlighterGWS.pas
│ │ ├── QSynHighlighterGalaxy.pas
│ │ ├── QSynHighlighterGeneral.pas
│ │ ├── QSynHighlighterHC11.pas
│ │ ├── QSynHighlighterHP48.pas
│ │ ├── QSynHighlighterHashEntries.pas
│ │ ├── QSynHighlighterHaskell.pas
│ │ ├── QSynHighlighterHtml.pas
│ │ ├── QSynHighlighterIDL.pas
│ │ ├── QSynHighlighterIni.pas
│ │ ├── QSynHighlighterInno.pas
│ │ ├── QSynHighlighterJScript.pas
│ │ ├── QSynHighlighterJava.pas
│ │ ├── QSynHighlighterKix.pas
│ │ ├── QSynHighlighterLDraw.pas
│ │ ├── QSynHighlighterM3.pas
│ │ ├── QSynHighlighterManager.pas
│ │ ├── QSynHighlighterModelica.pas
│ │ ├── QSynHighlighterMsg.pas
│ │ ├── QSynHighlighterMulti.pas
│ │ ├── QSynHighlighterPHP.pas
│ │ ├── QSynHighlighterPas.pas
│ │ ├── QSynHighlighterPerl.pas
│ │ ├── QSynHighlighterProgress.pas
│ │ ├── QSynHighlighterPython.pas
│ │ ├── QSynHighlighterRC.pas
│ │ ├── QSynHighlighterRuby.pas
│ │ ├── QSynHighlighterSDD.pas
│ │ ├── QSynHighlighterSQL.pas
│ │ ├── QSynHighlighterST.pas
│ │ ├── QSynHighlighterSml.pas
│ │ ├── QSynHighlighterTclTk.pas
│ │ ├── QSynHighlighterTeX.pas
│ │ ├── QSynHighlighterUNIXShellScript.pas
│ │ ├── QSynHighlighterURI.pas
│ │ ├── QSynHighlighterUnreal.pas
│ │ ├── QSynHighlighterVB.pas
│ │ ├── QSynHighlighterVBScript.pas
│ │ ├── QSynHighlighterVrml97.pas
│ │ ├── QSynHighlighterXML.pas
│ │ ├── QSynMacroRecorder.pas
│ │ ├── QSynMemo.pas
│ │ ├── QSynRegExpr.pas
│ │ ├── QSynURIOpener.pas
│ │ ├── QSynUnicode.pas
│ │ ├── SynAutoCorrect.pas
│ │ ├── SynAutoCorrectEditor.dfm
│ │ ├── SynAutoCorrectEditor.pas
│ │ ├── SynCompletionProposal.pas
│ │ ├── SynDBEdit.pas
│ │ ├── SynEdit.inc
│ │ ├── SynEdit.pas
│ │ ├── SynEdit.res
│ │ ├── SynEditAutoComplete.pas
│ │ ├── SynEditExport.pas
│ │ ├── SynEditHighlighter.pas
│ │ ├── SynEditHighlighterOptions.pas
│ │ ├── SynEditJedi.inc
│ │ ├── SynEditKbdHandler.pas
│ │ ├── SynEditKeyCmdEditor.dfm
│ │ ├── SynEditKeyCmdEditor.pas
│ │ ├── SynEditKeyCmds.pas
│ │ ├── SynEditKeyCmdsEditor.dfm
│ │ ├── SynEditKeyCmdsEditor.pas
│ │ ├── SynEditKeyConst.pas
│ │ ├── SynEditMiscClasses.pas
│ │ ├── SynEditMiscProcs.pas
│ │ ├── SynEditOptionsDialog.dfm
│ │ ├── SynEditOptionsDialog.pas
│ │ ├── SynEditPlugins.pas
│ │ ├── SynEditPrint.pas
│ │ ├── SynEditPrintHeaderFooter.pas
│ │ ├── SynEditPrintMargins.pas
│ │ ├── SynEditPrintMarginsDialog.dfm
│ │ ├── SynEditPrintMarginsDialog.pas
│ │ ├── SynEditPrintPreview.pas
│ │ ├── SynEditPrintTypes.pas
│ │ ├── SynEditPrinterInfo.pas
│ │ ├── SynEditPropertyReg.pas
│ │ ├── SynEditPythonBehaviour.pas
│ │ ├── SynEditReg.dcr
│ │ ├── SynEditReg.pas
│ │ ├── SynEditReg.res
│ │ ├── SynEditRegexSearch.pas
│ │ ├── SynEditSearch.pas
│ │ ├── SynEditStrConst.pas
│ │ ├── SynEditTextBuffer.pas
│ │ ├── SynEditTypes.pas
│ │ ├── SynEditWildcardSearch.pas
│ │ ├── SynEditWordWrap.pas
│ │ ├── SynExportHTML.pas
│ │ ├── SynExportRTF.pas
│ │ ├── SynExportTeX.pas
│ │ ├── SynHighlighterADSP21xx.pas
│ │ ├── SynHighlighterAWK.pas
│ │ ├── SynHighlighterAsm.pas
│ │ ├── SynHighlighterBaan.pas
│ │ ├── SynHighlighterBat.pas
│ │ ├── SynHighlighterCAC.pas
│ │ ├── SynHighlighterCPM.pas
│ │ ├── SynHighlighterCS.pas
│ │ ├── SynHighlighterCache.pas
│ │ ├── SynHighlighterCobol.pas
│ │ ├── SynHighlighterCpp.pas
│ │ ├── SynHighlighterCss.pas
│ │ ├── SynHighlighterDOT.pas
│ │ ├── SynHighlighterDWS.pas
│ │ ├── SynHighlighterDfm.pas
│ │ ├── SynHighlighterDml.pas
│ │ ├── SynHighlighterEiffel.pas
│ │ ├── SynHighlighterFortran.pas
│ │ ├── SynHighlighterFoxpro.pas
│ │ ├── SynHighlighterGWS.pas
│ │ ├── SynHighlighterGalaxy.pas
│ │ ├── SynHighlighterGeneral.pas
│ │ ├── SynHighlighterHC11.pas
│ │ ├── SynHighlighterHP48.pas
│ │ ├── SynHighlighterHashEntries.pas
│ │ ├── SynHighlighterHaskell.pas
│ │ ├── SynHighlighterHtml.pas
│ │ ├── SynHighlighterIDL.pas
│ │ ├── SynHighlighterIni.pas
│ │ ├── SynHighlighterInno.pas
│ │ ├── SynHighlighterJScript.pas
│ │ ├── SynHighlighterJava.pas
│ │ ├── SynHighlighterKix.pas
│ │ ├── SynHighlighterLDraw.pas
│ │ ├── SynHighlighterLLVM.pas
│ │ ├── SynHighlighterM3.pas
│ │ ├── SynHighlighterManager.pas
│ │ ├── SynHighlighterModelica.pas
│ │ ├── SynHighlighterMsg.pas
│ │ ├── SynHighlighterMulti.pas
│ │ ├── SynHighlighterPHP.pas
│ │ ├── SynHighlighterPas.pas
│ │ ├── SynHighlighterPerl.pas
│ │ ├── SynHighlighterProgress.pas
│ │ ├── SynHighlighterPython.pas
│ │ ├── SynHighlighterRC.pas
│ │ ├── SynHighlighterRuby.pas
│ │ ├── SynHighlighterSDD.pas
│ │ ├── SynHighlighterSQL.pas
│ │ ├── SynHighlighterST.pas
│ │ ├── SynHighlighterSml.pas
│ │ ├── SynHighlighterTclTk.pas
│ │ ├── SynHighlighterTeX.pas
│ │ ├── SynHighlighterUNIXShellScript.pas
│ │ ├── SynHighlighterURI.pas
│ │ ├── SynHighlighterUnreal.pas
│ │ ├── SynHighlighterVB.pas
│ │ ├── SynHighlighterVBScript.pas
│ │ ├── SynHighlighterVrml97.pas
│ │ ├── SynHighlighterWebIDL.pas
│ │ ├── SynHighlighterXML.pas
│ │ ├── SynMacroRecorder.pas
│ │ ├── SynMemo.pas
│ │ ├── SynRegExpr.pas
│ │ ├── SynTextDrawer.pas
│ │ ├── SynURIOpener.pas
│ │ ├── SynUnicode.pas
│ │ ├── SynUsp10.pas
│ │ └── kTextDrawer.pas
│ └── VirtualTreeView/
│ └── Source/
│ ├── VTAccessibility.pas
│ ├── VTAccessibilityFactory.pas
│ ├── VTHeaderPopup.pas
│ ├── VirtualTrees.Actions.pas
│ ├── VirtualTrees.Classes.pas
│ ├── VirtualTrees.ClipBoard.pas
│ ├── VirtualTrees.Export.pas
│ ├── VirtualTrees.StyleHooks.pas
│ ├── VirtualTrees.Utils.pas
│ ├── VirtualTrees.WorkerThread.pas
│ ├── VirtualTrees.pas
│ └── VirtualTrees.res
├── GdiPlus/
│ ├── GdiPlus.pas
│ └── GdiPlusHelpers.pas
├── JclPeImage.pas
├── JclTD32Ex.pas
├── MapDebugInfo.pas
├── Other/
│ └── uMacroParser.pas
├── Readme.md
├── Spider.dpr
├── Spider.dproj
├── Spider.res
├── SpiderXE6.dpr
├── SpiderXE6.dproj
├── SpiderXE6.res
├── Spider_Project.groupproj
├── WinAPIUtils.pas
├── uActionController.pas
├── uDebugerThread.pas
├── uExceptionHook.pas
├── uFastList.pas
├── uFeedback.dfm
├── uFeedback.pas
├── uGA.pas
├── uMain.dfm
├── uMain.pas
├── uProcessList.dfm
├── uProcessList.pas
├── uProjectOptions.dfm
├── uProjectOptions.pas
├── uRWLock.pas
├── uSQLiteDB.pas
├── uSelectSource.dfm
├── uSelectSource.pas
├── uShareData.dfm
├── uShareData.pas
├── uSharedObject.pas
├── uSourceViewFrame.dfm
├── uSourceViewFrame.pas
├── uSpiderOptions.pas
└── uUpdateInfo.pas
================================================
FILE CONTENTS
================================================
================================================
FILE: ClassUtils.pas
================================================
unit ClassUtils;
interface
uses Windows, Classes, SysUtils, StrUtils, XMLDoc, XMLIntf, Graphics, GdiPlus, GdiPlusHelpers, Collections.Dictionaries;
const
EIndexError: String = 'List index error: %d';
type
TStringArray = Array of String;
TGradientInfo = class(TObject)
private
FColor: TColor;
FBrush: IGPBrush;
FPen: IGPPen;
FGrList: array of TGPColor;
procedure Init(const AHeight: Integer; const ADelta: Byte);
procedure InitGrList(const AHeight: Integer; const ADelta: Byte);
public
constructor Create(const AColor: TColor; const AHeight: Integer; const ADelta: Byte = 50);
destructor Destroy; override;
property Color: TColor read FColor;
property Brush: IGPBrush read FBrush;
property Pen: IGPPen read FPen;
end;
TGradientInfoList = class(TObjectDictionary<TColor, TGradientInfo>)
private
class var
_GradientInfoList: TGradientInfoList;
public
class function GetGradientInfo(const AColor: TColor; const AHeight: Integer): TGradientInfo;
end;
procedure DrawVGradientRect(const GP: IGPGraphics; const Rect: TGPRect; const Color: TColor);
procedure DrawHInterval(const GP: IGPGraphics; const Rect: TGPRect; const Color: TColor);
function GPRect(const Left, Top, Right, Bottom: Integer): TGPRect; inline;
procedure RGBToHSV(const Color: TColor; var h, s, v: Integer);
function HSV2RGB(const h, s, v: Integer): TColor;
procedure ClearStringList(SL: TStringList);
procedure FreeStringList(var SL: TStringList);
procedure ClearList(L: TList);
procedure FreeList(var L: TList);
function IncPointer(Ptr: Pointer; Offset: Integer): Pointer; inline;
procedure SplitStr(const Str: String; const Delimiter: Char; var StrList: TStringArray);
function GetXMLValue(const ParentNode: IXMLNode; const NodeName: String): String;
procedure SetXMLValue(const ParentNode: IXMLNode; const NodeName, NodeValue: String);
function GetXMLChildNode(const ParentNode: IXMLNode; const NodeName: String; const AutoCreate: LongBool = True): IXMLNode;
function Compare(var Value1, Value2: UInt64): Integer; overload; inline;
function Compare(var Value1, Value2: Int64): Integer; overload; inline;
function Compare(var Value1, Value2: NativeInt): Integer; overload; inline;
function Compare(var Value1, Value2: NativeUInt): Integer; overload; inline;
function Compare(var Value1, Value2: String; const EmptyRes: Integer): Integer; overload;
function CompareNumberStr(const Value1, Value2: String): Integer;
function PercentStr(const Count, All: UInt64): String;
implementation
uses Math;
function PercentStr(const Count, All: UInt64): String;
var
Res: Integer;
begin
if All > 0 then
Res := Round(100 * Count / All)
else
Res := 0;
Result := '(' + IntToStr(Res) + '%)';
end;
{ TGradientInfo }
constructor TGradientInfo.Create(const AColor: TColor; const AHeight: Integer; const ADelta: Byte = 50);
begin
inherited Create;
FColor := AColor;
Init(AHeight, ADelta);
InitGrList(AHeight, ADelta);
end;
destructor TGradientInfo.Destroy;
begin
FBrush := nil;
FPen := nil;
inherited;
end;
procedure TGradientInfo.Init(const AHeight: Integer; const ADelta: Byte);
var
C1, C2: TGPColor;
H, S, V: Integer;
R: TGPRect;
begin
RGBToHSV(FColor, H, S, V);
C1 := TGPColor.Create(HSV2RGB(H, S, V + ADelta));
C1.Alpha := $C0;
C2 := TGPColor.Create(HSV2RGB(H, S, V - ADelta));
C2.Alpha := $C0;
R := TGPRect.Create(Rect(0, 0, 1, AHeight + 2));
FBrush := TGPLinearGradientBrush.Create(R, C1, C2, LinearGradientModeVertical);
FPen := TGPPen.Create(Brush);
FPen.Alignment := PenAlignmentInset;
end;
procedure TGradientInfo.InitGrList(const AHeight: Integer; const ADelta: Byte);
var
I: Integer;
H, S, V: Integer;
StartColor: TColor;
EndColor: TColor;
LStartRGB, LEndRGB: TColor;
DeltaR: Double;
DeltaG: Double;
DeltaB: Double;
DeltaColor: TColor;
begin
SetLength(FGrList, AHeight);
if AHeight = 0 then Exit;
RGBToHSV(Color, H, S, V);
StartColor := HSV2RGB(H, S, V + ADelta);
EndColor := HSV2RGB(H, S, V - ADelta);
LStartRGB := ColorToRGB(StartColor);
LEndRGB := ColorToRGB(EndColor);
DeltaR := (GetRValue(LEndRGB) - GetRValue(LStartRGB)) / AHeight;
DeltaG := (GetGValue(LEndRGB) - GetGValue(LStartRGB)) / AHeight;
DeltaB := (GetBValue(LEndRGB) - GetBValue(LStartRGB)) / AHeight;
for I := 0 to AHeight - 1 do
begin
DeltaColor := RGB(
GetRValue(LStartRGB) + Round(I * DeltaR),
GetGValue(LStartRGB) + Round(I * DeltaG),
GetBValue(LStartRGB) + Round(I * DeltaB)
);
FGrList[I] := TGPColor.Create(DeltaColor);
end;
end;
function CompareNumberStr(const Value1, Value2: String): Integer;
begin
Result := Length(Value1) - Length(Value2);
if Result = 0 then
Result := CompareStr(Value1, Value2);
end;
function Compare(var Value1, Value2: String; const EmptyRes: Integer): Integer;
begin
if (Value1 <> '') and (Value2 <> '') then
Result := CompareText(Value1, Value2)
else
begin
if (Value1 = '') and (Value2 <> '') then
Result := EmptyRes
else
if (Value1 <> '') and (Value2 = '') then
Result := -EmptyRes
else
Result := 0;
end;
end;
procedure DrawVGradientRect(const GP: IGPGraphics; const Rect: TGPRect; const Color: TColor);
var
GrInfo: TGradientInfo;
begin
GrInfo := TGradientInfoList.GetGradientInfo(Color, Rect.Height);
if Rect.Width <> 0 then
GP.FillRectangle(GrInfo.Brush, Rect)
else
GP.DrawLine(GrInfo.Pen, Rect.Left, Rect.Top, Rect.Left, Rect.Bottom - 1);
end;
procedure DrawHInterval(const GP: IGPGraphics; const Rect: TGPRect; const Color: TColor);
var
Brush: IGPBrush;
C: TGPColor;
begin
if Rect.Width <> 0 then
begin
C := TGPColor.Create(Color);
C.Alpha := $20;
Brush := TGPSolidBrush.Create(C);
GP.FillRectangle(Brush, Rect);
end;
end;
function GPRect(const Left, Top, Right, Bottom: Integer): TGPRect;
begin
Result.Initialize(Left, Top, Right - Left, Bottom - Top);
end;
(*
procedure DrawVGradientRect(Canvas: TCanvas; const Rect: TRect; const StartColor, EndColor: TColor);
var
I: Integer;
R: TRect;
LStartRGB, LEndRGB: TColor;
LSteps: Integer;
DeltaR: Double;
DeltaG: Double;
DeltaB: Double;
DeltaColor: TColor;
begin
LSteps := Rect.Bottom - Rect.Top;
if LSteps = 0 then Exit;
LStartRGB := ColorToRGB(StartColor);
LEndRGB := ColorToRGB(EndColor);
DeltaR := (GetRValue(LEndRGB) - GetRValue(LStartRGB)) / LSteps;
DeltaG := (GetGValue(LEndRGB) - GetGValue(LStartRGB)) / LSteps;
DeltaB := (GetBValue(LEndRGB) - GetBValue(LStartRGB)) / LSteps;
R.Left := Rect.Left;
R.Right := Rect.Right;
Canvas.Pen.Style := psSolid;
for I := 0 to LSteps - 1 do
begin
R.Top := Rect.Top + I;
DeltaColor := RGB(
GetRValue(LStartRGB) + Round(I * DeltaR),
GetGValue(LStartRGB) + Round(I * DeltaG),
GetBValue(LStartRGB) + Round(I * DeltaB)
);
if R.Left = R.Right then
begin
Canvas.Pixels[R.Left, R.Top] := DeltaColor;
end
else
begin
Canvas.Pen.Color := DeltaColor;
Canvas.MoveTo(R.Left, R.Top);
Canvas.LineTo(R.Right, R.Top);
end;
end;
end;
procedure DrawVGradientRect2(Canvas: TCanvas; const Rect: TRect; const Color: TColor; const Delta: Byte = 50);
var
H, S, V: Integer;
C1, C2: TColor;
begin
RGBToHSV(Color, H, S, V);
C1 := HSV2RGB(H, S, V + Delta);
C2 := HSV2RGB(H, S, V - Delta);
DrawVGradientRect(Canvas, Rect, C1, C2);
end;
*)
function Compare(var Value1, Value2: Int64): Integer;
begin
Result := Value1 - Value2;
end;
function Compare(var Value1, Value2: UInt64): Integer;
begin
Result := Int64(Value1) - Int64(Value2);
end;
function Compare(var Value1, Value2: NativeInt): Integer;
begin
Result := Value1 - Value2;
end;
function Compare(var Value1, Value2: NativeUInt): Integer;
begin
Result := NativeInt(Value1) - NativeInt(Value2);
end;
// h=[0..360] s,v=[0..255]
procedure RGBToHSV(const Color: TColor; var h, s, v: Integer);
var
Delta: Integer;
MinRGB, MaxRGB: Integer;
r, g, b: Byte;
begin
r := GetRValue(Color);
g := GetGValue(Color);
b := GetBValue(Color);
MinRGB := Min(r, Min(g, b));
MaxRGB := Max(r, Max(g, b));
v := MaxRGB;
Delta := MaxRGB - MinRGB;
if MaxRGB = 0 then
s := 0
else
s := (255 * Delta) div MaxRGB;
if s = 0 then
h := 0
else
begin
if r = MaxRGB then
h := (60 * (g - b)) div Delta
else
if g = MaxRGB then
h := 120 + (60 * (b - r)) div Delta
else
h := 240 + (60 * (r - g)) div Delta;
if h < 0 then
h := h + 360;
end;
end;
function HSV2RGB(const h, s, v: Integer): TColor;
var
Hi: Integer;
f, p, q, t: Double;
r, g, b: Double;
sf, vf: Double;
hf: Integer;
begin
sf := Max(0, Min(255, s));
vf := Max(0, Min(255, v));
hf := Max(0, Min(360, h));
sf := sf / 255;
vf := vf / 255;
f := hf / 60 - (hf div 60);
p := vf * (1 - sf);
q := vf * (1 - f * sf);
t := vf * (1 - (1 - f) * sf);
Hi := (hf div 60) mod 6;
case Hi of
0: begin r := vf; g := t; b := p; end;
1: begin r := q; g := vf; b := p; end;
2: begin r := p; g := vf; b := t; end;
3: begin r := p; g := q; b := vf; end;
4: begin r := t; g := p; b := vf; end;
5: begin r := vf; g := p; b := q; end;
else
begin r := 0; g := 0; b := 0; end;
end;
Result := RGB(Round(r * 255), Round(g * 255), Round(b * 255));
end;
procedure SetXMLValue(const ParentNode: IXMLNode; const NodeName, NodeValue: String);
begin
if Assigned(ParentNode) then
ParentNode.ChildValues[AnsiLowerCase(NodeName)] := NodeValue;
end;
function GetXMLChildNode(const ParentNode: IXMLNode; const NodeName: String; const AutoCreate: LongBool = True): IXMLNode;
begin
Result := nil;
if Assigned(ParentNode) then
begin
Result := ParentNode.ChildNodes.FindNode(AnsiLowerCase(NodeName));
if not Assigned(Result) and AutoCreate then
Result := ParentNode.AddChild(NodeName);
end;
end;
function GetXMLValue(const ParentNode: IXMLNode; const NodeName: String): String;
var
ResNode: IXMLNode;
begin
Result := '';
if Assigned(ParentNode) then
begin
ResNode := ParentNode.ChildNodes.FindNode(AnsiLowerCase(NodeName));
if Assigned(ResNode) and ResNode.IsTextElement then
Result := ResNode.Text;
end;
end;
procedure SplitStr(const Str: String; const Delimiter: Char; var StrList: TStringArray);
var
SL: TStringList;
I: Integer;
begin
SL := TStringList.Create;
try
SL.Delimiter := Delimiter;
SL.StrictDelimiter;
SL.Duplicates := dupAccept;
SL.DelimitedText := Str;
SetLength(StrList, SL.Count);
for I := 0 to SL.Count - 1 do
StrList[I] := SL.Strings[I];
finally
FreeAndNil(SL);
end;
end;
function IncPointer(Ptr: Pointer; Offset: Integer): Pointer;
begin
Result := Pointer(Integer(Ptr) + Offset);
end;
procedure ClearStringList(SL: TStringList);
var
I: Integer;
Obj: TObject;
begin
if SL = nil then Exit;
for I := 0 to SL.Count - 1 do
begin
Obj := SL.Objects[I];
if Obj <> nil then
begin
SL.Objects[I] := nil;
FreeAndNil(Obj);
end;
end;
SL.Clear;
end;
procedure FreeStringList(var SL: TStringList);
begin
ClearStringList(SL);
FreeAndNil(SL);
end;
procedure ClearList(L: TList);
var
I: Integer;
Obj: TObject;
begin
if L = nil then Exit;
for I := 0 to L.Count - 1 do
begin
Obj := L[I];
if Obj <> nil then
begin
L[I] := nil;
FreeAndNil(Obj);
end;
end;
L.Clear;
end;
procedure FreeList(var L: TList);
begin
ClearList(L);
FreeAndNil(L);
end;
{ TGradientInfoList }
class function TGradientInfoList.GetGradientInfo(const AColor: TColor;
const AHeight: Integer): TGradientInfo;
begin
if not _GradientInfoList.TryGetValue(AColor, Result) then
begin
Result := TGradientInfo.Create(AColor, AHeight);
_GradientInfoList.AddOrSetValue(AColor, Result);
end;
end;
initialization
TGradientInfoList._GradientInfoList := TGradientInfoList.Create;
TGradientInfoList._GradientInfoList.OwnsValues := True;
finalization
FreeAndNil(TGradientInfoList._GradientInfoList);
end.
================================================
FILE: CollectList.inc
================================================
{ TCollectList<T> }
function TCollectList<T>.Add: PData;
var
Idx: Cardinal;
Seg, Offset: Integer;
begin
Idx := Count;
IndexToSegment(Idx, Seg, Offset);
CheckSeg(Seg);
FCount := Idx + 1;
Result := @FSegList[Seg][Offset];
FillChar(Result^, SizeOf(T), 0);
end;
procedure TCollectList<T>.CheckSeg(const Seg: Integer);
begin
if Length(FSegList) <= Seg then
begin
SetLength(FSegList, Seg + 1);
SetLength(FSegList[Seg], FSegSize);
end;
end;
procedure TCollectList<T>.Clear;
begin
FCount := 0;
SetLength(FSegList, 0);
end;
constructor TCollectList<T>.Create;
begin
inherited;
FCount := 0;
FLock := TCriticalSection.Create;
FSegSize := _SEGMENT_SIZE div SizeOf(T);
SetLength(FSegList, 0);
end;
destructor TCollectList<T>.Destroy;
begin
Clear;
FreeAndNil(FLock);
inherited;
end;
function TCollectList<T>.GetItem(const Index: Cardinal): PData;
var
Seg, Offset: Integer;
begin
if IndexToSegment(Index, Seg, Offset) then
Result := @FSegList[Seg][Offset]
else
RaiseError(@EIndexError, [Index]);
end;
function TCollectList<T>.IndexToSegment(const Index: Cardinal; var Seg, Offset: Integer): Boolean;
begin
Result := Index < Count;
Seg := Index div FSegSize;
Offset := Index mod FSegSize;
end;
procedure TCollectList<T>.RaiseError(Msg: PString; const Args: Array of const);
begin
raise TCollectListError.CreateFmt(Msg^, Args);
end;
procedure TCollectList<T>.Lock;
begin
FLock.Enter;
end;
procedure TCollectList<T>.UnLock;
begin
FLock.Leave;
end;
================================================
FILE: CollectList.pas
================================================
unit CollectList;
interface
uses Classes, SysUtils, SyncObjs, ClassUtils;
const
_DEF_SEGMENT_SIZE = 16 * 1024;
_SEG_LIST_GROW = 16;
type
TSegment<T> = Array of T;
TSegList<T> = Array of TSegment<T>;
TCollectListError = class(Exception);
PData = Pointer;
TBaseCollectList = class
private
FCount: Integer;
FAddCount: Integer;
FLock: TMREWSync;
protected
FSegLength: Integer;
function GetItem(const Index: Integer): PData; virtual; abstract;
procedure CheckSeg(const Seg: Integer); virtual; abstract;
function IndexToSegment(const Index: Integer; var Seg, Offset: Integer): LongBool;
procedure RaiseError(Msg: PString; const Args: Array of const);
public
constructor Create;
destructor Destroy; override;
function Add: PData; virtual;
procedure Commit; virtual;
procedure Clear; virtual;
procedure BeginRead; inline;
procedure EndRead; inline;
procedure BeginWrite; inline;
procedure EndWrite; inline;
property Count: Integer read FCount;
property Items[const Index: Integer]: PData read GetItem; default;
property Lock: TMREWSync read FLock;
end;
TCollectList<T> = class(TBaseCollectList)
private
FSegList: TSegList<T>;
protected
function GetItem(const Index: Integer): PData; override;
procedure CheckSeg(const Seg: Integer); override;
public
constructor Create(const SegSize: Integer = _DEF_SEGMENT_SIZE);
destructor Destroy; override;
function Add: PData; override;
procedure Clear; override;
end;
//XE6 bug? default AtomicIncrement gives an AV!
function AtomicIncrement(var Target: Integer; Increment: Integer): Integer; overload;
function AtomicIncrement(var Target: Integer): Integer; overload;
implementation
uses
Winapi.Windows;
{ TBaseCollectList }
function AtomicIncrement(var Target: Integer; Increment: Integer): Integer; overload; inline;
begin
Result := InterlockedExchangeAdd(Target, Increment);
end;
function AtomicIncrement(var Target: Integer): Integer; overload; inline;
begin
Result := InterlockedIncrement(Target);
end;
function TBaseCollectList.Add: PData;
begin
Result := Nil;
AtomicIncrement(FAddCount);
end;
procedure TBaseCollectList.Clear;
begin
FCount := 0;
end;
procedure TBaseCollectList.Commit;
begin
BeginWrite;
AtomicIncrement(FCount, FAddCount);
AtomicExchange(FAddCount, 0);
EndWrite;
end;
constructor TBaseCollectList.Create;
begin
inherited;
FCount := 0;
FLock := TMREWSync.Create;
end;
destructor TBaseCollectList.Destroy;
begin
Clear;
FreeAndNil(FLock);
inherited;
end;
procedure TBaseCollectList.BeginRead;
begin
FLock.BeginRead;
end;
procedure TBaseCollectList.BeginWrite;
begin
FLock.BeginWrite;
end;
procedure TBaseCollectList.RaiseError(Msg: PString; const Args: array of const);
begin
raise TCollectListError.CreateFmt(Msg^, Args);
end;
procedure TBaseCollectList.EndRead;
begin
FLock.EndRead;
end;
procedure TBaseCollectList.EndWrite;
begin
FLock.EndWrite;
end;
function TBaseCollectList.IndexToSegment(const Index: Integer; var Seg, Offset: Integer): LongBool;
begin
Result := (Index < FCount) and (Index >= 0);
Seg := Index div FSegLength;
Offset := Index mod FSegLength;
end;
{ TCollectList<T> }
function TCollectList<T>.Add: PData;
var
Seg, Offset: Integer;
NextIdx: Integer;
begin
BeginRead;
//
NextIdx := FCount + AtomicIncrement(FAddCount) - 1;
//
IndexToSegment(NextIdx, Seg, Offset);
CheckSeg(Seg);
//
Result := @FSegList[Seg][Offset];
EndRead;
FillChar(Result^, SizeOf(T), 0);
//Initialize(T(Result^));
end;
procedure TCollectList<T>.CheckSeg(const Seg: Integer);
begin
//BeginRead;
if Length(FSegList) <= Seg then
begin
BeginWrite;
SetLength(FSegList, Seg + _SEG_LIST_GROW);
SetLength(FSegList[Seg], FSegLength);
EndWrite;
end;
if Length(FSegList[Seg]) = 0 then
begin
BeginWrite;
SetLength(FSegList[Seg], FSegLength);
EndWrite;
end;
//EndRead;
end;
procedure TCollectList<T>.Clear;
begin
BeginWrite;
inherited Clear;
SetLength(FSegList, 0);
EndWrite;
end;
constructor TCollectList<T>.Create(const SegSize: Integer = _DEF_SEGMENT_SIZE);
begin
inherited Create;
FSegLength := SegSize div SizeOf(T);
SetLength(FSegList, 0);
end;
destructor TCollectList<T>.Destroy;
begin
Clear;
inherited;
end;
function TCollectList<T>.GetItem(const Index: Integer): PData;
var
Seg, Offset: Integer;
begin
Result := nil;
if IndexToSegment(Index, Seg, Offset) then
begin
BeginRead;
Result := @FSegList[Seg][Offset];
EndRead;
end
else
RaiseError(@EIndexError, [Index]);
end;
end.
================================================
FILE: CollectListIntf.inc
================================================
const
_SEGMENT_SIZE = 16 * 1024;
type
TSegment<T> = Array of T;
TSegList<T> = Array of TSegment<T>;
TCollectListError = class(Exception);
PData = Pointer;
TCollectList<T> = class
private
FCount: Cardinal;
FSegSize: Cardinal;
FLock: TCriticalSection;
FSegList: TSegList<T>;
function GetItem(const Index: Cardinal): PData;
procedure CheckSeg(const Seg: Integer);
protected
function IndexToSegment(const Index: Cardinal; var Seg, Offset: Integer): Boolean;
procedure RaiseError(Msg: PString; const Args: Array of const);
public
constructor Create;
destructor Destroy; override;
function Add: PData;
procedure Clear;
procedure Lock;
procedure UnLock;
property Count: Cardinal read FCount;
property Items[const Index: Cardinal]: PData read GetItem; default;
end;
================================================
FILE: Collections/Collections.Bags.pas
================================================
(*
* Copyright (c) 2009-2012, Ciobanu Alexandru
* 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.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ''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 AUTHOR 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.
*)
unit Collections.Bags;
interface
uses SysUtils,
Generics.Defaults,
Generics.Collections,
Collections.Base,
Collections.Dictionaries;
type
/// <summary>The abstract base class for all <c>bag</c> collections.</summary>
/// <remarks>This base class introduces and implements all bag operations. Specific <c>bag</c> implementations must
/// override only one method in order to create the specific dictionary type that is going to hold the element to weight associations.</remarks>
TAbstractBag<T> = class(TCollection<T>, IBag<T>)
private type
{$REGION 'Internal Types'}
TEnumerator = class(TAbstractEnumerator<T>)
private
FCurrentWeight: NativeInt;
FDictionaryEnumerator: IEnumerator<TPair<T, NativeUInt>>;
public
function TryMoveNext(out ACurrent: T): Boolean; override;
end;
{$ENDREGION}
private var
FDictionary: IDictionary<T, NativeUInt>;
FKnownCount: NativeInt;
protected
/// <summary>Specifies the internal dictionary used to store the element to weight associations.</summary>
/// <remarks>The value of this property is <c>nil</c> only when the object is still being created.</remarks>
/// <returns>A new dictionary whose keys are the bag's elements and the values are the weights associated with
/// those elements.</returns>
property Dictionary: IDictionary<T, NativeUInt> read FDictionary;
/// <summary>Returns the number of elements in the bag.</summary>
/// <returns>A positive value specifying the number of elements in the bag.</returns>
/// <remarks>The count of a bag is calculated by taking each element multiplied by its weight. For example, if the bag only contains one element
/// with weight <c>10</c>, then the size of the bag is <c>10</c>.</remarks>
function GetCount(): NativeInt; override;
/// <summary>Returns the weight of an element in the bag.</summary>
/// <param name="AValue">The element to return the weight for.</param>
/// <returns>A positive number specifying the weight of the requested element.</returns>
/// <remarks>If the value is not found in the bag, a zero weight is assumed.</remarks>
function GetWeight(const AValue: T): NativeUInt;
/// <summary>Sets the weight of an element in the bag.</summary>
/// <param name="AValue">The element to set the weight for.</param>
/// <param name="AWeight">The new weight to set.</param>
/// <remarks>If the value is not found in the bag, this method acts like an <c>Add</c> operation; otherwise
/// the weight of the stored item is adjusted accordingly.</remarks>
procedure SetWeight(const AValue: T; const AWeight: NativeUInt);
/// <summary>Called when the map needs to initialize its internal dictionary.</summary>
/// <param name="ARules">The rule set describing the elements.</param>
/// <remarks>This method creates a hash-based dictionary used as the underlying back-end for the bag.</remarks>
function CreateDictionary(const ARules: TRules<T>): IDictionary<T, NativeUInt>; virtual; abstract;
public
/// <summary>Creates a new <c>bag</c> collection.</summary>
/// <param name="ARules">A rule set describing the elements in the bag.</param>
constructor Create(const ARules: TRules<T>);
/// <summary>Clears the contents of the bag.</summary>
procedure Clear(); override;
/// <summary>Adds an element into the bag with a weight of <c>1</c>.</summary>
/// <param name="AValue">The value to add.</param>
procedure Add(const AValue: T); override;
/// <summary>Adds an element to the bag.</summary>
/// <param name="AValue">The element to add.</param>
/// <param name="AWeight">The weight of the element.</param>
/// <remarks>If the bag already contains the given value, its stored weight is incremented to by <paramref name="AWeight"/>.
/// If the value of <paramref name="AWeight"/> is zero, nothing happens.</remarks>
procedure AddWeight(const AValue: T; const AWeight: NativeUInt = 1);
/// <summary>Decreases the weight for an element by <c>1</c>.</summary>
/// <param name="AValue">The value to decrese weight for.</param>
procedure Remove(const AValue: T); override;
/// <summary>Removes an element from the bag.</summary>
/// <param name="AValue">The value to remove.</param>
/// <param name="AWeight">The weight to remove.</param>
/// <remarks>This method decreses the weight of the stored item by <paramref name="AWeight"/>. If the resulting weight is less
/// than zero or zero, the element is removed from the bag. If <paramref name="AWeight"/> is zero, nothing happens.</remarks>
procedure RemoveWeight(const AValue: T; const AWeight: NativeUInt = 1);
/// <summary>Removes an element from the bag.</summary>
/// <param name="AValue">The value to remove.</param>
/// <remarks>This method completely removes an item from the bag ignoring its stored weight. Nothing happens if the given value
/// is not in the bag to begin with.</remarks>
procedure RemoveAllWeight(const AValue: T);
/// <summary>Checks whether the bag contains an element with at least the weight of <c>1</c>.</summary>
/// <param name="AValue">The value to check for.</param>
/// <returns><c>True</c> if the condition is met; <c>False</c> otherwise.</returns>
function Contains(const AValue: T): Boolean; override;
/// <summary>Checks whether the bag contains an element with at least the required weight.</summary>
/// <param name="AValue">The value to check.</param>
/// <param name="AWeight">The smallest allowed weight.</param>
/// <returns><c>True</c> if the condition is met; <c>False</c> otherwise.</returns>
/// <remarks>This method checks whether the bag contains the given value and that the contained value has at least the
/// given weight.</remarks>
function ContainsWeight(const AValue: T; const AWeight: NativeUInt = 1): Boolean;
/// <summary>Sets or gets the weight of an item in the bag.</summary>
/// <param name="AValue">The value.</param>
/// <remarks>If the value is not found in the bag, this method acts like an <c>Add</c> operation; otherwise
/// the weight of the stored item is adjusted.</remarks>
property Weights[const AValue: T]: NativeUInt read GetWeight write SetWeight; default;
/// <summary>Returns the number of elements in the bag.</summary>
/// <returns>A positive value specifying the number of elements in the bag.</returns>
/// <remarks>The count of a bag is calculated by taking each element multiplied by its weight. For example, if the bag only contains one element
/// with weight <c>10</c>, then the size of the bag is <c>10</c>.</remarks>
property Count: NativeInt read FKnownCount;
/// <summary>Returns a new enumerator object used to enumerate this bag.</summary>
/// <remarks>This method is usually called by compiler-generated code. Its purpose is to create an enumerator
/// object that is used to actually traverse the bag.</remarks>
/// <returns>An enumerator object.</returns>
function GetEnumerator(): IEnumerator<T>; override;
/// <summary>Copies the values stored in the bag to a given array.</summary>
/// <param name="AArray">An array where to copy the contents of the bag.</param>
/// <param name="AStartIndex">The index into the array at which the copying begins.</param>
/// <remarks>This method assumes that <paramref name="AArray"/> has enough space to hold the contents of the bag.</remarks>
/// <exception cref="SysUtils|EArgumentOutOfRangeException"><paramref name="AStartIndex"/> is out of bounds.</exception>
/// <exception cref="Collections.Base|EArgumentOutOfSpaceException">The array is not long enough.</exception>
procedure CopyTo(var AArray: array of T; const AStartIndex: NativeInt); overload; override;
/// <summary>Checks whether the bag is empty.</summary>
/// <returns><c>True</c> if the bag is empty; <c>False</c> otherwise.</returns>
/// <remarks>This method is the recommended way of detecting if the bag is empty.</remarks>
function Empty(): Boolean; override;
/// <summary>Returns the biggest element.</summary>
/// <returns>An element from the bag considered to have the biggest value.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The bag is empty.</exception>
function Max(): T; override;
/// <summary>Returns the smallest element.</summary>
/// <returns>An element from the bag considered to have the smallest value.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The bag is empty.</exception>
function Min(): T; override;
/// <summary>Returns the first element.</summary>
/// <returns>The first element in the bag.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The bag is empty.</exception>
function First(): T; override;
/// <summary>Returns the first element or a default, if the bag is empty.</summary>
/// <param name="ADefault">The default value returned if the bag is empty.</param>
/// <returns>The first element in the bag if the bag is not empty; otherwise <paramref name="ADefault"/> is returned.</returns>
function FirstOrDefault(const ADefault: T): T; override;
/// <summary>Returns the last element.</summary>
/// <returns>The last element in the bag.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The bag is empty.</exception>
function Last(): T; override;
/// <summary>Returns the last element or a default, if the bag is empty.</summary>
/// <param name="ADefault">The default value returned if the bag is empty.</param>
/// <returns>The last element in the bag if the bag is not empty; otherwise <paramref name="ADefault"/> is returned.</returns>
function LastOrDefault(const ADefault: T): T; override;
/// <summary>Returns the single element stored in the bag.</summary>
/// <returns>The element in the bag.</returns>
/// <remarks>This method checks whether the bag contains just one element, in which case it is returned.</remarks>
/// <exception cref="Collections.Base|ECollectionEmptyException">The bag is empty.</exception>
/// <exception cref="Collections.Base|ECollectionNotOneException">There is more than one element in the bag.</exception>
function Single(): T; override;
/// <summary>Returns the single element stored in the bag, or a default value.</summary>
/// <param name="ADefault">The default value returned if there are less or more elements in the bag.</param>
/// <returns>The element in the bag if the condition is satisfied; <paramref name="ADefault"/> is returned otherwise.</returns>
/// <remarks>This method checks whether the bag contains just one element, in which case it is returned. Otherwise
/// the value in <paramref name="ADefault"/> is returned.</remarks>
function SingleOrDefault(const ADefault: T): T; override;
/// <summary>Checks whether at least one element in the bag satisfies a given predicate.</summary>
/// <param name="APredicate">The predicate to check for each element.</param>
/// <returns><c>True</c> if at least one element satisfies a given predicate; <c>False</c> otherwise.</returns>
/// <remarks>This method traverses the whole bag and checks the value of the predicate for each element. This method
/// stops on the first element for which the predicate returns <c>True</c>. The logical equivalent of this operation is "OR".</remarks>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="APredicate"/> is <c>nil</c>.</exception>
function Any(const APredicate: TPredicate<T>): Boolean; override;
/// <summary>Checks that all elements in the bag satisfy a given predicate.</summary>
/// <param name="APredicate">The predicate to check for each element.</param>
/// <returns><c>True</c> if all elements satisfy a given predicate; <c>False</c> otherwise.</returns>
/// <remarks>This method traverses the whole bag and checks the value of the predicate for each element. This method
/// stops on the first element for which the predicate returns <c>False</c>. The logical equivalent of this operation is "AND".</remarks>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="APredicate"/> is <c>nil</c>.</exception>
function All(const APredicate: TPredicate<T>): Boolean; override;
end;
type
/// <summary>The generic <c>bag</c> collection.</summary>
/// <remarks>This particular <c>bag</c> implementation uses a hash-based dictionary to store its element to weight associations.</remarks>
TBag<T> = class(TAbstractBag<T>)
private var
FInitialCapacity: NativeInt;
protected
/// <summary>Called when the bag needs to initialize its internal dictionary.</summary>
/// <param name="ARules">The rule set describing the bag's elements.</param>
/// <remarks>This method creates a hash-based dictionary used as the underlying back-end for the bag.</remarks>
function CreateDictionary(const ARules: TRules<T>): IDictionary<T, NativeUInt>; override;
public
/// <summary>Creates a new <c>bag</c> collection.</summary>
/// <remarks>This constructor requests the default rule set. Call the overloaded constructor if
/// specific a set of rules need to be passed.</remarks>
constructor Create(); overload;
/// <summary>Creates a new <c>bag</c> collection.</summary>
/// <param name="ARules">A rule set describing the elements in the bag.</param>
constructor Create(const ARules: TRules<T>); overload;
/// <summary>Creates a new <c>bag</c> collection.</summary>
/// <param name="ARules">A rule set describing the elements in the bag.</param>
/// <param name="AInitialCapacity">The stack's initial capacity.</param>
constructor Create(const ARules: TRules<T>; const AInitialCapacity: NativeInt); overload;
end;
/// <summary>The generic <c>bag</c> collection designed to store objects.</summary>
/// <remarks>This particular <c>bag</c> implementation uses a hash-based dictionary to store its element to weight associations.</remarks>
TObjectBag<T: class> = class(TBag<T>)
private
FOwnsObjects: Boolean;
protected
/// <summary>Frees the object that was removed from the collection.</summary>
/// <param name="AElement">The object that was removed from the collection.</param>
/// <remarks>This method will only free the removed element if <c>OwnsObjects</c> property is set to <c>True</c>;
/// otherwise it will simply be ignored.</remarks>
procedure HandleElementRemoved(const AElement: T); override;
public
/// <summary>Specifies whether this bag owns the elements stored in it.</summary>
/// <returns><c>True</c> if the bag owns its elements; <c>False</c> otherwise.</returns>
/// <remarks>This property specifies the way the bag controls the life-time of its elements.</remarks>
property OwnsObjects: Boolean read FOwnsObjects write FOwnsObjects;
end;
type
/// <summary>The generic sorted <c>bag</c> collection.</summary>
/// <remarks>This particular <c>bag</c> implementation uses an AVL-based dictionary to store its element to weight associations.</remarks>
TSortedBag<T> = class(TAbstractBag<T>)
private var
FAscendingSort: Boolean;
protected
/// <summary>Called when the bag needs to initialize its internal dictionary.</summary>
/// <param name="ARules">The rule set describing the bag's elements.</param>
/// <remarks>This method creates an AVL-based dictionary used as the underlying back-end for the bag.</remarks>
function CreateDictionary(const ARules: TRules<T>): IDictionary<T, NativeUInt>; override;
public
/// <summary>Creates a new <c>bag</c> collection.</summary>
/// <remarks>This constructor requests the default rule set. Call the overloaded constructor if
/// specific a set of rules need to be passed. The elements are stored in ascending order.</remarks>
constructor Create(); overload;
/// <summary>Creates a new <c>bag</c> collection.</summary>
/// <param name="ARules">A rule set describing the elements in the bag.</param>
/// <remarks>The elements are stored in ascending order.</remarks>
constructor Create(const ARules: TRules<T>); overload;
/// <summary>Creates a new <c>bag</c> collection.</summary>
/// <param name="AAscending">Pass in a value of <c>True</c> if the elements should be kept in ascending order.
/// Pass in <c>False</c> for descending order.</param>
/// <param name="ARules">A rule set describing the elements in the bag.</param>
constructor Create(const ARules: TRules<T>; const AAscending: Boolean); overload;
end;
/// <summary>The generic sorted <c>bag</c> collection designed to store objects.</summary>
/// <remarks>This particular <c>bag</c> implementation uses an AVL-based dictionary to store its element to weight associations.</remarks>
TObjectSortedBag<T: class> = class(TSortedBag<T>)
private
FOwnsObjects: Boolean;
protected
/// <summary>Frees the object that was removed from the collection.</summary>
/// <param name="AElement">The object that was removed from the collection.</param>
/// <remarks>This method will only free the removed element if <c>OwnsObjects</c> property is set to <c>True</c>;
/// otherwise it will simply be ignored.</remarks>
procedure HandleElementRemoved(const AElement: T); override;
public
/// <summary>Specifies whether this bag owns the elements stored in it.</summary>
/// <returns><c>True</c> if the bag owns its elements; <c>False</c> otherwise.</returns>
/// <remarks>This property specifies the way the bag controls the life-time of its elements.</remarks>
property OwnsObjects: Boolean read FOwnsObjects write FOwnsObjects;
end;
implementation
{ TAbstractBag<T> }
procedure TAbstractBag<T>.Add(const AValue: T);
begin
AddWeight(AValue, 1);
end;
procedure TAbstractBag<T>.AddWeight(const AValue: T; const AWeight: NativeUInt);
var
LOldCount: NativeUInt;
begin
{ Check count > 0 }
if AWeight = 0 then
Exit;
{ Add or update count }
if FDictionary.TryGetValue(AValue, LOldCount) then
FDictionary[AValue] := LOldCount + AWeight
else
FDictionary.Add(AValue, AWeight);
Inc(FKnownCount, AWeight);
NotifyCollectionChanged();
end;
function TAbstractBag<T>.All(const APredicate: TPredicate<T>): Boolean;
begin
{ Use TDictionary's Keys }
Result := FDictionary.Keys.All(APredicate);
end;
function TAbstractBag<T>.Any(const APredicate: TPredicate<T>): Boolean;
begin
{ Use TDictionary's Keys }
Result := FDictionary.Keys.Any(APredicate);
end;
procedure TAbstractBag<T>.Clear;
begin
if Assigned(FDictionary) then
begin
{ Simply clear the dictionary }
FDictionary.Clear();
FKnownCount := 0;
NotifyCollectionChanged();
end;
end;
function TAbstractBag<T>.Contains(const AValue: T): Boolean;
begin
Result := ContainsWeight(AValue, 1);
end;
function TAbstractBag<T>.ContainsWeight(const AValue: T; const AWeight: NativeUInt): Boolean;
var
LInCount: NativeUInt;
begin
{ Check count > 0 }
if AWeight = 0 then
Exit(true);
{ Check the counts in the bag }
Result := (FDictionary.TryGetValue(AValue, LInCount)) and (LInCount >= AWeight);
end;
procedure TAbstractBag<T>.CopyTo(var AArray: array of T; const AStartIndex: NativeInt);
var
LTempArray: array of TPair<T, NativeUInt>;
I, X, Y: NativeInt;
begin
if (AStartIndex >= Length(AArray)) or (AStartIndex < 0) then
ExceptionHelper.Throw_ArgumentOutOfRangeError('AStartIndex');
{ Check for indexes }
if (Length(AArray) - AStartIndex) < Count then
ExceptionHelper.Throw_ArgumentOutOfSpaceError('AArray');
{ Nothing to do? }
if Count = 0 then
Exit;
{ Initialize the temporary array }
SetLength(LTempArray, FDictionary.Count);
FDictionary.CopyTo(LTempArray);
X := AStartIndex;
{ OK! Now let's simply copy }
for I := 0 to Length(LTempArray) - 1 do
begin
{ Copy one value for a number of counts }
for Y := 0 to LTempArray[I].Value - 1 do
begin
AArray[X] := LTempArray[I].Key;
Inc(X);
end;
end;
end;
constructor TAbstractBag<T>.Create(const ARules: TRules<T>);
begin
inherited Create(ARules);
FDictionary := CreateDictionary(ElementRules);
end;
function TAbstractBag<T>.Empty: Boolean;
begin
Result := (FKnownCount = 0);
end;
function TAbstractBag<T>.First: T;
begin
{ Use TDictionary's Keys }
Result := FDictionary.Keys.First();
end;
function TAbstractBag<T>.FirstOrDefault(const ADefault: T): T;
begin
{ Use TDictionary's Keys }
Result := FDictionary.Keys.FirstOrDefault(ADefault);
end;
function TAbstractBag<T>.Last: T;
begin
{ Use TDictionary's Keys }
Result := FDictionary.Keys.Last();
end;
function TAbstractBag<T>.LastOrDefault(const ADefault: T): T;
begin
{ Use TDictionary's Keys }
Result := FDictionary.Keys.LastOrDefault(ADefault);
end;
function TAbstractBag<T>.Max: T;
begin
{ Use TDictionary's Keys }
Result := FDictionary.Keys.Max();
end;
function TAbstractBag<T>.Min: T;
begin
{ Use TDictionary's Keys }
Result := FDictionary.Keys.Min();
end;
function TAbstractBag<T>.GetCount: NativeInt;
begin
{ Dictionary knows the real count }
Result := FKnownCount;
end;
function TAbstractBag<T>.GetWeight(const AValue: T): NativeUInt;
begin
{ Get the count }
if not FDictionary.TryGetValue(AValue, Result) then
Result := 0;
end;
function TAbstractBag<T>.GetEnumerator: IEnumerator<T>;
var
LEnumerator: TEnumerator;
begin
LEnumerator := TEnumerator.Create(Self);
LEnumerator.FDictionaryEnumerator := FDictionary.GetEnumerator();
Result := LEnumerator;
end;
procedure TAbstractBag<T>.RemoveWeight(const AValue: T; const AWeight: NativeUInt);
var
LOldCount: NativeUInt;
begin
{ Check count > 0 }
if AWeight = 0 then
Exit;
{ Check that the key os present in the dictionary first }
if not FDictionary.TryGetValue(AValue, LOldCount) then
Exit;
if LOldCount < AWeight then
LOldCount := 0
else
LOldCount := LOldCount - AWeight;
{ Update the counts }
if LOldCount = 0 then
FDictionary.Remove(AValue)
else
FDictionary[AValue] := LOldCount;
Dec(FKnownCount, AWeight);
NotifyCollectionChanged();
end;
procedure TAbstractBag<T>.Remove(const AValue: T);
begin
RemoveWeight(AValue, 1);
end;
procedure TAbstractBag<T>.RemoveAllWeight(const AValue: T);
var
LOldCount: NativeUInt;
begin
{ Check that the key is present in the dictionary first }
if not FDictionary.TryGetValue(AValue, LOldCount) then
Exit;
FDictionary.Remove(AValue);
Dec(FKnownCount, LOldCount);
NotifyCollectionChanged();
end;
procedure TAbstractBag<T>.SetWeight(const AValue: T; const AWeight: NativeUInt);
var
LOldValue: NativeUInt;
begin
{ Check count > 0 }
if Count = 0 then
Exit;
if FDictionary.ContainsKey(AValue) then
begin
LOldValue := FDictionary[AValue];
FDictionary[AValue] := AWeight;
end else
begin
LOldValue := 0;
FDictionary.Add(AValue, AWeight);
end;
{ Change the counts }
FKnownCount := FKnownCount - NativeInt(LOldValue + AWeight);
NotifyCollectionChanged();
end;
function TAbstractBag<T>.Single: T;
begin
{ Use TDictionary's Keys }
Result := FDictionary.Keys.Single();
end;
function TAbstractBag<T>.SingleOrDefault(const ADefault: T): T;
begin
{ Use TDictionary's Keys }
Result := FDictionary.Keys.SingleOrDefault(ADefault);
end;
{ TAbstractBag<T>.TEnumerator }
function TAbstractBag<T>.TEnumerator.TryMoveNext(out ACurrent: T): Boolean;
begin
{ Repeat until something happens }
while True do
begin
if FCurrentWeight > 0 then
begin
{ Decrease the count of the bag item }
Dec(FCurrentWeight);
Result := True;
Break;
end else
begin
Result := FDictionaryEnumerator.MoveNext();
if Result then
FCurrentWeight := FDictionaryEnumerator.Current.Value
else
Break;
end;
end;
if Result then
ACurrent := FDictionaryEnumerator.Current.Key;
end;
{ TBag<T> }
constructor TBag<T>.Create(const ARules: TRules<T>; const AInitialCapacity: NativeInt);
begin
FInitialCapacity := AInitialCapacity;
inherited Create(ARules);
end;
constructor TBag<T>.Create;
begin
Create(TRules<T>.Default, CDefaultSize);
end;
constructor TBag<T>.Create(const ARules: TRules<T>);
begin
Create(ARules, CDefaultSize);
end;
function TBag<T>.CreateDictionary(const ARules: TRules<T>): IDictionary<T, NativeUInt>;
var
LNewCapacity: NativeInt;
LDictionary: TDictionary<T, NativeUInt>;
begin
{ Create a simple dictionary }
if FInitialCapacity <= 0 then
LNewCapacity := CDefaultSize
else
LNewCapacity := FInitialCapacity;
LDictionary := TDictionary<T, NativeUInt>.Create(ARules, TRules<NativeUInt>.Default, LNewCapacity);
LDictionary.KeyRemoveNotification := NotifyElementRemoved;
Result := LDictionary;
end;
{ TObjectBag<T> }
procedure TObjectBag<T>.HandleElementRemoved(const AElement: T);
begin
if FOwnsObjects then
TObject(AElement).Free;
end;
{ TSortedBag<T> }
constructor TSortedBag<T>.Create;
begin
Create(TRules<T>.Default, True);
end;
constructor TSortedBag<T>.Create(const ARules: TRules<T>);
begin
Create(ARules, True);
end;
function TSortedBag<T>.CreateDictionary(const ARules: TRules<T>): IDictionary<T, NativeUInt>;
var
LDictionary: TSortedDictionary<T, NativeUInt>;
begin
{ Create a sorted dictionary }
LDictionary := TSortedDictionary<T, NativeUInt>.Create(ARules, TRules<NativeUInt>.Default, FAscendingSort);
LDictionary.KeyRemoveNotification := NotifyElementRemoved;
Result := LDictionary;
end;
constructor TSortedBag<T>.Create(const ARules: TRules<T>; const AAscending: Boolean);
begin
{ Call upper constructor }
FAscendingSort := AAscending;
inherited Create(ARules);
end;
{ TObjectSortedBag<T> }
procedure TObjectSortedBag<T>.HandleElementRemoved(const AElement: T);
begin
if FOwnsObjects then
TObject(AElement).Free;
end;
end.
================================================
FILE: Collections/Collections.Base.pas
================================================
(*
* Copyright (c) 2008-2012, Ciobanu Alexandru
* 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.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the <organization> nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ''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 AUTHOR 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.
*)
unit Collections.Base;
interface
uses
SysUtils,
TypInfo,
Rtti,
Collections.Dynamic,
Generics.Collections,
Generics.Defaults;
{$REGION 'Base Collection Interfaces'}
type
/// <summary>The predicate that accepts two input values.</summary>
/// <param name="Arg1">The first argument.</param>
/// <param name="Arg2">The second argument.</param>
/// <returns>A boolean value that indicates the result of the logical predicate.</returns>
TPredicate<T1, T2> = reference to function(Arg1: T1; Arg2: T2): Boolean;
TBalanceAct = (baStart, baLeft, baRight, baLoop, baEnd);
/// <summary>Base interface describing all enumerators in this package.</summary>
/// <remarks><see cref="Collections.Base|IEnumerator<T>">Collections.Base.IEnumerator<T></see> is implemented by
/// all enumerator objects in this package.</remarks>
IEnumerator<T> = interface
/// <summary>Returns the current element of the enumerated collection.</summary>
/// <remarks><see cref="Collections.Base|IEnumerator<T>.GetCurrent">Collections.Base.IEnumerator<T>.GetCurrent</see> is the
/// getter method for the <see cref="Collections.Base|IEnumerator<T>.Current">Collections.Base.IEnumerator<T>.Current</see>
/// property. Use the property to obtain the element instead.</remarks>
/// <returns>The current element of the enumerated collection.</returns>
function GetCurrent(): T;
/// <summary>Moves the enumerator to the next element of the collection.</summary>
/// <remarks><see cref="Collections.Base|IEnumerator<T>.MoveNext">Collections.Base.IEnumerator<T>.MoveNext</see> is usually
/// called by compiler-generated code. Its purpose is to move the "pointer" to the next element in the collection
/// (if there are elements left). Also note that many enumerator implementations may throw various exceptions if the
/// enumerated collections were changed in the meantime.</remarks>
/// <returns><c>True</c> if the enumerator successfully selected the next element; <c>False</c> if there are
/// no more elements to be enumerated.</returns>
function MoveNext(): Boolean;
/// <summary>Returns the current element of the traversed collection.</summary>
/// <remarks><see cref="Collections.Base|IEnumerator<T>.Current">Collections.Base.IEnumerator<T>.Current</see> can only return a
/// valid element if <see cref="Collections.Base|IEnumerator<T>.MoveNext">Collections.Base.IEnumerator<T>.MoveNext</see> was
/// priorly called and returned <c>True</c>; otherwise the behavior of this property is undefined. Note that many enumerator implementations
/// may throw exceptions if the collection was changed in the meantime.
/// </remarks>
/// <returns>The current element of the enumerator collection.</returns>
property Current: T read GetCurrent;
end;
/// <summary>Base interface describing all enumerable collections in this package.</summary>
/// <remarks><see cref="Collections.Base|IEnumerable<T>">Collections.Base.IEnumerable<T></see> is implemented by all
/// enumerable collections in this package.</remarks>
IEnumerable<T> = interface
/// <summary>Returns a <see cref="Collections.Base|IEnumerator<T>">Collections.Base.IEnumerator<T></see> interface that is used
/// to enumerate the collection.</summary>
/// <remarks><see cref="Collections.Base|IEnumerable<T>.MoveNext">Collections.Base.IEnumerable<T>.MoveNext</see> is usually
/// called by compiler-generated code. Its purpose is to create an enumerator object that is used to actually traverse
/// the collections.
/// Note that many collections generate enumerators that depend on the state of the collection. If the collection is changed
/// after the <see cref="Collections.Base|IEnumerator<T>">Collections.Base.IEnumerator<T></see> had been obtained,
/// <see cref="Collections.Base|ECollectionChangedException">Collections.Base.ECollectionChangedException</see> is thrown.</remarks>
/// <returns>The <see cref="Collections.Base|IEnumerator<T>">Collections.Base.IEnumerator<T></see> interface.</returns>
function GetEnumerator(): IEnumerator<T>;
end;
/// <summary>A special record designed to hold both a comparer and an equality
/// comparer. All collections require this type in order to function properly.</summary>
/// <remarks>The collection provided in this package provides extended functionality (Enex), which
/// implies comparing values in many circumstances, which requires the presence of the comparer.
/// Some collections need an additional equality comparer. This type is meant to provide both
/// on the need basis.</remarks>
TRules<T> = record
private
FComparer: IComparer<T>;
FEqComparer: IEqualityComparer<T>;
public
/// <summary>Initializes a rule set with the given comparers.</summary>
/// <param name="AComparer">The comparer.</param>
/// <param name="AEqualityComparer">The equality comparer.</param>
/// <returns>A rule set initialized with the provided comparers.</returns>
/// <exception cref="SysUtils|EArgumentNilException"> if <paramref name="AComparer"/> is <c>nil</c>.</exception>
/// <exception cref="SysUtils|EArgumentNilException"> if <paramref name="AEqualityComparer"/> is <c>nil</c>.</exception>
class function Create(const AComparer: IComparer<T>; const AEqualityComparer: IEqualityComparer<T>): TRules<T>; static;
/// <summary>Initializes a rule set with a given custom comparer.</summary>
/// <param name="AComparer">The custom comparer.</param>
/// <returns>A rule set initialized with the custom comparer.</returns>
/// <exception cref="SysUtils|EArgumentNilException"> if <paramref name="AComparer"/> is <c>nil</c>.</exception>
class function Custom(const AComparer: TCustomComparer<T>): TRules<T>; static;
/// <summary>Initializes a rule set using default comparers.</summary>
/// <returns>A rule set initialized with the default comparers.</returns>
class function Default: TRules<T>; static;
end;
/// <summary>Base interface inherited by all specific collection interfaces.</summary>
/// <remarks>This interface defines a set of traits common to all collections implemented in this package.</remarks>
IContainer<T> = interface(IEnumerable<T>)
/// <summary>Returns the current version of the collection.</summary>
/// <returns>An integer value specifying the current "structural version" of the collection.</returns>
/// <remarks>This function returns a number that is modified by the implementing collection each time
/// the collection changes. This version can be used to identify if a collection has chnaged since last time it was used
/// in a specific piece of code.</remarks>
function Version(): NativeInt;
/// <summary>Returns the number of elements in the collection.</summary>
/// <returns>A positive value specifying the number of elements in the collection.</returns>
/// <remarks>For associative collections such as dictionaries or multimaps, this value represents the
/// number of key-value pairs stored in the collection. A call to this method can be costly because some
/// collections cannot detect the number of stored elements directly, resorting to enumerating themselves.</remarks>
function GetCount(): NativeInt;
/// <summary>Checks whether the collection is empty.</summary>
/// <returns><c>True</c> if the collection is empty; <c>False</c> otherwise.</returns>
/// <remarks>This method is the recommended way of detecting if the collection is empty. It is optimized
/// in most collections to offer a fast response.</remarks>
function Empty(): Boolean;
/// <summary>Returns the single element stored in the collection.</summary>
/// <returns>The element in the collection.</returns>
/// <remarks>This method checks whether the collection contains just one element, in which case it is returned.</remarks>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="Collections.Base|ECollectionNotOneException">There is more than one element in the collection.</exception>
function Single(): T;
/// <summary>Returns the single element stored in the collection, or a default value.</summary>
/// <param name="ADefault">The default value returned if there is less or more elements in the collection.</param>
/// <returns>The element in the collection if the condition is satisfied; <paramref name="ADefault"/> is returned otherwise.</returns>
/// <remarks>This method checks whether the collection contains just one element, in which case it is returned. Otherwise
/// the value in <paramref name="ADefault"/> is returned.</remarks>
function SingleOrDefault(const ADefault: T): T;
/// <summary>Copies the values stored in the collection to a given array.</summary>
/// <param name="AArray">An array where to copy the contents of the collection.</param>
/// <remarks>This method assumes that <paramref name="AArray"/> has enough space to hold the contents of the collection.</remarks>
/// <exception cref="Collections.Base|EArgumentOutOfSpaceException">The array is not long enough.</exception>
procedure CopyTo(var AArray: array of T); overload;
/// <summary>Copies the values stored in the collection to a given array.</summary>
/// <param name="AArray">An array where to copy the contents of the collection.</param>
/// <param name="AStartIndex">The index into the array at which the copying begins.</param>
/// <remarks>This method assumes that <paramref name="AArray"/> has enough space to hold the contents of the collection.</remarks>
/// <exception cref="SysUtils|EArgumentOutOfRangeException"><paramref name="AStartIndex"/> is out of bounds.</exception>
/// <exception cref="Collections.Base|EArgumentOutOfSpaceException">The array is not long enough.</exception>
procedure CopyTo(var AArray: array of T; const AStartIndex: NativeInt); overload;
/// <summary>Creates a new Delphi array with the contents of the collection.</summary>
/// <remarks>The length of the new array is equal to the value of the <c>Count</c> property.</remarks>
function ToArray(): TArray<T>;
/// <summary>Specifies the number of elements in the collection.</summary>
/// <returns>A positive value specifying the number of elements in the collection.</returns>
/// <remarks>For associative collections such as dictionaries or multimaps, this value represents the
/// number of key-value pairs stored in the collection. Accesing this property can be costly because some
/// collections cannot detect the number of stored elements directly, resorting to enumerating themselves.</remarks>
property Count: NativeInt read GetCount;
end;
{ Pre-declarations }
IList<T> = interface;
ISet<T> = interface;
IDictionary<TKey, TValue> = interface;
ISequence<T> = interface;
IGrouping<TKey, T> = interface;
/// <summary>Offers an extended set of Enex operations.</summary>
/// <remarks>This type is exposed by Enex collections, and serves simply as a bridge between the interfaces
/// and some advanced operations that require parameterized methods. For example, expressions such as
/// <c>List.Op.Select<Integer></c> are based on this type.</remarks>
TEnexExtOps<T> = record
private
FRules: TRules<T>;
FInstance: Pointer;
FKeepAlive: IInterface;
public
/// <summary>Represents a "select" operation.</summary>
/// <param name="ASelector">A selector method invoked for each element in the collection.</param>
/// <param name="ARules">A rule set representing the elements in the output collection.</param>
/// <returns>A new collection containing the selected values.</returns>
/// <remarks>This method is used when it is required to select values related to the ones in the operated collection.
/// For example, you can select a collection of integers where each integer is a field of a class in the original collection.</remarks>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ASelector"/> is <c>nil</c>.</exception>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ARules"/> is <c>nil</c>.</exception>
function Select<TOut>(const ASelector: TFunc<T, TOut>; const ARules: TRules<TOut>): ISequence<TOut>; overload;
/// <summary>Represents a "select" operation.</summary>
/// <param name="ASelector">A selector method invoked for each element in the collection.</param>
/// <returns>A new collection containing the selected values.</returns>
/// <remarks>This method is used when it is required to select values related to the ones in the operated collection.
/// For example, you can select a collection of integers where each integer is a field of a class in the original collection.</remarks>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ASelector"/> is <c>nil</c>.</exception>
function Select<TOut>(const ASelector: TFunc<T, TOut>): ISequence<TOut>; overload;
{$IF CompilerVersion > 21}
/// <summary>Represents a "select" operation.</summary>
/// <param name="AMemberName">A record or class field/property name that will be selected.</param>
/// <returns>A new collection containing the selected values.</returns>
/// <remarks>This method will only work for classes and record types!</remarks>
/// <exception cref="Generics.Collections|ENotSupportedException"><paramref name="AMemberName"/> is not a real member of record or class.</exception>
/// <exception cref="Generics.Collections|ENotSupportedException">The collection's elements are not objects ore records.</exception>
function Select<TOut>(const AMemberName: string): ISequence<TOut>; overload;
/// <summary>Represents a "select" operation.</summary>
/// <param name="AMemberName">A record or class field/property name that will be selected.</param>
/// <returns>A new collection containing the selected values represented as Rtti <c>TValue</c>s.</returns>
/// <remarks>This method will only work for classes and record types!</remarks>
/// <exception cref="Generics.Collections|ENotSupportedException"><paramref name="AMemberName"/> is not a real member of record or class.</exception>
/// <exception cref="Generics.Collections|ENotSupportedException">The collection's elements are not objects ore records.</exception>
function Select(const AMemberName: string): ISequence<TAny>; overload;
/// <summary>Represents a "select" operation.</summary>
/// <param name="AMemberNames">A record or class field/property names that will be selected.</param>
/// <returns>A new collection containing the selected values represented as a view.</returns>
/// <remarks>This method will only work for classes and record types! The resulting view contains the selected members.</remarks>
/// <exception cref="Generics.Collections|ENotSupportedException"><paramref name="AMemberName"/> is not a real member of record or class.</exception>
/// <exception cref="Generics.Collections|ENotSupportedException">The collection's elements are not objects ore records.</exception>
function Select(const AMemberNames: array of string): ISequence<TView>; overload;
{$IFEND}
/// <summary>Represents a "where, select object" operation.</summary>
/// <returns>A new collection containing the selected values.</returns>
/// <remarks>This method can be used on a collection containing objects. The operation involves two steps,
/// where and select. First, each object is checked to be derived from <c>TOut</c>. If that is true, it is then
/// cast to <c>TOut</c>. The result of the operation is a new collection that contains only the objects of a given
/// class. For example, <c>AList.Op.Select<TMyObject></c> results in a new collection that only contains
/// "TMyObject" instances.</remarks>
/// <exception cref="Generics.Collections|ENotSupportedException">The collection's elements are not objects.</exception>
function Select<TOut: class>(): ISequence<TOut>; overload;
/// <summary>Groups all elements in the collection by a given key.</summary>
/// <param name="ASelector">The selector function. Returns the key (based on each collection element) that serves for grouping purposes.</param>
/// <returns>A collection of grouping collections.</returns>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ASelector"/> is <c>nil</c>.</exception>
/// <remarks>This operation will call <paramref name="ASelector"/> for each element in the collection and retrieve a "key". Using this key,
/// the elements are grouped into new collections called groupings. The result of this operation is a collection of groupings. Each grouping
/// contains the elements from the original collection that have the same group and a key (which is the group value used).</remarks>
function GroupBy<TKey>(const ASelector: TFunc<T, TKey>): ISequence<IGrouping<TKey, T>>; overload;
/// <summary>Orders the collection based on selector method.</summary>
/// <param name="ASelector">The selector function. Returns the key (based on each collection element) that serves for ordering purposes.</param>
/// <returns>The resulting ordered collection.</returns>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ASelector1"/> is <c>nil</c>.</exception>
/// <remarks>This operation will call <paramref name="ASelector"/> for each element in the collection and retrieve a "key". Using this key,
/// the elements are ordered into a new collection.</remarks>
function OrderBy<TKey>(const ASelector: TFunc<T, TKey>): ISequence<T>; overload;
/// <summary>Orders the collection based on selector method.</summary>
/// <param name="ASelector1">The selector function for the first key. Returns the key (based on each collection element) that serves for ordering purposes.</param>
/// <param name="ASelector2">The selector function for the second key. Returns the key (based on each collection element) that serves for ordering purposes.</param>
/// <returns>The resulting ordered collection.</returns>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ASelector1"/> is <c>nil</c>.</exception>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ASelector2"/> is <c>nil</c>.</exception>
/// <remarks>This operation will call each <paramref name="ASelector"/> for elements in the collection and retrieve the ordering "keys". Using these keys,
/// the elements are ordered into a new collection.</remarks>
function OrderBy<TKey1, TKey2>(const ASelector1: TFunc<T, TKey1>; const ASelector2: TFunc<T, TKey2>): ISequence<T>; overload;
/// <summary>Orders the collection based on selector method.</summary>
/// <param name="ASelector1">The selector function for the first key. Returns the key (based on each collection element) that serves for ordering purposes.</param>
/// <param name="ASelector2">The selector function for the second key. Returns the key (based on each collection element) that serves for ordering purposes.</param>
/// <param name="ASelector3">The selector function for the third key. Returns the key (based on each collection element) that serves for ordering purposes.</param>
/// <returns>The resulting ordered collection.</returns>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ASelector1"/> is <c>nil</c>.</exception>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ASelector2"/> is <c>nil</c>.</exception>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ASelector3"/> is <c>nil</c>.</exception>
/// <remarks>This operation will call each <paramref name="ASelector"/> for elements in the collection and retrieve the ordering "keys". Using these keys,
/// the elements are ordered into a new collection.</remarks>
function OrderBy<TKey1, TKey2, TKey3>(const ASelector1: TFunc<T, TKey1>; const ASelector2: TFunc<T, TKey2>;
const ASelector3: TFunc<T, TKey3>): ISequence<T>; overload;
/// <summary>Orders the collection based on selector method.</summary>
/// <param name="ASelector1">The selector function for the first key. Returns the key (based on each collection element) that serves for ordering purposes.</param>
/// <param name="ASelector2">The selector function for the second key. Returns the key (based on each collection element) that serves for ordering purposes.</param>
/// <param name="ASelector3">The selector function for the third key. Returns the key (based on each collection element) that serves for ordering purposes.</param>
/// <param name="ASelector4">The selector function for the fourth key. Returns the key (based on each collection element) that serves for ordering purposes.</param>
/// <returns>The resulting ordered collection.</returns>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ASelector1"/> is <c>nil</c>.</exception>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ASelector2"/> is <c>nil</c>.</exception>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ASelector3"/> is <c>nil</c>.</exception>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ASelector4"/> is <c>nil</c>.</exception>
/// <remarks>This operation will call each <paramref name="ASelector"/> for elements in the collection and retrieve the ordering "keys". Using these keys,
/// the elements are ordered into a new collection.</remarks>
function OrderBy<TKey1, TKey2, TKey3, TKey4>(const ASelector1: TFunc<T, TKey1>; const ASelector2: TFunc<T, TKey2>;
const ASelector3: TFunc<T, TKey3>; const ASelector4: TFunc<T, TKey4>): ISequence<T>; overload;
/// <summary>Orders the collection based on selector method.</summary>
/// <param name="ASelector1">The selector function for the first key. Returns the key (based on each collection element) that serves for ordering purposes.</param>
/// <param name="ASelector2">The selector function for the second key. Returns the key (based on each collection element) that serves for ordering purposes.</param>
/// <param name="ASelector3">The selector function for the third key. Returns the key (based on each collection element) that serves for ordering purposes.</param>
/// <param name="ASelector4">The selector function for the fourth key. Returns the key (based on each collection element) that serves for ordering purposes.</param>
/// <param name="ASelector5">The selector function for the fifth key. Returns the key (based on each collection element) that serves for ordering purposes.</param>
/// <returns>The resulting ordered collection.</returns>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ASelector1"/> is <c>nil</c>.</exception>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ASelector2"/> is <c>nil</c>.</exception>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ASelector3"/> is <c>nil</c>.</exception>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ASelector4"/> is <c>nil</c>.</exception>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ASelector5"/> is <c>nil</c>.</exception>
/// <remarks>This operation will call each <paramref name="ASelector"/> for elements in the collection and retrieve the ordering "keys". Using these keys,
/// the elements are ordered into a new collection.</remarks>
function OrderBy<TKey1, TKey2, TKey3, TKey4, TKey5>(const ASelector1: TFunc<T, TKey1>; const ASelector2: TFunc<T, TKey2>;
const ASelector3: TFunc<T, TKey3>; const ASelector4: TFunc<T, TKey4>; const ASelector5: TFunc<T, TKey5>): ISequence<T>; overload;
/// <summary>Joins this sequence with another enumerable collection using a common key.</summary>
/// <param name="AInner">The inner collection to join with.</param>
/// <param name="AKeySelector">The selector function for the key of this collection.</param>
/// <param name="AInnerKeySelector">The selector function for the key of the inner collection.</param>
/// <param name="AResultSelector">The selector function that combines the result.</param>
/// <returns>The resulting joined collection.</returns>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ASelector"/> is <c>nil</c>.</exception>
/// <remarks>This operation will enumerate the collection and extract the key for each element. For each key it will try to
/// pair up the element with elements in the <c>AInner</c> collection. This function can also be considered an "INNER JOIN" where the elements in the outer
/// collection are paired up with elements in the inner collection by the means of a common key (provided by the selector functions).</remarks>
function Join<TInner, TKey, TResult>(const AInner: IEnumerable<TInner>; const AKeySelector: TFunc<T, TKey>;
const AInnerKeySelector: TFunc<TInner, TKey>; const AResultSelector: TFunc<T, TInner, TResult>): ISequence<TResult>; overload;
/// <summary>Joins ang groups this sequence with another enumerable collection using a common key.</summary>
/// <param name="AInner">The inner collection to join with.</param>
/// <param name="AKeySelector">The selector function for the key of this collection.</param>
/// <param name="AInnerKeySelector">The selector function for the key of the inner collection.</param>
/// <param name="AResultSelector">The selector function that combines the result.</param>
/// <returns>The resulting joined collection.</returns>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ASelector"/> is <c>nil</c>.</exception>
/// <remarks>This operation will enumerate the collection and extract the key for each element. For each key it will try to
/// pair up the element with elements in the <c>AInner</c> collection; and generate a group of elements.</remarks>
function GroupJoin<TInner, TKey, TResult>(const AInner: IEnumerable<TInner>; const AKeySelector: TFunc<T, TKey>;
const AInnerKeySelector: TFunc<TInner, TKey>; const AResultSelector: TFunc<T, ISequence<TInner>, TResult>): ISequence<TResult>; overload;
end;
/// <summary>Base sequence interface inherited by all specific collection interfaces.</summary>
/// <remarks>This interface defines a set of traits common to all collections implemented in this package. It also introduces
/// a large set of extended operations that can be performed on any collection that supports enumerability.</remarks>
ISequence<T> = interface(IContainer<T>)
/// <summary>Checks whether the elements in this collection are equal to the elements in another collection.</summary>
/// <param name="ACollection">The collection to compare to.</param>
/// <returns><c>True</c> if the collections are equal; <c>False</c> if the collections are different.</returns>
/// <remarks>This method checks that each element at position X in this collection is equal to an element at position X in
/// the provided collection. If the number of elements in both collections is different, then the collections are considered different.
/// Note that comparison of element is done using the rule set used by this collection. This means that comparing this collection
/// to another one might yield a different result than comparing the other collection to this one.</remarks>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ACollection"/> is <c>nil</c>.</exception>
function EqualsTo(const ACollection: IEnumerable<T>): Boolean;
/// <summary>Creates a new list containing the elements of this collection.</summary>
/// <returns>A list containing the elements copied from this collection.</returns>
/// <remarks>This method also copies the rule set of this collection. Be careful if the rule set
/// performs cleanup on the elements.</remarks>
function ToList(): IList<T>;
/// <summary>Creates a new set containing the elements of this collection.</summary>
/// <returns>A set containing the elements copied from this collection.</returns>
/// <remarks>This method also copies the rule set of this collection. Be careful if the rule set
/// performs cleanup on the elements.</remarks>
function ToSet(): ISet<T>;
/// <summary>Returns the biggest element.</summary>
/// <returns>An element from the collection considered to have the biggest value.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
function Max(): T;
/// <summary>Returns the smallest element.</summary>
/// <returns>An element from the collection considered to have the smallest value.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
function Min(): T;
/// <summary>Returns the first element.</summary>
/// <returns>The first element in the collection.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
function First(): T;
/// <summary>Returns the first element or a default if the collection is empty.</summary>
/// <param name="ADefault">The default value returned if the collection is empty.</param>
/// <returns>The first element in the collection if the collection is not empty; otherwise <paramref name="ADefault"/> is returned.</returns>
function FirstOrDefault(const ADefault: T): T;
/// <summary>Returns the first element that satisfies the given predicate.</summary>
/// <param name="APredicate">The predicate to use.</param>
/// <returns>The first element that satisfies the given predicate.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="Collections.Base|ECollectionFilteredEmptyException">No elements satisfy the predicate.</exception>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="APredicate"/> is <c>nil</c>.</exception>
function FirstWhere(const APredicate: TPredicate<T>): T;
/// <summary>Returns the first element that satisfies the given predicate or a default value.</summary>
/// <param name="APredicate">The predicate to use.</param>
/// <param name="ADefault">The default value.</param>
/// <returns>The first element that satisfies the given predicate; <paramref name="ADefault"/> otherwise.</returns>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="APredicate"/> is <c>nil</c>.</exception>
function FirstWhereOrDefault(const APredicate: TPredicate<T>; const ADefault: T): T;
/// <summary>Returns the first element that does not satisfy the given predicate.</summary>
/// <param name="APredicate">The predicate to use.</param>
/// <returns>The first element that does not satisfy the given predicate.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="Collections.Base|ECollectionFilteredEmptyException">No elements that do not satisfy the predicate.</exception>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="APredicate"/> is <c>nil</c>.</exception>
function FirstWhereNot(const APredicate: TPredicate<T>): T;
/// <summary>Returns the first element that does not satisfy the given predicate or a default value.</summary>
/// <param name="APredicate">The predicate to use.</param>
/// <param name="ADefault">The default value.</param>
/// <returns>The first element that does not satisfy the given predicate; <paramref name="ADefault"/> otherwise.</returns>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="APredicate"/> is <c>nil</c>.</exception>
function FirstWhereNotOrDefault(const APredicate: TPredicate<T>; const ADefault: T): T;
/// <summary>Returns the first element lower than a given value.</summary>
/// <param name="ABound">The value to compare against.</param>
/// <returns>The first element that satisfies the given condition.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="Collections.Base|ECollectionFilteredEmptyException">No elements satisfy the condition.</exception>
function FirstWhereLower(const ABound: T): T;
/// <summary>Returns the first element lower than a given value or a default.</summary>
/// <param name="ABound">The value to compare against.</param>
/// <param name="ADefault">The default value.</param>
/// <returns>The first element that satisfies the given condition; <paramref name="ADefault"/> otherwise.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="Collections.Base|ECollectionFilteredEmptyException">No elements satisfy the condition.</exception>
function FirstWhereLowerOrDefault(const ABound: T; const ADefault: T): T;
/// <summary>Returns the first element lower than or equal to a given value.</summary>
/// <param name="ABound">The value to compare against.</param>
/// <returns>The first element that satisfies the given condition.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="Collections.Base|ECollectionFilteredEmptyException">No elements satisfy the condition.</exception>
function FirstWhereLowerOrEqual(const ABound: T): T;
/// <summary>Returns the first element lower than or equal to a given value or a default.</summary>
/// <param name="ABound">The value to compare against.</param>
/// <param name="ADefault">The default value.</param>
/// <returns>The first element that satisfies the given condition; <paramref name="ADefault"/> otherwise.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="Collections.Base|ECollectionFilteredEmptyException">No elements satisfy the condition.</exception>
function FirstWhereLowerOrEqualOrDefault(const ABound: T; const ADefault: T): T;
/// <summary>Returns the first element greater than a given value.</summary>
/// <param name="ABound">The value to compare against.</param>
/// <returns>The first element that satisfies the given condition.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="Collections.Base|ECollectionFilteredEmptyException">No elements satisfy the condition.</exception>
function FirstWhereGreater(const ABound: T): T;
/// <summary>Returns the first element greater than a given value or a default.</summary>
/// <param name="ABound">The value to compare against.</param>
/// <param name="ADefault">The default value.</param>
/// <returns>The first element that satisfies the given condition; <paramref name="ADefault"/> otherwise.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="Collections.Base|ECollectionFilteredEmptyException">No elements satisfy the condition.</exception>
function FirstWhereGreaterOrDefault(const ABound: T; const ADefault: T): T;
/// <summary>Returns the first element greater than or equal to a given value.</summary>
/// <param name="ABound">The value to compare against.</param>
/// <returns>The first element that satisfies the given condition.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="Collections.Base|ECollectionFilteredEmptyException">No elements satisfy the condition.</exception>
function FirstWhereGreaterOrEqual(const ABound: T): T;
/// <summary>Returns the first element greater than or equal to a given value or a default.</summary>
/// <param name="ABound">The value to compare against.</param>
/// <param name="ADefault">The default value.</param>
/// <returns>The first element that satisfies the given condition; <paramref name="ADefault"/> otherwise.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="Collections.Base|ECollectionFilteredEmptyException">No elements satisfy the condition.</exception>
function FirstWhereGreaterOrEqualOrDefault(const ABound: T; const ADefault: T): T;
/// <summary>Returns the first element situated within the given bounds.</summary>
/// <param name="ALower">The lower bound.</param>
/// <param name="AHigher">The higher bound.</param>
/// <returns>The first element that satisfies the given condition.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="Collections.Base|ECollectionFilteredEmptyException">No elements satisfy the condition.</exception>
function FirstWhereBetween(const ALower, AHigher: T): T;
/// <summary>Returns the first element situated within the given bounds or a default.</summary>
/// <param name="ALower">The lower bound.</param>
/// <param name="AHigher">The higher bound.</param>
/// <param name="ADefault">The default value.</param>
/// <returns>The first element that satisfies the given condition; <paramref name="ADefault"/> otherwise.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="Collections.Base|ECollectionFilteredEmptyException">No elements satisfy the condition.</exception>
function FirstWhereBetweenOrDefault(const ALower, AHigher: T; const ADefault: T): T;
/// <summary>Returns the last element.</summary>
/// <returns>The last element in the collection.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
function Last(): T;
/// <summary>Returns the last element or a default if the collection is empty.</summary>
/// <param name="ADefault">The default value returned if the collection is empty.</param>
/// <returns>The last element in the collection if the collection is not empty; otherwise <paramref name="ADefault"/> is returned.</returns>
function LastOrDefault(const ADefault: T): T;
/// <summary>Aggregates a value based on the collection's elements.</summary>
/// <param name="AAggregator">The aggregator method.</param>
/// <returns>A value that contains the collection's aggregated value.</returns>
/// <remarks>This method returns the first element if the collection only has one element. Otherwise,
/// <paramref name="AAggregator"/> is invoked for each two elements (first and second; then the result of the first two
/// and the third, and so on). The simplest example of aggregation is the "sum" operation where you can obtain the sum of all
/// elements in the value.</remarks>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="AAggregator"/> is <c>nil</c>.</exception>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
function Aggregate(const AAggregator: TFunc<T, T, T>): T;
/// <summary>Aggregates a value based on the collection's elements.</summary>
/// <param name="AAggregator">The aggregator method.</param>
/// <param name="ADefault">The default value returned if the collection is empty.</param>
/// <returns>A value that contains the collection's aggregated value. If the collection is empty, <paramref name="ADefault"/> is returned.</returns>
/// <remarks>This method returns the first element if the collection only has one element. Otherwise,
/// <paramref name="AAggregator"/> is invoked for each two elements (first and second; then the result of the first two
/// and the third, and so on). The simplest example of aggregation is the "sum" operation where you can obtain the sum of all
/// elements in the value.</remarks>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="AAggregator"/> is <c>nil</c>.</exception>
function AggregateOrDefault(const AAggregator: TFunc<T, T, T>; const ADefault: T): T;
/// <summary>Returns the element at a given position.</summary>
/// <param name="AIndex">The index from which to return the element.</param>
/// <returns>The element at the specified position.</returns>
/// <remarks>This method is slow for collections that cannot reference their elements by indexes; for example: linked lists</remarks>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="SysUtils|EArgumentOutOfRangeException"><paramref name="AIndex"/> is out of bounds.</exception>
function ElementAt(const AIndex: NativeInt): T;
/// <summary>Returns the element at a given position.</summary>
/// <param name="AIndex">The index from which to return the element.</param>
/// <param name="ADefault">The default value returned if the collection is empty.</param>
/// <returns>The element at the specified position if the collection is not empty and the position is not out of bounds; otherwise
/// the value of <paramref name="ADefault"/> is returned.</returns>
/// <remarks>This method is slow for collections that cannot reference their elements by indexes; for example: linked lists</remarks>
function ElementAtOrDefault(const AIndex: NativeInt; const ADefault: T): T;
/// <summary>Check whether at least one element in the collection satisfies a given predicate.</summary>
/// <param name="APredicate">The predicate to check for each element.</param>
/// <returns><c>True</c> if the at least one element satisfies a given predicate; <c>False</c> otherwise.</returns>
/// <remarks>This method traverses the whole collection and checks the value of the predicate for each element. This method
/// stops on the first element for which the predicate returns <c>True</c>. The logical equivalent of this operation is "OR".</remarks>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="APredicate"/> is <c>nil</c>.</exception>
function Any(const APredicate: TPredicate<T>): Boolean;
/// <summary>Checks that all elements in the collection satisfies a given predicate.</summary>
/// <param name="APredicate">The predicate to check for each element.</param>
/// <returns><c>True</c> if all elements satisfy a given predicate; <c>False</c> otherwise.</returns>
/// <remarks>This method traverses the whole collection and checks the value of the predicate for each element. This method
/// stops on the first element for which the predicate returns <c>False</c>. The logical equivalent of this operation is "AND".</remarks>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="APredicate"/> is <c>nil</c>.</exception>
function All(const APredicate: TPredicate<T>): Boolean;
/// <summary>Selects only the elements that satisfy a given rule.</summary>
/// <param name="APredicate">The predicate that represents the rule.</param>
/// <returns>A new collection that contains only the elements that satisfy the given rule.</returns>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="APredicate"/> is <c>nil</c>.</exception>
function Where(const APredicate: TPredicate<T>): ISequence<T>;
/// <summary>Selects only the elements that do not satisfy a given rule.</summary>
/// <param name="APredicate">The predicate that represents the rule.</param>
/// <returns>A new collection that contains only the elements that do not satisfy the given rule.</returns>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="APredicate"/> is <c>nil</c>.</exception>
function WhereNot(const APredicate: TPredicate<T>): ISequence<T>;
/// <summary>Selects only the elements that are less than a given value.</summary>
/// <param name="ABound">The element to compare against.</param>
/// <returns>A new collection that contains only the elements that satisfy the relationship.</returns>
function WhereLower(const ABound: T): ISequence<T>;
/// <summary>Selects only the elements that are less than or equal to a given value.</summary>
/// <param name="ABound">The element to compare against.</param>
/// <returns>A new collection that contains only the elements that satisfy the relationship.</returns>
function WhereLowerOrEqual(const ABound: T): ISequence<T>;
/// <summary>Selects only the elements that are greater than a given value.</summary>
/// <param name="ABound">The element to compare against.</param>
/// <returns>A new collection that contains only the elements that satisfy the relationship.</returns>
function WhereGreater(const ABound: T): ISequence<T>;
/// <summary>Selects only the elements that are greater than or equal to a given value.</summary>
/// <param name="ABound">The element to compare against.</param>
/// <returns>A new collection that contains only the elements that satisfy the relationship.</returns>
function WhereGreaterOrEqual(const ABound: T): ISequence<T>;
/// <summary>Selects only the elements whose values are contained whithin a given interval.</summary>
/// <param name="ALower">The lower bound.</param>
/// <param name="AHigher">The upper bound.</param>
/// <returns>A new collection that contains only the elements that satisfy the relationship.</returns>
/// <remarks>The elements that are equal to the lower or upper bounds, are also included.</remarks>
function WhereBetween(const ALower, AHigher: T): ISequence<T>;
/// <summary>Selects all the elements from the collection excluding duplicates.</summary>
/// <returns>A new collection that contains the distinct elements.</returns>
function Distinct(): ISequence<T>;
/// <summary>Returns a new ordered collection that contains the elements from this collection.</summary>
/// <param name="AAscending">Specifies whether the elements are ordered ascending or descending.</param>
/// <returns>A new ordered collection.</returns>
function Ordered(const AAscending: Boolean = true): ISequence<T>; overload;
/// <summary>Returns a new ordered collection that contains the elements from this collection.</summary>
/// <param name="ASortProc">The comparison method.</param>
/// <returns>A new ordered collection.</returns>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ASortProc"/> is <c>nil</c>.</exception>
function Ordered(const ASortProc: TComparison<T>): ISequence<T>; overload;
/// <summary>Revereses the contents of the collection.</summary>
/// <returns>A new collection that contains the elements from this collection but in reverse order.</returns>
function Reversed(): ISequence<T>;
/// <summary>Concatenates this collection with another collection.</summary>
/// <param name="ACollection">A collection to concatenate.</param>
/// <returns>A new collection that contains the elements from this collection followed by elements
/// from the given collection.</returns>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ACollection"/> is <c>nil</c>.</exception>
function Concat(const ACollection: ISequence<T>): ISequence<T>;
/// <summary>Creates a new collection that contains the elements from both collections taken a single time.</summary>
/// <param name="ACollection">The collection to unify with.</param>
/// <returns>A new collection that contains the elements from this collection followed by elements
/// from the given collection except the elements that already are present in this collection. This operation can be seen as
/// a "concat" operation followed by a "distinct" operation. </returns>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ACollection"/> is <c>nil</c>.</exception>
function Union(const ACollection: ISequence<T>): ISequence<T>;
/// <summary>Creates a new collection that contains the elements from this collection minus the ones in the given collection.</summary>
/// <param name="ACollection">The collection to exclude.</param>
/// <returns>A new collection that contains the elements from this collection minus the those elements that are common between
/// this and the given collection.</returns>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ACollection"/> is <c>nil</c>.</exception>
function Exclude(const ACollection: ISequence<T>): ISequence<T>;
/// <summary>Creates a new collection that contains the elements that are present in both collections.</summary>
/// <param name="ACollection">The collection to interset with.</param>
/// <returns>A new collection that contains the elements that are common to both collections.</returns>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ACollection"/> is <c>nil</c>.</exception>
function Intersect(const ACollection: ISequence<T>): ISequence<T>;
/// <summary>Select the elements that whose indexes are located in the given range.</summary>
/// <param name="AStart">The lower bound.</param>
/// <param name="AEnd">The upper bound.</param>
/// <returns>A new collection that contains the elements whose indexes in this collection are locate between <paramref name="AStart"/>
/// and <paramref name="AEnd"/>. Note that this method does not check the indexes. This means that a bad combination of parameters will
/// simply result in an empty or incorrect result.</returns>
function Range(const AStart, AEnd: NativeInt): ISequence<T>;
/// <summary>Selects only a given amount of elements.</summary>
/// <param name="ACount">The number of elements to select.</param>
/// <returns>A new collection that contains only the first <paramref name="ACount"/> elements.</returns>
/// <exception cref="SysUtils|EArgumentOutOfRangeException"><paramref name="ACount"/> is zero.</exception>
function Take(const ACount: NativeInt): ISequence<T>;
/// <summary>Selects all the elements from the collection while a given rule is satisfied.</summary>
/// <param name="APredicate">The rule to satisfy.</param>
/// <returns>A new collection that contains the selected elements.</returns>
/// <remarks>This method selects all elements from the collection while the given rule is satisfied.</remarks>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="APredicate"/> is <c>nil</c>.</exception>
function TakeWhile(const APredicate: TPredicate<T>): ISequence<T>;
/// <summary>Selects all the elements from the collection while elements are lower than a given value.</summary>
/// <param name="ABound">The value to check against.</param>
/// <returns>A new collection that contains the selected elements.</returns>
/// <remarks>This method selects all elements from the collection while the given rule is satisfied.</remarks>
function TakeWhileLower(const ABound: T): ISequence<T>;
/// <summary>Selects all the elements from the collection while elements are lower than
/// or equals to a given value.</summary>
/// <param name="ABound">The value to check against.</param>
/// <returns>A new collection that contains the selected elements.</returns>
/// <remarks>This method selects all elements from the collection while the given rule is satisfied.</remarks>
function TakeWhileLowerOrEqual(const ABound: T): ISequence<T>;
/// <summary>Selects all the elements from the collection while elements are greater than
/// a given value.</summary>
/// <param name="ABound">The value to check against.</param>
/// <returns>A new collection that contains the selected elements.</returns>
/// <remarks>This method selects all elements from the collection while the given rule is satisfied.</remarks>
function TakeWhileGreater(const ABound: T): ISequence<T>;
/// <summary>Selects all the elements from the collection while elements are greater than
/// or equals to a given value.</summary>
/// <param name="ABound">The value to check against.</param>
/// <returns>A new collection that contains the selected elements.</returns>
/// <remarks>This method selects all elements from the collection while the given rule is satisfied.</remarks>
function TakeWhileGreaterOrEqual(const ABound: T): ISequence<T>;
/// <summary>Selects all the elements from the collection while elements are between a given range of values.</summary>
/// <param name="ALower">The lower bound.</param>
/// <param name="AHigher">The higher bound.</param>
/// <returns>A new collection that contains the selected elements.</returns>
/// <remarks>This method selects all elements from the collection while the given rule is satisfied.</remarks>
function TakeWhileBetween(const ALower, AHigher: T): ISequence<T>;
/// <summary>Skips a given amount of elements.</summary>
/// <param name="ACount">The number of elements to skip.</param>
/// <returns>A new collection that contains the elements that were not skipped.</returns>
/// <exception cref="SysUtils|EArgumentOutOfRangeException"><paramref name="ACount"/> is zero.</exception>
function Skip(const ACount: NativeInt): ISequence<T>;
/// <summary>Skips all the elements from the collection while a given rule is satisfied.</summary>
/// <param name="APredicate">The rule to satisfy.</param>
/// <returns>A new collection that contains the elements that were not skipped.</returns>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="APredicate"/> is <c>nil</c>.</exception>
function SkipWhile(const APredicate: TPredicate<T>): ISequence<T>;
/// <summary>Skips all the elements from the collection while elements are lower than a given value.</summary>
/// <param name="ABound">The value to check.</param>
/// <returns>A new collection that contains the elements that were not skipped.</returns>
function SkipWhileLower(const ABound: T): ISequence<T>;
/// <summary>Skips all the elements from the collection while elements are lower than or equal to a given value.</summary>
/// <param name="ABound">The value to check.</param>
/// <returns>A new collection that contains the elements that were not skipped.</returns>
function SkipWhileLowerOrEqual(const ABound: T): ISequence<T>;
/// <summary>Skips all the elements from the collection while elements are greater than a given value.</summary>
/// <param name="ABound">The value to check.</param>
/// <returns>A new collection that contains the elements that were not skipped.</returns>
function SkipWhileGreater(const ABound: T): ISequence<T>;
/// <summary>Skips all the elements from the collection while elements are greater than or equal to a given value.</summary>
/// <param name="ABound">The value to check.</param>
/// <returns>A new collection that contains the elements that were not skipped.</returns>
function SkipWhileGreaterOrEqual(const ABound: T): ISequence<T>;
/// <summary>Skips all the elements from the collection while elements are between a given range of values.</summary>
/// <param name="ALower">The lower bound.</param>
/// <param name="AHigher">The higher bound.</param>
/// <returns>A new collection that contains the elements that were not skipped.</returns>
function SkipWhileBetween(const ALower, AHigher: T): ISequence<T>;
/// <summary>Exposes a type that provides extended Enex operations such as "select".</summary>
/// <returns>A record that exposes more Enex operations that otherwise would be impossible.</returns>
function Op: TEnexExtOps<T>;
end;
/// <summary>Enex collection that is presumed to be grouped by a certain key.</summary>
IGrouping<TKey, T> = interface(ISequence<T>)
/// <summary>Returns the key under which all elements in this collection are grouped.</summary>
/// <returns>The key of this grouping.</returns>
function GetKey(): TKey;
/// <summary>Returns the key under which all elements in this collection are grouped.</summary>
/// <returns>The key of this grouping.</returns>
property Key: TKey read GetKey;
end;
/// <summary>Specifies a set of methods specific to all simple (non-associative) collections.</summary>
/// <remarks>This collection exposes operations such as <c>Add</c> or <c>Clear</c> that need to be implemented
/// in almost every class out there.</remarks>
ICollection<T> = interface(ISequence<T>)
/// <summary>Clears the contents of this collection.</summary>
procedure Clear();
/// <summary>Adds an element to this collection.</summary>
/// <param name="AValue">The value to add.</param>
/// <remarks>Where exactly the element is added is unspecified and depends on the implementing collection.</remarks>
procedure Add(const AValue: T);
/// <summary>Adds all the elements from a collection to this collection.</summary>
/// <param name="ACollection">The values to add.</param>
/// <remarks>Where exactly the elements are added is unspecified and depends on the implementing collection.</remarks>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ACollection"/> is <c>nil</c>.</exception>
procedure AddAll(const ACollection: IEnumerable<T>);
/// <summary>Removes an element from this collection.</summary>
/// <param name="AValue">The value to remove. If there is no such element in the collection, nothing happens.</param>
procedure Remove(const AValue: T); overload;
/// <summary>Removes all the elements from a collection that are also found in this collection.</summary>
/// <param name="ACollection">The values to remove.</param>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ACollection"/> is <c>nil</c>.</exception>
procedure RemoveAll(const ACollection: IEnumerable<T>);
/// <summary>Checks whether a specified element is contained in this collection.</summary>
/// <param name="AValue">The value to check for.</param>
/// <returns><c>True</c> if the value was found in the collection; <c>False</c> otherwise.</returns>
function Contains(const AValue: T): Boolean; overload;
/// <summary>Checks whether all the elements from a specified collection are contained in this collection.</summary>
/// <param name="AValue">The value to check for.</param>
/// <returns><c>True</c> if the values were found in the collection; <c>False</c> otherwise.</returns>
function ContainsAll(const ACollection: IEnumerable<T>): Boolean;
end;
/// <summary>Base Enex (Extended enumerable) interface inherited by all specific associative collection interfaces.</summary>
/// <remarks>This interface defines a set of traits common to all associative collections implemented in this package. It also introduces
/// a large se of extended operations that can pe performed on any collection that supports enumerability.</remarks>
IAssociation<TKey, TValue> = interface(IContainer<TPair<TKey, TValue>>)
/// <summary>Creates a new dictionary containing the elements of this collection.</summary>
/// <returns>A dictionary containing the elements copied from this collection.</returns>
/// <remarks>This method also copies the rule sets of this collection. Be careful if the rule set
/// performs cleanup on the elements.</remarks>
/// <exception cref="Collections.Base|EDuplicateKeyException">The collection contains more than
/// one key-value pair with the same key.</exception>
function ToDictionary(): IDictionary<TKey, TValue>;
/// <summary>Returns the value associated with the given key.</summary>
/// <param name="AKey">The key for which to return the associated value.</param>
/// <returns>The value associated with the given key.</returns>
/// <exception cref="Collections.Base|EKeyNotFoundException">No such key in the collection.</exception>
function ValueForKey(const AKey: TKey): TValue;
/// <summary>Checks whether the collection contains a given key-value pair.</summary>
/// <param name="AKey">The key part of the pair.</param>
/// <param name="AValue">The value part of the pair.</param>
/// <returns><c>True</c> if the given key-value pair exists; <c>False</c> otherwise.</returns>
function KeyHasValue(const AKey: TKey; const AValue: TValue): Boolean;
/// <summary>Returns the biggest key.</summary>
/// <returns>The biggest key stored in the collection.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
function MaxKey(): TKey;
/// <summary>Returns the smallest key.</summary>
/// <returns>The smallest key stored in the collection.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
function MinKey(): TKey;
/// <summary>Returns the biggest value.</summary>
/// <returns>The biggest value stored in the collection.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
function MaxValue(): TValue;
/// <summary>Returns the smallest value.</summary>
/// <returns>The smallest value stored in the collection.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
function MinValue(): TValue;
/// <summary>Returns an Enex collection that contains only the keys.</summary>
/// <returns>An Enex collection that contains all the keys stored in the collection.</returns>
function SelectKeys(): ISequence<TKey>;
/// <summary>Returns a Enex collection that contains only the values.</summary>
/// <returns>An Enex collection that contains all the values stored in the collection.</returns>
function SelectValues(): ISequence<TValue>;
/// <summary>Specifies the collection that contains only the keys.</summary>
/// <returns>An Enex collection that contains all the keys stored in the collection.</returns>
property Keys: ISequence<TKey> read SelectKeys;
/// <summary>Specifies the collection that contains only the values.</summary>
/// <returns>An Enex collection that contains all the values stored in the collection.</returns>
property Values: ISequence<TValue> read SelectValues;
/// <summary>Selects all the key-value pairs from the collection excluding the duplicates by key.</summary>
/// <returns>A new collection that contains the distinct pairs.</returns>
function DistinctByKeys(): IAssociation<TKey, TValue>;
/// <summary>Selects all the key-value pairs from the collection excluding the duplicates by value.</summary>
/// <returns>A new collection that contains the distinct pairs.</returns>
function DistinctByValues(): IAssociation<TKey, TValue>;
/// <summary>Checks whether this collection includes the key-value pairs in another collection.</summary>
/// <param name="ACollection">The collection to check against.</param>
/// <returns><c>True</c> if this collection includes the elements in another; <c>False</c> otherwise.</returns>
function Includes(const ACollection: IEnumerable<TPair<TKey, TValue>>): Boolean;
/// <summary>Selects only the key-value pairs that satisfy a given rule.</summary>
/// <param name="APredicate">The predicate that represents the rule.</param>
/// <returns>A new collection that contains only the pairs that satisfy the given rule.</returns>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="APredicate"/> is <c>nil</c>.</exception>
function Where(const APredicate: TPredicate<TKey, TValue>): IAssociation<TKey, TValue>;
/// <summary>Selects only the key-value pairs that do not satisfy a given rule.</summary>
/// <param name="APredicate">The predicate that represents the rule.</param>
/// <returns>A new collection that contains only the pairs that do not satisfy the given rule.</returns>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="APredicate"/> is <c>nil</c>.</exception>
function WhereNot(const APredicate: TPredicate<TKey, TValue>): IAssociation<TKey, TValue>;
/// <summary>Selects only the key-value pairs whose keys are less than a given value.</summary>
/// <param name="ABound">The value to compare against.</param>
/// <returns>A new collection that contains only the pairs that satisfy the relationship.</returns>
function WhereKeyLower(const ABound: TKey): IAssociation<TKey, TValue>;
/// <summary>Selects only the key-value pairs whose keys are less than or equal to a given value.</summary>
/// <param name="ABound">The value to compare against.</param>
/// <returns>A new collection that contains only the pairs that satisfy the relationship.</returns>
function WhereKeyLowerOrEqual(const ABound: TKey): IAssociation<TKey, TValue>;
/// <summary>Selects only the key-value pairs whose keys are greater than a given value.</summary>
/// <param name="ABound">The value to compare against.</param>
/// <returns>A new collection that contains only the pairs that satisfy the relationship.</returns>
function WhereKeyGreater(const ABound: TKey): IAssociation<TKey, TValue>;
/// <summary>Selects only the key-value pairs whose keys are greater than or equal to a given value.</summary>
/// <param name="ABound">The value to compare against.</param>
/// <returns>A new collection that contains only the pairs that satisfy the relationship.</returns>
function WhereKeyGreaterOrEqual(const ABound: TKey): IAssociation<TKey, TValue>;
/// <summary>Selects only the key-value pairs whose keys are are contained whithin a given interval.</summary>
/// <param name="ALower">The lower bound.</param>
/// <param name="AHigher">The upper bound.</param>
/// <returns>A new collection that contains only the pairs that satisfy the relationship.</returns>
function WhereKeyBetween(const ALower, AHigher: TKey): IAssociation<TKey, TValue>;
/// <summary>Selects only the key-value pairs whose values are less than a given value.</summary>
/// <param name="ABound">The value to compare against.</param>
/// <returns>A new collection that contains only the pairs that satisfy the relationship.</returns>
function WhereValueLower(const ABound: TValue): IAssociation<TKey, TValue>;
/// <summary>Selects only the key-value pairs whose values are less than or equal to a given value.</summary>
/// <param name="ABound">The value to compare against.</param>
/// <returns>A new collection that contains only the pairs that satisfy the relationship.</returns>
function WhereValueLowerOrEqual(const ABound: TValue): IAssociation<TKey, TValue>;
/// <summary>Selects only the key-value pairs whose values are greater than a given value.</summary>
/// <param name="ABound">The value to compare against.</param>
/// <returns>A new collection that contains only the pairs that satisfy the relationship.</returns>
function WhereValueGreater(const ABound: TValue): IAssociation<TKey, TValue>;
/// <summary>Selects only the key-value pairs whose values are greater than or equal to a given value.</summary>
/// <param name="ABound">The value to compare against.</param>
/// <returns>A new collection that contains only the pairs that satisfy the relationship.</returns>
function WhereValueGreaterOrEqual(const ABound: TValue): IAssociation<TKey, TValue>;
/// <summary>Selects only the key-value pairs whose values are are contained whithin a given interval.</summary>
/// <param name="ALower">The lower bound.</param>
/// <param name="AHigher">The upper bound.</param>
/// <returns>A new collection that contains only the pairs that satisfy the relationship.</returns>
function WhereValueBetween(const ALower, AHigher: TValue): IAssociation<TKey, TValue>;
end;
/// <summary>The Enex interface that defines the behavior of a <c>stack</c>.</summary>
/// <remarks>This interface is implemented by all collections that provide the functionality of a <c>stack</c>.</remarks>
IStack<T> = interface(ICollection<T>)
/// <summary>Pushes an element to the top of the stack.</summary>
/// <param name="AValue">The value to push.</param>
procedure Push(const AValue: T);
/// <summary>Retrieves the element from the top of the stack.</summary>
/// <returns>The value at the top of the stack.</returns>
/// <remarks>This method removes the element from the top of the stack.</remarks>
/// <exception cref="Collections.Base|ECollectionEmptyException">The stack is empty.</exception>
function Pop(): T;
/// <summary>Reads the element from the top of the stack.</summary>
/// <returns>The value at the top of the stack.</returns>
/// <remarks>This method does not remove the element from the top of the stack. It merely reads it's value.</remarks>
/// <exception cref="Collections.Base|ECollectionEmptyException">The stack is empty.</exception>
function Peek(): T;
end;
/// <summary>The Enex interface that defines the behavior of a <c>queue</c>.</summary>
/// <remarks>This interface is implemented by all collections that provide the functionality of a <c>queue</c>.</remarks>
IQueue<T> = interface(ICollection<T>)
/// <summary>Appends an element to the head of the queue.</summary>
/// <param name="AValue">The value to append.</param>
procedure Enqueue(const AValue: T);
/// <summary>Retrieves the element from the bottom of the queue.</summary>
/// <returns>The value at the bottom of the queue.</returns>
/// <remarks>This method removes the element from the bottom of the queue.</remarks>
/// <exception cref="Collections.Base|ECollectionEmptyException">The queue is empty.</exception>
function Dequeue(): T;
/// <summary>Reads the element from the bottom of the queue.</summary>
/// <returns>The value at the bottom of the queue.</returns>
/// <remarks>This method does not remove the element from the bottom of the queue. It merely reads it's value.</remarks>
/// <exception cref="Collections.Base|ECollectionEmptyException">The queue is empty.</exception>
function Peek(): T;
end;
/// <summary>The Enex interface that defines the behavior of a <c>priority queue</c>.</summary>
/// <remarks>This interface is implemented by all collections that provide the functionality of a <c>priority queue</c>.</remarks>
IPriorityQueue<TPriority, TValue> = interface(IAssociation<TPriority, TValue>)
/// <summary>Clears the contents of the priority queue.</summary>
procedure Clear();
/// <summary>Adds an element to the priority queue.</summary>
/// <param name="AValue">The value to append.</param>
/// <remarks>The lowest possible priority of the element is assumed. This means that the element is appended to the top of the queue.</remarks>
procedure Enqueue(const AValue: TValue); overload;
/// <summary>Adds an element to the priority queue.</summary>
/// <param name="AValue">The value to add.</param>
/// <param name="APriority">The priority of the value.</param>
/// <remarks>The given priority is used to calculate the position of the value in the queue. Based on the priority the element might occupy any
/// given position (for example it might even end up at the bottom position).</remarks>
procedure Enqueue(const AValue: TValue; const APriority: TPriority); overload;
/// <summary>Retrieves the element from the bottom of the priority queue.</summary>
/// <returns>The value at the bottom of the priority queue.</returns>
/// <remarks>This method removes the element from the bottom of the priority queue.</remarks>
/// <exception cref="Collections.Base|ECollectionEmptyException">The queue is empty.</exception>
function Dequeue(): TValue;
/// <summary>Reads the element from the bottom of the priority queue.</summary>
/// <returns>The value at the bottom of the priority queue.</returns>
/// <remarks>This method does not remove the element from the bottom of the priority queue. It merely reads it's value.</remarks>
/// <exception cref="Collections.Base|ECollectionEmptyException">The queue is empty.</exception>
function Peek(): TValue;
/// <summary>Checks whether the priority queue contains a given value.</summary>
/// <param name="AValue">The value to check.</param>
/// <returns><c>True</c> if the value was found in the queue; <c>False</c> otherwise.</returns>
function Contains(const AValue: TValue): Boolean;
end;
/// <summary>The Enex interface that defines the behavior of a <c>set</c>.</summary>
/// <remarks>This interface is implemented by all collections that provide the functionality of a <c>set</c>.</remarks>
ISet<T> = interface(ICollection<T>)
end;
/// <summary>The Enex interface that defines the behavior of a <c>sorted set</c>.</summary>
/// <remarks>This interface is implemented by all collections that provide the functionality of a <c>sorted set</c>.</remarks>
ISortedSet<T> = interface(ISet<T>)
/// <summary>Returns the biggest set element.</summary>
/// <returns>An element from the set considered to have the biggest value.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The set is empty.</exception>
function Max(): T;
/// <summary>Returns the smallest set element.</summary>
/// <returns>An element from the set considered to have the smallest value.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The set is empty.</exception>
function Min(): T;
end;
/// <summary>The Enex interface that defines the behavior of a <c>bag</c>.</summary>
/// <remarks>This interface is implemented by all collections that provide the functionality of a <c>bag</c>.</remarks>
IBag<T> = interface(ISet<T>)
/// <summary>Adds an element to the bag.</summary>
/// <param name="AValue">The element to add.</param>
/// <param name="AWeight">The weight of the element.</param>
/// <remarks>If the bag already contains the given value, it's stored weight is incremented to by <paramref name="AWeight"/>.
/// If the value of <paramref name="AWeight"/> is zero, nothing happens.</remarks>
procedure AddWeight(const AValue: T; const AWeight: NativeUInt);
/// <summary>Removes an element from the bag.</summary>
/// <param name="AValue">The value to remove.</param>
/// <param name="AWeight">The weight to remove.</param>
/// <remarks>This method decreses the weight of the stored item by <paramref name="AWeight"/>. If the resulting weight is less
/// than zero or zero, the element is removed for the bag. If <paramref name="AWeight"/> is zero, nothing happens.</remarks>
procedure RemoveWeight(const AValue: T; const AWeight: NativeUInt);
/// <summary>Removes an element from the bag.</summary>
/// <param name="AValue">The value to remove.</param>
/// <remarks>This method completely removes an item from the bag ignoring it's stored weight. Nothing happens if the given value
/// is not in the bag to begin with.</remarks>
procedure RemoveAllWeight(const AValue: T);
/// <summary>Checks whether the bag contains an element with at least the required weight.</summary>
/// <param name="AValue">The value to check.</param>
/// <param name="AWeight">The smallest allowed weight.</param>
/// <returns><c>True</c> if the condition is met; <c>False</c> otherwise.</returns>
/// <remarks>This method checks whether the bag contains the given value and that the contained value has at least the
/// given weight.</remarks>
function ContainsWeight(const AValue: T; const AWeight: NativeUInt): Boolean;
/// <summary>Returns the weight of an element.</param>
/// <param name="AValue">The value to check.</param>
/// <returns>The weight of the value.</returns>
/// <remarks>If the value is not found in the bag, zero is returned.</remarks>
function GetWeight(const AValue: T): NativeUInt;
/// <summary>Sets the weight of an element.</param>
/// <param name="AValue">The value to set the weight for.</param>
/// <param name="AWeight">The new weight.</param>
/// <remarks>If the value is not found in the bag, this method acts like an <c>Add</c> operation; otherwise
/// the weight of the stored item is adjusted.</remarks>
procedure SetWeight(const AValue: T; const AWeight: NativeUInt);
/// <summary>Sets or gets the weight of an item in the bag.</summary>
/// <param name="AValue">The value.</param>
/// <remarks>If the value is not found in the bag, this method acts like an <c>Add</c> operation; otherwise
/// the weight of the stored item is adjusted.</remarks>
property Weights[const AValue: T]: NativeUInt read GetWeight write SetWeight; default;
end;
/// <summary>The Enex interface that defines the behavior of a <c>list</c>.</summary>
/// <remarks>This interface is implemented by all collections that provide the functionality of a <c>list</c>.</remarks>
IList<T> = interface(ICollection<T>)
/// <summary>Inserts an element into the list.</summary>
/// <param name="AIndex">The index to insert to.</param>
/// <param name="AValue">The value to insert.</param>
/// <remarks>All elements starting with <paramref name="AIndex"/> are moved to the right by one and then
/// <paramref name="AValue"/> is placed at position <paramref name="AIndex"/>.</remarks>
/// <exception cref="SysUtils|EArgumentOutOfRangeException"><paramref name="AIndex"/> is out of bounds.</exception>
procedure Insert(const AIndex: NativeInt; const AValue: T); overload;
/// <summary>Inserts the elements of a collection into the list.</summary>
/// <param name="AIndex">The index to insert to.</param>
/// <param name="ACollection">The values to insert.</param>
/// <remarks>All elements starting with <paramref name="AIndex"/> are moved to the right by the length of
/// <paramref name="ACollection"/> and then <paramref name="AValue"/> is placed at position <paramref name="AIndex"/>.</remarks>
/// <exception cref="SysUtils|EArgumentOutOfRangeException"><paramref name="AIndex"/> is out of bounds.</exception>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ACollection"/> is <c>nil</c>.</exception>
procedure InsertAll(const AIndex: NativeInt; const ACollection: IEnumerable<T>); overload;
/// <summary>Removes an element from the list at a given index.</summary>
/// <param name="AIndex">The index from which to remove the element.</param>
/// <remarks>This method removes the specified element and moves all following elements to the left by one.</remarks>
/// <exception cref="SysUtils|EArgumentOutOfRangeException"><paramref name="AIndex"/> is out of bounds.</exception>
procedure RemoveAt(const AIndex: NativeInt);
/// <summary>Extracts an element from the list at a given index.</summary>
/// <param name="AIndex">The index from which to extract the element.</param>
/// <remarks>This method removes the specified element and moves all following elements to the left by one.
/// The removed element is returned to the caller.</remarks>
/// <exception cref="SysUtils|EArgumentOutOfRangeException"><paramref name="AIndex"/> is out of bounds.</exception>
function ExtractAt(const AIndex: NativeInt): T;
/// <summary>Searches for the first appearance of a given element in this list.</summary>
/// <param name="AValue">The value to search for.</param>
/// <returns><c>-1</c> if the value was not found; otherwise a positive value indicating the index of the value.</returns>
function IndexOf(const AValue: T): NativeInt;
/// <summary>Searches for the last appearance of a given element in this list.</summary>
/// <param name="AValue">The value to search for.</param>
/// <returns><c>-1</c> if the value was not found; otherwise a positive value indicating the index of the value.</returns>
function LastIndexOf(const AValue: T): NativeInt;
/// <summary>Returns the item at a given index.</summary>
/// <param name="AIndex">The index in the list.</param>
/// <returns>The element at the specified position.</returns>
/// <exception cref="SysUtils|EArgumentOutOfRangeException"><paramref name="AIndex"/> is out of bounds.</exception>
function GetItem(const AIndex: NativeInt): T;
/// <summary>Sets the item at a given index.</summary>
/// <param name="AIndex">The index in the list.</param>
/// <param name="AValue">The new value.</param>
/// <exception cref="SysUtils|EArgumentOutOfRangeException"><paramref name="AIndex"/> is out of bounds.</exception>
procedure SetItem(const AIndex: NativeInt; const AValue: T);
/// <summary>Returns the item at a given index.</summary>
/// <param name="AIndex">The index in the collection.</param>
/// <returns>The element at the specified position.</returns>
/// <exception cref="SysUtils|EArgumentOutOfRangeException"><paramref name="AIndex"/> is out of bounds.</exception>
property Items[const AIndex: NativeInt]: T read GetItem write SetItem; default;
end;
/// <summary>The Enex interface that defines the behavior of a <c>linked list</c>.</summary>
/// <remarks>This interface is implemented by all collections that provide the functionality of a <c>linked list</c>.</remarks>
ILinkedList<T> = interface(IList<T>)
/// <summary>Appends an element to the back of list.</summary>
/// <param name="AValue">The value to append.</param>
/// <remarks>This method is functionally identical to <c>Add</c>. Classes that implement this interface can simply
/// alias this method to <c>Add</c>.</remarks>
procedure AddLast(const AValue: T); overload;
/// <summary>Appends the elements from a collection to the back of the list.</summary>
/// <param name="ACollection">The values to append.</param>
/// <remarks>This method is functionally identical to <c>Add</c>. Classes that implement this interface can simply
/// alias this method to <c>Add</c>.</remarks>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ACollection"/> is <c>nil</c>.</exception>
procedure AddAllLast(const ACollection: IEnumerable<T>); overload;
/// <summary>Appends an element to the front of the list.</summary>
/// <param name="AValue">The value to append.</param>
procedure AddFirst(const AValue: T); overload;
/// <summary>Appends the elements from a collection to the back of the list.</summary>
/// <param name="ACollection">The values to append.</param>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ACollection"/> is <c>nil</c>.</exception>
procedure AddAllFirst(const ACollection: IEnumerable<T>); overload;
/// <summary>Removes the first element of the list.</summary>
/// <exception cref="Collections.Base|ECollectionEmptyException">The list is empty.</exception>
procedure RemoveFirst();
/// <summary>Removes the last element of the list.</summary>
/// <exception cref="Collections.Base|ECollectionEmptyException">The list is empty.</exception>
procedure RemoveLast();
/// <summary>Extracts the first element of the list.</summary>
/// <returns>The first element of the list.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The list is empty.</exception>
function ExtractFirst(): T;
/// <summary>Removes the last element of the list.</summary>
/// <returns>The last element of the list.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The list is empty.</exception>
function ExtractLast(): T;
/// <summary>Returns the first element of the list.</summary>
/// <returns>The first element of the list.</returns>
/// <remarks>This method is functionally identical to <c>First</c> method exposed by the Enex intarfaces. It is provided here for consistency only.</remarks>
/// <exception cref="Collections.Base|ECollectionEmptyException">The list is empty.</exception>
function First(): T;
/// <summary>Returns the last element of the list.</summary>
/// <returns>The last element of the list.</returns>
/// <remarks>This method is functionally identical to <c>Last</c> method exposed by the Enex intarfaces. It is provided here for consistency only.</remarks>
/// <exception cref="Collections.Base|ECollectionEmptyException">The list is empty.</exception>
function Last(): T;
end;
/// <summary>The Enex interface that defines the basic behavior of all <c>map</c>-like collections.</summary>
/// <remarks>This interface is inherited by all interfaces that provide <c>map</c>-like functionality.</remarks>
IMap<TKey, TValue> = interface(IAssociation<TKey, TValue>)
/// <summary>Clears the contents of the map.</summary>
procedure Clear();
{$IF CompilerVersion > 21}
/// <summary>Adds a key-value pair to the map.</summary>
/// <param name="APair">The key-value pair to add.</param>
/// <exception cref="Collections.Base|EDuplicateKeyException">The map already contains a pair with the given key.</exception>
procedure Add(const APair: TPair<TKey, TValue>); overload;
/// <summary>Adds a collection of key-value pairs to the map.</summary>
/// <param name="ACollection">The collection to add.</param>
/// <exception cref="Collections.Base|EDuplicateKeyException">The map already contains a pair with the given key.</exception>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ACollection"/> is <c>nil</c>.</exception>
procedure AddAll(const ACollection: IEnumerable<TPair<TKey, TValue>>); overload;
{$IFEND}
/// <summary>Adds a key-value pair to the map.</summary>
/// <param name="AKey">The key of pair.</param>
/// <param name="AValue">The value associated with the key.</param>
/// <exception cref="Collections.Base|EDuplicateKeyException">The map already contains a pair with the given key.</exception>
procedure Add(const AKey: TKey; const AValue: TValue); overload;
/// <summary>Removes a key-value pair using a given key.</summary>
/// <param name="AKey">The key of pair.</param>
/// <remarks>If the specified key was not found in the map, nothing happens.</remarks>
procedure Remove(const AKey: TKey);
/// <summary>Checks whether the map contains a key-value pair identified by the given key.</summary>
/// <param name="AKey">The key to check for.</param>
/// <returns><c>True</c> if the map contains a pair identified by the given key; <c>False</c> otherwise.</returns>
function ContainsKey(const AKey: TKey): Boolean;
/// <summary>Checks whether the map contains a key-value pair that contains a given value.</summary>
/// <param name="AValue">The value to check for.</param>
/// <returns><c>True</c> if the map contains a pair containing the given value; <c>False</c> otherwise.</returns>
/// <remarks>This operation should be avoided. Its perfomance is poor is most map implementations.</remarks>
function ContainsValue(const AValue: TValue): Boolean;
end;
/// <summary>The Enex interface that defines the behavior of a <c>dictionary</c>.</summary>
/// <remarks>This interface is implemented by all collections that provide the functionality of a <c>dictionary</c>.</remarks>
IDictionary<TKey, TValue> = interface(IMap<TKey, TValue>)
/// <summary>Extracts a value using a given key.</summary>
/// <param name="AKey">The key of the associated value.</param>
/// <returns>The value associated with the key.</returns>
/// <remarks>This function is identical to <c>Remove</c> but will return the stored value. If there is no pair with the given key, an exception is raised.</remarks>
/// <exception cref="Collections.Base|EKeyNotFoundException">The <paramref name="AKey"/> is not part of the dictionary.</exception>
function Extract(const AKey: TKey): TValue;
/// <summary>Tries to obtain the value associated with a given key.</summary>
/// <param name="AKey">The key for which to try to retreive the value.</param>
/// <param name="AFoundValue">The found value (if the result is <c>True</c>).</param>
/// <returns><c>True</c> if the dictionary contains a value for the given key; <c>False</c> otherwise.</returns>
function TryGetValue(const AKey: TKey; out AFoundValue: TValue): Boolean;
/// <summary>Returns the value associated with the given key.</summary>
/// <param name="AKey">The key for which to try to retreive the value.</param>
/// <returns>The value associated with the key.</returns>
/// <exception cref="Collections.Base|EKeyNotFoundException">The key is not found in the dictionary.</exception>
function GetValue(const AKey: TKey): TValue;
/// <summary>Sets the value for a given key.</summary>
/// <param name="AKey">The key for which to set the value.</param>
/// <param name="AValue">The value to set.</param>
/// <remarks>If the dictionary does not contain the key, this method acts like <c>Add</c>; otherwise the
/// value of the specified key is modified.</remarks>
procedure SetValue(const AKey: TKey; const AValue: TValue);
/// <summary>Gets or sets the value for a given key.</summary>
/// <param name="AKey">The key for to operate on.</param>
/// <returns>The value associated with the key.</returns>
/// <remarks>If the dictionary does not contain the key, this method acts like <c>Add</c> if assignment is done to this property;
/// otherwise the value of the specified key is modified.</remarks>
/// <exception cref="Collections.Base|EKeyNotFoundException">Trying to read the value of a key that is
/// not found in the dictionary.</exception>
property Items[const AKey: TKey]: TValue read GetValue write SetValue; default;
end;
/// <summary>The Enex interface that defines the behavior of a <c>bidirectional dictionary</c>.</summary>
/// <remarks>This interface is implemented by all collections that provide the functionality of a <c>bidirectional dictionary</c>. In a
/// <c>bidirectional dictionary</c>, both the key and the value are treated as "keys".</remarks>
IBidiDictionary<TKey, TValue> = interface(IMap<TKey, TValue>)
/// <summary>Extracts a value using a given key.</summary>
/// <param name="AKey">The key of the associated value.</param>
/// <returns>The value associated with the key.</returns>
/// <remarks>This function is identical to <c>RemoveKey</c> but will return the stored value. If there is no pair with the given key, an exception is raised.</remarks>
/// <exception cref="Collections.Base|EKeyNotFoundException">The <paramref name="AKey"/> is not part of the map.</exception>
function ExtractValueForKey(const AKey: TKey): TValue;
/// <summary>Extracts a key using a given value.</summary>
/// <param name="AValue">The value of the associated key.</param>
/// <returns>The key associated with the value.</returns>
/// <remarks>This function is identical to <c>RemoveValue</c> but will return the stored key. If there is no pair with the given value, an exception is raised.</remarks>
/// <exception cref="Collections.Base|EKeyNotFoundException">The <paramref name="AValue"/> is not part of the map.</exception>
function ExtractKeyForValue(const AValue: TValue): TKey;
/// <summary>Removes a key-value pair using a given key.</summary>
/// <param name="AKey">The key (and its associated value) to remove.</param>
procedure RemoveValueForKey(const AKey: TKey);
/// <summary>Removes a key-value pair using a given value.</summary>
/// <param name="AValue">The value (and its associated key) to remove.</param>
procedure RemoveKeyForValue(const AValue: TValue);
/// <summary>Removes a specific key-value combination.</summary>
/// <param name="AKey">The key to remove.</param>
/// <param name="AValue">The value to remove.</param>
/// <remarks>This method only remove a key-value combination if that combination actually exists in the dictionary.
/// If the key is associated with another value, nothing happens.</remarks>
procedure RemovePair(const AKey: TKey; const AValue: TValue); overload;
{$IF CompilerVersion > 21}
/// <summary>Removes a key-value combination.</summary>
/// <param name="APair">The pair to remove.</param>
/// <remarks>This method only remove a key-value combination if that combination actually exists in the dictionary.
/// If the key is associated with another value, nothing happens.</remarks>
procedure RemovePair(const APair: TPair<TKey, TValue>); overload;
{$IFEND}
/// <summary>Checks whether the map contains the given key-value combination.</summary>
/// <param name="AKey">The key associated with the value.</param>
/// <param name="AValue">The value associated with the key.</param>
/// <returns><c>True</c> if the dictionary contains the given association; <c>False</c> otherwise.</returns>
function ContainsPair(const AKey: TKey; const AValue: TValue): Boolean; overload;
{$IF CompilerVersion > 21}
/// <summary>Checks whether the map contains a given key-value combination.</summary>
/// <param name="APair">The key-value pair combination.</param>
/// <returns><c>True</c> if the dictionary contains the given association; <c>False</c> otherwise.</returns>
function ContainsPair(const APair: TPair<TKey, TValue>): Boolean; overload;
{$IFEND}
/// <summary>Tries to obtain the value associated with a given key.</summary>
/// <param name="AKey">The key for which to try to retreive the value.</param>
/// <param name="AFoundValue">The found value (if the result is <c>True</c>).</param>
/// <returns><c>True</c> if the dictionary contains a value for the given key; <c>False</c> otherwise.</returns>
function TryGetValueForKey(const AKey: TKey; out AFoundValue: TValue): Boolean;
/// <summary>Returns the value associated with a key.</summary>
/// <param name="AKey">The key for which to obtain the associated value.</param>
/// <returns>The associated value.</returns>
/// <exception cref="Collections.Base|EKeyNotFoundException">The key is not found in the collection.</exception>
function GetValueForKey(const AKey: TKey): TValue;
/// <summary>Sets the value for a given key.</summary>
/// <param name="AKey">The key for which to set the value.</param>
/// <param name="AValue">The value to set.</param>
/// <remarks>If the dictionary does not contain the key, this method acts like <c>Add</c>; otherwise the
/// value of the specified key is modified.</remarks>
/// <exception cref="Collections.Base|EDuplicateKeyException">The new value is already used by another key.</exception>
procedure SetValueForKey(const AKey: TKey; const AValue: TValue);
/// <summary>Returns the value associated with a key.</summary>
/// <param name="AKey">The key for which to obtain the associated value.</param>
/// <returns>The associated value.</returns>
/// <exception cref="Collections.Base|EKeyNotFoundException">The key is not found in the collection.</exception>
property ByKey[const AKey: TKey]: TValue read GetValueForKey write SetValueForKey;
/// <summary>Tries to obtain the key associated with a given value.</summary>
/// <param name="AValue">The value for which to try to retreive the key.</param>
/// <param name="AFoundKey">The found key (if the result is <c>True</c>).</param>
/// <returns><c>True</c> if the dictionary contains a key for the given value; <c>False</c> otherwise.</returns>
function TryGetKeyForValue(const AValue: TValue; out AFoundKey: TKey): Boolean;
/// <summary>Returns the key associated with a value.</summary>
/// <param name="AValue">The value for which to obtain the associated key.</param>
/// <returns>The associated key.</returns>
/// <exception cref="Collections.Base|EKeyNotFoundException">The value is not found in the collection.</exception>
function GetKeyForValue(const AValue: TValue): TKey;
/// <summary>Sets the key for a given value.</summary>
/// <param name="AValue">The value for which to set the key.</param>
/// <param name="AKey">The key to set.</param>
/// <remarks>If the dictionary does not contain the value, this method acts like <c>Add</c>; otherwise the
/// key of the specified value is modified.</remarks>
/// <exception cref="Collections.Base|EDuplicateKeyException">The new key is already used by another value.</exception>
procedure SetKeyForValue(const AValue: TValue; const AKey: TKey);
/// <summary>Returns the key associated with a value.</summary>
/// <param name="AValue">The value for which to obtain the associated key.</param>
/// <returns>The associated key.</returns>
/// <exception cref="Collections.Base|EKeyNotFoundException">The value is not found in the collection.</exception>
property ByValue[const AValue: TValue]: TKey read GetKeyForValue write SetKeyForValue;
end;
/// <summary>The Enex interface that defines the behavior of a <c>bidirectional multi-map</c>.</summary>
/// <remarks>This interface is implemented by all collections that provide the functionality of a <c>bidirectional multi-map</c>. In a
/// <c>bidirectional multi-map</c>, both the key and the value are treated as "keys".</remarks>
IBidiMap<TKey, TValue> = interface(IMap<TKey, TValue>)
/// <summary>Removes a key-value pair using a given key.</summary>
/// <param name="AKey">The key (and its associated values) to remove.</param>
/// <remarks>This method removes all the values that are associated with the given key. The rule set's cleanup
/// routines are used to cleanup the values that are dropped from the map.</remarks>
procedure RemoveValuesForKey(const AKey: TKey);
/// <summary>Removes a key-value pair using a given value.</summary>
/// <param name="AValue">The value (and its associated keys) to remove.</param>
/// <remarks>This method removes all the keys that are associated with the given value. The rule set's cleanup
/// routines are used to cleanup the keys that are dropped from the map.</remarks>
procedure RemoveKeysForValue(const AValue: TValue);
/// <summary>Removes a specific key-value combination.</summary>
/// <param name="AKey">The key to remove.</param>
/// <param name="AValue">The value to remove.</param>
/// <remarks>This method only remove a key-value combination if that combination actually exists in the dictionary.
/// If the key is associated with another value, nothing happens.</remarks>
procedure RemovePair(const AKey: TKey; const AValue: TValue); overload;
{$IF CompilerVersion > 21}
/// <summary>Removes a key-value combination.</summary>
/// <param name="APair">The pair to remove.</param>
/// <remarks>This method only remove a key-value combination if that combination actually exists in the dictionary.
/// If the key is associated with another value, nothing happens.</remarks>
procedure RemovePair(const APair: TPair<TKey, TValue>); overload;
{$IFEND}
/// <summary>Checks whether the map contains the given key-value combination.</summary>
/// <param name="AKey">The key associated with the value.</param>
/// <param name="AValue">The value associated with the key.</param>
/// <returns><c>True</c> if the map contains the given association; <c>False</c> otherwise.</returns>
function ContainsPair(const AKey: TKey; const AValue: TValue): Boolean; overload;
{$IF CompilerVersion > 21}
/// <summary>Checks whether the map contains a given key-value combination.</summary>
/// <param name="APair">The key-value pair combination.</param>
/// <returns><c>True</c> if the map contains the given association; <c>False</c> otherwise.</returns>
function ContainsPair(const APair: TPair<TKey, TValue>): Boolean; overload;
{$IFEND}
/// <summary>Returns the collection of values associated with a key.</summary>
/// <param name="AKey">The key for which to obtain the associated values.</param>
/// <returns>An Enex collection that contains the values associated with this key.</returns>
/// <exception cref="Collections.Base|EKeyNotFoundException">The key is not found in the collection.</exception>
function GetValuesByKey(const AKey: TKey): ISequence<TValue>;
/// <summary>Returns the collection of values associated with a key.</summary>
/// <param name="AKey">The key for which to obtain the associated values.</param>
/// <returns>An Enex collection that contains the values associated with this key.</returns>
/// <exception cref="Collections.Base|EKeyNotFoundException">The key is not found in the collection.</exception>
property ByKey[const AKey: TKey]: ISequence<TValue> read GetValuesByKey;
/// <summary>Returns the collection of keys associated with a value.</summary>
/// <param name="AValue">The value for which to obtain the associated keys.</param>
/// <returns>An Enex collection that contains the values associated with this key.</returns>
/// <exception cref="Collections.Base|EKeyNotFoundException">The value is not found in the collection.</exception>
function GetKeysByValue(const AValue: TValue): ISequence<TKey>;
/// <summary>Returns the collection of keys associated with a value.</summary>
/// <param name="AValue">The value for which to obtain the associated keys.</param>
/// <returns>An Enex collection that contains the values associated with this key.</returns>
/// <exception cref="Collections.Base|EKeyNotFoundException">The value is not found in the collection.</exception>
property ByValue[const AValue: TValue]: ISequence<TKey> read GetKeysByValue;
end;
/// <summary>The Enex interface that defines the behavior of a <c>multi-map</c>.</summary>
/// <remarks>This interface is implemented by all collections that provide the functionality of a <c>multi-map</c>. In a
/// <c>multi-map</c>, a key is associated with multiple values, not just one.</remarks>
IMultiMap<TKey, TValue> = interface(IMap<TKey, TValue>)
/// <summary>Extracts all values using their key.</summary>
/// <param name="AKey">The key of the associated values.</param>
/// <returns>A collection of values associated with the key.</returns>
/// <remarks>This function is identical to <c>RemoveKey</c> but will return the associated values. If there is no given key, an exception is raised.</remarks>
/// <exception cref="Collections.Base|EKeyNotFoundException">The <paramref name="AKey"/> is not part of the map.</exception>
function ExtractValues(const AKey: TKey): ISequence<TValue>;
/// <summary>Removes a key-value pair using a given key and value.</summary>
/// <param name="AKey">The key associated with the value.</param>
/// <param name="AValue">The value to remove.</param>
/// <remarks>A multi-map allows storing multiple values for a given key. This method allows removing only the
/// specified value from the collection of values associated with the given key.</remarks>
procedure RemovePair(const AKey: TKey; const AValue: TValue); overload;
{$IF CompilerVersion > 21}
/// <summary>Removes a key-value pair using a given key and value.</summary>
/// <param name="APair">The key and its associated value to remove.</param>
/// <remarks>A multi-map allows storing multiple values for a given key. This method allows removing only the
/// specified value from the collection of values associated with the given key.</remarks>
procedure RemovePair(const APair: TPair<TKey, TValue>); overload;
{$IFEND}
/// <summary>Checks whether the multi-map contains a given key-value combination.</summary>
/// <param name="AKey">The key associated with the value.</param>
/// <param name="AValue">The value associated with the key.</param>
/// <returns><c>True</c> if the map contains the given association; <c>False</c> otherwise.</returns>
function ContainsPair(const AKey: TKey; const AValue: TValue): Boolean; overload;
{$IF CompilerVersion > 21}
/// <summary>Checks whether the multi-map contains a given key-value combination.</summary>
/// <param name="APair">The key-value pair to check for.</param>
/// <returns><c>True</c> if the map contains the given association; <c>False</c> otherwise.</returns>
function ContainsPair(const APair: TPair<TKey, TValue>): Boolean; overload;
{$IFEND}
/// <summary>Returns the collection of values associated with a key.</summary>
/// <param name="AKey">The key for which to obtain the associated values.</param>
/// <returns>An Enex collection that contains the values associated with this key.</returns>
/// <exception cref="Collections.Base|EKeyNotFoundException">The key is not found in the collection.</exception>
function GetValues(const AKey: TKey): ISequence<TValue>;
/// <summary>Returns the collection of values associated with a key.</summary>
/// <param name="AKey">The key for which to obtain the associated values.</param>
/// <returns>An Enex collection that contains the values associated with this key.</returns>
/// <exception cref="Collections.Base|EKeyNotFoundException">The key is not found in the collection.</exception>
property Items[const AKey: TKey]: ISequence<TValue> read GetValues; default;
/// <summary>Tries to extract the collection of values associated with a key.</summary>
/// <param name="AKey">The key for which to obtain the associated values.</param>
/// <param name="AValues">The Enex collection that stores the associated values.</param>
/// <returns><c>True</c> if the key exists in the collection; <c>False</c> otherwise;</returns>
function TryGetValues(const AKey: TKey; out AValues: ISequence<TValue>): Boolean; overload;
/// <summary>Tries to extract the collection of values associated with a key.</summary>
/// <param name="AKey">The key for which to obtain the associated values.</param>
/// <returns>The associated collection if the key if valid; an empty collection otherwise.</returns>
function TryGetValues(const AKey: TKey): ISequence<TValue>; overload;
end;
/// <summary>A special interface implemented by collections that support the concept of capacity.</summary>
/// <remarks>This interface specifies a set of method that allow controlling the capactity of a collection.</remarks>
IDynamic = interface
/// <summary>Returns the current capacity.</summary>
/// <returns>A positive number that specifies the number of elements that the collection can hold before it
/// needs to grow again.</returns>
/// <remarks>The value of this method is greater or equal to the amount of elements in the collection. If this value
/// if greater then the number of elements, it means that the collection has some extra capacity to operate upon.</remarks>
function GetCapacity(): NativeInt;
/// <summary>Removes the excess capacity from the collection.</summary>
/// <remarks>This method can be called manually to force the collection to drop the extra capacity it might hold. For example,
/// after performing some massive operations on a big list, call this method to ensure that all extra memory held by the
/// collection is released.</remarks>
procedure Shrink();
/// <summary>Forces the collection to increase its capacity.</summary>
/// <remarks>Call this method to force the collection to increase its capacity ahead of time. Manually adjusting the capacity
/// can be useful in certain situations. Each collection specifies its "growing" strategy. Most collections grow by a factor of two
/// <c>(New Capacity = Old Capacity * 2)</c>.</remarks>
procedure Grow();
/// <summary>Specifies the current capacity.</summary>
/// <returns>A positive number that specifies the number of elements that the collection can hold before it
/// needs to grow again.</returns>
/// <remarks>The value of this property is greater or equal to the amount of elements in the collection. If this value
/// if greater then the number of elements, it means that the collection has some extra capacity to operate upon.</remarks>
property Capacity: NativeInt read GetCapacity;
end;
{$ENDREGION}
{$REGION 'Base Collection Classes'}
type
{$HINTS OFF}
/// <summary>Base for all reference counted objects in this package.</summary>
/// <remarks><see cref="Collections.Base|TRefCountedObject">Collections.Base.TRefCountedObject</see> is designed to be used as a base class for all
/// objects that implement interfaces and require reference counting.</remarks>
TRefCountedObject = class abstract(TInterfacedObject, IInterface)
private
FKeepAliveList: TArray<IInterface>;
FInConstruction: Boolean;
protected
/// <summary>Registers a reference counted object as as keep-alive for this object.</summary>
/// <param name="AObject">The object to keep alive.</param>
/// <remarks>If <paramref name="AObject"/> is <c>nil</c> nothing happens. Otherwise, this object is
/// checked to have a positive reference count. If that is the case, a new interface reference is requested
/// and registered internally, preventing the object from being destroyed prematurely.</remarks>
/// <exception cref="Collections.Base|ECannotSelfReferenceException"> if trying to keep alive self.</exception>
procedure KeepObjectAlive(const AObject: TRefCountedObject);
/// <summary>Unregisters a reference counted object from the keep-alive list.</summary>
/// <param name="AObject">The object to unregister.</param>
/// <param name="AFreeObject">Specifies whether to free the object if its reference reaches is zero.</param>
/// <remarks>If <paramref name="AObject"/> is <c>nil</c> nothing happens. Otherwise, this object is
/// checked to have a positive reference count. If that is the case, the help reference is released.</remarks>
/// <exception cref="Collections.Base|ECannotSelfReferenceException"> if trying to release self.</exception>
procedure ReleaseObject(const AObject: TRefCountedObject;
const AFreeObject: Boolean = false);
/// <summary>Extract an interafce reference for this object.</summary>
/// <remarks>If the reference count is zero, then no reference is extracted.</remarks>
/// <returns>An interface reference or <c>nil</c>.</returns>
function ExtractReference(): IInterface;
/// <summary>Specifies whether the object is currently being constructed.</summary>
/// <returns><c>True</c> if the object is in construction; <c>False</c> otherwise.</returns>
property Constructing: Boolean read FInConstruction;
public
/// <summary>Initializes the internals of the <see cref="Collections.Base|TRefCountedObject">Collections.Base.TRefCountedObject</see> objects.</summary>
/// <remarks>Do not call this method directly. It is part of the object creation process.</remarks>
class function NewInstance: TObject; override;
/// <summary>Initializes the internals of the <see cref="Collections.Base|TRefCountedObject">Collections.Base.TRefCountedObject</see> objects.</summary>
/// <remarks>Do not call this method directly. It is part of the object creation process.</remarks>
procedure AfterConstruction; override;
end;
{$HINTS ON}
/// <summary>Procedural type used by collections to insert custom remove notification code
/// into inner collections.</summary>
/// <param name="AValue">The value being removed.</param>
TRemoveNotification<T> = reference to procedure(const AValue: T);
/// <summary>Non-generic base class for all collections.</summary>
/// <remarks>This class provides some basics like version management and count retrieval.</remarks>
TAbstractContainer = class abstract(TRefCountedObject)
private
FVersion: NativeInt;
FLock: TMREWSync;
FThreadSafe: LongBool;
protected
procedure SetThreadSafe(const Value: LongBool); virtual;
/// <summary>Returns the number of elements in the collection.</summary>
/// <returns>A positive value specifying the number of elements in the collection.</returns>
/// <remarks>A call to this method can be costly because some
/// collections cannot detect the number of stored elements directly, resorting to enumerating themselves.</remarks>
function GetCount(): NativeInt; virtual; abstract;
/// <summary>Call this method to notify the collection that it was modified.</summary>
/// <remarks>This method must be called by descending classes in order to update the version of the collection.</remarks>
procedure NotifyCollectionChanged(); virtual;
public
const CDefaultSize = 32;
constructor Create(const AThreadSafe: LongBool = False);
destructor Destroy; override;
/// <summary>Returns the current version of the collection.</summary>
/// <returns>An integer value specifying the current "structural version" of the collection.</returns>
/// <remarks>This function returns a number that is modified by the implementing collection each time
/// the collection changes. This version can be used to identify if a collection has chnaged since last time it was used
/// in a specific piece of code.</remarks>
function Version(): NativeInt; virtual;
/// <summary>Checks whether the collection is empty.</summary>
/// <returns><c>True</c> if the collection is empty; <c>False</c> otherwise.</returns>
/// <remarks>This method is the recommended way of detecting if the collection is empty. It is optimized
/// in most collections to offer a fast response.</remarks>
function Empty(): Boolean; virtual; abstract;
/// <summary>Specifies the number of elements in the collection.</summary>
/// <returns>A positive value specifying the number of elements in the collection.</returns>
/// <remarks>Accesing this property can be costly because some
/// collections cannot detect the number of stored elements directly, resorting to enumerating themselves.</remarks>
property Count: NativeInt read GetCount;
procedure LockForRead; inline;
procedure UnLockForRead; inline;
procedure LockForWrite; inline;
procedure UnLockForWrite; inline;
property Lock: TMREWSync read FLock;
property ThreadSafe: LongBool read FThreadSafe write SetThreadSafe;
end;
/// <summary>Base class for all collections.</summary>
/// <remarks>All collections are derived from this base class. It implements most Enex operations based on
/// enumerability .</remarks>
TAbstractContainer<T> = class abstract(TAbstractContainer, IContainer<T>, IEnumerable<T>)
protected
/// <summary>Returns the number of elements in the collection.</summary>
/// <returns>A positive value specifying the number of elements in the collection.</returns>
/// <remarks>A call to this method can be costly because some
/// collections cannot detect the number of stored elements directly, resorting to enumerating themselves.</remarks>
function GetCount(): NativeInt; override;
public
/// <summary>Checks whether the collection is empty.</summary>
/// <returns><c>True</c> if the collection is empty; <c>False</c> otherwise.</returns>
/// <remarks>This method is the recommended way of detecting if the collection is empty. It is optimized
/// in most collections to offer a fast response.</remarks>
function Empty(): Boolean; override;
/// <summary>Returns the single element stored in the collection.</summary>
/// <returns>The element in collection.</returns>
/// <remarks>This method checks if the collection contains just one element, in which case it is returned.</remarks>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="Collections.Base|ECollectionNotOneException">There is more than one element in the collection.</exception>
function Single(): T; virtual;
/// <summary>Returns the single element stored in the collection, or a default value.</summary>
/// <param name="ADefault">The default value returned if there is less or more elements in the collection.</param>
/// <returns>The element in the collection if the condition is satisfied; <paramref name="ADefault"/> is returned otherwise.</returns>
/// <remarks>This method checks if the collection contains just one element, in which case it is returned. Otherwise
/// the value in <paramref name="ADefault"/> is returned.</remarks>
function SingleOrDefault(const ADefault: T): T; virtual;
/// <summary>Copies the values stored in the collection to a given array.</summary>
/// <param name="AArray">An array where to copy the contents of the collection.</param>
/// <remarks>This method assumes that <paramref name="AArray"/> has enough space to hold the contents of the collection.</remarks>
/// <exception cref="Collections.Base|EArgumentOutOfSpaceException">There array is not long enough.</exception>
procedure CopyTo(var AArray: array of T); overload;
/// <summary>Copies the values stored in the collection to a given array.</summary>
/// <param name="AArray">An array where to copy the contents of the collection.</param>
/// <param name="AStartIndex">The index into the array at which the copying begins.</param>
/// <remarks>This method assumes that <paramref name="AArray"/> has enough space to hold the contents of the collection.</remarks>
/// <exception cref="SysUtils|EArgumentOutOfRangeException"><paramref name="AStartIndex"/> is out of bounds.</exception>
/// <exception cref="Collections.Base|EArgumentOutOfSpaceException">There array is not long enough.</exception>
procedure CopyTo(var AArray: array of T; const AStartIndex: NativeInt); overload; virtual;
/// <summary>Creates a new Delphi array with the contents of the collection.</summary>
/// <remarks>The length of the new array is equal to the value of <c>Count</c> property.</remarks>
function ToArray(): TArray<T>; virtual;
/// <summary>Returns a new enumerator object used to enumerate the collection.</summary>
/// <remarks>This method is usually called by compiler generated code. It's purpose is to create an enumerator
/// object that is used to actually traverse the collection.
/// Note that many collections generate enumerators that depend on the state of the collection. If the collection is changed
/// after the enumerator has been obtained, the enumerator is considered invalid. All subsequent operations on that enumerator
/// will throw exceptions.</remarks>
/// <returns>An enumerator object.</returns>
function GetEnumerator(): IEnumerator<T>; virtual; abstract;
/// <summary>Specifies the number of elements in the collection.</summary>
/// <returns>A positive value specifying the number of elements in the collection.</returns>
/// <remarks>Accesing this property can be costly because some
/// collections cannot detect the number of stored elements directly, resorting to enumerating themselves.</remarks>
property Count: NativeInt read GetCount;
end;
/// <summary>Base class for all Enex enumerator objects.</summary>
/// <remarks>All Enex collection are expected to provide enumerators that derive from
/// this class.</remarks>
TAbstractEnumerator<T> = class abstract(TRefCountedObject, IEnumerator<T>)
private
FCreatedAtVersion: NativeInt;
FOwner: TAbstractContainer;
FCurrent: T;
FEnded: Boolean;
protected
/// <summary>Specifies the owner collection.</summary>
/// <returns>The collection that generated this enumerator.</returns>
property Owner: TAbstractContainer read FOwner;
/// <summary>Returns the current element of the enumerated collection.</summary>
/// <remarks>This method is the getter for <c>Current</c> property. Use the property to obtain the element instead.</remarks>
/// <returns>The current element of the enumerated collection.</returns>
/// <exception cref="Collections.Base|ECollectionChangedException">The enumerated collection has changed.</exception>
function GetCurrent(): T;
/// <summary>Implement this method to move the iterator to the next element in the collection.</summary>
/// <param name="ACurrent">The "next" value. Must be returned by the descending classes.</param>
/// <returns><c>True</c> if the iteration to the next element was successful; <c>False</c> otherwise.</returns>
function TryMoveNext(out ACurrent: T): Boolean; virtual; abstract;
public
/// <summary>Initializes an enumerator object.</summary>
/// <param name="AOwner">The owner collection.</param>
/// <remarks>Descending classes must always call this constructor in their constructor.</remarks>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="AOwner"/> is <c>nil</c>.</exception>
constructor Create(const AOwner: TAbstractContainer);
/// <summary>Destroys this enumerator object.</summary>
destructor Destroy; override;
/// <summary>Moves the enumerator to the next element of collection.</summary>
/// <remarks>This method is usually called by compiler generated code. Its purpose is to move the "pointer" to the next element in
/// the collection (if there are elements left). Also note that many specific enumerator implementations may throw various
/// exceptions if the enumerated collection was changed while enumerating.</remarks>
/// <returns><c>True</c> if the enumerator succesefully selected the next element; <c>False</c> is there are
/// no more elements to be enumerated.</returns>
/// <exception cref="Collections.Base|ECollectionChangedException">The enumerated collection has changed.</exception>
function MoveNext(): Boolean;
/// <summary>Checking change of collection.</summary>
function VersionChanged: Boolean;
/// <summary>Returns the current element of the enumerated collection.</summary>
/// <remarks>This property can only return a valid element if <c>MoveNext</c> was priorly called and returned <c>True</c>;
/// otherwise the behavior of this property is undefined. </remarks>
/// <returns>The current element of the enumerated collection.</returns>
/// <exception cref="Collections.Base|ECollectionChangedException">The enumerated collection has changed.</exception>
property Current: T read GetCurrent;
end;
/// <summary>A variation of an enumerator object thet forwards all calls to an enclosed enumerator and allows filtering
/// the enumerated value.</summary>
/// <remarks>By default filtering is off, but it can be enaled by overriding the <c>AcceptValue</c> method.</remarks>
TForwardingEnumerator<T> = class abstract(TAbstractEnumerator<T>)
private
FForwardEnumerator: IEnumerator<T>;
protected
/// <summary>Obtains the next value from the use enumerator.</summary>
/// <param name="ACurrent">The "next" value. The value obtained from the forwarding enumerator.</param>
/// <remarks>This method calls <c>AcceptValue</c> and if the result is <c>False</c> iterates further until
/// a values from the enclised enumerator is accepted.</remarks>
/// <returns><c>True</c> if the iteration to the next element was successful; <c>False</c> otherwise.</returns>
function TryMoveNext(out ACurrent: T): Boolean; override;
/// <summary>Override in descending enumerator classes to accept or reject a value provided by the
/// enclosed enumerator.</summary>
/// <param name="AValue">The value to accept or reject.</param>
/// <returns><c>True</c> if the value is accepted; <c>False</c> otherwise.</returns>
/// <remarks>The current implementation always returns <c>True</c>.</remarks>
function AcceptValue(const AValue: T): Boolean; virtual;
public
/// <summary>Initializes a fprwarding enumerator object.</summary>
/// <param name="AOwner">The owner collection.</param>
/// <param name="AEnumerator">The enumerator to forward all calls to.</param>
/// <remarks>Descending classes must always call this constructor in their constructor.</remarks>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="AOwner"/> is <c>nil</c>.</exception>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="AEnumerator"/> is <c>nil</c>.</exception>
constructor Create(const AOwner: TAbstractContainer; const AEnumerator: IEnumerator<T>);
end;
/// <summary>Base class for all non-associative Enex collections.</summary>
/// <remarks>All normal Enex collections (ex. list or stack) are derived from this base class.
/// It implements the extended Enex operations based on enumerability.</remarks>
TSequence<T> = class abstract(TAbstractContainer<T>, IComparable, ISequence<T>)
private
FElementRules: TRules<T>;
protected
/// <summary>Compares two values for equality.</summary>
/// <param name="ALeft">The first value.</param>
/// <param name="ARight">The second value.</param>
/// <returns><c>True</c> if the values are equal; <c>False</c> otherwise.</returns>
/// <remarks>This method uses the equality comparer. If such a comparer was not provided
/// a default one is requested.</remarks>
function ElementsAreEqual(const ALeft, ARight: T): Boolean;
/// <summary>Compares two values.</summary>
/// <param name="ALeft">The first value.</param>
/// <param name="ARight">The second value.</param>
/// <returns>A value less than zero if <paramref name="ALeft"/> is less than <paramref name="ARight"/>.
/// A value greater than zero if <paramref name="ALeft"/> is greater than <paramref name="ARight"/>. Zero if
/// <paramref name="ALeft"/> is equal to <paramref name="ARight"/>.</returns>
/// <remarks>This method uses the comparer. If such a comparer was not provided
/// a default one is requested.</remarks>
function CompareElements(const ALeft, ARight: T): NativeInt;
/// <summary>Generates a hash code for the given value.</summary>
/// <param name="AValue">The value.</param>
/// <returns>The calculated hash code.</returns>
/// <remarks>This method uses the equality comparer. If such a comparer was not provided
/// a default one is requested.</remarks>
function GetElementHashCode(const AValue: T): NativeInt; overload;
/// <summary>Specifies the rule set that describes the stored elements.</summary>
/// <returns>A rule set describing the stored elements.</returns>
property ElementRules: TRules<T> read FElementRules;
public
/// <summary>Instantiates this class.</summary>
/// <remarks>The default comparer and equality comparer are requested if this constructor is used. Do not call this method if
/// you don't know what you are doing.</remarks>
constructor Create(); overload;
/// <summary>Instantiates this class.</summary>
/// <param name="ARules">The rules set used by the collection.</param>
/// <remarks>The provided rules set is used by this collection. This constructor must be called from descendent collections.</remarks>
constructor Create(const ARules: TRules<T>); overload;
/// <summary>Returns the biggest element.</summary>
/// <returns>An element from the collection considered to have the biggest value.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
function Max(): T; virtual;
/// <summary>Returns the smallest element.</summary>
/// <returns>An element from the collection considered to have the smallest value.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
function Min(): T; virtual;
/// <summary>Returns the first element.</summary>
/// <returns>The first element in collection.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
function First(): T; virtual;
/// <summary>Returns the first element or a default if the collection is empty.</summary>
/// <param name="ADefault">The default value returned if the collection is empty.</param>
/// <returns>The first element in collection if the collection is not empty; otherwise <paramref name="ADefault"/> is returned.</returns>
function FirstOrDefault(const ADefault: T): T; virtual;
/// <summary>Returns the first element that satisfies the given predicate.</summary>
/// <param name="APredicate">The predicate to use.</param>
/// <returns>The first element that satisfies the given predicate.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="Collections.Base|ECollectionFilteredEmptyException">No elements satisfy the predicate.</exception>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="APredicate"/> is <c>nil</c>.</exception>
function FirstWhere(const APredicate: TPredicate<T>): T; virtual;
/// <summary>Returns the first element that satisfies the given predicate or a default value.</summary>
/// <param name="APredicate">The predicate to use.</param>
/// <param name="ADefault">The default value.</param>
/// <returns>The first element that satisfies the given predicate; or <paramref name="ADefault"/> otherwise.</returns>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="APredicate"/> is <c>nil</c>.</exception>
function FirstWhereOrDefault(const APredicate: TPredicate<T>; const ADefault: T): T; virtual;
/// <summary>Returns the first element that does not satisfy the given predicate.</summary>
/// <param name="APredicate">The predicate to use.</param>
/// <returns>The first element that does not satisfy the given predicate.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="Collections.Base|ECollectionFilteredEmptyException">No elements that do not satisfy the predicate.</exception>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="APredicate"/> is <c>nil</c>.</exception>
function FirstWhereNot(const APredicate: TPredicate<T>): T;
/// <summary>Returns the first element that does not satisfy the given predicate or a default value.</summary>
/// <param name="APredicate">The predicate to use.</param>
/// <param name="ADefault">The default value.</param>
/// <returns>The first element that does not satisfy the given predicate; or <paramref name="ADefault"/> otherwise.</returns>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="APredicate"/> is <c>nil</c>.</exception>
function FirstWhereNotOrDefault(const APredicate: TPredicate<T>; const ADefault: T): T;
/// <summary>Returns the first element lower than a given value.</summary>
/// <param name="ABound">The value to compare against.</param>
/// <returns>The first element that satisfies the given condition.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="Collections.Base|ECollectionFilteredEmptyException">No elements satisfy the condition.</exception>
function FirstWhereLower(const ABound: T): T;
/// <summary>Returns the first element lower than a given value or a default.</summary>
/// <param name="ABound">The value to compare against.</param>
/// <param name="ADefault">The default value.</param>
/// <returns>The first element that satisfies the given condition; or <paramref name="ADefault"/> otherwise.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="Collections.Base|ECollectionFilteredEmptyException">No elements satisfy the condition.</exception>
function FirstWhereLowerOrDefault(const ABound: T; const ADefault: T): T;
/// <summary>Returns the first element lower than or equal to a given value.</summary>
/// <param name="ABound">The value to compare against.</param>
/// <returns>The first element that satisfies the given condition.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="Collections.Base|ECollectionFilteredEmptyException">No elements satisfy the condition.</exception>
function FirstWhereLowerOrEqual(const ABound: T): T;
/// <summary>Returns the first element lower than or equal to a given value or a default.</summary>
/// <param name="ABound">The value to compare against.</param>
/// <param name="ADefault">The default value.</param>
/// <returns>The first element that satisfies the given condition; or <paramref name="ADefault"/> otherwise.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="Collections.Base|ECollectionFilteredEmptyException">No elements satisfy the condition.</exception>
function FirstWhereLowerOrEqualOrDefault(const ABound: T; const ADefault: T): T;
/// <summary>Returns the first element greater than a given value.</summary>
/// <param name="ABound">The value to compare against.</param>
/// <returns>The first element that satisfies the given condition.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="Collections.Base|ECollectionFilteredEmptyException">No elements satisfy the condition.</exception>
function FirstWhereGreater(const ABound: T): T;
/// <summary>Returns the first element greater than a given value or a default.</summary>
/// <param name="ABound">The value to compare against.</param>
/// <param name="ADefault">The default value.</param>
/// <returns>The first element that satisfies the given condition; or <paramref name="ADefault"/> otherwise.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="Collections.Base|ECollectionFilteredEmptyException">No elements satisfy the condition.</exception>
function FirstWhereGreaterOrDefault(const ABound: T; const ADefault: T): T;
/// <summary>Returns the first element greater than or equal to a given value.</summary>
/// <param name="ABound">The value to compare against.</param>
/// <returns>The first element that satisfies the given condition.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="Collections.Base|ECollectionFilteredEmptyException">No elements satisfy the condition.</exception>
function FirstWhereGreaterOrEqual(const ABound: T): T;
/// <summary>Returns the first element greater than or equal to a given value or a default.</summary>
/// <param name="ABound">The value to compare against.</param>
/// <param name="ADefault">The default value.</param>
/// <returns>The first element that satisfies the given condition; or <paramref name="ADefault"/> otherwise.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="Collections.Base|ECollectionFilteredEmptyException">No elements satisfy the condition.</exception>
function FirstWhereGreaterOrEqualOrDefault(const ABound: T; const ADefault: T): T;
/// <summary>Returns the first element situated within the given bounds.</summary>
/// <param name="ALower">The lower bound.</param>
/// <param name="AHigher">The higher bound.</param>
/// <returns>The first element that satisfies the given condition.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="Collections.Base|ECollectionFilteredEmptyException">No elements satisfy the condition.</exception>
function FirstWhereBetween(const ALower, AHigher: T): T;
/// <summary>Returns the first element situated within the given bounds or a default.</summary>
/// <param name="ALower">The lower bound.</param>
/// <param name="AHigher">The higher bound.</param>
/// <param name="ADefault">The default value.</param>
/// <returns>The first element that satisfies the given condition; or <paramref name="ADefault"/> otherwise.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="Collections.Base|ECollectionFilteredEmptyException">No elements satisfy the condition.</exception>
function FirstWhereBetweenOrDefault(const ALower, AHigher: T; const ADefault: T): T;
/// <summary>Returns the last element.</summary>
/// <returns>The last element in collection.</returns>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
function Last(): T; virtual;
/// <summary>Returns the last element or a default if the collection is empty.</summary>
/// <param name="ADefault">The default value returned if the collection is empty.</param>
/// <returns>The last element in collection if the collection is not empty; otherwise <paramref name="ADefault"/> is returned.</returns>
function LastOrDefault(const ADefault: T): T; virtual;
/// <summary>Aggregates a value based on the collection's elements.</summary>
/// <param name="AAggregator">The aggregator method.</param>
/// <returns>A value that contains the collection's aggregated value.</returns>
/// <remarks>This method returns the first element if the collection only has one element. Otherwise,
/// <paramref name="AAggregator"/> is invoked for each two elements (first and second; then the result of the first two
/// and the third, and so on). The simplest example of aggregation is the "sum" operation where you can obtain the sum of all
/// elements in the value.</remarks>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="AAggregator"/> is <c>nil</c>.</exception>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
function Aggregate(const AAggregator: TFunc<T, T, T>): T; virtual;
/// <summary>Aggregates a value based on the collection's elements.</summary>
/// <param name="AAggregator">The aggregator method.</param>
/// <param name="ADefault">The default value returned if the collection is empty.</param>
/// <returns>A value that contains the collection's aggregated value. If the collection is empty, <paramref name="ADefault"/> is returned.</returns>
/// <remarks>This method returns the first element if the collection only has one element. Otherwise,
/// <paramref name="AAggregator"/> is invoked for each two elements (first and second; then the result of the first two
/// and the third, and so on). The simplest example of aggregation is the "sum" operation where you can obtain the sum of all
/// elements in the value.</remarks>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="AAggregator"/> is <c>nil</c>.</exception>
function AggregateOrDefault(const AAggregator: TFunc<T, T, T>; const ADefault: T): T; virtual;
/// <summary>Returns the element at a given position.</summary>
/// <param name="AIndex">The index from which to return the element.</param>
/// <returns>The element at the specified position.</returns>
/// <remarks>This method is slow for collections that cannot reference their elements by indexes, for example linked lists.</remarks>
/// <exception cref="Collections.Base|ECollectionEmptyException">The collection is empty.</exception>
/// <exception cref="SysUtils|EArgumentOutOfRangeException"><paramref name="AIndex"/> is out of bounds.</exception>
function ElementAt(const AIndex: NativeInt): T; virtual;
/// <summary>Returns the element at a given position.</summary>
/// <param name="AIndex">The index from which to return the element.</param>
/// <param name="ADefault">The default value returned if the collection is empty.</param>
/// <returns>The element at the specified position if the collection is not empty and the position is not out of bounds; otherwise
/// the value of <paramref name="ADefault"/> is returned.</returns>
/// <remarks>This method is slow for collections that cannot reference their elements by indexes, for example linked lists.</remarks>
function ElementAtOrDefault(const AIndex: NativeInt; const ADefault: T): T; virtual;
/// <summary>Check whether at least one element in the collection satisfies a given predicate.</summary>
/// <param name="APredicate">The predicate to check for each element.</param>
/// <returns><c>True</c> if at least one element satisfies a given predicate; <c>False</c> otherwise.</returns>
/// <remarks>This method traverses the whole collection and checks the value of the predicate for each element. This method
/// stops on the first element for which the predicate returns <c>True</c>. The logical equivalent of this operation is "OR".</remarks>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="APredicate"/> is <c>nil</c>.</exception>
function Any(const APredicate: TPredicate<T>): Boolean; virtual;
/// <summary>Checks that all elements in the collection satisfies a given predicate.</summary>
/// <param name="APredicate">The predicate to check for each element.</param>
/// <returns><c>True</c> if all elements satisfy a given predicate; <c>False</c> otherwise.</returns>
/// <remarks>This method traverses the whole collection and checks the value of the predicate for each element. This method
/// stops on the first element for which the predicate returns <c>False</c>. The logical equivalent of this operation is "AND".</remarks>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="APredicate"/> is <c>nil</c>.</exception>
function All(const APredicate: TPredicate<T>): Boolean; virtual;
/// <summary>Checks whether the elements in this collection are equal to the elements in another collection.</summary>
/// <param name="ACollection">The collection to compare to.</param>
/// <returns><c>True</c> if the collections are equal; <c>False</c> if the collections are different.</returns>
/// <remarks>This method checks that each element at position X in this collection is equal to an element at position X in
/// the provided collection. If the number of elements in both collections is different, then the collections are considered different.
/// Note that comparison of element is done using the rule set used by this collection. This means that comparing this collection
/// to another one might yield a different result than comparing the other collection to this one.</remarks>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="ACollection"/> is <c>nil</c>.</exception>
function EqualsTo(const ACollection: IEnumerable<T>): Boolean; virtual;
/// <summary>Selects only the elements that satisfy a given rule.</summary>
/// <param name="APredicate">The predicate that represents the rule.</param>
/// <returns>A new collection that contains only the elements that satisfy the given rule.</returns>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="APredicate"/> is <c>nil</c>.</exception>
function Where(const APredicate: TPredicate<T>): ISequence<T>;
/// <summary>Selects only the elements that do not satisfy a given rule.</summary>
/// <param name="APredicate">The predicate that represents the rule.</param>
/// <returns>A new collection that contains only the elements that do not satisfy the given rule.</returns>
/// <exception cref="SysUtils|EArgumentNilException"><paramref name="APredicate"/> is <c>nil</c>.</exception>
function WhereNot(const APredicate: TPredicate<T>): ISequence<T>;
/// <summary>Selects only the elements that are less than a given value.</summary>
/// <param name="ABound">
gitextract_1k5rhwaz/ ├── ClassUtils.pas ├── CollectList.inc ├── CollectList.pas ├── CollectListIntf.inc ├── Collections/ │ ├── Collections.Bags.pas │ ├── Collections.Base.pas │ ├── Collections.BidiDictionaries.pas │ ├── Collections.BidiMaps.pas │ ├── Collections.Dictionaries.pas │ ├── Collections.Dynamic.pas │ ├── Collections.Lists.pas │ ├── Collections.MultiMaps.pas │ ├── Collections.Queues.pas │ ├── Collections.Serialization.pas │ ├── Collections.Sets.pas │ ├── Collections.Stacks.pas │ ├── Collections.dpk │ ├── Collections.dproj │ ├── Collections.identcache │ ├── Collections.res │ └── Collections_project.tvsconfig ├── DbgCodeProfiler.pas ├── DbgHook32.dpr ├── DbgHook32.dproj ├── DbgHook32.res ├── DbgHookCS.pas ├── DbgHookMemory.pas ├── DbgHookPerf.pas ├── DbgHookSyncObjs.pas ├── DbgHookThread.pas ├── DbgHookTypes.pas ├── DbgHookUtils.pas ├── DbgMemoryProfiler.pas ├── DbgSamplingProfiler.pas ├── DbgSyncObjsProfiler.pas ├── DbgWorkerThread.pas ├── DebugHook.pas ├── DebugInfo.pas ├── Debuger.pas ├── DebugerTypes.pas ├── DelphiDebugInfo.pas ├── External/ │ ├── Jedi/ │ │ ├── Jcl/ │ │ │ └── source/ │ │ │ ├── common/ │ │ │ │ ├── Jcl8087.pas │ │ │ │ ├── JclAbstractContainers.pas │ │ │ │ ├── JclAlgorithms.pas │ │ │ │ ├── JclAnsiStrings.pas │ │ │ │ ├── JclArrayLists.pas │ │ │ │ ├── JclArraySets.pas │ │ │ │ ├── JclBase.pas │ │ │ │ ├── JclBinaryTrees.pas │ │ │ │ ├── JclCharsets.pas │ │ │ │ ├── JclCompilerUtils.pas │ │ │ │ ├── JclComplex.pas │ │ │ │ ├── JclCompression.pas │ │ │ │ ├── JclContainerIntf.pas │ │ │ │ ├── JclCounter.pas │ │ │ │ ├── JclDateTime.pas │ │ │ │ ├── JclDevToolsResources.pas │ │ │ │ ├── JclExprEval.pas │ │ │ │ ├── JclFileUtils.pas │ │ │ │ ├── JclHashMaps.pas │ │ │ │ ├── JclHashSets.pas │ │ │ │ ├── JclIDEUtils.pas │ │ │ │ ├── JclIniFiles.pas │ │ │ │ ├── JclLinkedLists.pas │ │ │ │ ├── JclLogic.pas │ │ │ │ ├── JclMIDI.pas │ │ │ │ ├── JclMath.pas │ │ │ │ ├── JclMime.pas │ │ │ │ ├── JclNotify.pas │ │ │ │ ├── JclPCRE.pas │ │ │ │ ├── JclPreProcessorAlgorithmsTemplates.pas │ │ │ │ ├── JclPreProcessorArrayListsTemplates.pas │ │ │ │ ├── JclPreProcessorArraySetsTemplates.pas │ │ │ │ ├── JclPreProcessorBinaryTreesTemplates.pas │ │ │ │ ├── JclPreProcessorContainer1DTemplates.pas │ │ │ │ ├── JclPreProcessorContainer2DTemplates.pas │ │ │ │ ├── JclPreProcessorContainerIntfTemplates.pas │ │ │ │ ├── JclPreProcessorContainerKnownMaps.pas │ │ │ │ ├── JclPreProcessorContainerKnownTypes.pas │ │ │ │ ├── JclPreProcessorContainerTemplates.pas │ │ │ │ ├── JclPreProcessorContainerTypes.pas │ │ │ │ ├── JclPreProcessorExcDlgTemplates.pas │ │ │ │ ├── JclPreProcessorHashMapsTemplates.pas │ │ │ │ ├── JclPreProcessorHashSetsTemplates.pas │ │ │ │ ├── JclPreProcessorLexer.pas │ │ │ │ ├── JclPreProcessorLinkedListsTemplates.pas │ │ │ │ ├── JclPreProcessorParser.pas │ │ │ │ ├── JclPreProcessorQueuesTemplates.pas │ │ │ │ ├── JclPreProcessorSortedMapsTemplates.pas │ │ │ │ ├── JclPreProcessorStacksTemplates.pas │ │ │ │ ├── JclPreProcessorTemplates.pas │ │ │ │ ├── JclPreProcessorTreesTemplates.pas │ │ │ │ ├── JclPreProcessorVectorsTemplates.pas │ │ │ │ ├── JclQueues.pas │ │ │ │ ├── JclRTTI.pas │ │ │ │ ├── JclResources.pas │ │ │ │ ├── JclSchedule.pas │ │ │ │ ├── JclSimpleXml.pas │ │ │ │ ├── JclSortedMaps.pas │ │ │ │ ├── JclStacks.pas │ │ │ │ ├── JclStatistics.pas │ │ │ │ ├── JclStrHashMap.pas │ │ │ │ ├── JclStreams.pas │ │ │ │ ├── JclStringConversions.pas │ │ │ │ ├── JclStringLists.pas │ │ │ │ ├── JclStrings.pas │ │ │ │ ├── JclSynch.pas │ │ │ │ ├── JclSysInfo.pas │ │ │ │ ├── JclSysUtils.pas │ │ │ │ ├── JclTrees.pas │ │ │ │ ├── JclUnicode.pas │ │ │ │ ├── JclUnicode.rc │ │ │ │ ├── JclUnicode.res │ │ │ │ ├── JclUnicodeBZip2.res │ │ │ │ ├── JclUnicodeBzip2.rc │ │ │ │ ├── JclUnicodeZLib.rc │ │ │ │ ├── JclUnicodeZLib.res │ │ │ │ ├── JclUnitConv.pas │ │ │ │ ├── JclUnitVersioning.pas │ │ │ │ ├── JclUnitVersioningProviders.pas │ │ │ │ ├── JclUsesUtils.pas │ │ │ │ ├── JclValidation.pas │ │ │ │ ├── JclVectors.pas │ │ │ │ ├── JclWideStrings.pas │ │ │ │ ├── bzip2.pas │ │ │ │ ├── dirinfo.txt │ │ │ │ ├── pcre.pas │ │ │ │ ├── zconf.h │ │ │ │ ├── zlib.h │ │ │ │ └── zlibh.pas │ │ │ ├── include/ │ │ │ │ ├── crossplatform.inc │ │ │ │ ├── jcl.inc │ │ │ │ ├── jcl.template.inc │ │ │ │ ├── jcld17win32.inc │ │ │ │ ├── jcld17win64.inc │ │ │ │ ├── jedi/ │ │ │ │ │ ├── jedi.inc │ │ │ │ │ └── kylix.inc │ │ │ │ ├── unixonly.inc │ │ │ │ └── windowsonly.inc │ │ │ └── windows/ │ │ │ ├── Hardlinks.pas │ │ │ ├── JclAppInst.pas │ │ │ ├── JclCIL.pas │ │ │ ├── JclCLR.pas │ │ │ ├── JclCOM.pas │ │ │ ├── JclCommCtrlAdmin.manifest │ │ │ ├── JclCommCtrlAdmin.rc │ │ │ ├── JclCommCtrlAdmin.res │ │ │ ├── JclCommCtrlAsInvoker.manifest │ │ │ ├── JclCommCtrlAsInvoker.rc │ │ │ ├── JclCommCtrlAsInvoker.res │ │ │ ├── JclConsole.pas │ │ │ ├── JclCppException.pas │ │ │ ├── JclDebug.pas │ │ │ ├── JclDebugSerialization.pas │ │ │ ├── JclDebugXMLDeserializer.pas │ │ │ ├── JclDebugXMLSerializer.pas │ │ │ ├── JclDotNet.pas │ │ │ ├── JclHelpUtils.pas │ │ │ ├── JclHookExcept.pas │ │ │ ├── JclLANMan.pas │ │ │ ├── JclLocales.pas │ │ │ ├── JclMapi.pas │ │ │ ├── JclMetadata.pas │ │ │ ├── JclMiscel.pas │ │ │ ├── JclMsBuild.pas │ │ │ ├── JclMsdosSys.pas │ │ │ ├── JclMultimedia.pas │ │ │ ├── JclNTFS.pas │ │ │ ├── JclNoDepAdmin.manifest │ │ │ ├── JclNoDepAdmin.rc │ │ │ ├── JclNoDepAdmin.res │ │ │ ├── JclNoDepAsInvoker.manifest │ │ │ ├── JclNoDepAsInvoker.rc │ │ │ ├── JclNoDepAsInvoker.res │ │ │ ├── JclPeImage.pas │ │ │ ├── JclRegistry.pas │ │ │ ├── JclSecurity.pas │ │ │ ├── JclShell.pas │ │ │ ├── JclStructStorage.pas │ │ │ ├── JclSvcCtrl.pas │ │ │ ├── JclTD32.pas │ │ │ ├── JclTask.pas │ │ │ ├── JclTimeZones.pas │ │ │ ├── JclWin32.pas │ │ │ ├── JclWin32Ex.pas │ │ │ ├── JclWinMIDI.pas │ │ │ ├── MSHelpServices_TLB.pas │ │ │ ├── MSTask.pas │ │ │ ├── Snmp.pas │ │ │ ├── dirinfo.txt │ │ │ ├── mscoree_TLB.pas │ │ │ ├── mscorlib_TLB.pas │ │ │ ├── obj/ │ │ │ │ ├── bzip2/ │ │ │ │ │ ├── win32/ │ │ │ │ │ │ ├── blocksort.obj │ │ │ │ │ │ ├── bzlib.obj │ │ │ │ │ │ ├── compress.obj │ │ │ │ │ │ ├── crctable.obj │ │ │ │ │ │ ├── decompress.obj │ │ │ │ │ │ ├── dirinfo.txt │ │ │ │ │ │ ├── huffman.obj │ │ │ │ │ │ ├── makefile.mak │ │ │ │ │ │ └── randtable.obj │ │ │ │ │ └── win64/ │ │ │ │ │ ├── blocksort.obj │ │ │ │ │ ├── bzlib.obj │ │ │ │ │ ├── compress.obj │ │ │ │ │ ├── crctable.obj │ │ │ │ │ ├── decompress.obj │ │ │ │ │ ├── dirinfo.txt │ │ │ │ │ ├── huffman.obj │ │ │ │ │ ├── makefile.mak │ │ │ │ │ └── randtable.obj │ │ │ │ ├── pcre/ │ │ │ │ │ ├── win32/ │ │ │ │ │ │ ├── dirinfo.txt │ │ │ │ │ │ ├── makefile.mak │ │ │ │ │ │ ├── pcre16_chartables.obj │ │ │ │ │ │ ├── pcre16_compile.obj │ │ │ │ │ │ ├── pcre16_config.obj │ │ │ │ │ │ ├── pcre16_dfa_exec.obj │ │ │ │ │ │ ├── pcre16_exec.obj │ │ │ │ │ │ ├── pcre16_fullinfo.obj │ │ │ │ │ │ ├── pcre16_get.obj │ │ │ │ │ │ ├── pcre16_jit_compile.obj │ │ │ │ │ │ ├── pcre16_maketables.obj │ │ │ │ │ │ ├── pcre16_newline.obj │ │ │ │ │ │ ├── pcre16_ord2utf16.obj │ │ │ │ │ │ ├── pcre16_refcount.obj │ │ │ │ │ │ ├── pcre16_string_utils.obj │ │ │ │ │ │ ├── pcre16_study.obj │ │ │ │ │ │ ├── pcre16_tables.obj │ │ │ │ │ │ ├── pcre16_ucd.obj │ │ │ │ │ │ ├── pcre16_valid_utf16.obj │ │ │ │ │ │ ├── pcre16_version.obj │ │ │ │ │ │ ├── pcre16_xclass.obj │ │ │ │ │ │ ├── pcre_chartables.obj │ │ │ │ │ │ ├── pcre_compile.obj │ │ │ │ │ │ ├── pcre_config.obj │ │ │ │ │ │ ├── pcre_dfa_exec.obj │ │ │ │ │ │ ├── pcre_exec.obj │ │ │ │ │ │ ├── pcre_fullinfo.obj │ │ │ │ │ │ ├── pcre_get.obj │ │ │ │ │ │ ├── pcre_jit_compile.obj │ │ │ │ │ │ ├── pcre_maketables.obj │ │ │ │ │ │ ├── pcre_newline.obj │ │ │ │ │ │ ├── pcre_ord2utf8.obj │ │ │ │ │ │ ├── pcre_refcount.obj │ │ │ │ │ │ ├── pcre_study.obj │ │ │ │ │ │ ├── pcre_tables.obj │ │ │ │ │ │ ├── pcre_ucd.obj │ │ │ │ │ │ ├── pcre_valid_utf8.obj │ │ │ │ │ │ ├── pcre_version.obj │ │ │ │ │ │ └── pcre_xclass.obj │ │ │ │ │ └── win64/ │ │ │ │ │ ├── dirinfo.txt │ │ │ │ │ ├── makefile.mak │ │ │ │ │ ├── pcre16_chartables.obj │ │ │ │ │ ├── pcre16_compile.obj │ │ │ │ │ ├── pcre16_config.obj │ │ │ │ │ ├── pcre16_dfa_exec.obj │ │ │ │ │ ├── pcre16_exec.obj │ │ │ │ │ ├── pcre16_fullinfo.obj │ │ │ │ │ ├── pcre16_get.obj │ │ │ │ │ ├── pcre16_jit_compile.obj │ │ │ │ │ ├── pcre16_maketables.obj │ │ │ │ │ ├── pcre16_newline.obj │ │ │ │ │ ├── pcre16_ord2utf16.obj │ │ │ │ │ ├── pcre16_refcount.obj │ │ │ │ │ ├── pcre16_string_utils.obj │ │ │ │ │ ├── pcre16_study.obj │ │ │ │ │ ├── pcre16_tables.obj │ │ │ │ │ ├── pcre16_ucd.obj │ │ │ │ │ ├── pcre16_valid_utf16.obj │ │ │ │ │ ├── pcre16_version.obj │ │ │ │ │ ├── pcre16_xclass.obj │ │ │ │ │ ├── pcre_chartables.obj │ │ │ │ │ ├── pcre_compile.obj │ │ │ │ │ ├── pcre_config.obj │ │ │ │ │ ├── pcre_dfa_exec.obj │ │ │ │ │ ├── pcre_exec.obj │ │ │ │ │ ├── pcre_fullinfo.obj │ │ │ │ │ ├── pcre_get.obj │ │ │ │ │ ├── pcre_jit_compile.obj │ │ │ │ │ ├── pcre_maketables.obj │ │ │ │ │ ├── pcre_newline.obj │ │ │ │ │ ├── pcre_ord2utf8.obj │ │ │ │ │ ├── pcre_refcount.obj │ │ │ │ │ ├── pcre_study.obj │ │ │ │ │ ├── pcre_tables.obj │ │ │ │ │ ├── pcre_ucd.obj │ │ │ │ │ ├── pcre_valid_utf8.obj │ │ │ │ │ ├── pcre_version.obj │ │ │ │ │ └── pcre_xclass.obj │ │ │ │ └── zlib/ │ │ │ │ ├── win32/ │ │ │ │ │ ├── adler32.obj │ │ │ │ │ ├── compress.obj │ │ │ │ │ ├── crc32.obj │ │ │ │ │ ├── deflate.obj │ │ │ │ │ ├── dirinfo.txt │ │ │ │ │ ├── infback.obj │ │ │ │ │ ├── inffast.obj │ │ │ │ │ ├── inflate.obj │ │ │ │ │ ├── inftrees.obj │ │ │ │ │ ├── makefile.mak │ │ │ │ │ ├── trees.obj │ │ │ │ │ ├── uncompr.obj │ │ │ │ │ └── zutil.obj │ │ │ │ └── win64/ │ │ │ │ ├── adler32.obj │ │ │ │ ├── compress.obj │ │ │ │ ├── crc32.obj │ │ │ │ ├── deflate.obj │ │ │ │ ├── dirinfo.txt │ │ │ │ ├── infback.obj │ │ │ │ ├── inffast.obj │ │ │ │ ├── inflate.obj │ │ │ │ ├── inftrees.obj │ │ │ │ ├── makefile.mak │ │ │ │ ├── trees.obj │ │ │ │ ├── uncompr.obj │ │ │ │ └── zutil.obj │ │ │ └── sevenzip.pas │ │ └── Jvcl/ │ │ ├── common/ │ │ │ ├── common.txt │ │ │ ├── crossplatform.inc │ │ │ ├── jedi/ │ │ │ │ ├── jedi.inc │ │ │ │ └── kylix.inc │ │ │ ├── jvcl.inc │ │ │ ├── jvclbase.inc │ │ │ ├── jvclc6.inc │ │ │ ├── jvcld10.inc │ │ │ ├── jvcld11.inc │ │ │ ├── jvcld12.inc │ │ │ ├── jvcld14.inc │ │ │ ├── jvcld15.inc │ │ │ ├── jvcld16.inc │ │ │ ├── jvcld16_x64.inc │ │ │ ├── jvcld17.inc │ │ │ ├── jvcld17_x64.inc │ │ │ ├── jvcld6.inc │ │ │ ├── jvcld7.inc │ │ │ ├── jvcld9.inc │ │ │ ├── linuxonly.inc │ │ │ ├── windowsonly.inc │ │ │ └── windowsversion.inc │ │ ├── resources/ │ │ │ ├── JvAppFrmReg.dcr │ │ │ ├── JvBDEReg.dcr │ │ │ ├── JvBaseEdits.res │ │ │ ├── JvCSVBase.res │ │ │ ├── JvCalc.res │ │ │ ├── JvCheckmarks.res │ │ │ ├── JvCmpReg.dcr │ │ │ ├── JvColorCombo.res │ │ │ ├── JvComponentPanel.res │ │ │ ├── JvConsts.res │ │ │ ├── JvControlsReg.dcr │ │ │ ├── JvCoreReg.dcr │ │ │ ├── JvCryptReg.dcr │ │ │ ├── JvCtrls.res │ │ │ ├── JvCustomReg.dcr │ │ │ ├── JvDBControls.res │ │ │ ├── JvDBGrid.res │ │ │ ├── JvDBReg.dcr │ │ │ ├── JvDice.res │ │ │ ├── JvDlgsReg.dcr │ │ │ ├── JvDockingReg.dcr │ │ │ ├── JvDotNetCtrlsReg.dcr │ │ │ ├── JvErrorIndicator.res │ │ │ ├── JvExplorerBar.res │ │ │ ├── JvGammaPanel.res │ │ │ ├── JvGlobusReg.dcr │ │ │ ├── JvHMIReg.dcr │ │ │ ├── JvJansReg.dcr │ │ │ ├── JvLED.res │ │ │ ├── JvMMReg.dcr │ │ │ ├── JvManagedThreadsReg.dcr │ │ │ ├── JvNetReg.dcr │ │ │ ├── JvOutlookBar.res │ │ │ ├── JvPageListTreeViewReg.dcr │ │ │ ├── JvPageSetupTitled.res │ │ │ ├── JvPascalInterpreterReg.dcr │ │ │ ├── JvPluginSystemReg.dcr │ │ │ ├── JvPluginWiz.res │ │ │ ├── JvPoweredBy.res │ │ │ ├── JvPreviewReg.dcr │ │ │ ├── JvQConsts.res │ │ │ ├── JvQErrorIndicator.res │ │ │ ├── JvRegistryTreeView.res │ │ │ ├── JvRuntimeDesign.res │ │ │ ├── JvRuntimeDesignReg.dcr │ │ │ ├── JvScrollMax.res │ │ │ ├── JvSegmentedLEDDisplay.res │ │ │ ├── JvSimImages.res │ │ │ ├── JvSlider.res │ │ │ ├── JvSpin.res │ │ │ ├── JvStdCtrlsReg.dcr │ │ │ ├── JvSwitch.res │ │ │ ├── JvSystemReg.dcr │ │ │ ├── JvTMTimeLine.res │ │ │ ├── JvTimeFrameWorkReg.dcr │ │ │ ├── JvTimeLine.res │ │ │ ├── JvTipOfDay.res │ │ │ ├── JvToolEdit.res │ │ │ ├── JvWinampLabel.res │ │ │ ├── JvWizardsReg.dcr │ │ │ ├── JvXPBar.res │ │ │ ├── JvXPCore.res │ │ │ ├── JvXPCtrlsReg.dcr │ │ │ ├── JvgButton.res │ │ │ ├── JvgCaption.res │ │ │ ├── JvgCheckBox.res │ │ │ ├── JvgHint.res │ │ │ ├── JvgLabelEditorForm.res │ │ │ ├── JvxCheckListBox.res │ │ │ ├── JvxSlider.res │ │ │ └── resources.txt │ │ └── run/ │ │ ├── Cfg.pas │ │ ├── CfgMgr32.pas │ │ ├── DBT.pas │ │ ├── Hid.pas │ │ ├── HidToken.pas │ │ ├── HidUsage.pas │ │ ├── JVCLVer.pas │ │ ├── JvADOQuery.pas │ │ ├── JvAVICapture.pas │ │ ├── JvActions.pas │ │ ├── JvActionsEngine.pas │ │ ├── JvAddPrinter.pas │ │ ├── JvAirBrush.pas │ │ ├── JvAlarms.pas │ │ ├── JvAni.pas │ │ ├── JvAnimTitle.pas │ │ ├── JvAnimate.pas │ │ ├── JvAnimatedImage.pas │ │ ├── JvAppAnimatedIcon.pas │ │ ├── JvAppCommand.pas │ │ ├── JvAppDBStorage.pas │ │ ├── JvAppEvent.pas │ │ ├── JvAppHotKey.pas │ │ ├── JvAppIniStorage.pas │ │ ├── JvAppInst.pas │ │ ├── JvAppRegistryStorage.pas │ │ ├── JvAppStorage.pas │ │ ├── JvAppStoragePropertyEngineDB.pas │ │ ├── JvAppStorageSelectList.pas │ │ ├── JvAppXMLStorage.pas │ │ ├── JvArrayButton.pas │ │ ├── JvArrowButton.pas │ │ ├── JvAutoComplete.pas │ │ ├── JvBDECheckPasswordForm.dfm │ │ ├── JvBDECheckPasswordForm.pas │ │ ├── JvBDEExceptionForm.dfm │ │ ├── JvBDEExceptionForm.pas │ │ ├── JvBDEFilter.pas │ │ ├── JvBDEIndex.pas │ │ ├── JvBDELists.pas │ │ ├── JvBDELoginDialog.pas │ │ ├── JvBDEMemTable.pas │ │ ├── JvBDEMove.pas │ │ ├── JvBDEProgress.pas │ │ ├── JvBDEQBE.pas │ │ ├── JvBDEQuery.pas │ │ ├── JvBDESQLScript.pas │ │ ├── JvBDESecurity.pas │ │ ├── JvBackgrounds.pas │ │ ├── JvBalloonHint.pas │ │ ├── JvBandForms.pas │ │ ├── JvBandObject.pas │ │ ├── JvBaseDBDialog.pas │ │ ├── JvBaseDBLogonDialog.pas │ │ ├── JvBaseDBPasswordDialog.pas │ │ ├── JvBaseDBThreadedDataset.pas │ │ ├── JvBaseDlg.pas │ │ ├── JvBaseEdits.pas │ │ ├── JvBaseThumbnail.pas │ │ ├── JvBdeUtils.pas │ │ ├── JvBehaviorLabel.pas │ │ ├── JvBevel.pas │ │ ├── JvBitBtn.pas │ │ ├── JvBitmapButton.pas │ │ ├── JvBmpAnimator.pas │ │ ├── JvBoxProcs.pas │ │ ├── JvBrowseFolder.pas │ │ ├── JvButton.pas │ │ ├── JvButtonPersistent.pas │ │ ├── JvButtons.pas │ │ ├── JvCSVBaseControls.pas │ │ ├── JvCabFile.pas │ │ ├── JvCalc.pas │ │ ├── JvCalendar.pas │ │ ├── JvCaptionButton.pas │ │ ├── JvCaptionPanel.pas │ │ ├── JvCaret.pas │ │ ├── JvChangeNotify.pas │ │ ├── JvCharMap.pas │ │ ├── JvChart.pas │ │ ├── JvCheckBox.pas │ │ ├── JvCheckListBox.pas │ │ ├── JvCheckTreeView.pas │ │ ├── JvCheckedMaskEdit.pas │ │ ├── JvCipher.pas │ │ ├── JvClipboardMonitor.pas │ │ ├── JvClipboardViewer.pas │ │ ├── JvClipbrd.pas │ │ ├── JvClock.pas │ │ ├── JvColorBox.pas │ │ ├── JvColorButton.pas │ │ ├── JvColorCombo.pas │ │ ├── JvColorForm.pas │ │ ├── JvColorProvider.pas │ │ ├── JvColorTrackbar.pas │ │ ├── JvComCtrls.pas │ │ ├── JvComboListBox.pas │ │ ├── JvCombobox.pas │ │ ├── JvCommStatus.pas │ │ ├── JvCommonExecDlg.pas │ │ ├── JvComponent.pas │ │ ├── JvComponentBase.pas │ │ ├── JvComponentPanel.pas │ │ ├── JvComputerInfoEx.pas │ │ ├── JvConnectNetwork.pas │ │ ├── JvConsts.pas │ │ ├── JvContentScroller.pas │ │ ├── JvContextProvider.pas │ │ ├── JvControlActions.pas │ │ ├── JvControlActionsEngine.pas │ │ ├── JvControlActionsEngineCxEditors.pas │ │ ├── JvControlActionsEngineCxGrid.pas │ │ ├── JvControlActionsEngineCxPivotGrid.pas │ │ ├── JvControlActionsEngineCxTreeList.pas │ │ ├── JvControlActionsEngineCxVerticalGrid.pas │ │ ├── JvControlActionsEngineDBGrid.pas │ │ ├── JvControlActionsEngineStringGrid.pas │ │ ├── JvControlActionsEngineTreeView.pas │ │ ├── JvControlBar.pas │ │ ├── JvControlComponent.pas │ │ ├── JvControlPanelButton.pas │ │ ├── JvConverter.pas │ │ ├── JvCoolBar.pas │ │ ├── JvCopyError.pas │ │ ├── JvCpuUsage.pas │ │ ├── JvCreateProcess.pas │ │ ├── JvCsvData.pas │ │ ├── JvCsvParse.pas │ │ ├── JvCtrls.pas │ │ ├── JvCursor.pas │ │ ├── JvCustomFileMessageDialog.pas │ │ ├── JvCustomItemViewer.pas │ │ ├── JvDBActions.pas │ │ ├── JvDBActionsEngine.pas │ │ ├── JvDBActionsEngineControlCxGrid.pas │ │ ├── JvDBActionsEngineControlCxPivotGrid.pas │ │ ├── JvDBActionsEngineControlCxTreeList.pas │ │ ├── JvDBActionsEngineDatasetAdo.pas │ │ ├── JvDBActionsEngineDatasetCSVDataset.pas │ │ ├── JvDBActionsEngineDatasetDBExpress.pas │ │ ├── JvDBActionsEngineDatasetDevart.pas │ │ ├── JvDBActionsEngineDatasetDoa.pas │ │ ├── JvDBCheckBox.pas │ │ ├── JvDBCombobox.pas │ │ ├── JvDBControls.pas │ │ ├── JvDBDatePickerEdit.pas │ │ ├── JvDBDateTimePicker.pas │ │ ├── JvDBDotNetControls.pas │ │ ├── JvDBFilterExpr.pas │ │ ├── JvDBFindEdit.pas │ │ ├── JvDBGrid.pas │ │ ├── JvDBGridExport.pas │ │ ├── JvDBGridFooter.pas │ │ ├── JvDBGridSelectColumnForm.dfm │ │ ├── JvDBGridSelectColumnForm.pas │ │ ├── JvDBHTLabel.pas │ │ ├── JvDBImage.pas │ │ ├── JvDBLogonDialogBaseDevart.pas │ │ ├── JvDBLogonDialogDoa.pas │ │ ├── JvDBLogonDialogOdac.pas │ │ ├── JvDBLogonDialogUniDac.pas │ │ ├── JvDBLookup.pas │ │ ├── JvDBLookupComboEdit.pas │ │ ├── JvDBLookupTreeView.pas │ │ ├── JvDBPasswordDialogDoa.pas │ │ ├── JvDBPasswordDialogOdac.pas │ │ ├── JvDBPasswordDialogUniDac.pas │ │ ├── JvDBProgressBar.pas │ │ ├── JvDBQueryParamsForm.dfm │ │ ├── JvDBQueryParamsForm.pas │ │ ├── JvDBRadioPanel.pas │ │ ├── JvDBRemoteLogin.pas │ │ ├── JvDBRichEdit.pas │ │ ├── JvDBSearchComboBox.pas │ │ ├── JvDBSearchEdit.pas │ │ ├── JvDBSpinEdit.pas │ │ ├── JvDBTreeView.pas │ │ ├── JvDBUltimGrid.pas │ │ ├── JvDBUtils.pas │ │ ├── JvDSADialogs.pas │ │ ├── JvDataEmbedded.pas │ │ ├── JvDataProvider.pas │ │ ├── JvDataProviderIntf.pas │ │ ├── JvDataSource.pas │ │ ├── JvDataSourceIntf.pas │ │ ├── JvDatePickerEdit.pas │ │ ├── JvDateTimePicker.pas │ │ ├── JvDdeCmd.pas │ │ ├── JvDebugHandler.pas │ │ ├── JvDeleteError.pas │ │ ├── JvDesignClip.pas │ │ ├── JvDesignImp.pas │ │ ├── JvDesignSurface.pas │ │ ├── JvDesignUtils.pas │ │ ├── JvDesktopAlert.pas │ │ ├── JvDesktopAlertForm.pas │ │ ├── JvDiagramShape.pas │ │ ├── JvDialButton.pas │ │ ├── JvDialogActns.pas │ │ ├── JvDialogs.pas │ │ ├── JvDice.pas │ │ ├── JvDiskPrompt.pas │ │ ├── JvDockAdvTree.pas │ │ ├── JvDockConjoinHost.dfm │ │ ├── JvDockControlForm.pas │ │ ├── JvDockDelphiStyle.pas │ │ ├── JvDockGlobals.pas │ │ ├── JvDockHashTable.pas │ │ ├── JvDockInfo.pas │ │ ├── JvDockSupportClass.pas │ │ ├── JvDockSupportControl.pas │ │ ├── JvDockSupportProc.pas │ │ ├── JvDockTabHost.dfm │ │ ├── JvDockTree.pas │ │ ├── JvDockVCStyle.pas │ │ ├── JvDockVIDStyle.pas │ │ ├── JvDockVIDVCStyle.pas │ │ ├── JvDockVSNetStyle.pas │ │ ├── JvDockableForm.dfm │ │ ├── JvDotNetControls.pas │ │ ├── JvDotNetUtils.pas │ │ ├── JvDragDrop.pas │ │ ├── JvDrawImage.pas │ │ ├── JvDriveCtrls.pas │ │ ├── JvDropDownForm.pas │ │ ├── JvDsgnIntf.pas │ │ ├── JvDualList.pas │ │ ├── JvDualListForm.dfm │ │ ├── JvDualListForm.pas │ │ ├── JvDynControlEngine.pas │ │ ├── JvDynControlEngineDB.pas │ │ ├── JvDynControlEngineDBIntf.pas │ │ ├── JvDynControlEngineDBTools.pas │ │ ├── JvDynControlEngineDBToolscxVGrid.pas │ │ ├── JvDynControlEngineDevExpCx.pas │ │ ├── JvDynControlEngineDevExpCxDB.pas │ │ ├── JvDynControlEngineIntf.pas │ │ ├── JvDynControlEngineJVCL.pas │ │ ├── JvDynControlEngineJVCLDB.pas │ │ ├── JvDynControlEngineJVCLInspector.pas │ │ ├── JvDynControlEngineTools.pas │ │ ├── JvDynControlEngineVCL.pas │ │ ├── JvDynControlEngineVCLDB.pas │ │ ├── JvEasterEgg.pas │ │ ├── JvEdit.pas │ │ ├── JvEditor.pas │ │ ├── JvEditorCommon.pas │ │ ├── JvEmbeddedForms.pas │ │ ├── JvEnterTab.pas │ │ ├── JvErrorIndicator.pas │ │ ├── JvExButtons.pas │ │ ├── JvExCheckLst.pas │ │ ├── JvExComCtrls.pas │ │ ├── JvExControls.pas │ │ ├── JvExDBGrids.pas │ │ ├── JvExExtCtrls.pas │ │ ├── JvExForms.pas │ │ ├── JvExGrids.pas │ │ ├── JvExMask.pas │ │ ├── JvExStdCtrls.pas │ │ ├── JvExceptionForm.dfm │ │ ├── JvExceptionForm.pas │ │ ├── JvExplorerBar.pas │ │ ├── JvExplorerBarItems.pas │ │ ├── JvExprParser.pas │ │ ├── JvExtComponent.pas │ │ ├── JvFavoritesButton.pas │ │ ├── JvFindFiles.pas │ │ ├── JvFindReplace.pas │ │ ├── JvFixedEditPopUp.pas │ │ ├── JvFooter.pas │ │ ├── JvFormAnimatedIcon.pas │ │ ├── JvFormAnimation.pas │ │ ├── JvFormAutoSize.pas │ │ ├── JvFormMagnet.pas │ │ ├── JvFormPlacement.pas │ │ ├── JvFormPlacementSelectList.pas │ │ ├── JvFormToHtml.pas │ │ ├── JvFormTransparent.pas │ │ ├── JvFormWallpaper.pas │ │ ├── JvForth.pas │ │ ├── JvFullColorCircleForm.dfm │ │ ├── JvFullColorCircleForm.pas │ │ ├── JvFullColorCtrls.pas │ │ ├── JvFullColorDialogs.pas │ │ ├── JvFullColorForm.dfm │ │ ├── JvFullColorForm.pas │ │ ├── JvFullColorRotate.pas │ │ ├── JvFullColorSpaces.pas │ │ ├── JvGIF.pas │ │ ├── JvGIFCtrl.pas │ │ ├── JvGammaPanel.pas │ │ ├── JvGenetic.pas │ │ ├── JvGnugettext.pas │ │ ├── JvGradient.pas │ │ ├── JvGradientCaption.pas │ │ ├── JvGradientHeaderPanel.pas │ │ ├── JvGridFilter.pas │ │ ├── JvGridPreviewForm.dfm │ │ ├── JvGridPreviewForm.pas │ │ ├── JvGridPrinter.pas │ │ ├── JvGrids.pas │ │ ├── JvGroupBox.pas │ │ ├── JvGroupHeader.pas │ │ ├── JvHLEditor.pas │ │ ├── JvHLEditorPropertyForm.dfm │ │ ├── JvHLEditorPropertyForm.pas │ │ ├── JvHLParser.pas │ │ ├── JvHeaderControl.pas │ │ ├── JvHidControllerClass.pas │ │ ├── JvHint.pas │ │ ├── JvHints.pas │ │ ├── JvHotKey.pas │ │ ├── JvHotTrackPersistent.pas │ │ ├── JvHtControls.pas │ │ ├── JvHtmlParser.pas │ │ ├── JvID3v2Base.pas │ │ ├── JvIconList.pas │ │ ├── JvId3v1.pas │ │ ├── JvId3v2.pas │ │ ├── JvId3v2Types.pas │ │ ├── JvImage.pas │ │ ├── JvImageDlg.pas │ │ ├── JvImageDrawThread.pas │ │ ├── JvImageList.pas │ │ ├── JvImageListViewer.pas │ │ ├── JvImageRotate.pas │ │ ├── JvImageSquare.pas │ │ ├── JvImageTransform.pas │ │ ├── JvImagesViewer.pas │ │ ├── JvInspDB.pas │ │ ├── JvInspExtraEditors.pas │ │ ├── JvInspXVCL.pas │ │ ├── JvInspector.pas │ │ ├── JvInstallLabel.pas │ │ ├── JvInterpreter.pas │ │ ├── JvInterpreterConst.pas │ │ ├── JvInterpreterFm.pas │ │ ├── JvInterpreterParser.pas │ │ ├── JvInterpreter_Buttons.pas │ │ ├── JvInterpreter_Classes.pas │ │ ├── JvInterpreter_ComCtrls.pas │ │ ├── JvInterpreter_Contnrs.pas │ │ ├── JvInterpreter_Controls.pas │ │ ├── JvInterpreter_DBTables.pas │ │ ├── JvInterpreter_Db.pas │ │ ├── JvInterpreter_DbCtrls.pas │ │ ├── JvInterpreter_DbGrids.pas │ │ ├── JvInterpreter_Dialogs.pas │ │ ├── JvInterpreter_ExtCtrls.pas │ │ ├── JvInterpreter_Forms.pas │ │ ├── JvInterpreter_Graphics.pas │ │ ├── JvInterpreter_Grids.pas │ │ ├── JvInterpreter_JvEditor.pas │ │ ├── JvInterpreter_JvInterpreter.pas │ │ ├── JvInterpreter_JvUtils.pas │ │ ├── JvInterpreter_Math.pas │ │ ├── JvInterpreter_Menus.pas │ │ ├── JvInterpreter_Quickrpt.pas │ │ ├── JvInterpreter_StdCtrls.pas │ │ ├── JvInterpreter_SysUtils.pas │ │ ├── JvInterpreter_System.pas │ │ ├── JvInterpreter_Types.pas │ │ ├── JvInterpreter_Windows.pas │ │ ├── JvInterpreter_all.pas │ │ ├── JvInterpreter_httpapp.pas │ │ ├── JvItemsPanel.pas │ │ ├── JvItemsSearchs.pas │ │ ├── JvJCLUtils.pas │ │ ├── JvJVCLAboutForm.dfm │ │ ├── JvJVCLAboutForm.pas │ │ ├── JvJVCLUtils.pas │ │ ├── JvJanTreeView.pas │ │ ├── JvJclUnitVersioningBrowser.pas │ │ ├── JvJoystick.pas │ │ ├── JvLED.pas │ │ ├── JvLabel.pas │ │ ├── JvLinkLabel.pas │ │ ├── JvLinkLabelDebug.pas │ │ ├── JvLinkLabelParser.pas │ │ ├── JvLinkLabelRenderer.pas │ │ ├── JvLinkLabelTextHandler.pas │ │ ├── JvLinkLabelTools.pas │ │ ├── JvLinkLabelTree.pas │ │ ├── JvLinkedControls.pas │ │ ├── JvListBox.pas │ │ ├── JvListComb.pas │ │ ├── JvListView.pas │ │ ├── JvLogClasses.pas │ │ ├── JvLogFile.pas │ │ ├── JvLogForm.dfm │ │ ├── JvLogForm.pas │ │ ├── JvLoginForm.dfm │ │ ├── JvLoginForm.pas │ │ ├── JvLookOut.pas │ │ ├── JvMRUList.pas │ │ ├── JvMRUManager.pas │ │ ├── JvMTComponents.pas │ │ ├── JvMTConsts.pas │ │ ├── JvMTData.pas │ │ ├── JvMTSync.pas │ │ ├── JvMTSyncMon.pas │ │ ├── JvMTThreading.pas │ │ ├── JvMail.pas │ │ ├── JvMailSlots.pas │ │ ├── JvMarkupCommon.pas │ │ ├── JvMarkupLabel.pas │ │ ├── JvMarkupViewer.pas │ │ ├── JvMaskEdit.pas │ │ ├── JvMaxPixel.pas │ │ ├── JvMemo.pas │ │ ├── JvMemoryDataset.pas │ │ ├── JvMenus.pas │ │ ├── JvMergeManager.pas │ │ ├── JvMessageControl.pas │ │ ├── JvMonthCalendar.pas │ │ ├── JvMouseGesture.pas │ │ ├── JvMouseTimer.pas │ │ ├── JvMovableBevel.pas │ │ ├── JvNTEventLog.pas │ │ ├── JvNavigationPane.pas │ │ ├── JvNetscapeSplitter.pas │ │ ├── JvObjectPickerDialog.pas │ │ ├── JvOdacSmartQuery.pas │ │ ├── JvOfficeColorButton.pas │ │ ├── JvOfficeColorForm.pas │ │ ├── JvOfficeColorPanel.pas │ │ ├── JvOfficeDragBarForm.pas │ │ ├── JvOracleDataSet.pas │ │ ├── JvOutlookBar.pas │ │ ├── JvOwnerDrawViewer.pas │ │ ├── JvPageList.pas │ │ ├── JvPageListTreeView.pas │ │ ├── JvPageManager.pas │ │ ├── JvPageScroller.pas │ │ ├── JvPageSetup.pas │ │ ├── JvPageSetupTitled.pas │ │ ├── JvPaintFX.pas │ │ ├── JvPainterEffectsForm.dfm │ │ ├── JvPainterEffectsForm.pas │ │ ├── JvPainterQBForm.dfm │ │ ├── JvPainterQBForm.pas │ │ ├── JvPanel.pas │ │ ├── JvParameterList.pas │ │ ├── JvParameterListParameter.pas │ │ ├── JvParameterListTools.pas │ │ ├── JvParserForm.dfm │ │ ├── JvParserForm.pas │ │ ├── JvPatchFile.pas │ │ ├── JvPatchForm.dfm │ │ ├── JvPatchForm.pas │ │ ├── JvPcx.pas │ │ ├── JvPerfMon95.pas │ │ ├── JvPicClip.pas │ │ ├── JvPickDate.pas │ │ ├── JvPlaylist.pas │ │ ├── JvPlugin.pas │ │ ├── JvPluginManager.pas │ │ ├── JvPoweredBy.pas │ │ ├── JvPrint.pas │ │ ├── JvProfilerForm.dfm │ │ ├── JvProfilerForm.pas │ │ ├── JvProgramVersionCheck.pas │ │ ├── JvProgressBar.pas │ │ ├── JvProgressComponent.pas │ │ ├── JvProgressDialog.pas │ │ ├── JvProgressForm.dfm │ │ ├── JvProgressForm.pas │ │ ├── JvProgressUtils.pas │ │ ├── JvPropertyStorage.pas │ │ ├── JvPropertyStore.pas │ │ ├── JvPropertyStoreEditor.dfm │ │ ├── JvPropertyStoreEditor.pas │ │ ├── JvPropertyStoreEditorIntf.pas │ │ ├── JvPrvwDoc.pas │ │ ├── JvPrvwRender.pas │ │ ├── JvQuickPreviewForm.dfm │ │ ├── JvQuickPreviewForm.pas │ │ ├── JvRadioButton.pas │ │ ├── JvRadioGroup.pas │ │ ├── JvRas32.pas │ │ ├── JvRecentMenuButton.pas │ │ ├── JvRegistryTreeview.pas │ │ ├── JvRenameError.pas │ │ ├── JvResample.pas │ │ ├── JvResources.pas │ │ ├── JvRgbToHtml.pas │ │ ├── JvRichEdit.pas │ │ ├── JvRichEditToHtml.pas │ │ ├── JvRollOut.pas │ │ ├── JvRuler.pas │ │ ├── JvSAL.pas │ │ ├── JvSALCore.pas │ │ ├── JvSALHashList.pas │ │ ├── JvSALMath.pas │ │ ├── JvSHFileOperation.pas │ │ ├── JvSLDMappingEditorDialog.dfm │ │ ├── JvSLDMappingEditorDialog.pas │ │ ├── JvSchedEvtStore.pas │ │ ├── JvScheduledEvents.pas │ │ ├── JvScreenResolution.pas │ │ ├── JvScreenSaveSuppress.pas │ │ ├── JvScreenSaver.pas │ │ ├── JvScrollBar.pas │ │ ├── JvScrollBox.pas │ │ ├── JvScrollMax.pas │ │ ├── JvScrollPanel.pas │ │ ├── JvScrollText.pas │ │ ├── JvSearchFiles.pas │ │ ├── JvSecretPanel.pas │ │ ├── JvSegmentedLEDDisplay.pas │ │ ├── JvSegmentedLEDDisplayMapperFrame.dfm │ │ ├── JvSegmentedLEDDisplayMapperFrame.pas │ │ ├── JvSelectDirectory.pas │ │ ├── JvSerialMaker.pas │ │ ├── JvSetupApi.pas │ │ ├── JvShape.pas │ │ ├── JvShapedButton.pas │ │ ├── JvShellHook.pas │ │ ├── JvSimIndicator.pas │ │ ├── JvSimLogic.pas │ │ ├── JvSimPID.pas │ │ ├── JvSimPIDLinker.pas │ │ ├── JvSimScope.pas │ │ ├── JvSimpleXml.pas │ │ ├── JvSlider.pas │ │ ├── JvSoundControl.pas │ │ ├── JvSpacer.pas │ │ ├── JvSpecialImage.pas │ │ ├── JvSpecialProgress.pas │ │ ├── JvSpeedButton.pas │ │ ├── JvSpeedbar.pas │ │ ├── JvSpeedbarSetupForm.dfm │ │ ├── JvSpeedbarSetupForm.pas │ │ ├── JvSpellChecker.pas │ │ ├── JvSpellIntf.pas │ │ ├── JvSpellerForm.dfm │ │ ├── JvSpellerForm.pas │ │ ├── JvSpin.pas │ │ ├── JvSplashWindow.pas │ │ ├── JvSplit.pas │ │ ├── JvSplitter.pas │ │ ├── JvStarfield.pas │ │ ├── JvStartMenuButton.pas │ │ ├── JvStaticText.pas │ │ ├── JvStatusBar.pas │ │ ├── JvStdEditActions.pas │ │ ├── JvSticker.pas │ │ ├── JvStrToHtml.pas │ │ ├── JvStringGrid.pas │ │ ├── JvStringHolder.pas │ │ ├── JvStringListToHtml.pas │ │ ├── JvStrings.pas │ │ ├── JvSwitch.pas │ │ ├── JvSyncSplitter.pas │ │ ├── JvSysRequirements.pas │ │ ├── JvSystemPopup.pas │ │ ├── JvTFAlarm.pas │ │ ├── JvTFDays.pas │ │ ├── JvTFGantt.pas │ │ ├── JvTFGlance.pas │ │ ├── JvTFGlanceTextViewer.pas │ │ ├── JvTFManager.pas │ │ ├── JvTFMonths.pas │ │ ├── JvTFSparseMatrix.pas │ │ ├── JvTFUtils.pas │ │ ├── JvTFWeeks.pas │ │ ├── JvTMTimeLine.pas │ │ ├── JvTabBar.pas │ │ ├── JvTabBarXPPainter.pas │ │ ├── JvTextListBox.pas │ │ ├── JvThemes.pas │ │ ├── JvThread.pas │ │ ├── JvThreadDialog.pas │ │ ├── JvThreadTimer.pas │ │ ├── JvThumbImage.pas │ │ ├── JvThumbViews.pas │ │ ├── JvThumbnails.pas │ │ ├── JvTimeLimit.pas │ │ ├── JvTimeLine.pas │ │ ├── JvTimer.pas │ │ ├── JvTimerList.pas │ │ ├── JvTipOfDay.pas │ │ ├── JvToolBar.pas │ │ ├── JvToolEdit.pas │ │ ├── JvTracker.pas │ │ ├── JvTranslateString.pas │ │ ├── JvTranslator.pas │ │ ├── JvTransparentButton.pas │ │ ├── JvTrayIcon.pas │ │ ├── JvTurtle.pas │ │ ├── JvTypes.pas │ │ ├── JvUniDacQuery.pas │ │ ├── JvUnicodeCanvas.pas │ │ ├── JvUnicodeEditor.pas │ │ ├── JvUnicodeHLEditor.pas │ │ ├── JvUninstallControls.pas │ │ ├── JvUpDown.pas │ │ ├── JvUrlGrabbers.pas │ │ ├── JvUrlListGrabber.pas │ │ ├── JvValidateEdit.pas │ │ ├── JvValidators.pas │ │ ├── JvVersionControlActions.pas │ │ ├── JvVersionControlActionsEngine.pas │ │ ├── JvVersionControlActionsEngineFileListBox.pas │ │ ├── JvVersionInfo.pas │ │ ├── JvVirtualKeySelectionFrame.dfm │ │ ├── JvVirtualKeySelectionFrame.pas │ │ ├── JvWaitingGradient.pas │ │ ├── JvWaitingProgress.pas │ │ ├── JvWallpaperEditForm.dfm │ │ ├── JvWallpaperEditForm.pas │ │ ├── JvWavePlayer.pas │ │ ├── JvWin32.pas │ │ ├── JvWinDialogs.pas │ │ ├── JvWinHelp.pas │ │ ├── JvWinampLabel.pas │ │ ├── JvWizard.pas │ │ ├── JvWizardCommon.pas │ │ ├── JvWizardRouteMapList.pas │ │ ├── JvWizardRouteMapNodes.pas │ │ ├── JvWizardRouteMapSteps.pas │ │ ├── JvWndProcHook.pas │ │ ├── JvXPBar.pas │ │ ├── JvXPButtons.pas │ │ ├── JvXPCheckCtrls.pas │ │ ├── JvXPContainer.pas │ │ ├── JvXPCore.pas │ │ ├── JvXPCoreUtils.pas │ │ ├── JvXPProgressBar.pas │ │ ├── JvXmlDatabase.pas │ │ ├── JvXmlTree.pas │ │ ├── JvYearGrid.pas │ │ ├── JvYearGridEditForm.dfm │ │ ├── JvYearGridEditForm.pas │ │ ├── JvZlibMultiple.pas │ │ ├── JvZoom.pas │ │ ├── JvaScrollText.pas │ │ ├── Jvg3DColors.pas │ │ ├── JvgAlignFunction.pas │ │ ├── JvgAskListBox.pas │ │ ├── JvgButton.pas │ │ ├── JvgCaption.pas │ │ ├── JvgCheckBox.pas │ │ ├── JvgCommClasses.pas │ │ ├── JvgCrossTable.pas │ │ ├── JvgDigits.pas │ │ ├── JvgDrawTab.pas │ │ ├── JvgExport.pas │ │ ├── JvgExportComponents.pas │ │ ├── JvgFileIterator.pas │ │ ├── JvgGraph.pas │ │ ├── JvgGroupBox.pas │ │ ├── JvgHTTPVersionInfo.pas │ │ ├── JvgHint.pas │ │ ├── JvgHoleShape.pas │ │ ├── JvgImage.pas │ │ ├── JvgImageGroup.pas │ │ ├── JvgLabel.pas │ │ ├── JvgListBox.pas │ │ ├── JvgLogics.pas │ │ ├── JvgPage.pas │ │ ├── JvgProgress.pas │ │ ├── JvgQPrintPreviewForm.dfm │ │ ├── JvgQPrintPreviewForm.pas │ │ ├── JvgQPrintSetupForm.dfm │ │ ├── JvgQPrintSetupForm.pas │ │ ├── JvgQRLabel.pas │ │ ├── JvgReport.pas │ │ ├── JvgReportParamsEditor.pas │ │ ├── JvgShade.pas │ │ ├── JvgShadow.pas │ │ ├── JvgSpeedButton.pas │ │ ├── JvgStringGrid.pas │ │ ├── JvgTab.pas │ │ ├── JvgTabComm.pas │ │ ├── JvgTypes.pas │ │ ├── JvgUtils.pas │ │ ├── JvgWebDocumentIterator.pas │ │ ├── JvgXMLSerializer.pas │ │ ├── JvxCheckListBox.pas │ │ ├── JvxSlider.pas │ │ ├── ModuleLoader.pas │ │ ├── ObjSel.pas │ │ ├── Ras32.pas │ │ ├── VFW.pas │ │ ├── WinConvTypes.pas │ │ ├── Winamp.pas │ │ └── run.txt │ ├── KOLDetours.pas │ ├── SynEdit/ │ │ └── Source/ │ │ ├── Contributors.txt │ │ ├── QSynAutoCorrect.pas │ │ ├── QSynAutoCorrectEditor.dfm │ │ ├── QSynAutoCorrectEditor.pas │ │ ├── QSynCompletionProposal.pas │ │ ├── QSynDBEdit.pas │ │ ├── QSynEdit.pas │ │ ├── QSynEditAutoComplete.pas │ │ ├── QSynEditExport.pas │ │ ├── QSynEditHighlighter.pas │ │ ├── QSynEditKbdHandler.pas │ │ ├── QSynEditKeyCmdEditor.dfm │ │ ├── QSynEditKeyCmdEditor.pas │ │ ├── QSynEditKeyCmds.pas │ │ ├── QSynEditKeyCmdsEditor.dfm │ │ ├── QSynEditKeyCmdsEditor.pas │ │ ├── QSynEditKeyConst.pas │ │ ├── QSynEditMiscClasses.pas │ │ ├── QSynEditMiscProcs.pas │ │ ├── QSynEditOptionsDialog.dfm │ │ ├── QSynEditOptionsDialog.pas │ │ ├── QSynEditPlugins.pas │ │ ├── QSynEditPrint.pas │ │ ├── QSynEditPrintHeaderFooter.pas │ │ ├── QSynEditPrintMargins.pas │ │ ├── QSynEditPrintMarginsDialog.dfm │ │ ├── QSynEditPrintMarginsDialog.pas │ │ ├── QSynEditPrintPreview.pas │ │ ├── QSynEditPrintTypes.pas │ │ ├── QSynEditPrinterInfo.pas │ │ ├── QSynEditPropertyReg.pas │ │ ├── QSynEditPythonBehaviour.pas │ │ ├── QSynEditReg.pas │ │ ├── QSynEditRegexSearch.pas │ │ ├── QSynEditSearch.pas │ │ ├── QSynEditStrConst.pas │ │ ├── QSynEditTextBuffer.pas │ │ ├── QSynEditTypes.pas │ │ ├── QSynEditWildcardSearch.pas │ │ ├── QSynEditWordWrap.pas │ │ ├── QSynExportHTML.pas │ │ ├── QSynExportRTF.pas │ │ ├── QSynExportTeX.pas │ │ ├── QSynHighlighterADSP21xx.pas │ │ ├── QSynHighlighterAWK.pas │ │ ├── QSynHighlighterAsm.pas │ │ ├── QSynHighlighterBaan.pas │ │ ├── QSynHighlighterBat.pas │ │ ├── QSynHighlighterCAC.pas │ │ ├── QSynHighlighterCPM.pas │ │ ├── QSynHighlighterCS.pas │ │ ├── QSynHighlighterCache.pas │ │ ├── QSynHighlighterCobol.pas │ │ ├── QSynHighlighterCpp.pas │ │ ├── QSynHighlighterCss.pas │ │ ├── QSynHighlighterDOT.pas │ │ ├── QSynHighlighterDfm.pas │ │ ├── QSynHighlighterDml.pas │ │ ├── QSynHighlighterEiffel.pas │ │ ├── QSynHighlighterFortran.pas │ │ ├── QSynHighlighterFoxpro.pas │ │ ├── QSynHighlighterGWS.pas │ │ ├── QSynHighlighterGalaxy.pas │ │ ├── QSynHighlighterGeneral.pas │ │ ├── QSynHighlighterHC11.pas │ │ ├── QSynHighlighterHP48.pas │ │ ├── QSynHighlighterHashEntries.pas │ │ ├── QSynHighlighterHaskell.pas │ │ ├── QSynHighlighterHtml.pas │ │ ├── QSynHighlighterIDL.pas │ │ ├── QSynHighlighterIni.pas │ │ ├── QSynHighlighterInno.pas │ │ ├── QSynHighlighterJScript.pas │ │ ├── QSynHighlighterJava.pas │ │ ├── QSynHighlighterKix.pas │ │ ├── QSynHighlighterLDraw.pas │ │ ├── QSynHighlighterM3.pas │ │ ├── QSynHighlighterManager.pas │ │ ├── QSynHighlighterModelica.pas │ │ ├── QSynHighlighterMsg.pas │ │ ├── QSynHighlighterMulti.pas │ │ ├── QSynHighlighterPHP.pas │ │ ├── QSynHighlighterPas.pas │ │ ├── QSynHighlighterPerl.pas │ │ ├── QSynHighlighterProgress.pas │ │ ├── QSynHighlighterPython.pas │ │ ├── QSynHighlighterRC.pas │ │ ├── QSynHighlighterRuby.pas │ │ ├── QSynHighlighterSDD.pas │ │ ├── QSynHighlighterSQL.pas │ │ ├── QSynHighlighterST.pas │ │ ├── QSynHighlighterSml.pas │ │ ├── QSynHighlighterTclTk.pas │ │ ├── QSynHighlighterTeX.pas │ │ ├── QSynHighlighterUNIXShellScript.pas │ │ ├── QSynHighlighterURI.pas │ │ ├── QSynHighlighterUnreal.pas │ │ ├── QSynHighlighterVB.pas │ │ ├── QSynHighlighterVBScript.pas │ │ ├── QSynHighlighterVrml97.pas │ │ ├── QSynHighlighterXML.pas │ │ ├── QSynMacroRecorder.pas │ │ ├── QSynMemo.pas │ │ ├── QSynRegExpr.pas │ │ ├── QSynURIOpener.pas │ │ ├── QSynUnicode.pas │ │ ├── SynAutoCorrect.pas │ │ ├── SynAutoCorrectEditor.dfm │ │ ├── SynAutoCorrectEditor.pas │ │ ├── SynCompletionProposal.pas │ │ ├── SynDBEdit.pas │ │ ├── SynEdit.inc │ │ ├── SynEdit.pas │ │ ├── SynEdit.res │ │ ├── SynEditAutoComplete.pas │ │ ├── SynEditExport.pas │ │ ├── SynEditHighlighter.pas │ │ ├── SynEditHighlighterOptions.pas │ │ ├── SynEditJedi.inc │ │ ├── SynEditKbdHandler.pas │ │ ├── SynEditKeyCmdEditor.dfm │ │ ├── SynEditKeyCmdEditor.pas │ │ ├── SynEditKeyCmds.pas │ │ ├── SynEditKeyCmdsEditor.dfm │ │ ├── SynEditKeyCmdsEditor.pas │ │ ├── SynEditKeyConst.pas │ │ ├── SynEditMiscClasses.pas │ │ ├── SynEditMiscProcs.pas │ │ ├── SynEditOptionsDialog.dfm │ │ ├── SynEditOptionsDialog.pas │ │ ├── SynEditPlugins.pas │ │ ├── SynEditPrint.pas │ │ ├── SynEditPrintHeaderFooter.pas │ │ ├── SynEditPrintMargins.pas │ │ ├── SynEditPrintMarginsDialog.dfm │ │ ├── SynEditPrintMarginsDialog.pas │ │ ├── SynEditPrintPreview.pas │ │ ├── SynEditPrintTypes.pas │ │ ├── SynEditPrinterInfo.pas │ │ ├── SynEditPropertyReg.pas │ │ ├── SynEditPythonBehaviour.pas │ │ ├── SynEditReg.dcr │ │ ├── SynEditReg.pas │ │ ├── SynEditReg.res │ │ ├── SynEditRegexSearch.pas │ │ ├── SynEditSearch.pas │ │ ├── SynEditStrConst.pas │ │ ├── SynEditTextBuffer.pas │ │ ├── SynEditTypes.pas │ │ ├── SynEditWildcardSearch.pas │ │ ├── SynEditWordWrap.pas │ │ ├── SynExportHTML.pas │ │ ├── SynExportRTF.pas │ │ ├── SynExportTeX.pas │ │ ├── SynHighlighterADSP21xx.pas │ │ ├── SynHighlighterAWK.pas │ │ ├── SynHighlighterAsm.pas │ │ ├── SynHighlighterBaan.pas │ │ ├── SynHighlighterBat.pas │ │ ├── SynHighlighterCAC.pas │ │ ├── SynHighlighterCPM.pas │ │ ├── SynHighlighterCS.pas │ │ ├── SynHighlighterCache.pas │ │ ├── SynHighlighterCobol.pas │ │ ├── SynHighlighterCpp.pas │ │ ├── SynHighlighterCss.pas │ │ ├── SynHighlighterDOT.pas │ │ ├── SynHighlighterDWS.pas │ │ ├── SynHighlighterDfm.pas │ │ ├── SynHighlighterDml.pas │ │ ├── SynHighlighterEiffel.pas │ │ ├── SynHighlighterFortran.pas │ │ ├── SynHighlighterFoxpro.pas │ │ ├── SynHighlighterGWS.pas │ │ ├── SynHighlighterGalaxy.pas │ │ ├── SynHighlighterGeneral.pas │ │ ├── SynHighlighterHC11.pas │ │ ├── SynHighlighterHP48.pas │ │ ├── SynHighlighterHashEntries.pas │ │ ├── SynHighlighterHaskell.pas │ │ ├── SynHighlighterHtml.pas │ │ ├── SynHighlighterIDL.pas │ │ ├── SynHighlighterIni.pas │ │ ├── SynHighlighterInno.pas │ │ ├── SynHighlighterJScript.pas │ │ ├── SynHighlighterJava.pas │ │ ├── SynHighlighterKix.pas │ │ ├── SynHighlighterLDraw.pas │ │ ├── SynHighlighterLLVM.pas │ │ ├── SynHighlighterM3.pas │ │ ├── SynHighlighterManager.pas │ │ ├── SynHighlighterModelica.pas │ │ ├── SynHighlighterMsg.pas │ │ ├── SynHighlighterMulti.pas │ │ ├── SynHighlighterPHP.pas │ │ ├── SynHighlighterPas.pas │ │ ├── SynHighlighterPerl.pas │ │ ├── SynHighlighterProgress.pas │ │ ├── SynHighlighterPython.pas │ │ ├── SynHighlighterRC.pas │ │ ├── SynHighlighterRuby.pas │ │ ├── SynHighlighterSDD.pas │ │ ├── SynHighlighterSQL.pas │ │ ├── SynHighlighterST.pas │ │ ├── SynHighlighterSml.pas │ │ ├── SynHighlighterTclTk.pas │ │ ├── SynHighlighterTeX.pas │ │ ├── SynHighlighterUNIXShellScript.pas │ │ ├── SynHighlighterURI.pas │ │ ├── SynHighlighterUnreal.pas │ │ ├── SynHighlighterVB.pas │ │ ├── SynHighlighterVBScript.pas │ │ ├── SynHighlighterVrml97.pas │ │ ├── SynHighlighterWebIDL.pas │ │ ├── SynHighlighterXML.pas │ │ ├── SynMacroRecorder.pas │ │ ├── SynMemo.pas │ │ ├── SynRegExpr.pas │ │ ├── SynTextDrawer.pas │ │ ├── SynURIOpener.pas │ │ ├── SynUnicode.pas │ │ ├── SynUsp10.pas │ │ └── kTextDrawer.pas │ └── VirtualTreeView/ │ └── Source/ │ ├── VTAccessibility.pas │ ├── VTAccessibilityFactory.pas │ ├── VTHeaderPopup.pas │ ├── VirtualTrees.Actions.pas │ ├── VirtualTrees.Classes.pas │ ├── VirtualTrees.ClipBoard.pas │ ├── VirtualTrees.Export.pas │ ├── VirtualTrees.StyleHooks.pas │ ├── VirtualTrees.Utils.pas │ ├── VirtualTrees.WorkerThread.pas │ ├── VirtualTrees.pas │ └── VirtualTrees.res ├── GdiPlus/ │ ├── GdiPlus.pas │ └── GdiPlusHelpers.pas ├── JclPeImage.pas ├── JclTD32Ex.pas ├── MapDebugInfo.pas ├── Other/ │ └── uMacroParser.pas ├── Readme.md ├── Spider.dpr ├── Spider.dproj ├── Spider.res ├── SpiderXE6.dpr ├── SpiderXE6.dproj ├── SpiderXE6.res ├── Spider_Project.groupproj ├── WinAPIUtils.pas ├── uActionController.pas ├── uDebugerThread.pas ├── uExceptionHook.pas ├── uFastList.pas ├── uFeedback.dfm ├── uFeedback.pas ├── uGA.pas ├── uMain.dfm ├── uMain.pas ├── uProcessList.dfm ├── uProcessList.pas ├── uProjectOptions.dfm ├── uProjectOptions.pas ├── uRWLock.pas ├── uSQLiteDB.pas ├── uSelectSource.dfm ├── uSelectSource.pas ├── uShareData.dfm ├── uShareData.pas ├── uSharedObject.pas ├── uSourceViewFrame.dfm ├── uSourceViewFrame.pas ├── uSpiderOptions.pas └── uUpdateInfo.pas
SYMBOL INDEX (19 symbols across 2 files)
FILE: External/Jedi/Jcl/source/common/zconf.h
type Byte (line 333) | typedef unsigned char Byte;
type uInt (line 335) | typedef unsigned int uInt;
type uLong (line 336) | typedef unsigned long uLong;
type Byte (line 342) | typedef Byte FAR Bytef;
type charf (line 344) | typedef char FAR charf;
type intf (line 345) | typedef int FAR intf;
type uInt (line 346) | typedef uInt FAR uIntf;
type uLong (line 347) | typedef uLong FAR uLongf;
type Byte (line 354) | typedef Byte const *voidpc;
type Byte (line 355) | typedef Byte FAR *voidpf;
type Byte (line 356) | typedef Byte *voidp;
FILE: External/Jedi/Jcl/source/common/zlib.h
type voidpf (line 80) | typedef voidpf (*alloc_func)
type internal_state (line 83) | struct internal_state
type z_stream (line 85) | typedef struct z_stream_s {
type z_stream (line 106) | typedef z_stream FAR *z_streamp;
type gz_header (line 112) | typedef struct gz_header_s {
type gz_header (line 129) | typedef gz_header FAR *gz_headerp;
type voidp (line 1165) | typedef voidp gzFile;
type internal_state (line 1600) | struct internal_state {int dummy;}
Copy disabled (too large)
Download .json
Condensed preview — 1372 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (48,559K chars).
[
{
"path": "ClassUtils.pas",
"chars": 12624,
"preview": "unit ClassUtils;\r\n\r\ninterface\r\n\r\nuses Windows, Classes, SysUtils, StrUtils, XMLDoc, XMLIntf, Graphics, GdiPlus, GdiPlusH"
},
{
"path": "CollectList.inc",
"chars": 1605,
"preview": "{ TCollectList<T> }\r\n\r\nfunction TCollectList<T>.Add: PData;\r\nvar\r\n Idx: Cardinal;\r\n Seg, Offset: Integer;\r\nbegin\r\n Id"
},
{
"path": "CollectList.pas",
"chars": 4928,
"preview": "unit CollectList;\r\n\r\ninterface\r\n\r\nuses Classes, SysUtils, SyncObjs, ClassUtils;\r\n\r\nconst\r\n _DEF_SEGMENT_SIZE = 16 * 102"
},
{
"path": "CollectListIntf.inc",
"chars": 890,
"preview": "const\r\n _SEGMENT_SIZE = 16 * 1024;\r\n\r\ntype\r\n TSegment<T> = Array of T;\r\n\r\n TSegList<T> = Array of TSegment<T>;\r\n\r\n T"
},
{
"path": "Collections/Collections.Bags.pas",
"chars": 28510,
"preview": "(*\r\n* Copyright (c) 2009-2012, Ciobanu Alexandru\r\n* All rights reserved.\r\n*\r\n* Redistribution and use in source and bina"
},
{
"path": "Collections/Collections.Base.pas",
"chars": 325104,
"preview": "(*\r\n* Copyright (c) 2008-2012, Ciobanu Alexandru\r\n* All rights reserved.\r\n*\r\n* Redistribution and use in source and bina"
},
{
"path": "Collections/Collections.BidiDictionaries.pas",
"chars": 45442,
"preview": "(*\r\n* Copyright (c) 2011-2012, Ciobanu Alexandru\r\n* All rights reserved.\r\n*\r\n* Redistribution and use in source and bina"
},
{
"path": "Collections/Collections.BidiMaps.pas",
"chars": 38276,
"preview": "(*\r\n* Copyright (c) 2009-2012, Ciobanu Alexandru\r\n* All rights reserved.\r\n*\r\n* Redistribution and use in source and bina"
},
{
"path": "Collections/Collections.Dictionaries.pas",
"chars": 96398,
"preview": "(*\r\n* Copyright (c) 2008-2012, Ciobanu Alexandru\r\n* All rights reserved.\r\n*\r\n* Redistribution and use in source and bina"
},
{
"path": "Collections/Collections.Dynamic.pas",
"chars": 11156,
"preview": "(*\r\n* Copyright (c) 2011-2012, Ciobanu Alexandru\r\n* All rights reserved.\r\n*\r\n* Redistribution and use in source and bina"
},
{
"path": "Collections/Collections.Lists.pas",
"chars": 100992,
"preview": "(*\r\n* Copyright (c) 2008-2012, Ciobanu Alexandru\r\n* All rights reserved.\r\n*\r\n* Redistribution and use in source and bina"
},
{
"path": "Collections/Collections.MultiMaps.pas",
"chars": 60586,
"preview": "(*\r\n* Copyright (c) 2009-2012, Ciobanu Alexandru\r\n* All rights reserved.\r\n*\r\n* Redistribution and use in source and bina"
},
{
"path": "Collections/Collections.Queues.pas",
"chars": 77017,
"preview": "(*\r\n* Copyright (c) 2008-2012, Ciobanu Alexandru\r\n* All rights reserved.\r\n*\r\n* Redistribution and use in source and bina"
},
{
"path": "Collections/Collections.Serialization.pas",
"chars": 149388,
"preview": "(*\r\n* Copyright (c) 2011-2012, Ciobanu Alexandru\r\n* All rights reserved.\r\n*\r\n* Redistribution and use in source and bina"
},
{
"path": "Collections/Collections.Sets.pas",
"chars": 103243,
"preview": "(*\r\n* Copyright (c) 2008-2012, Ciobanu Alexandru\r\n* All rights reserved.\r\n*\r\n* Redistribution and use in source and bina"
},
{
"path": "Collections/Collections.Stacks.pas",
"chars": 52945,
"preview": "(*\r\n* Copyright (c) 2008-2012, Ciobanu Alexandru\r\n* All rights reserved.\r\n*\r\n* Redistribution and use in source and bina"
},
{
"path": "Collections/Collections.dpk",
"chars": 1275,
"preview": "package Collections;\r\n\r\n{$R *.res}\r\n{$IFDEF IMPLICITBUILDING This IFDEF should not be used by users}\r\n{$ALIGN 8}\r\n{$ASSE"
},
{
"path": "Collections/Collections.dproj",
"chars": 8593,
"preview": "\t<Project xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\">\r\n\t\t<PropertyGroup>\r\n\t\t\t<ProjectGuid>{B6403A30-71"
},
{
"path": "Collections/Collections_project.tvsconfig",
"chars": 72,
"preview": "<?xml version=\"1.0\"?>\r\n<TgConfig Version=\"3\" SubLevelDisabled=\"False\" />"
},
{
"path": "DbgCodeProfiler.pas",
"chars": 17302,
"preview": "unit DbgCodeProfiler;\r\n\r\ninterface\r\n\r\nuses System.Classes, WinApi.Windows, Collections.Queues, DbgHookTypes,\r\n System.S"
},
{
"path": "DbgHook32.dpr",
"chars": 816,
"preview": "library DbgHook32;\r\n\r\nuses\r\n Windows,\r\n DbgHookTypes in 'DbgHookTypes.pas',\r\n DbgHookThread in 'DbgHookThread.pas',\r\n"
},
{
"path": "DbgHook32.dproj",
"chars": 7935,
"preview": "<Project xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\">\r\n <PropertyGroup>\r\n <ProjectGuid>{5769B"
},
{
"path": "DbgHookCS.pas",
"chars": 1106,
"preview": "unit DbgHookCS;\r\n\r\ninterface\r\n\r\nuses Windows;\r\n\r\ntype\r\n TDbgCriticalSection = class\r\n private\r\n FLock: TRTLCritical"
},
{
"path": "DbgHookMemory.pas",
"chars": 6440,
"preview": "unit DbgHookMemory;\r\n\r\ninterface\r\n\r\nuses DbgHookTypes, DbgHookCS;\r\n\r\nprocedure InitMemoryHook(MemoryMgr: Pointer; Memory"
},
{
"path": "DbgHookPerf.pas",
"chars": 3080,
"preview": "unit DbgHookPerf;\r\n\r\ninterface\r\n\r\nprocedure InitPerfomance(Delta: Cardinal); stdcall;\r\nprocedure ResetPerfomance; stdcal"
},
{
"path": "DbgHookSyncObjs.pas",
"chars": 19006,
"preview": "unit DbgHookSyncObjs;\r\n\r\ninterface\r\n\r\nuses WinApi.Windows, DbgHookCS, DbgHookTypes;\r\n\r\ntype\r\n TKernel32_Sleep =\r\n pr"
},
{
"path": "DbgHookThread.pas",
"chars": 4398,
"preview": "unit DbgHookThread;\r\n\r\ninterface\r\n\r\nfunction InitThreadHook(ImageBase: Pointer; _vmtClassName: Integer): LongBool; stdca"
},
{
"path": "DbgHookTypes.pas",
"chars": 2814,
"preview": "unit DbgHookTypes;\r\n\r\ninterface\r\n\r\nuses\r\n WinApi.Windows;\r\n\r\nconst\r\n DBG_EXCEPTION = $0EEDFFF0;\r\n\r\n _EHOOK_GetCallSta"
},
{
"path": "DbgHookUtils.pas",
"chars": 4693,
"preview": "unit DbgHookUtils;\r\n\r\ninterface\r\n\r\nuses System.SysUtils, DbgHookTypes;\r\n\r\ntype\r\n TJclAddr = NativeInt;\r\n\r\n PStackFrame"
},
{
"path": "DbgMemoryProfiler.pas",
"chars": 7934,
"preview": "unit DbgMemoryProfiler;\r\n\r\ninterface\r\n\r\nuses System.Classes, WinApi.Windows, Collections.Queues, DbgHookTypes,\r\n System"
},
{
"path": "DbgSamplingProfiler.pas",
"chars": 8557,
"preview": "unit DbgSamplingProfiler;\r\n\r\ninterface\r\n\r\nuses System.Classes, WinApi.Windows, Collections.Queues, DbgHookTypes,\r\n Syst"
},
{
"path": "DbgSyncObjsProfiler.pas",
"chars": 7480,
"preview": "unit DbgSyncObjsProfiler;\r\n\r\ninterface\r\n\r\nuses System.Classes, WinApi.Windows, Collections.Queues, DbgHookTypes,\r\n Syst"
},
{
"path": "DbgWorkerThread.pas",
"chars": 1734,
"preview": "unit DbgWorkerThread;\r\n\r\ninterface\r\n\r\nuses System.Classes, System.SysUtils;\r\n\r\ntype\r\n TDbgWorkerThread = class(TThread)"
},
{
"path": "DebugHook.pas",
"chars": 7990,
"preview": "unit DebugHook;\r\n\r\ninterface\r\n\r\nuses Windows, DebugInfo;\r\n\r\nfunction LoadDbgHookDll(hProcess: THandle; const DllPath: St"
},
{
"path": "DebugInfo.pas",
"chars": 57140,
"preview": "Unit DebugInfo;\r\n\r\nInterface\r\n\r\nUses\r\n SysUtils, Windows, Classes, Debuger, DebugerTypes, Generics.Collections, Generic"
},
{
"path": "Debuger.pas",
"chars": 83812,
"preview": "unit Debuger;\r\n\r\ninterface\r\n\r\nuses\r\n WinApi.Windows, System.Classes, System.SysUtils, System.SyncObjs,\r\n ClassUtils, J"
},
{
"path": "DebugerTypes.pas",
"chars": 49878,
"preview": "unit DebugerTypes;\r\n\r\ninterface\r\n\r\nuses System.SysUtils, WinApi.Windows, System.Classes, JclPeImage, System.SyncObjs, Cl"
},
{
"path": "DelphiDebugInfo.pas",
"chars": 59091,
"preview": "unit DelphiDebugInfo;\r\n\r\nInterface\r\n\r\nUses\r\n SysUtils, Windows, Classes, DebugInfo, Debuger, DebugerTypes, JclTD32Ex;\r\n"
},
{
"path": "External/Jedi/Jcl/source/common/Jcl8087.pas",
"chars": 12159,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclAbstractContainers.pas",
"chars": 97183,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclAlgorithms.pas",
"chars": 128472,
"preview": "{**************************************************************************************************}\r\n{ WARNING: JEDI "
},
{
"path": "External/Jedi/Jcl/source/common/JclAnsiStrings.pas",
"chars": 114451,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclArrayLists.pas",
"chars": 313345,
"preview": "{**************************************************************************************************}\r\n{ WARNING: JEDI "
},
{
"path": "External/Jedi/Jcl/source/common/JclArraySets.pas",
"chars": 69069,
"preview": "{**************************************************************************************************}\r\n{ WARNING: JEDI "
},
{
"path": "External/Jedi/Jcl/source/common/JclBase.pas",
"chars": 19225,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclBinaryTrees.pas",
"chars": 585360,
"preview": "{**************************************************************************************************}\r\n{ WARNING: JEDI "
},
{
"path": "External/Jedi/Jcl/source/common/JclCharsets.pas",
"chars": 33902,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclCompilerUtils.pas",
"chars": 46555,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclComplex.pas",
"chars": 47498,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclCompression.pas",
"chars": 311657,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclContainerIntf.pas",
"chars": 205576,
"preview": "{**************************************************************************************************}\r\n{ WARNING: JEDI "
},
{
"path": "External/Jedi/Jcl/source/common/JclCounter.pas",
"chars": 8811,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclDateTime.pas",
"chars": 47967,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclDevToolsResources.pas",
"chars": 11692,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclExprEval.pas",
"chars": 130715,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclFileUtils.pas",
"chars": 222394,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclHashMaps.pas",
"chars": 832778,
"preview": "{**************************************************************************************************}\r\n{ WARNING: JEDI "
},
{
"path": "External/Jedi/Jcl/source/common/JclHashSets.pas",
"chars": 383162,
"preview": "{**************************************************************************************************}\r\n{ WARNING: JEDI "
},
{
"path": "External/Jedi/Jcl/source/common/JclIDEUtils.pas",
"chars": 166348,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclIniFiles.pas",
"chars": 7266,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclLinkedLists.pas",
"chars": 465201,
"preview": "{**************************************************************************************************}\r\n{ WARNING: JEDI "
},
{
"path": "External/Jedi/Jcl/source/common/JclLogic.pas",
"chars": 62116,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclMIDI.pas",
"chars": 33222,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclMath.pas",
"chars": 131937,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclMime.pas",
"chars": 34809,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclNotify.pas",
"chars": 15349,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclPCRE.pas",
"chars": 42916,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclPreProcessorAlgorithmsTemplates.pas",
"chars": 29731,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclPreProcessorArrayListsTemplates.pas",
"chars": 12800,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclPreProcessorArraySetsTemplates.pas",
"chars": 8437,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclPreProcessorBinaryTreesTemplates.pas",
"chars": 18533,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclPreProcessorContainer1DTemplates.pas",
"chars": 21174,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclPreProcessorContainer2DTemplates.pas",
"chars": 29289,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclPreProcessorContainerIntfTemplates.pas",
"chars": 35785,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclPreProcessorContainerKnownMaps.pas",
"chars": 58750,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclPreProcessorContainerKnownTypes.pas",
"chars": 79905,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclPreProcessorContainerTemplates.pas",
"chars": 28668,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclPreProcessorContainerTypes.pas",
"chars": 21438,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclPreProcessorExcDlgTemplates.pas",
"chars": 11703,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclPreProcessorHashMapsTemplates.pas",
"chars": 14300,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclPreProcessorHashSetsTemplates.pas",
"chars": 13415,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclPreProcessorLexer.pas",
"chars": 14242,
"preview": "{ **************************************************************************** }\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclPreProcessorLinkedListsTemplates.pas",
"chars": 15355,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclPreProcessorParser.pas",
"chars": 47300,
"preview": "{ **************************************************************************** }\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclPreProcessorQueuesTemplates.pas",
"chars": 7661,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclPreProcessorSortedMapsTemplates.pas",
"chars": 12739,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclPreProcessorStacksTemplates.pas",
"chars": 7527,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclPreProcessorTemplates.pas",
"chars": 6122,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclPreProcessorTreesTemplates.pas",
"chars": 17135,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclPreProcessorVectorsTemplates.pas",
"chars": 12694,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclQueues.pas",
"chars": 104723,
"preview": "{**************************************************************************************************}\r\n{ WARNING: JEDI "
},
{
"path": "External/Jedi/Jcl/source/common/JclRTTI.pas",
"chars": 92214,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclResources.pas",
"chars": 111169,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclSchedule.pas",
"chars": 43729,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclSimpleXml.pas",
"chars": 132278,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclSortedMaps.pas",
"chars": 851555,
"preview": "{**************************************************************************************************}\r\n{ WARNING: JEDI "
},
{
"path": "External/Jedi/Jcl/source/common/JclStacks.pas",
"chars": 75025,
"preview": "{**************************************************************************************************}\r\n{ WARNING: JEDI "
},
{
"path": "External/Jedi/Jcl/source/common/JclStatistics.pas",
"chars": 15311,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclStrHashMap.pas",
"chars": 20432,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclStreams.pas",
"chars": 94891,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclStringConversions.pas",
"chars": 125605,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclStringLists.pas",
"chars": 47162,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclStrings.pas",
"chars": 152244,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclSynch.pas",
"chars": 56373,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclSysInfo.pas",
"chars": 213782,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclSysUtils.pas",
"chars": 131858,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclTrees.pas",
"chars": 568309,
"preview": "{**************************************************************************************************}\r\n{ WARNING: JEDI "
},
{
"path": "External/Jedi/Jcl/source/common/JclUnicode.pas",
"chars": 268549,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclUnicode.rc",
"chars": 530636,
"preview": "/****************************************************************************************************\r\n\r\n\r\n ..\\..\\jcl\\s"
},
{
"path": "External/Jedi/Jcl/source/common/JclUnicodeBzip2.rc",
"chars": 232195,
"preview": "/****************************************************************************************************\r\n\r\n\r\n ..\\..\\jcl\\s"
},
{
"path": "External/Jedi/Jcl/source/common/JclUnicodeZLib.rc",
"chars": 229401,
"preview": "/****************************************************************************************************\r\n\r\n\r\n ..\\..\\jcl\\s"
},
{
"path": "External/Jedi/Jcl/source/common/JclUnitConv.pas",
"chars": 30950,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclUnitVersioning.pas",
"chars": 21465,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclUnitVersioningProviders.pas",
"chars": 14363,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclUsesUtils.pas",
"chars": 25013,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclValidation.pas",
"chars": 7331,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/JclVectors.pas",
"chars": 310213,
"preview": "{**************************************************************************************************}\r\n{ WARNING: JEDI "
},
{
"path": "External/Jedi/Jcl/source/common/JclWideStrings.pas",
"chars": 64270,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/bzip2.pas",
"chars": 20528,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/dirinfo.txt",
"chars": 56,
"preview": "This is the directory where cross platform code resides."
},
{
"path": "External/Jedi/Jcl/source/common/pcre.pas",
"chars": 110741,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/common/zconf.h",
"chars": 13846,
"preview": "/* zconf.h -- configuration of the zlib compression library\r\n * Copyright (C) 1995-2010 Jean-loup Gailly.\r\n * For condit"
},
{
"path": "External/Jedi/Jcl/source/common/zlib.h",
"chars": 81177,
"preview": "/* zlib.h -- interface of the 'zlib' general purpose compression library\r\n version 1.2.5, April 19th, 2010\r\n\r\n Copyrig"
},
{
"path": "External/Jedi/Jcl/source/common/zlibh.pas",
"chars": 106120,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/include/crossplatform.inc",
"chars": 2653,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/include/jcl.inc",
"chars": 18627,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/include/jcl.template.inc",
"chars": 7095,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/include/jcld17win32.inc",
"chars": 7085,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/include/jcld17win64.inc",
"chars": 7085,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/include/jedi/jedi.inc",
"chars": 64215,
"preview": "{$IFNDEF JEDI_INC}\r\n{$DEFINE JEDI_INC}\r\n\r\n{*****************************************************************************"
},
{
"path": "External/Jedi/Jcl/source/include/jedi/kylix.inc",
"chars": 966,
"preview": "//\r\n// This is FPC-incompatible code and was excluded from jedi.inc for this reason\r\n//\r\n// Kylix 3/C++ for some reason "
},
{
"path": "External/Jedi/Jcl/source/include/unixonly.inc",
"chars": 3002,
"preview": "{$IFNDEF UNIXONLY_INC}\r\n{$DEFINE UNIXONLY_INC}\r\n\r\n{*********************************************************************"
},
{
"path": "External/Jedi/Jcl/source/include/windowsonly.inc",
"chars": 3122,
"preview": "{$IFNDEF WINDOWSONLY_INC}\r\n{$DEFINE WINDOWSONLY_INC}\r\n\r\n{***************************************************************"
},
{
"path": "External/Jedi/Jcl/source/windows/Hardlinks.pas",
"chars": 34702,
"preview": "{**************************************************************************************************}\r\n{ WARNING: JEDI "
},
{
"path": "External/Jedi/Jcl/source/windows/JclAppInst.pas",
"chars": 35101,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclCIL.pas",
"chars": 48994,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclCLR.pas",
"chars": 57832,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclCOM.pas",
"chars": 23441,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclCommCtrlAdmin.manifest",
"chars": 855,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\r\n<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVers"
},
{
"path": "External/Jedi/Jcl/source/windows/JclCommCtrlAdmin.rc",
"chars": 278,
"preview": "/****************************************************************************************************\r\n\r\n VistaElevate."
},
{
"path": "External/Jedi/Jcl/source/windows/JclCommCtrlAsInvoker.manifest",
"chars": 844,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\r\n<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVers"
},
{
"path": "External/Jedi/Jcl/source/windows/JclCommCtrlAsInvoker.rc",
"chars": 282,
"preview": "/****************************************************************************************************\r\n\r\n VistaElevate."
},
{
"path": "External/Jedi/Jcl/source/windows/JclConsole.pas",
"chars": 51206,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclCppException.pas",
"chars": 27228,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclDebug.pas",
"chars": 218922,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclDebugSerialization.pas",
"chars": 28059,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclDebugXMLDeserializer.pas",
"chars": 4583,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclDebugXMLSerializer.pas",
"chars": 5135,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclDotNet.pas",
"chars": 48137,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclHelpUtils.pas",
"chars": 17474,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclHookExcept.pas",
"chars": 27860,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclLANMan.pas",
"chars": 16483,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclLocales.pas",
"chars": 39560,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclMapi.pas",
"chars": 48879,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclMetadata.pas",
"chars": 164911,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclMiscel.pas",
"chars": 20234,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclMsBuild.pas",
"chars": 89671,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclMsdosSys.pas",
"chars": 21428,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclMultimedia.pas",
"chars": 46146,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclNTFS.pas",
"chars": 82421,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclNoDepAdmin.manifest",
"chars": 545,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\r\n<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVers"
},
{
"path": "External/Jedi/Jcl/source/windows/JclNoDepAdmin.rc",
"chars": 275,
"preview": "/****************************************************************************************************\r\n\r\n VistaElevate."
},
{
"path": "External/Jedi/Jcl/source/windows/JclNoDepAsInvoker.manifest",
"chars": 534,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\r\n<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVers"
},
{
"path": "External/Jedi/Jcl/source/windows/JclNoDepAsInvoker.rc",
"chars": 279,
"preview": "/****************************************************************************************************\r\n\r\n VistaElevate."
},
{
"path": "External/Jedi/Jcl/source/windows/JclPeImage.pas",
"chars": 225592,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclRegistry.pas",
"chars": 79080,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclSecurity.pas",
"chars": 28559,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclShell.pas",
"chars": 52518,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclStructStorage.pas",
"chars": 29813,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclSvcCtrl.pas",
"chars": 48005,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclTD32.pas",
"chars": 58874,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclTask.pas",
"chars": 31055,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclTimeZones.pas",
"chars": 31415,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclWin32.pas",
"chars": 353117,
"preview": "{**************************************************************************************************}\r\n{ WARNING: JEDI "
},
{
"path": "External/Jedi/Jcl/source/windows/JclWin32Ex.pas",
"chars": 16390,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/JclWinMIDI.pas",
"chars": 10762,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/MSHelpServices_TLB.pas",
"chars": 84445,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/MSTask.pas",
"chars": 26246,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/Snmp.pas",
"chars": 40403,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/dirinfo.txt",
"chars": 56,
"preview": "This is the directory where Win32-specific units reside."
},
{
"path": "External/Jedi/Jcl/source/windows/mscoree_TLB.pas",
"chars": 22427,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/mscorlib_TLB.pas",
"chars": 1596040,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jcl/source/windows/obj/bzip2/win32/dirinfo.txt",
"chars": 88,
"preview": "This is the directory where object files of bzip (http://www.bzip.org) for win32 reside."
},
{
"path": "External/Jedi/Jcl/source/windows/obj/bzip2/win32/makefile.mak",
"chars": 3570,
"preview": "#\r\n# makefile to make bzip2 .obj files using Borland's C++ compiler bcc32\r\n# derived from a makefile generated by BCB6' "
},
{
"path": "External/Jedi/Jcl/source/windows/obj/bzip2/win64/dirinfo.txt",
"chars": 88,
"preview": "This is the directory where object files of bzip (http://www.bzip.org) for win64 reside."
},
{
"path": "External/Jedi/Jcl/source/windows/obj/bzip2/win64/makefile.mak",
"chars": 2206,
"preview": "#\r\n# makefile to make bzip2 .obj files using Microsoft C++ compiler (cl.exe)\r\n#\r\n# if bzip2 source directory is differen"
},
{
"path": "External/Jedi/Jcl/source/windows/obj/pcre/win32/dirinfo.txt",
"chars": 89,
"preview": "This is the directory where object files of PCRE (http://www.pcre.org/) for win32 reside."
},
{
"path": "External/Jedi/Jcl/source/windows/obj/pcre/win32/makefile.mak",
"chars": 4874,
"preview": "#\r\n# makefile to make pcre .obj files using Borland's C++ compiler bcc32\r\n# derived from a makefile generated by BCB6' b"
},
{
"path": "External/Jedi/Jcl/source/windows/obj/pcre/win64/dirinfo.txt",
"chars": 89,
"preview": "This is the directory where object files of PCRE (http://www.pcre.org/) for win64 reside."
},
{
"path": "External/Jedi/Jcl/source/windows/obj/pcre/win64/makefile.mak",
"chars": 3857,
"preview": "#\r\n# makefile to make pcre .obj files using Microsoft C++ compiler (cl.exe)\r\n#\r\n# if pcre source directory is different "
},
{
"path": "External/Jedi/Jcl/source/windows/obj/zlib/win32/dirinfo.txt",
"chars": 88,
"preview": "This is the directory where object files of zlib (http://www.zlib.net) for win32 reside."
},
{
"path": "External/Jedi/Jcl/source/windows/obj/zlib/win32/makefile.mak",
"chars": 3696,
"preview": "#\r\n# makefile to make zlib .obj files using Borland's C++ compiler bcc32\r\n# derived from a makefile generated by BCB6' b"
},
{
"path": "External/Jedi/Jcl/source/windows/obj/zlib/win64/dirinfo.txt",
"chars": 88,
"preview": "This is the directory where object files of zlib (http://www.zlib.net) for win64 reside."
},
{
"path": "External/Jedi/Jcl/source/windows/obj/zlib/win64/makefile.mak",
"chars": 2371,
"preview": "#\r\n# makefile to make zlib .obj files using Microsoft C++ compiler (cl.exe)\r\n#\r\n# if zlib source directory is different "
},
{
"path": "External/Jedi/Jcl/source/windows/sevenzip.pas",
"chars": 34372,
"preview": "{**************************************************************************************************}\r\n{ "
},
{
"path": "External/Jedi/Jvcl/common/common.txt",
"chars": 108,
"preview": "This folder contains files that might be shared by other parts of JEDI, like INC files and API translation. "
},
{
"path": "External/Jedi/Jvcl/common/crossplatform.inc",
"chars": 1328,
"preview": "{-----------------------------------------------------------------------------\r\nThe contents of this file are subject to"
},
{
"path": "External/Jedi/Jvcl/common/jedi/jedi.inc",
"chars": 64215,
"preview": "{$IFNDEF JEDI_INC}\r\n{$DEFINE JEDI_INC}\r\n\r\n{*****************************************************************************"
},
{
"path": "External/Jedi/Jvcl/common/jedi/kylix.inc",
"chars": 966,
"preview": "//\r\n// This is FPC-incompatible code and was excluded from jedi.inc for this reason\r\n//\r\n// Kylix 3/C++ for some reason "
},
{
"path": "External/Jedi/Jvcl/common/jvcl.inc",
"chars": 8032,
"preview": "{-----------------------------------------------------------------------------\r\nThe contents of this file are subject to"
}
]
// ... and 1172 more files (download for full content)
About this extraction
This page contains the full source code of the yavfast/dbg-spider GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1372 files (43.6 MB), approximately 11.5M tokens, and a symbol index with 19 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.