Ignore:
Timestamp:
Sep 24, 2012, 1:47:39 PM (12 years ago)
Author:
chronos
Message:
Location:
Generics/TemplateGenerics/Specialized
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • Generics/TemplateGenerics/Specialized/SpecializedDictionary.pas

    r301 r426  
    1818{$DEFINE TGDictionary := TDictionaryStringString}
    1919{$DEFINE TGDictionaryList := TDictionaryStringStringList}
    20 {$DEFINE TGDictionarySortCompare := TDictionaryStringStringSortCompare}
    21 {$DEFINE TGDictionaryToStringConverter := TDictionaryStringStringToStringConverter}
    22 {$DEFINE TGDictionaryFromStringConverter := TDictionaryStringStringFromStringConverter}
    23 {$DEFINE TGDictionaryItemArray := TDictionaryStringStringItemArray}
    2420{$DEFINE INTERFACE}
    2521{$I 'GenericDictionary.inc'}
     
    3228{$DEFINE TGDictionary := TDictionaryIntegerString}
    3329{$DEFINE TGDictionaryList := TDictionaryIntegerStringList}
    34 {$DEFINE TGDictionarySortCompare := TDictionaryIntegerStringSortCompare}
    35 {$DEFINE TGDictionaryToStringConverter := TDictionaryIntegerStringToStringConverter}
    36 {$DEFINE TGDictionaryFromStringConverter := TDictionaryIntegerStringFromStringConverter}
    37 {$DEFINE TGDictionaryItemArray := TDictionaryIntegerStringItemArray}
    3830{$DEFINE INTERFACE}
    3931{$I 'GenericDictionary.inc'}
     
    5345{$DEFINE TGDictionary := TDictionaryStringString}
    5446{$DEFINE TGDictionaryList := TDictionaryStringStringList}
    55 {$DEFINE TGDictionarySortCompare := TDictionaryStringStringSortCompare}
    56 {$DEFINE TGDictionaryToStringConverter := TDictionaryStringStringToStringConverter}
    57 {$DEFINE TGDictionaryFromStringConverter := TDictionaryStringStringFromStringConverter}
    58 {$DEFINE TGDictionaryItemArray := TDictionaryStringStringItemArray}
    5947{$DEFINE IMPLEMENTATION}
    6048{$I 'GenericDictionary.inc'}
     
    6755{$DEFINE TGDictionary := TDictionaryIntegerString}
    6856{$DEFINE TGDictionaryList := TDictionaryIntegerStringList}
    69 {$DEFINE TGDictionarySortCompare := TDictionaryIntegerStringSortCompare}
    70 {$DEFINE TGDictionaryToStringConverter := TDictionaryIntegerStringToStringConverter}
    71 {$DEFINE TGDictionaryFromStringConverter := TDictionaryIntegerStringFromStringConverter}
    72 {$DEFINE TGDictionaryItemArray := TDictionaryIntegerStringItemArray}
    7357{$DEFINE IMPLEMENTATION}
    7458{$I 'GenericDictionary.inc'}
  • Generics/TemplateGenerics/Specialized/SpecializedList.pas

    r398 r426  
    1515{$DEFINE TGListItem := Integer}
    1616{$DEFINE TGList := TListInteger}
    17 {$DEFINE TGListSortCompare := TListIntegerSortCompare}
    18 {$DEFINE TGListToStringConverter := TListIntegerToStringConverter}
    19 {$DEFINE TGListFromStringConverter := TListIntegerFromStringConverter}
    20 {$DEFINE TGListItemArray := TListIntegerItemArray}
    2117{$DEFINE INTERFACE}
    2218{$I 'GenericList.inc'}
     
    2622{$DEFINE TGListItem := Boolean}
    2723{$DEFINE TGList := TListBoolean}
    28 {$DEFINE TGListSortCompare := TListBooleanSortCompare}
    29 {$DEFINE TGListToStringConverter := TListBooleanToStringConverter}
    30 {$DEFINE TGListFromStringConverter := TListBooleanFromStringConverter}
    31 {$DEFINE TGListItemArray := TListBooleanItemArray}
    3224{$DEFINE INTERFACE}
    3325{$I 'GenericList.inc'}
     
    3729{$DEFINE TGListItem := SmallInt}
    3830{$DEFINE TGList := TListSmallInt}
    39 {$DEFINE TGListSortCompare := TListSmallIntSortCompare}
    40 {$DEFINE TGListToStringConverter := TListSmallIntToStringConverter}
    41 {$DEFINE TGListFromStringConverter := TListSmallIntFromStringConverter}
    42 {$DEFINE TGListItemArray := TListSmallIntItemArray}
    4331{$DEFINE INTERFACE}
    4432{$I 'GenericList.inc'}
     
    4836{$DEFINE TGListItem := Double}
    4937{$DEFINE TGList := TListDouble}
    50 {$DEFINE TGListSortCompare := TListDoubleSortCompare}
    51 {$DEFINE TGListToStringConverter := TListDoubleToStringConverter}
    52 {$DEFINE TGListFromStringConverter := TListDoubleFromStringConverter}
    53 {$DEFINE TGListItemArray := TListDoubleItemArray}
    5438{$DEFINE INTERFACE}
    5539{$INCLUDE '..\Generic\GenericList.inc'}
     
    5943{$DEFINE TGListItem := Pointer}
    6044{$DEFINE TGList := TListPointer}
    61 {$DEFINE TGListSortCompare := TListPointerSortCompare}
    62 {$DEFINE TGListToStringConverter := TListPointerToStringConverter}
    63 {$DEFINE TGListFromStringConverter := TListPointerFromStringConverter}
    64 {$DEFINE TGListItemArray := TListPointerItemArray}
    6545{$DEFINE INTERFACE}
    6646{$I 'GenericList.inc'}
     
    7050{$DEFINE TGListStringItem := string}
    7151{$DEFINE TGListString := TListString}
    72 {$DEFINE TGListStringSortCompare := TListStringSortCompare}
    73 {$DEFINE TGListStringToStringConverter := TListStringToStringConverter}
    74 {$DEFINE TGListStringFromStringConverter := TListStringFromStringConverter}
    75 {$DEFINE TGListItemArray := TListStringItemArray}
    7652{$DEFINE INTERFACE}
    7753{$I 'GenericListString.inc'}
     
    8157{$DEFINE TGListItem := Byte}
    8258{$DEFINE TGList := TListByteBase}
    83 {$DEFINE TGListSortCompare := TListByteSortCompare}
    84 {$DEFINE TGListToStringConverter := TListByteToStringConverter}
    85 {$DEFINE TGListFromStringConverter := TListByteFromStringConverter}
    86 {$DEFINE TGListItemArray := TListByteItemArray}
    8759{$DEFINE INTERFACE}
    8860{$I 'GenericList.inc'}
     
    10375{$DEFINE TGListItem := Char}
    10476{$DEFINE TGList := TListCharBase}
    105 {$DEFINE TGListSortCompare := TListSortCompareChar}
    106 {$DEFINE TGListToStringConverter := TListToStringConverterChar}
    107 {$DEFINE TGListFromStringConverter := TListFromStringConverterChar}
    108 {$DEFINE TGListItemArray := TListStringItemArray}
    10977{$DEFINE INTERFACE}
    11078{$I 'GenericList.inc'}
     
    11583{$DEFINE TGListObjectList := TListObjectList}
    11684{$DEFINE TGListObject := TListObject}
    117 {$DEFINE TGListObjectSortCompare := TListObjectSortCompare}
    118 {$DEFINE TGListObjectToStringConverter := TListObjectToStringConverter}
    119 {$DEFINE TGListObjectFromStringConverter := TListObjectFromStringConverter}
    120 {$DEFINE TGListItemArray := TListObjectItemArray}
    12185{$DEFINE INTERFACE}
    12286{$I 'GenericListObject.inc'}
     
    138102{$DEFINE TGListItem := TMethod}
    139103{$DEFINE TGList := TListMethodBase}
    140 {$DEFINE TGListSortCompare := TListMethodSortCompare}
    141 {$DEFINE TGListToStringConverter := TListMethodToStringConverter}
    142 {$DEFINE TGListFromStringConverter := TListMethodFromStringConverter}
    143 {$DEFINE TGListItemArray := TListMethodItemArray}
    144104{$DEFINE INTERFACE}
    145105{$I 'GenericList.inc'}
     
    154114{$DEFINE TGListItem := TNotifyEvent}
    155115{$DEFINE TGList := TListNotifyEventBase}
    156 {$DEFINE TGListSortCompare := TListNotifyEventSortCompare}
    157 {$DEFINE TGListToStringConverter := TListNotifyEventToStringConverter}
    158 {$DEFINE TGListFromStringConverter := TListNotifyEventFromStringConverter}
    159 {$DEFINE TGListItemArray := TListNotifyEventItemArray}
    160116{$DEFINE INTERFACE}
    161117{$I 'GenericList.inc'}
     
    173129{$DEFINE TGListItem := TBaseEvent}
    174130{$DEFINE TGList := TListSimpleEventBase}
    175 {$DEFINE TGListSortCompare := TListSimpleEventSortCompare}
    176 {$DEFINE TGListToStringConverter := TListSimpleEventToStringConverter}
    177 {$DEFINE TGListFromStringConverter := TListSimpleEventFromStringConverter}
    178 {$DEFINE TGListItemArray := TListSimpleEventItemArray}
    179131{$DEFINE INTERFACE}
    180132{$I 'GenericList.inc'}
     
    186138
    187139
     140// TFileListByte<Integer, Byte>
     141{$DEFINE TGFileListIndex := Integer}
     142{$DEFINE TGFileListItem := Byte}
     143{$DEFINE TGFileListList := TFileListListByte}
     144{$DEFINE TGFileList := TFileListByte}
     145{$DEFINE INTERFACE}
     146{$I 'GenericFileList.inc'}
     147
    188148function StrToStr(Value: string): string;
     149
     150
     151
     152
    189153
    190154implementation
     
    197161{$DEFINE TGListItem := Integer}
    198162{$DEFINE TGList := TListInteger}
    199 {$DEFINE TGListSortCompare := TListIntegerSortCompare}
    200 {$DEFINE TGListToStringConverter := TListIntegerToStringConverter}
    201 {$DEFINE TGListFromStringConverter := TListIntegerFromStringConverter}
    202 {$DEFINE TGListItemArray := TListIntegerItemArray}
    203163{$DEFINE IMPLEMENTATION}
    204164{$I 'GenericList.inc'}
     
    208168{$DEFINE TGListItem := SmallInt}
    209169{$DEFINE TGList := TListSmallInt}
    210 {$DEFINE TGListSortCompare := TListSmallIntSortCompare}
    211 {$DEFINE TGListToStringConverter := TListSmallIntToStringConverter}
    212 {$DEFINE TGListFromStringConverter := TListSmallIntFromStringConverter}
    213 {$DEFINE TGListItemArray := TListSmallIntItemArray}
    214170{$DEFINE IMPLEMENTATION}
    215171{$I 'GenericList.inc'}
     
    219175{$DEFINE TGListItem := Boolean}
    220176{$DEFINE TGList := TListBoolean}
    221 {$DEFINE TGListSortCompare := TListBooleanSortCompare}
    222 {$DEFINE TGListToStringConverter := TListBooleanToStringConverter}
    223 {$DEFINE TGListFromStringConverter := TListBooleanFromStringConverter}
    224 {$DEFINE TGListItemArray := TListBooleanItemArray}
    225177{$DEFINE IMPLEMENTATION}
    226178{$I 'GenericList.inc'}
     
    230182{$DEFINE TGListItem := Double}
    231183{$DEFINE TGList := TListDouble}
    232 {$DEFINE TGListSortCompare := TListDoubleSortCompare}
    233 {$DEFINE TGListToStringConverter := TListDoubleToStringConverter}
    234 {$DEFINE TGListFromStringConverter := TListDoubleFromStringConverter}
    235 {$DEFINE TGListItemArray := TListDoubleItemArray}
    236184{$DEFINE IMPLEMENTATION}
    237185{$I 'GenericList.inc'}
     
    241189{$DEFINE TGListItem := Pointer}
    242190{$DEFINE TGList := TListPointer}
    243 {$DEFINE TGListSortCompare := TListPointerSortCompare}
    244 {$DEFINE TGListToStringConverter := TListPointerToStringConverter}
    245 {$DEFINE TGListFromStringConverter := TListPointerFromStringConverter}
    246 {$DEFINE TGListItemArray := TListPointerItemArray}
    247191{$DEFINE IMPLEMENTATION}
    248192{$I 'GenericList.inc'}
     
    252196{$DEFINE TGListStringItem := string}
    253197{$DEFINE TGListString := TListString}
    254 {$DEFINE TGListStringSortCompare := TListStringSortCompare}
    255 {$DEFINE TGListStringToStringConverter := TListStringToStringConverter}
    256 {$DEFINE TGListStringFromStringConverter := TListStringFromStringConverter}
    257 {$DEFINE TGListItemArray := TListStringItemArray}
    258198{$DEFINE IMPLEMENTATION}
    259199{$I 'GenericListString.inc'}
     
    263203{$DEFINE TGListItem := Byte}
    264204{$DEFINE TGList := TListByteBase}
    265 {$DEFINE TGListSortCompare := TListByteSortCompare}
    266 {$DEFINE TGListToStringConverter := TListByteToStringConverter}
    267 {$DEFINE TGListFromStringConverter := TListByteFromStringConverter}
    268 {$DEFINE TGListItemArray := TListByteItemArray}
    269205{$DEFINE IMPLEMENTATION}
    270206{$I 'GenericList.inc'}
     
    274210{$DEFINE TGListItem := Char}
    275211{$DEFINE TGList := TListCharBase}
    276 {$DEFINE TGListSortCompare := TListSortCompareChar}
    277 {$DEFINE TGListToStringConverter := TListToStringConverterChar}
    278 {$DEFINE TGListFromStringConverter := TListFromStringConverterChar}
    279 {$DEFINE TGListItemArray := TListStringItemArray}
    280212{$DEFINE IMPLEMENTATION}
    281213{$I 'GenericList.inc'}
     
    286218{$DEFINE TGListObjectList := TListObjectList}
    287219{$DEFINE TGListObject := TListObject}
    288 {$DEFINE TGListObjectSortCompare := TListObjectSortCompare}
    289 {$DEFINE TGListObjectToStringConverter := TListObjectToStringConverter}
    290 {$DEFINE TGListObjectFromStringConverter := TListObjectFromStringConverter}
    291 {$DEFINE TGListItemArray := TListObjectItemArray}
    292220{$DEFINE IMPLEMENTATION}
    293221{$I 'GenericListObject.inc'}
     
    297225{$DEFINE TGListItem := TMethod}
    298226{$DEFINE TGList := TListMethodBase}
    299 {$DEFINE TGListSortCompare := TListMethodSortCompare}
    300 {$DEFINE TGListToStringConverter := TListMethodToStringConverter}
    301 {$DEFINE TGListFromStringConverter := TListMethodFromStringConverter}
    302 {$DEFINE TGListItemArray := TListMethodItemArray}
    303227{$DEFINE IMPLEMENTATION}
    304228{$I 'GenericList.inc'}
     
    308232{$DEFINE TGListItem := TNotifyEvent}
    309233{$DEFINE TGList := TListNotifyEventBase}
    310 {$DEFINE TGListSortCompare := TListNotifyEventSortCompare}
    311 {$DEFINE TGListToStringConverter := TListNotifyEventToStringConverter}
    312 {$DEFINE TGListFromStringConverter := TListNotifyEventFromStringConverter}
    313 {$DEFINE TGListItemArray := TListNotifyEventItemArray}
    314234{$DEFINE IMPLEMENTATION}
    315235{$I 'GenericList.inc'}
     
    319239{$DEFINE TGListItem := TBaseEvent}
    320240{$DEFINE TGList := TListSimpleEventBase}
    321 {$DEFINE TGListSortCompare := TListSimpleEventSortCompare}
    322 {$DEFINE TGListToStringConverter := TListSimpleEventToStringConverter}
    323 {$DEFINE TGListFromStringConverter := TListSimpleEventFromStringConverter}
    324 {$DEFINE TGListItemArray := TListSimpleEventItemArray}
    325 {$DEFINE IMPLEMENTATION}
    326 {$I 'GenericList.inc'}
    327 
     241{$DEFINE IMPLEMENTATION}
     242{$I 'GenericList.inc'}
     243
     244// TFileListByte<Integer, Byte>
     245{$DEFINE TGFileListIndex := Integer}
     246{$DEFINE TGFileListItem := Byte}
     247{$DEFINE TGFileListList := TFileListListByte}
     248{$DEFINE TGFileList := TFileListByte}
     249{$DEFINE IMPLEMENTATION}
     250{$I 'GenericFileList.inc'}
    328251
    329252
     
    501424end;
    502425
     426
    503427end.
  • Generics/TemplateGenerics/Specialized/SpecializedMatrix.pas

    r175 r426  
    1818{$DEFINE TGMatrixRow := TMatrixIntegerRow}
    1919{$DEFINE TGMatrix := TMatrixInteger}
    20 {$DEFINE TGMatrixSortCompare := TMatrixIntegerSortCompare}
    21 {$DEFINE TGMatrixToStringConverter := TMatrixIntegerToStringConverter}
    22 {$DEFINE TGMatrixFromStringConverter := TMatrixIntegerFromStringConverter}
    23 {$DEFINE TGMatrixMerge := TMatrixIntegerMerge}
    2420{$DEFINE INTERFACE}
    2521{$I 'GenericMatrix.inc'}
     
    3228{$DEFINE TGMatrixRow := TMatrixByteRow}
    3329{$DEFINE TGMatrix := TMatrixByte}
    34 {$DEFINE TGMatrixSortCompare := TMatrixByteSortCompare}
    35 {$DEFINE TGMatrixToStringConverter := TMatrixByteToStringConverter}
    36 {$DEFINE TGMatrixFromStringConverter := TMatrixByteFromStringConverter}
    37 {$DEFINE TGMatrixMerge := TMatrixByteMerge}
    3830{$DEFINE INTERFACE}
    3931{$I 'GenericMatrix.inc'}
     
    4638{$DEFINE TGMatrixRow := TMatrixObjectRow}
    4739{$DEFINE TGMatrix := TMatrixObject}
    48 {$DEFINE TGMatrixSortCompare := TMatrixObjectSortCompare}
    49 {$DEFINE TGMatrixToStringConverter := TMatrixObjectToStringConverter}
    50 {$DEFINE TGMatrixFromStringConverter := TMatrixObjectFromStringConverter}
    51 {$DEFINE TGMatrixMerge := TMatrixStringMerge}
    5240{$DEFINE INTERFACE}
    5341{$I 'GenericMatrix.inc'}
     
    6553{$DEFINE TGMatrixRow := TMatrixIntegerRow}
    6654{$DEFINE TGMatrix := TMatrixInteger}
    67 {$DEFINE TGMatrixSortCompare := TMatrixIntegerSortCompare}
    68 {$DEFINE TGMatrixToStringConverter := TMatrixIntegerToStringConverter}
    69 {$DEFINE TGMatrixFromStringConverter := TMatrixIntegerFromStringConverter}
    70 {$DEFINE TGMatrixMerge := TMatrixIntegerMerge}
    7155{$DEFINE IMPLEMENTATION}
    7256{$I 'GenericMatrix.inc'}
     
    7963{$DEFINE TGMatrixRow := TMatrixByteRow}
    8064{$DEFINE TGMatrix := TMatrixByte}
    81 {$DEFINE TGMatrixSortCompare := TMatrixByteSortCompare}
    82 {$DEFINE TGMatrixToStringConverter := TMatrixByteToStringConverter}
    83 {$DEFINE TGMatrixFromStringConverter := TMatrixByteFromStringConverter}
    84 {$DEFINE TGMatrixMerge := TMatrixByteMerge}
    8565{$DEFINE IMPLEMENTATION}
    8666{$I 'GenericMatrix.inc'}
     
    9373{$DEFINE TGMatrixRow := TMatrixObjectRow}
    9474{$DEFINE TGMatrix := TMatrixObject}
    95 {$DEFINE TGMatrixSortCompare := TMatrixObjectSortCompare}
    96 {$DEFINE TGMatrixToStringConverter := TMatrixObjectToStringConverter}
    97 {$DEFINE TGMatrixFromStringConverter := TMatrixObjectFromStringConverter}
    98 {$DEFINE TGMatrixMerge := TMatrixStringMerge}
    9975{$DEFINE IMPLEMENTATION}
    10076{$I 'GenericMatrix.inc'}
  • Generics/TemplateGenerics/Specialized/SpecializedQueue.pas

    r112 r426  
    1616{$DEFINE TGQueue := TQueueInteger}
    1717{$DEFINE TGQueueList := TQueueListInteger}
    18 {$DEFINE TGQueueSortCompare := TQueueSortCompareInteger}
    19 {$DEFINE TGQueueToStringConverter := TQueueToStringConverterInteger}
    20 {$DEFINE TGQueueFromStringConverter := TQueueFromStringConverterInteger}
    21 {$DEFINE TGQueueItemArray := TQueueIntegerItemArray}
    2218{$DEFINE INTERFACE}
    2319{$I 'GenericQueue.inc'}
     
    2824{$DEFINE TGQueue := TQueuePointer}
    2925{$DEFINE TGQueueList := TQueueListPointer}
    30 {$DEFINE TGQueueSortCompare := TQueueSortComparePointer}
    31 {$DEFINE TGQueueToStringConverter := TQueueToStringConverterPointer}
    32 {$DEFINE TGQueueFromStringConverter := TQueueFromStringConverterPointer}
    33 {$DEFINE TGQueueItemArray := TQueuePointerItemArray}
    3426{$DEFINE INTERFACE}
    3527{$I 'GenericQueue.inc'}
     
    4032{$DEFINE TGQueue := TQueueByte}
    4133{$DEFINE TGQueueList := TQueueListByte}
    42 {$DEFINE TGQueueSortCompare := TQueueSortCompareByte}
    43 {$DEFINE TGQueueToStringConverter := TQueueToStringConverterByte}
    44 {$DEFINE TGQueueFromStringConverter := TQueueFromStringConverterByte}
    45 {$DEFINE TGQueueItemArray := TQueueByteItemArray}
    4634{$DEFINE INTERFACE}
    4735{$I 'GenericQueue.inc'}
     
    5745{$DEFINE TGQueue := TQueueInteger}
    5846{$DEFINE TGQueueList := TQueueListInteger}
    59 {$DEFINE TGQueueSortCompare := TQueueSortCompareInteger}
    60 {$DEFINE TGQueueToStringConverter := TQueueToStringConverterInteger}
    61 {$DEFINE TGQueueFromStringConverter := TQueueFromStringConverterInteger}
    62 {$DEFINE TGQueueItemArray := TQueueIntegerItemArray}
    6347{$DEFINE IMPLEMENTATION}
    6448{$I '..\Generic\GenericQueue.inc'}
     
    6953{$DEFINE TGQueue := TQueuePointer}
    7054{$DEFINE TGQueueList := TQueueListPointer}
    71 {$DEFINE TGQueueSortCompare := TQueueSortComparePointer}
    72 {$DEFINE TGQueueToStringConverter := TQueueToStringConverterPointer}
    73 {$DEFINE TGQueueFromStringConverter := TQueueFromStringConverterPointer}
    74 {$DEFINE TGQueueItemArray := TQueuePointerItemArray}
    7555{$DEFINE IMPLEMENTATION}
    7656{$I 'GenericQueue.inc'}
     
    8161{$DEFINE TGQueue := TQueueByte}
    8262{$DEFINE TGQueueList := TQueueListByte}
    83 {$DEFINE TGQueueSortCompare := TQueueSortCompareByte}
    84 {$DEFINE TGQueueToStringConverter := TQueueToStringConverterByte}
    85 {$DEFINE TGQueueFromStringConverter := TQueueFromStringConverterByte}
    86 {$DEFINE TGQueueItemArray := TQueueByteItemArray}
    8763{$DEFINE IMPLEMENTATION}
    8864{$I 'GenericQueue.inc'}
  • Generics/TemplateGenerics/Specialized/SpecializedSet.pas

    r112 r426  
    1616{$DEFINE TGSetList := TSetListInteger}
    1717{$DEFINE TGSet := TSetInteger}
    18 {$DEFINE TGSetSortCompare := TSetSortCompareInteger}
    19 {$DEFINE TGSetToStringConverter := TSetToStringConverterInteger}
    20 {$DEFINE TGSetFromStringConverter := TSetFromStringConverterInteger}
    21 {$DEFINE TGSetItemArray := TSetIntegerItemArray}
    2218{$DEFINE INTERFACE}
    2319{$I 'GenericSet.inc'}
     
    2824{$DEFINE TGSetList := TSetListPointer}
    2925{$DEFINE TGSet := TSetPointer}
    30 {$DEFINE TGSetSortCompare := TSetSortComparePointer}
    31 {$DEFINE TGSetToStringConverter := TSetToStringConverterPointer}
    32 {$DEFINE TGSetFromStringConverter := TSetFromStringConverterPointer}
    33 {$DEFINE TGSetItemArray := TSetPointerItemArray}
    3426{$DEFINE INTERFACE}
    3527{$I 'GenericSet.inc'}
     
    4537{$DEFINE TGSetList := TSetListInteger}
    4638{$DEFINE TGSet := TSetInteger}
    47 {$DEFINE TGSetSortCompare := TSetSortCompareInteger}
    48 {$DEFINE TGSetToStringConverter := TSetToStringConverterInteger}
    49 {$DEFINE TGSetFromStringConverter := TSetFromStringConverterInteger}
    50 {$DEFINE TGSetItemArray := TSetIntegerItemArray}
    5139{$DEFINE IMPLEMENTATION}
    5240{$I 'GenericSet.inc'}
     
    5745{$DEFINE TGSetList := TSetListPointer}
    5846{$DEFINE TGSet := TSetPointer}
    59 {$DEFINE TGSetSortCompare := TSetSortComparePointer}
    60 {$DEFINE TGSetToStringConverter := TSetToStringConverterPointer}
    61 {$DEFINE TGSetFromStringConverter := TSetFromStringConverterPointer}
    62 {$DEFINE TGSetItemArray := TSetPointerItemArray}
    6347{$DEFINE IMPLEMENTATION}
    6448{$I 'GenericSet.inc'}
  • Generics/TemplateGenerics/Specialized/SpecializedStack.pas

    r112 r426  
    1616{$DEFINE TGStackList := TListStackInteger}
    1717{$DEFINE TGStack := TStackInteger}
    18 {$DEFINE TGStackSortCompare := TStackSortCompareInteger}
    19 {$DEFINE TGStackToStringConverter := TStackToStringConverterInteger}
    20 {$DEFINE TGStackFromStringConverter := TStackFromStringConverterInteger}
    21 {$DEFINE TGStackItemArray := TStackIntegerItemArray}
    2218{$DEFINE INTERFACE}
    2319{$I 'GenericStack.inc'}
     
    2824{$DEFINE TGStackList := TListStackPointer}
    2925{$DEFINE TGStack := TStackPointer}
    30 {$DEFINE TGStackSortCompare := TStackSortComparePointer}
    31 {$DEFINE TGStackToStringConverter := TStackToStringConverterPointer}
    32 {$DEFINE TGStackFromStringConverter := TStackFromStringConverterPointer}
    33 {$DEFINE TGStackItemArray := TStackStringItemArray}
    3426{$DEFINE INTERFACE}
    3527{$I 'GenericStack.inc'}
     
    4638{$DEFINE TGStackList := TListStackInteger}
    4739{$DEFINE TGStack := TStackInteger}
    48 {$DEFINE TGStackSortCompare := TStackSortCompareInteger}
    49 {$DEFINE TGStackToStringConverter := TStackToStringConverterInteger}
    50 {$DEFINE TGStackFromStringConverter := TStackFromStringConverterInteger}
    51 {$DEFINE TGStackItemArray := TStackIntegerItemArray}
    5240{$DEFINE IMPLEMENTATION}
    5341{$I 'GenericStack.inc'}
     
    5846{$DEFINE TGStackList := TListStackPointer}
    5947{$DEFINE TGStack := TStackPointer}
    60 {$DEFINE TGStackSortCompare := TStackSortComparePointer}
    61 {$DEFINE TGStackToStringConverter := TStackToStringConverterPointer}
    62 {$DEFINE TGStackFromStringConverter := TStackFromStringConverterPointer}
    63 {$DEFINE TGStackItemArray := TStackStringItemArray}
    6448{$DEFINE IMPLEMENTATION}
    6549{$I 'GenericStack.inc'}
  • Generics/TemplateGenerics/Specialized/SpecializedStream.pas

    r342 r426  
    1818{$DEFINE TGStreamList := TListStreamInteger}
    1919{$DEFINE TGStream := TStreamInteger}
    20 {$DEFINE TGStreamSortCompare := TStreamIntegerSortCompare}
    21 {$DEFINE TGStreamToStringConverter := TStreamIntegerToStringConverter}
    22 {$DEFINE TGStreamFromStringConverter := TStreamIntegerFromStringConverter}
    23 {$DEFINE TGStreamItemArray := TStreamIntegerItemArray}
    2420{$DEFINE INTERFACE}
    2521{$I 'GenericStream.inc'}
     
    3026{$DEFINE TGStreamList := TListStreamByte}
    3127{$DEFINE TGStream := TBaseStreamByte}
    32 {$DEFINE TGStreamSortCompare := TStreamByteSortCompare}
    33 {$DEFINE TGStreamToStringConverter := TStreamByteToStringConverter}
    34 {$DEFINE TGStreamFromStringConverter := TStreamByteFromStringConverter}
    35 {$DEFINE TGStreamItemArray := TStreamByteItemArray}
    3628{$DEFINE INTERFACE}
    3729{$I 'GenericStream.inc'}
     
    4234{$DEFINE TGStreamList := TListStreamPointer}
    4335{$DEFINE TGStream := TStreamPointer}
    44 {$DEFINE TGStreamSortCompare := TStreamPointerSortCompare}
    45 {$DEFINE TGStreamToStringConverter := TStreamPointerToStringConverter}
    46 {$DEFINE TGStreamFromStringConverter := TStreamPointerFromStringConverter}
    47 {$DEFINE TGStreamItemArray := TStreamPointerItemArray}
    4836{$DEFINE INTERFACE}
    4937{$I 'GenericStream.inc'}
     
    6957    procedure WriteStream(Stream: TBaseStreamByte; Count: Integer); override;
    7058    function Read: Byte; override;
    71     function ReadArray(Count: Integer): TStreamByteItemArray; override;
     59    function ReadArray(Count: Integer): TItemArray; override;
    7260    function ReadList(List: TListByte; Count: Integer): Integer;
    7361    function ReadBuffer(var Buffer; Count: Integer): Integer; override;
     
    134122end;
    135123
    136 function TMemoryStreamByte.ReadArray(Count: Integer): TStreamByteItemArray;
     124function TMemoryStreamByte.ReadArray(Count: Integer): TItemArray;
    137125begin
    138126  Result := FList.GetArray(FPosition, Count);
     
    211199{$DEFINE TGStreamList := TListStreamInteger}
    212200{$DEFINE TGStream := TStreamInteger}
    213 {$DEFINE TGStreamSortCompare := TStreamIntegerSortCompare}
    214 {$DEFINE TGStreamToStringConverter := TStreamIntegerToStringConverter}
    215 {$DEFINE TGStreamFromStringConverter := TStreamIntegerFromStringConverter}
    216 {$DEFINE TGStreamItemArray := TStreamIntegerItemArray}
    217201{$DEFINE IMPLEMENTATION}
    218202{$I 'GenericStream.inc'}
     
    223207{$DEFINE TGStreamList := TListStreamByte}
    224208{$DEFINE TGStream := TBaseStreamByte}
    225 {$DEFINE TGStreamSortCompare := TStreamByteSortCompare}
    226 {$DEFINE TGStreamToStringConverter := TStreamByteToStringConverter}
    227 {$DEFINE TGStreamFromStringConverter := TStreamByteFromStringConverter}
    228 {$DEFINE TGStreamItemArray := TStreamByteItemArray}
    229209{$DEFINE IMPLEMENTATION}
    230210{$I 'GenericStream.inc'}
     
    235215{$DEFINE TGStreamList := TListStreamPointer}
    236216{$DEFINE TGStream := TStreamPointer}
    237 {$DEFINE TGStreamSortCompare := TStreamPointerSortCompare}
    238 {$DEFINE TGStreamToStringConverter := TStreamPointerToStringConverter}
    239 {$DEFINE TGStreamFromStringConverter := TStreamPointerFromStringConverter}
    240 {$DEFINE TGStreamItemArray := TStreamPointerItemArray}
    241217{$DEFINE IMPLEMENTATION}
    242218{$I 'GenericStream.inc'}
  • Generics/TemplateGenerics/Specialized/SpecializedTree.pas

    r112 r426  
    1616{$DEFINE TGTreeNode := TTreeNodeInteger}
    1717{$DEFINE TGTreeNodeList := TTreeNodeListInteger}
    18 {$DEFINE TGTreeSortCompare := TTreeSortCompareInteger}
    19 {$DEFINE TGTreeToStringConverter := TTreeToStringConverterInteger}
    20 {$DEFINE TGTreeFromStringConverter := TTreeFromStringConverterInteger}
    21 {$DEFINE TGTreeItemArray := TTreeIntegerItemArray}
    2218{$DEFINE INTERFACE}
    2319{$I 'GenericTree.inc'}
     
    2925{$DEFINE TGTreeNode := TTreeNodeString}
    3026{$DEFINE TGTreeNodeList := TTreeNodeListString}
    31 {$DEFINE TGTreeSortCompare := TTreeSortCompareString}
    32 {$DEFINE TGTreeToStringConverter := TTreeToStringConverterString}
    33 {$DEFINE TGTreeFromStringConverter := TTreeFromStringConverterString}
    34 {$DEFINE TGTreeItemArray := TTreeStringItemArray}
    3527{$DEFINE INTERFACE}
    3628{$I 'GenericTree.inc'}
     
    4234{$DEFINE TGTreeNode := TTreeNodePointer}
    4335{$DEFINE TGTreeNodeList := TTreeNodeListPointer}
    44 {$DEFINE TGTreeSortCompare := TTreeSortComparePointer}
    45 {$DEFINE TGTreeToStringConverter := TTreeToStringConverterPointer}
    46 {$DEFINE TGTreeFromStringConverter := TTreeFromStringConverterPointer}
    47 {$DEFINE TGTreeItemArray := TTreePointerItemArray}
    4836{$DEFINE INTERFACE}
    4937{$I 'GenericTree.inc'}
     
    6048{$DEFINE TGTreeNode := TTreeNodeInteger}
    6149{$DEFINE TGTreeNodeList := TTreeNodeListInteger}
    62 {$DEFINE TGTreeSortCompare := TTreeSortCompareInteger}
    63 {$DEFINE TGTreeToStringConverter := TTreeToStringConverterInteger}
    64 {$DEFINE TGTreeFromStringConverter := TTreeFromStringConverterInteger}
    65 {$DEFINE TGTreeItemArray := TTreeIntegerItemArray}
    6650{$DEFINE IMPLEMENTATION}
    6751{$I 'GenericTree.inc'}
     
    7357{$DEFINE TGTreeNode := TTreeNodeString}
    7458{$DEFINE TGTreeNodeList := TTreeNodeListString}
    75 {$DEFINE TGTreeSortCompare := TTreeSortCompareString}
    76 {$DEFINE TGTreeToStringConverter := TTreeToStringConverterString}
    77 {$DEFINE TGTreeFromStringConverter := TTreeFromStringConverterString}
    78 {$DEFINE TGTreeItemArray := TTreeStringItemArray}
    7959{$DEFINE IMPLEMENTATION}
    8060{$I 'GenericTree.inc'}
     
    8666{$DEFINE TGTreeNode := TTreeNodePointer}
    8767{$DEFINE TGTreeNodeList := TTreeNodeListPointer}
    88 {$DEFINE TGTreeSortCompare := TTreeSortComparePointer}
    89 {$DEFINE TGTreeToStringConverter := TTreeToStringConverterPointer}
    90 {$DEFINE TGTreeFromStringConverter := TTreeFromStringConverterPointer}
    91 {$DEFINE TGTreeItemArray := TTreePointerItemArray}
    9268{$DEFINE IMPLEMENTATION}
    9369{$I 'GenericTree.inc'}
Note: See TracChangeset for help on using the changeset viewer.