1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
|
<?xml version="1.0" encoding="ISO-8859-1"?>
<?xml-stylesheet type="text/xsl" href="stylesheet.xsl"?>
<doc>
<title>Containers</title>
<!-- ************************************************************************* -->
<body>
<p>
Many of these containers were inspired by the work of the <a
href="http://www.cse.ohio-state.edu/~weide/rsrg/index.html">Reusable
Software Research Group</a> at Ohio State. As such, many of the objects do not support
copying in any form, only swapping is allowed. That is, when objects
are added or removed from most of these containers they are swapped in
and out, not copied.
</p>
<p>
This allows you to do things like have containers of containers of
containers without encountering the overhead of the massive copying
that would likely result if you did the same thing with the STL. It
also means you can store objects that are not copyable inside these
containers, which is not something you can do with the STL prior to C++11.
</p>
<p>
Note that it is assumed by these containers that swap() and
operator< do not throw. They may not function correctly if this
assumption is broken. Also note that the built in types (int, long,
char, etc.) and std::string will not cause operator< or swap() to
throw.
</p>
<p>
Note also that most of the containers inherit from the
<a href="#enumerable">enumerable</a> interface. Thus, all the
member functions inherited from enumerable are defined in the
enumerable class and their documentation is not repeated in each
container's documentation. This includes the size() member
function in each container.
</p>
</body>
<!-- ************************************************************************* -->
<menu width="150">
<top>
<section>
<name>Objects</name>
<item>static_set</item>
<item>any</item>
<item>any_trainer</item>
<item>any_function</item>
<item>any_decision_function</item>
<item>array</item>
<item>array2d</item>
<item>binary_search_tree</item>
<item>hash_map</item>
<item>hash_set</item>
<item>hash_table</item>
<item>directed_graph</item>
<item>graph</item>
<item>map</item>
<item>queue</item>
<item>reference_counter</item>
<item>type_safe_union</item>
<item>unordered_pair</item>
<item>sequence</item>
<item>set</item>
<item>stack</item>
<item>std_vector_c</item>
<item>static_map</item>
<item>sliding_buffer</item>
<item>circular_buffer</item>
<item>tuple</item>
<item>reference_wrapper</item>
</section>
<section>
<name>Interfaces</name>
<item>map_pair</item>
<item>enumerable</item>
<item>
<name>remover</name>
<sub>
<item>
<name>remover</name>
<link>dlib/interfaces/remover.h.html#remover</link>
</item>
<item>
<name>asc_remover</name>
<link>dlib/interfaces/remover.h.html#asc_remover</link>
</item>
<item>
<name>pair_remover</name>
<link>dlib/interfaces/remover.h.html#pair_remover</link>
</item>
<item>
<name>asc_pair_remover</name>
<link>dlib/interfaces/remover.h.html#asc_pair_remover</link>
</item>
</sub>
</item>
</section>
</top>
</menu>
<!-- ************************************************************************* -->
<!-- ************************************************************************* -->
<!-- ************************************************************************* -->
<components>
<component>
<name>array</name>
<file>dlib/array.h</file>
<spec_file>dlib/array/array_kernel_abstract.h</spec_file>
<description>
This object represents a 1-Dimensional array of objects.
</description>
</component>
<!-- ************************************************************************* -->
<component checked="true">
<name>sliding_buffer</name>
<file>dlib/sliding_buffer.h</file>
<spec_file>dlib/sliding_buffer/sliding_buffer_kernel_abstract.h</spec_file>
<description>
This object represents an array with the ability to rotate its contents
left or right. Note that the size of this object is always a power of two.
If you need arbitrary sized objects then use a <a href="#circular_buffer">circular_buffer</a>.
</description>
<implementations>
<implementation>
<name>sliding_buffer_kernel_1</name>
<file>dlib/sliding_buffer/sliding_buffer_kernel_1.h</file>
<description>
This object is implemented using a C style array in the obvious way. See the code for details.
</description>
<typedefs>
<typedef>
<name>kernel_1a</name>
<description>is a typedef for sliding_buffer_kernel_1</description>
</typedef>
</typedefs>
</implementation>
</implementations>
</component>
<!-- ************************************************************************* -->
<component>
<name>circular_buffer</name>
<file>dlib/sliding_buffer.h</file>
<spec_file>dlib/sliding_buffer/circular_buffer_abstract.h</spec_file>
<description>
This object represents a simple sliding buffer which can contain
and arbitrary number of elements.
</description>
</component>
<!-- ************************************************************************* -->
<component>
<name>array2d</name>
<file>dlib/array2d.h</file>
<spec_file>dlib/array2d/array2d_kernel_abstract.h</spec_file>
<description>
This object represents a 2-Dimensional array of objects.
</description>
<examples>
<example>image_ex.cpp.html</example>
</examples>
</component>
<!-- ************************************************************************* -->
<component checked="true">
<name>binary_search_tree</name>
<file>dlib/binary_search_tree.h</file>
<spec_file>dlib/binary_search_tree/binary_search_tree_kernel_abstract.h</spec_file>
<description>
This object represents a data dictionary that is built on top of some kind of binary search tree.
</description>
<implementations>
<implementation>
<name>binary_search_tree_kernel_1</name>
<file>dlib/binary_search_tree/binary_search_tree_kernel_1.h</file>
<description>
This implementation is done using an AVL binary search tree. It uses the
<a href="other.html#memory_manager">memory_manager</a> for all memory allocations.
</description>
<typedefs>
<typedef>
<name>kernel_1a</name>
<description>is a typedef for binary_search_tree_kernel_1</description>
</typedef>
</typedefs>
</implementation>
<implementation>
<name>binary_search_tree_kernel_2</name>
<file>dlib/binary_search_tree/binary_search_tree_kernel_2.h</file>
<description>
This implementation is done using a red-black binary search tree. It uses the
<a href="other.html#memory_manager">memory_manager</a> for all memory allocations.
</description>
<typedefs>
<typedef>
<name>kernel_2a</name>
<description>is a typedef for binary_search_tree_kernel_2</description>
</typedef>
</typedefs>
</implementation>
</implementations>
</component>
<!-- ************************************************************************* -->
<component checked="true">
<name>hash_map</name>
<file>dlib/hash_map.h</file>
<spec_file>dlib/hash_map/hash_map_kernel_abstract.h</spec_file>
<description>
This object represents a hashed mapping of items of type domain onto items of type range.
</description>
<implementations>
<implementation>
<name>hash_map_kernel_1</name>
<file>dlib/hash_map/hash_map_kernel_1.h</file>
<description>
This implementation is done using a <a href="#hash_table">hash_table</a> object. It uses the
<a href="other.html#memory_manager">memory_manager</a> for all memory allocations.
</description>
<typedefs>
<typedef>
<name>kernel_1a</name>
<description>is a typedef for hash_map_kernel_1 that uses hash_table_kernel_1a</description>
</typedef>
<typedef>
<name>kernel_1b</name>
<description>is a typedef for hash_map_kernel_1 that uses hash_table_kernel_2a</description>
</typedef>
<typedef>
<name>kernel_1c</name>
<description>is a typedef for hash_map_kernel_1 that uses hash_table_kernel_2b</description>
</typedef>
</typedefs>
</implementation>
</implementations>
</component>
<!-- ************************************************************************* -->
<component checked="true">
<name>hash_set</name>
<file>dlib/hash_set.h</file>
<spec_file>dlib/hash_set/hash_set_kernel_abstract.h</spec_file>
<description>
This object represents a hashed unordered and unaddressed collection of unique items.
</description>
<implementations>
<implementation>
<name>hash_set_kernel_1</name>
<file>dlib/hash_set/hash_set_kernel_1.h</file>
<description>
This implementation is done using a <a href="#hash_table">hash_table</a> object. It uses the
<a href="other.html#memory_manager">memory_manager</a> for all memory allocations.
</description>
<typedefs>
<typedef>
<name>kernel_1a</name>
<description>is a typedef for hash_set_kernel_1 that uses hash_table_kernel_1a</description>
</typedef>
<typedef>
<name>kernel_1b</name>
<description>is a typedef for hash_set_kernel_1 that uses hash_table_kernel_2a</description>
</typedef>
<typedef>
<name>kernel_1c</name>
<description>is a typedef for hash_set_kernel_1 that uses hash_table_kernel_2b</description>
</typedef>
</typedefs>
</implementation>
</implementations>
</component>
<!-- ************************************************************************* -->
<component checked="true">
<name>hash_table</name>
<file>dlib/hash_table.h</file>
<spec_file>dlib/hash_table/hash_table_kernel_abstract.h</spec_file>
<description>
This object represents a data dictionary that is built on top of some kind of
hash table.
</description>
<implementations>
<implementation>
<name>hash_table_kernel_1</name>
<file>dlib/hash_table/hash_table_kernel_1.h</file>
<description>
This implementation is done using singly linked lists as hashing buckets. It uses the
<a href="other.html#memory_manager">memory_manager</a> for all memory allocations.
</description>
<typedefs>
<typedef>
<name>kernel_1a</name>
<description>is a typedef for hash_table_kernel_1. </description>
</typedef>
</typedefs>
</implementation>
<implementation>
<name>hash_table_kernel_2</name>
<file>dlib/hash_table/hash_table_kernel_2.h</file>
<description>
This implementation is done using <a href="#binary_search_tree">
binary_search_tree</a> objects as hashing buckets. It uses the
<a href="other.html#memory_manager">memory_manager</a> for all memory allocations.
</description>
<typedefs>
<typedef>
<name>kernel_2a</name>
<description>is a typedef for hash_table_kernel_2 that uses binary_search_tree_kernel_1</description>
</typedef>
<typedef>
<name>kernel_2b</name>
<description>is a typedef for hash_table_kernel_2 that uses binary_search_tree_kernel_2</description>
</typedef>
</typedefs>
</implementation>
</implementations>
</component>
<!-- ************************************************************************* -->
<component checked="true">
<name>map</name>
<file>dlib/map.h</file>
<spec_file>dlib/map/map_kernel_abstract.h</spec_file>
<description>
This object represents a mapping of items of type domain onto items of type range.
</description>
<implementations>
<implementation>
<name>map_kernel_1</name>
<file>dlib/map/map_kernel_1.h</file>
<description>
This is implemented using the <a href="#binary_search_tree">binary_search_tree</a> component. It uses the
<a href="other.html#memory_manager">memory_manager</a> for all memory allocations.
</description>
<typedefs>
<typedef>
<name>kernel_1a</name>
<description>is a typedef for map_kernel_1 that uses binary_search_tree_kernel_1</description>
</typedef>
<typedef>
<name>kernel_1b</name>
<description>is a typedef for map_kernel_1 that uses binary_search_tree_kernel_2</description>
</typedef>
</typedefs>
</implementation>
</implementations>
</component>
<!-- ************************************************************************* -->
<component>
<name>enumerable</name>
<file>dlib/interfaces/enumerable.h</file>
<spec_file>dlib/interfaces/enumerable.h</spec_file>
<description>
This object is an abstract class which represents an interface for iterating over
all the elements of a container.
</description>
</component>
<!-- ************************************************************************* -->
<component>
<name>map_pair</name>
<file>dlib/interfaces/map_pair.h</file>
<spec_file>dlib/interfaces/map_pair.h</spec_file>
<description>
This object is an abstract class which represents an interface for accessing a
pair from a container such as the map, hash_table, etc.
</description>
</component>
<!-- ************************************************************************* -->
<component>
<name>remover</name>
<file>dlib/interfaces/remover.h</file>
<spec_file>dlib/interfaces/remover.h</spec_file>
<description>
This is a set of interfaces which gives the ability to remove all the items in a
container without actually knowing what kind of container contains them.
</description>
</component>
<!-- ************************************************************************* -->
<component>
<name>type_safe_union</name>
<file>dlib/type_safe_union.h</file>
<spec_file link="true">dlib/type_safe_union/type_safe_union_kernel_abstract.h</spec_file>
<description>
This object is a type safe analogue of the classic C union object.
The type_safe_union, unlike a union, can contain non-POD types such
as std::string.
<p>It is also implemented without performing any
heap memory allocations and instead it stores everything on the stack.</p>
</description>
<examples>
<example>pipe_ex_2.cpp.html</example>
<example>bridge_ex.cpp.html</example>
</examples>
</component>
<!-- ************************************************************************* -->
<component>
<name>unordered_pair</name>
<file>dlib/unordered_pair.h</file>
<spec_file link="true">dlib/unordered_pair.h</spec_file>
<description>
This object is very similar to the std::pair struct except unordered_pair
is only capable of representing an unordered set of two items rather than
an ordered list of two items like std::pair.
</description>
</component>
<!-- ************************************************************************* -->
<component>
<name>any</name>
<file>dlib/any.h</file>
<spec_file link="true">dlib/any/any_abstract.h</spec_file>
<description>
This object is basically a type-safe version of a void*. In particular,
it is a container which can contain only one object but the object may
be of any type.
<p>
It is somewhat like the <a href="#type_safe_union">type_safe_union</a> except you don't have to declare
the set of possible content types beforehand. So in some sense this is
like a less type-strict version of the type_safe_union.
</p>
</description>
</component>
<!-- ************************************************************************* -->
<component>
<name>any_decision_function</name>
<file>dlib/any.h</file>
<spec_file link="true">dlib/any/any_decision_function_abstract.h</spec_file>
<description>
This object is a version of dlib::<a href="#any">any</a> that is restricted to containing
elements which are some kind of function object with an operator() with
the following signature:
<tt>result_type operator()(const sample_type&) const</tt>
<p>
It is intended to be used to contain dlib::<a href="ml.html#decision_function">decision_function</a>
objects and other types which represent learned decision functions. It allows you
to write code which contains and processes these decision functions
without needing to know the specific types of decision functions used.
</p>
</description>
</component>
<!-- ************************************************************************* -->
<component>
<name>any_function</name>
<file>dlib/any.h</file>
<spec_file link="true">dlib/any/any_function_abstract.h</spec_file>
<description>
This object is a version of dlib::<a href="#any">any</a> that is restricted to containing
elements which are some kind of function or function object.
</description>
</component>
<!-- ************************************************************************* -->
<component>
<name>any_trainer</name>
<file>dlib/any.h</file>
<spec_file link="true">dlib/any/any_trainer_abstract.h</spec_file>
<description>
This object is a version of dlib::<a href="#any">any</a> that is restricted to containing
elements which are some kind of object with a .train() method compatible
with the following signature:
<pre> decision_function train(
const std::vector<sample_type>& samples,
const std::vector<scalar_type>& labels
) const
</pre>
Where <tt>decision_function</tt> is a type capable of being stored in an
<a href="#any_decision_function">any_decision_function</a> object.
<p>
any_trainer is intended to be used to contain objects such as the <a href="ml.html#svm_nu_trainer">svm_nu_trainer</a>
and other similar types which represent supervised machine learning algorithms.
It allows you to write code which contains and processes these trainer objects
without needing to know the specific types of trainer objects used.
</p>
</description>
</component>
<!-- ************************************************************************* -->
<component>
<name>tuple</name>
<file>dlib/tuple.h</file>
<spec_file>dlib/tuple/tuple_abstract.h</spec_file>
<description>
This is an implementation of a very simple templated container object.
It contains between 0 and 31 objects where each object is listed
explicitly in the tuple's template arguments.
<p>
Note that there is only one implementation of this object so there aren't any
different kernels to choose from when you create instances of the tuple object.
So for example, you
could declare a tuple of 3 ints using the following statement:
<tt>dlib::tuple<int,int,int> t;</tt>
</p>
</description>
</component>
<!-- ************************************************************************* -->
<component>
<name>reference_wrapper</name>
<file>dlib/ref.h</file>
<spec_file>dlib/ref.h</spec_file>
<description>
This is a simple object that just holds a reference to another object.
It is useful because it can serve as a kind of "copyable reference".
</description>
<examples>
<example>thread_function_ex.cpp.html</example>
</examples>
</component>
<!-- ************************************************************************* -->
<component checked="true">
<name>graph</name>
<file>dlib/graph.h</file>
<spec_file>dlib/graph/graph_kernel_abstract.h</spec_file>
<description>
This object represents a graph which is a set of nodes with undirected
edges connecting various nodes.
</description>
<implementations>
<implementation>
<name>graph_kernel_1</name>
<file>dlib/graph/graph_kernel_1.h</file>
<description>
This is implemented using std::vector to contain all the nodes and edges.
</description>
<typedefs>
<typedef>
<name>kernel_1a</name>
<description>is a typedef for graph_kernel_1</description>
</typedef>
</typedefs>
</implementation>
</implementations>
</component>
<!-- ************************************************************************* -->
<component checked="true">
<name>directed_graph</name>
<file>dlib/directed_graph.h</file>
<spec_file>dlib/directed_graph/directed_graph_kernel_abstract.h</spec_file>
<description>
This object represents a directed graph which is a set of nodes with directed
edges connecting various nodes.
</description>
<implementations>
<implementation>
<name>directed_graph_kernel_1</name>
<file>dlib/directed_graph/directed_graph_kernel_1.h</file>
<description>
This is implemented using std::vector to contain all the nodes and edges.
</description>
<typedefs>
<typedef>
<name>kernel_1a</name>
<description>is a typedef for directed_graph_kernel_1</description>
</typedef>
</typedefs>
</implementation>
</implementations>
</component>
<!-- ************************************************************************* -->
<component checked="true">
<name>queue</name>
<file>dlib/queue.h</file>
<spec_file>dlib/queue/queue_kernel_abstract.h</spec_file>
<description>
This object represents a first in first out queue.
</description>
<examples>
<example>queue_ex.cpp.html</example>
</examples>
<implementations>
<implementation>
<name>queue_kernel_1</name>
<file>dlib/queue/queue_kernel_1.h</file>
<description>
This is implemented in the obvious way using a singly linked list. It does not use the
<a href="other.html#memory_manager">memory_manager</a> at all.
</description>
<typedefs>
<typedef>
<name>kernel_1a</name>
<description>is a typedef for queue_kernel_1</description>
</typedef>
</typedefs>
</implementation>
<implementation>
<name>queue_kernel_2</name>
<file>dlib/queue/queue_kernel_2.h</file>
<description>
This is implemented using a singly linked list and each node in the list
contains block_size (a template parameter) elements. It uses the
<a href="other.html#memory_manager">memory_manager</a> for all memory allocations.
</description>
<typedefs>
<typedef>
<name>kernel_2a</name>
<description>is a typedef for queue_kernel_2 with a block_size of 20</description>
</typedef>
<typedef>
<name>kernel_2b</name>
<description>is a typedef for queue_kernel_2 with a block_size of 100</description>
</typedef>
</typedefs>
</implementation>
</implementations>
<extensions>
<extension>
<name>queue_sort</name>
<spec_file>dlib/queue/queue_sort_abstract.h</spec_file>
<description>
This extension gives a queue the ability to sort its contents.
</description>
<implementations>
<implementation>
<name>queue_sort_1</name>
<file>dlib/queue/queue_sort_1.h</file>
<description>
This is a version of the QuickSort algorithm.
</description>
<typedefs>
<typedef>
<name>sort_1a</name>
<description>is a typedef for queue_kernel_1a extended by queue_sort_1</description>
</typedef>
<typedef>
<name>sort_1b</name>
<description>is a typedef for queue_kernel_2a extended by queue_sort_1</description>
</typedef>
<typedef>
<name>sort_1c</name>
<description>is a typedef for queue_kernel_2b extended by queue_sort_1</description>
</typedef>
</typedefs>
</implementation>
</implementations>
</extension>
</extensions>
</component>
<!-- ************************************************************************* -->
<component>
<name>reference_counter</name>
<file>dlib/reference_counter.h</file>
<spec_file>dlib/reference_counter/reference_counter_kernel_abstract.h</spec_file>
<description>
This object represents a container for an object and provides reference counting
capabilities for the object it contains.
</description>
<implementations>
<implementation>
<name>reference_counter_kernel_1</name>
<file>dlib/reference_counter/reference_counter_kernel_1.h</file>
<description>
This implementation is done using pointers in the obvious way.
</description>
<typedefs>
<typedef>
<name>kernel_1a</name>
<description>is a typedef for reference_counter_kernel_1</description>
</typedef>
</typedefs>
</implementation>
</implementations>
</component>
<!-- ************************************************************************* -->
<component checked="true">
<name>sequence</name>
<file>dlib/sequence.h</file>
<spec_file>dlib/sequence/sequence_kernel_abstract.h</spec_file>
<description>
This object represents an ordered sequence of items, each item is
associated with an integer value. The items are numbered from 0 to the number of items in the
sequence minus 1.
</description>
<implementations>
<implementation>
<name>sequence_kernel_1</name>
<file>dlib/sequence/sequence_kernel_1.h</file>
<description>
This is implemented as an AVL binary search tree.
Accessing(or adding or removing) an element always takes O(log n) time.
It uses the <a href="other.html#memory_manager">memory_manager</a> for all memory allocations.
</description>
<typedefs>
<typedef>
<name>kernel_1a</name>
<description>is a typedef for sequence_kernel_1</description>
</typedef>
</typedefs>
</implementation>
<implementation>
<name>sequence_kernel_2</name>
<file>dlib/sequence/sequence_kernel_2.h</file>
<description>
This implementation is done using a doubly linked list in the shape of a ring.
It will remember the last element accessed(or added or removed) and give O(1)
access time to the elements just left and right of it. Aside from that,
accessing(or adding or removing) a random element will take O(n) and in the worst
case it will take time proportional to the size of the sequence/2.
<p>
It does not use the
<a href="other.html#memory_manager">memory_manager</a> at all.
</p>
</description>
<typedefs>
<typedef>
<name>kernel_2a</name>
<description>is a typedef for sequence_kernel_2</description>
</typedef>
</typedefs>
</implementation>
</implementations>
<extensions>
<extension>
<name>sequence_sort</name>
<spec_file>dlib/sequence/sequence_sort_abstract.h</spec_file>
<description>
This extension gives a sequence the ability to sort its contents.
</description>
<implementations>
<implementation>
<name>sequence_sort_1</name>
<file>dlib/sequence/sequence_sort_1.h</file>
<description>
This is a version of the QuickSort algorithm and it sorts sequences of less
than 30 elements with a selection sort. This implementation is fastest when
used with sequence_kernel_2 and fairly slow when used with sequence_kernel_1
</description>
<typedefs>
<typedef>
<name>sort_1a</name>
<description>is a typedef for sequence_kernel_2a extended by sequence_sort_1</description>
</typedef>
</typedefs>
</implementation>
<implementation>
<name>sequence_sort_2</name>
<file>dlib/sequence/sequence_sort_2.h</file>
<description>
This is a version of the QuickSort algorithm. This implementation of sort is
the best to use with sequence_kernel_1 objects but gives extremely poor performance
with sequence_kernel_2 objects.
</description>
<typedefs>
<typedef>
<name>sort_2a</name>
<description>is a typedef for sequence_kernel_1a extended by sequence_sort_2</description>
</typedef>
</typedefs>
</implementation>
</implementations>
</extension>
<extension>
<name>sequence_compare</name>
<spec_file>dlib/sequence/sequence_compare_abstract.h</spec_file>
<description>
This extension gives sequences the ability to compare themselves using
operator< and operator==. Thus they can be used in the other container classes
that require this ability. (maps, sets, etc.)
</description>
<implementations>
<implementation>
<name>sequence_compare_1</name>
<file>dlib/sequence/sequence_compare_1.h</file>
<description>
The implementation is obvious. Click on the sequence_compare_1 link if you want to see.
</description>
<typedefs>
<typedef>
<name>compare_1a</name>
<description>is a typedef for sequence_kernel_1a extended by sequence_compare_1</description>
</typedef>
<typedef>
<name>compare_1b</name>
<description>is a typedef for sequence_kernel_2a extended by sequence_compare_1</description>
</typedef>
</typedefs>
</implementation>
</implementations>
</extension>
</extensions>
</component>
<!-- ************************************************************************* -->
<component checked="true">
<name>set</name>
<file>dlib/set.h</file>
<spec_file>dlib/set/set_kernel_abstract.h</spec_file>
<description>
This object represents an unordered and unaddressed collection of unique items.
</description>
<implementations>
<implementation>
<name>set_kernel_1</name>
<file>dlib/set/set_kernel_1.h</file>
<description>
This is implemented using the <a href="#binary_search_tree">binary_search_tree</a> component. It uses the
<a href="other.html#memory_manager">memory_manager</a> for all memory allocations.
</description>
<typedefs>
<typedef>
<name>kernel_1a</name>
<description>is a typedef for set_kernel_1 that uses binary_search_tree_kernel_1</description>
</typedef>
<typedef>
<name>kernel_1b</name>
<description>is a typedef for set_kernel_1 that uses binary_search_tree_kernel_2</description>
</typedef>
</typedefs>
</implementation>
</implementations>
<extensions>
<extension>
<name>set_compare</name>
<spec_file>dlib/set/set_compare_abstract.h</spec_file>
<description>
This extension gives sets the ability to compare themselves using operator< and
operator==. Thus they can be used in the other container classes that require
this ability. (maps, sets, etc.)
</description>
<implementations>
<implementation>
<name>set_compare_1</name>
<file>dlib/set/set_compare_1.h</file>
<description>
The implementation is obvious. Click on the set_compare_1 link if you want to see.
</description>
<typedefs>
<typedef>
<name>compare_1a</name>
<description>is a typedef for set_kernel_1a extended by set_compare_1</description>
</typedef>
<typedef>
<name>compare_1b</name>
<description>is a typedef for set_kernel_1b extended by set_compare_1</description>
</typedef>
</typedefs>
</implementation>
</implementations>
</extension>
</extensions>
</component>
<!-- ************************************************************************* -->
<component checked="true">
<name>stack</name>
<file>dlib/stack.h</file>
<spec_file>dlib/stack/stack_kernel_abstract.h</spec_file>
<description>
This object represents a last in first out stack.
</description>
<implementations>
<implementation>
<name>stack_kernel_1</name>
<file>dlib/stack/stack_kernel_1.h</file>
<description>
This implementation is done in the obvious way using a singly linked list. It uses the
<a href="other.html#memory_manager">memory_manager</a> for all memory allocations.
</description>
<typedefs>
<typedef>
<name>kernel_1a</name>
<description>is a typedef for stack_kernel_1</description>
</typedef>
</typedefs>
</implementation>
</implementations>
</component>
<!-- ************************************************************************* -->
<component checked="true">
<name>static_map</name>
<file>dlib/static_map.h</file>
<spec_file>dlib/static_map/static_map_kernel_abstract.h</spec_file>
<description>
This object represents a mapping of items of type domain onto items of type range.
The difference between this object and the normal <a href="#map">map</a> object is that it does not support adding
or removing individual objects from itself. This allows implementations to focus on using less memory and
achieving faster searching.
</description>
<implementations>
<implementation>
<name>static_map_kernel_1</name>
<file>dlib/static_map/static_map_kernel_1.h</file>
<description>
This implementation is just a sorted array which can be searched using a binary search.
</description>
<typedefs>
<typedef>
<name>kernel_1a</name>
<description>is a typedef for static_map_kernel_1</description>
</typedef>
</typedefs>
</implementation>
</implementations>
</component>
<!-- ************************************************************************* -->
<component checked="true">
<name>static_set</name>
<file>dlib/static_set.h</file>
<spec_file>dlib/static_set/static_set_kernel_abstract.h</spec_file>
<description>
This object represents an unordered and unaddressed collection of items.
The difference between this object and the normal <a href="#set">set</a> object is that it does not support adding
or removing individual objects from itself. This allows implementations to focus on using less memory and
achieving faster searching.
</description>
<implementations>
<implementation>
<name>static_set_kernel_1</name>
<file>dlib/static_set/static_set_kernel_1.h</file>
<description>
This implementation is just a sorted array which can be searched using a binary search.
</description>
<typedefs>
<typedef>
<name>kernel_1a</name>
<description>is a typedef for static_set_kernel_1</description>
</typedef>
</typedefs>
</implementation>
</implementations>
<extensions>
<extension>
<name>static_set_compare</name>
<spec_file>dlib/static_set/static_set_compare_abstract.h</spec_file>
<description>
This extension gives static_sets the ability to compare themselves using operator< and
operator==. Thus they can be used in the other container classes that require
this ability. (maps, static_sets, etc.)
</description>
<implementations>
<implementation>
<name>static_set_compare_1</name>
<file>dlib/static_set/static_set_compare_1.h</file>
<description>
The implementation is obvious. Click on the static_set_compare_1 link if you want to see.
</description>
<typedefs>
<typedef>
<name>compare_1a</name>
<description>is a typedef for static_set_kernel_1a extended by static_set_compare_1</description>
</typedef>
</typedefs>
</implementation>
</implementations>
</extension>
</extensions>
</component>
<!-- ************************************************************************* -->
<component>
<name>std_vector_c</name>
<file>dlib/stl_checked.h</file>
<spec_file link="true">dlib/stl_checked/std_vector_c_abstract.h</spec_file>
<description>
This object is a simple wrapper around the std::vector object. It
provides an identical interface but also checks the preconditions of
each member function. That is, if you violate a requires
clause the dlib::fatal_error exception is thrown.
</description>
</component>
<!-- ************************************************************************* -->
</components>
<!-- ************************************************************************* -->
</doc>
|
