-
Notifications
You must be signed in to change notification settings - Fork 0
/
rapidxml.cs
2576 lines (2299 loc) · 131 KB
/
rapidxml.cs
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
//namespace rapidxml
//{
// //! Parse error exception.
// //! This exception is thrown by the parser when an error occurs.
// //! Use what() function to get human-readable error message.
// //! Use where() function to get a pointer to position within source text where error was detected.
// //! <br><br>
// //! If throwing exceptions by the parser is undesirable,
// //! it can be disabled by defining RAPIDXML_NO_EXCEPTIONS macro before rapidxml.hpp is included.
// //! This will cause the parser to call rapidxml::parse_error_handler() function instead of throwing an exception.
// //! This function must be defined by the user.
// //! <br><br>
// //! This class derives from <code>std::exception</code> class.
// public class parse_error: std.exception
// {
// //! Constructs parse error
// public parse_error(string what, IntPtr @where)
// {
// m_what = what;
// m_where = @where;
// }
// //! Gets human readable description of error.
// //! \return Pointer to null terminated description of the error.
////C++ TO C# CONVERTER WARNING: Throw clauses are not available in C#:
////ORIGINAL LINE: virtual string what() const throw()
// public virtual string what() const
// {
// return m_what;
// }
// //! Gets pointer to character data where error happened.
// //! Ch should be the same as char type of xml_document that produced the error.
// //! \return Pointer to location within the parsed string where error occured.
////C++ TO C# CONVERTER TODO TASK: The original C++ template specifier was replaced with a C# generic specifier, which may not produce the same behavior:
////ORIGINAL LINE: template<class Ch>
////
////ORIGINAL LINE: Ch *where() const
// public Ch where<Ch>()
// {
////C++ TO C# CONVERTER TODO TASK: There is no equivalent to 'reinterpret_cast' in C#:
// return reinterpret_cast<Ch *>(m_where);
// }
// private string m_what;
// private IntPtr m_where;
// }
//}
//#endif
//namespace rapidxml
//{
// //! When exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS,
// //! this function is called to notify user about the error.
// //! It must be defined by the user.
// //! <br><br>
// //! This function cannot return. If it does, the results are undefined.
// //! <br><br>
// //! A very simple definition might look like that:
// //! <pre>
// //! void %rapidxml::%parse_error_handler(const char *what, void *where)
// //! {
// //! std::cout << "Parse error: " << what << "\n";
// //! std::abort();
// //! }
// //! </pre>
// //! \param what Human readable description of the error.
// //! \param where Pointer to character data where error was detected.
////C++ TO C# CONVERTER TODO TASK: The implementation of the following method could not be found:
// // void parse_error_handler(string what, IntPtr where);
// ///////////////////////////////////////////////////////////////////////
// // Parsing flags
// //! Parse flag instructing the parser to not create data nodes.
// //! Text of first data node will still be placed in value of parent element, unless rapidxml::parse_no_element_values flag is also specified.
// //! Can be combined with other flags by use of | operator.
// //! <br><br>
// //! See xml_document::parse() function.
// public const int parse_no_data_nodes = 0x1;
// //! Parse flag instructing the parser to not use text of first data node as a value of parent element.
// //! Can be combined with other flags by use of | operator.
// //! Note that child data nodes of element node take precendence over its value when printing.
// //! That is, if element has one or more child data nodes <em>and</em> a value, the value will be ignored.
// //! Use rapidxml::parse_no_data_nodes flag to prevent creation of data nodes if you want to manipulate data using values of elements.
// //! <br><br>
// //! See xml_document::parse() function.
// public const int parse_no_element_values = 0x2;
// //! Parse flag instructing the parser to not place zero terminators after strings in the source text.
// //! By default zero terminators are placed, modifying source text.
// //! Can be combined with other flags by use of | operator.
// //! <br><br>
// //! See xml_document::parse() function.
// public const int parse_no_string_terminators = 0x4;
// //! Parse flag instructing the parser to not translate entities in the source text.
// //! By default entities are translated, modifying source text.
// //! Can be combined with other flags by use of | operator.
// //! <br><br>
// //! See xml_document::parse() function.
// public const int parse_no_entity_translation = 0x8;
// //! Parse flag instructing the parser to disable UTF-8 handling and assume plain 8 bit characters.
// //! By default, UTF-8 handling is enabled.
// //! Can be combined with other flags by use of | operator.
// //! <br><br>
// //! See xml_document::parse() function.
// public const int parse_no_utf8 = 0x10;
// //! Parse flag instructing the parser to create XML declaration node.
// //! By default, declaration node is not created.
// //! Can be combined with other flags by use of | operator.
// //! <br><br>
// //! See xml_document::parse() function.
// public const int parse_declaration_node = 0x20;
// //! Parse flag instructing the parser to create comments nodes.
// //! By default, comment nodes are not created.
// //! Can be combined with other flags by use of | operator.
// //! <br><br>
// //! See xml_document::parse() function.
// public const int parse_comment_nodes = 0x40;
// //! Parse flag instructing the parser to create DOCTYPE node.
// //! By default, doctype node is not created.
// //! Although W3C specification allows at most one DOCTYPE node, RapidXml will silently accept documents with more than one.
// //! Can be combined with other flags by use of | operator.
// //! <br><br>
// //! See xml_document::parse() function.
// public const int parse_doctype_node = 0x80;
// //! Parse flag instructing the parser to create PI nodes.
// //! By default, PI nodes are not created.
// //! Can be combined with other flags by use of | operator.
// //! <br><br>
// //! See xml_document::parse() function.
// public const int parse_pi_nodes = 0x100;
// //! Parse flag instructing the parser to validate closing tag names.
// //! If not set, name inside closing tag is irrelevant to the parser.
// //! By default, closing tags are not validated.
// //! Can be combined with other flags by use of | operator.
// //! <br><br>
// //! See xml_document::parse() function.
// public const int parse_validate_closing_tags = 0x200;
// //! Parse flag instructing the parser to trim all leading and trailing whitespace of data nodes.
// //! By default, whitespace is not trimmed.
// //! This flag does not cause the parser to modify source text.
// //! Can be combined with other flags by use of | operator.
// //! <br><br>
// //! See xml_document::parse() function.
// public const int parse_trim_whitespace = 0x400;
// //! Parse flag instructing the parser to condense all whitespace runs of data nodes to a single space character.
// //! Trimming of leading and trailing whitespace of data is controlled by rapidxml::parse_trim_whitespace flag.
// //! By default, whitespace is not normalized.
// //! If this flag is specified, source text will be modified.
// //! Can be combined with other flags by use of | operator.
// //! <br><br>
// //! See xml_document::parse() function.
// public const int parse_normalize_whitespace = 0x800;
// // Compound flags
// //! Parse flags which represent default behaviour of the parser.
// //! This is always equal to 0, so that all other flags can be simply ored together.
// //! Normally there is no need to inconveniently disable flags by anding with their negated (~) values.
// //! This also means that meaning of each flag is a <i>negation</i> of the default setting.
// //! For example, if flag name is rapidxml::parse_no_utf8, it means that utf-8 is <i>enabled</i> by default,
// //! and using the flag will disable it.
// //! <br><br>
// //! See xml_document::parse() function.
// public const int parse_default = 0;
// //! A combination of parse flags that forbids any modifications of the source text.
// //! This also results in faster parsing. However, note that the following will occur:
// //! <ul>
// //! <li>names and values of nodes will not be zero terminated, you have to use xml_base::name_size() and xml_base::value_size() functions to determine where name and value ends</li>
// //! <li>entities will not be translated</li>
// //! <li>whitespace will not be normalized</li>
// //! </ul>
// //! See xml_document::parse() function.
// public const int parse_non_destructive = parse_no_string_terminators | parse_no_entity_translation;
// //! A combination of parse flags resulting in fastest possible parsing, without sacrificing important data.
// //! <br><br>
// //! See xml_document::parse() function.
// public const int parse_fastest = parse_non_destructive | parse_no_data_nodes;
// //! A combination of parse flags resulting in largest amount of data being extracted.
// //! This usually results in slowest parsing.
// //! <br><br>
// //! See xml_document::parse() function.
// public const int parse_full = parse_declaration_node | parse_comment_nodes | parse_doctype_node | parse_pi_nodes | parse_validate_closing_tags;
// // Find length of the string
// public static std.int measure<Ch>(Ch p)
// {
////C++ TO C# CONVERTER TODO TASK: Pointer arithmetic is detected on this variable, so pointers on this variable are left unchanged.
// const Ch *tmp = p;
// while (*tmp)
// ++tmp;
// return tmp - p;
// }
////C++ TO C# CONVERTER TODO TASK: The original C++ template specifier was replaced with a C# generic specifier, which may not produce the same behavior:
////ORIGINAL LINE: template<class Ch>
// // Compare strings for equality
// public static bool compare<Ch>(Ch p1, std.int size1, Ch p2, std.int size2, bool case_sensitive)
// {
// if (size1 != size2)
// return false;
// if (case_sensitive)
// {
// for (const Ch end = p1 + size1; p1 < end; ++p1, ++p2)
// if ( p1 != p2)
// return false;
// }
// else
// {
// for (const Ch end = p1 + size1; p1 < end; ++p1, ++p2)
// if (lookup_tables<0>.lookup_upcase[(byte)( p1)] != lookup_tables<0>.lookup_upcase[(byte)( p2)])
// return false;
// }
// return true;
// }
// // Whitespace (space \n \r \t)
// public static readonly byte[] lookup_tables<Dummy>.lookup_whitespace = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
////C++ TO C# CONVERTER TODO TASK: C++ template specifiers with non-type parameters cannot be converted to C#:
////ORIGINAL LINE: template<int Dummy>
// // 0 1 2 3 4 5 6 7 8 9 A B C D E F
// // Node name (anything but space \n \r \t / > ? \0)
// public static readonly byte[] lookup_tables<Dummy>.lookup_node_name = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
////C++ TO C# CONVERTER TODO TASK: C++ template specifiers with non-type parameters cannot be converted to C#:
////ORIGINAL LINE: template<int Dummy>
// // 0 1 2 3 4 5 6 7 8 9 A B C D E F
// // Text (i.e. PCDATA) (anything but < \0)
// public static readonly byte[] lookup_tables<Dummy>.lookup_text = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
////C++ TO C# CONVERTER TODO TASK: C++ template specifiers with non-type parameters cannot be converted to C#:
////ORIGINAL LINE: template<int Dummy>
// // 0 1 2 3 4 5 6 7 8 9 A B C D E F
// // Text (i.e. PCDATA) that does not require processing when ws normalization is disabled
// // (anything but < \0 &)
// public static readonly byte[] lookup_tables<Dummy>.lookup_text_pure_no_ws = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
////C++ TO C# CONVERTER TODO TASK: C++ template specifiers with non-type parameters cannot be converted to C#:
////ORIGINAL LINE: template<int Dummy>
// // 0 1 2 3 4 5 6 7 8 9 A B C D E F
// // Text (i.e. PCDATA) that does not require processing when ws normalizationis is enabled
// // (anything but < \0 & space \n \r \t)
// public static readonly byte[] lookup_tables<Dummy>.lookup_text_pure_with_ws = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
////C++ TO C# CONVERTER TODO TASK: C++ template specifiers with non-type parameters cannot be converted to C#:
////ORIGINAL LINE: template<int Dummy>
// // 0 1 2 3 4 5 6 7 8 9 A B C D E F
// // Attribute name (anything but space \n \r \t / < > = ? ! \0)
// public static readonly byte[] lookup_tables<Dummy>.lookup_attribute_name = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
////C++ TO C# CONVERTER TODO TASK: C++ template specifiers with non-type parameters cannot be converted to C#:
////ORIGINAL LINE: template<int Dummy>
// // 0 1 2 3 4 5 6 7 8 9 A B C D E F
// // Attribute data with single quote (anything but ' \0)
// public static readonly byte[] lookup_tables<Dummy>.lookup_attribute_data_1 = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
////C++ TO C# CONVERTER TODO TASK: C++ template specifiers with non-type parameters cannot be converted to C#:
////ORIGINAL LINE: template<int Dummy>
// // 0 1 2 3 4 5 6 7 8 9 A B C D E F
// // Attribute data with single quote that does not require processing (anything but ' \0 &)
// public static readonly byte[] lookup_tables<Dummy>.lookup_attribute_data_1_pure = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
////C++ TO C# CONVERTER TODO TASK: C++ template specifiers with non-type parameters cannot be converted to C#:
////ORIGINAL LINE: template<int Dummy>
// // 0 1 2 3 4 5 6 7 8 9 A B C D E F
// // Attribute data with double quote (anything but " \0)
// public static readonly byte[] lookup_tables<Dummy>.lookup_attribute_data_2 = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
////C++ TO C# CONVERTER TODO TASK: C++ template specifiers with non-type parameters cannot be converted to C#:
////ORIGINAL LINE: template<int Dummy>
// // 0 1 2 3 4 5 6 7 8 9 A B C D E F
// // Attribute data with double quote that does not require processing (anything but " \0 &)
// public static readonly byte[] lookup_tables<Dummy>.lookup_attribute_data_2_pure = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
////C++ TO C# CONVERTER TODO TASK: C++ template specifiers with non-type parameters cannot be converted to C#:
////ORIGINAL LINE: template<int Dummy>
// // 0 1 2 3 4 5 6 7 8 9 A B C D E F
// // Digits (dec and hex, 255 denotes end of numeric character reference)
// public static readonly byte[] lookup_tables<Dummy>.lookup_digits = { 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,255,255,255,255,255,255, 255, 10, 11, 12, 13, 14, 15,255,255,255,255,255,255,255,255,255, 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 255, 10, 11, 12, 13, 14, 15,255,255,255,255,255,255,255,255,255, 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255 };
////C++ TO C# CONVERTER TODO TASK: C++ template specifiers with non-type parameters cannot be converted to C#:
////ORIGINAL LINE: template<int Dummy>
// // 0 1 2 3 4 5 6 7 8 9 A B C D E F
// // Upper case conversion
// public static readonly byte[] lookup_tables<Dummy>.lookup_upcase = { 0, 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, 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, 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 };
////C++ TO C# CONVERTER TODO TASK: The original C++ template specifier was replaced with a C# generic specifier, which may not produce the same behavior:
////ORIGINAL LINE: template<class Ch>
// // Forward declarations
////C++ TO C# CONVERTER NOTE: C# has no need of forward class declarations:
//// class xml_node;
////C++ TO C# CONVERTER TODO TASK: The original C++ template specifier was replaced with a C# generic specifier, which may not produce the same behavior:
////ORIGINAL LINE: template<class Ch>
////C++ TO C# CONVERTER NOTE: C# has no need of forward class declarations:
//// class xml_attribute;
////C++ TO C# CONVERTER TODO TASK: The original C++ template specifier was replaced with a C# generic specifier, which may not produce the same behavior:
////ORIGINAL LINE: template<class Ch>
////C++ TO C# CONVERTER NOTE: C# has no need of forward class declarations:
//// class xml_document;
// //! Enumeration listing all node types produced by the parser.
// //! Use xml_node::type() function to query node type.
// public enum node_type: int
// {
// node_document, //!< A document node. Name and value are empty.
// node_element, //!< An element node. Name contains element name. Value contains text of first data node.
// node_data, //!< A data node. Name is empty. Value contains data text.
// node_cdata, //!< A CDATA node. Name is empty. Value contains data text.
// node_comment, //!< A comment node. Name is empty. Value contains comment text.
// node_declaration, //!< A declaration node. Name and value are empty. Declaration parameters (version, encoding and standalone) are in node attributes.
// node_doctype, //!< A DOCTYPE node. Name is empty. Value contains DOCTYPE text.
// node_pi //!< A PI node. Name contains target. Value contains instructions.
// }
// ///////////////////////////////////////////////////////////////////////
// // Internals
// //! \cond internal
// //namespace internal
// {
////C++ TO C# CONVERTER TODO TASK: C++ template specifiers with non-type parameters cannot be converted to C#:
////ORIGINAL LINE: template<int Dummy>
// // Struct that contains lookup tables for the parser
// // It must be a template to allow correct linking (because it has static data members, which are defined in a header file).
// public class lookup_tables <int Dummy>
// {
// public readonly byte[] lookup_whitespace = new byte[256]; // Whitespace table
// public readonly byte[] lookup_node_name = new byte[256]; // Node name table
// public readonly byte[] lookup_text = new byte[256]; // Text table
// public readonly byte[] lookup_text_pure_no_ws = new byte[256]; // Text table
// public readonly byte[] lookup_text_pure_with_ws = new byte[256]; // Text table
// public readonly byte[] lookup_attribute_name = new byte[256]; // Attribute name table
// public readonly byte[] lookup_attribute_data_1 = new byte[256]; // Attribute data table with single quote
// public readonly byte[] lookup_attribute_data_1_pure = new byte[256]; // Attribute data table with single quote
// public readonly byte[] lookup_attribute_data_2 = new byte[256]; // Attribute data table with double quotes
// public readonly byte[] lookup_attribute_data_2_pure = new byte[256]; // Attribute data table with double quotes
// public readonly byte[] lookup_digits = new byte[256]; // Digits
// public readonly byte[] lookup_upcase = new byte[256]; // To uppercase conversion table for ASCII characters
// }
////C++ TO C# CONVERTER TODO TASK: The original C++ template specifier was replaced with a C# generic specifier, which may not produce the same behavior:
////ORIGINAL LINE: template<class Ch>
// }
////C++ TO C# CONVERTER TODO TASK: C++ template specifiers containing defaults cannot be converted to C#:
////ORIGINAL LINE: template<class Ch = sbyte>
// //! \endcond
// ///////////////////////////////////////////////////////////////////////
// // Memory pool
// //! This class is used by the parser to create new nodes and attributes, without overheads of dynamic memory allocation.
// //! In most cases, you will not need to use this class directly.
// //! However, if you need to create nodes manually or modify names/values of nodes,
// //! you are encouraged to use memory_pool of relevant xml_document to allocate the memory.
// //! Not only is this faster than allocating them by using <code>new</code> operator,
// //! but also their lifetime will be tied to the lifetime of document,
// //! possibly simplyfing memory management.
// //! <br><br>
// //! Call allocate_node() or allocate_attribute() functions to obtain new nodes or attributes from the pool.
// //! You can also call allocate_string() function to allocate strings.
// //! Such strings can then be used as names or values of nodes without worrying about their lifetime.
// //! Note that there is no <code>free()</code> function -- all allocations are freed at once when clear() function is called,
// //! or when the pool is destroyed.
// //! <br><br>
// //! It is also possible to create a standalone memory_pool, and use it
// //! to allocate nodes, whose lifetime will not be tied to any document.
// //! <br><br>
// //! Pool maintains <code>RAPIDXML_STATIC_POOL_SIZE</code> bytes of statically allocated memory.
// //! Until static memory is exhausted, no dynamic memory allocations are done.
// //! When static memory is exhausted, pool allocates additional blocks of memory of size <code>RAPIDXML_DYNAMIC_POOL_SIZE</code> each,
// //! by using global <code>new[]</code> and <code>delete[]</code> operators.
// //! This behaviour can be changed by setting custom allocation routines.
// //! Use set_allocator() function to set them.
// //! <br><br>
// //! Allocations for nodes, attributes and strings are aligned at <code>RAPIDXML_ALIGNMENT</code> bytes.
// //! This value defaults to the size of pointer on target architecture.
// //! <br><br>
// //! To obtain absolutely top performance from the parser,
// //! it is important that all nodes are allocated from a single, contiguous block of memory.
// //! Otherwise, cache misses when jumping between two (or more) disjoint blocks of memory can slow down parsing quite considerably.
// //! If required, you can tweak <code>RAPIDXML_STATIC_POOL_SIZE</code>, <code>RAPIDXML_DYNAMIC_POOL_SIZE</code> and <code>RAPIDXML_ALIGNMENT</code>
// //! to obtain best wasted memory to performance compromise.
// //! To do it, define their values before rapidxml.hpp file is included.
// //! \param Ch Character type of created nodes.
// public class memory_pool <Ch = sbyte>
// {
// //! \cond internal
// typedef IntPtr (alloc_func)(std.int); // Type of user-defined function used to allocate memory
// typedef void (free_func)(IntPtr); // Type of user-defined function used to free memory
// //! \endcond
// //! Constructs empty pool with default allocator functions.
// public memory_pool()
// {
// m_alloc_func = 0;
// m_free_func = 0;
// init();
// }
// //! Destroys pool and frees all the memory.
// //! This causes memory occupied by nodes allocated by the pool to be freed.
// //! Nodes allocated from the pool are no longer valid.
// public void Dispose()
// {
// clear();
// }
// //! Allocates a new node from the pool, and optionally assigns name and value to it.
// //! If the allocation request cannot be accomodated, this function will throw <code>std::bad_alloc</code>.
// //! If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function
// //! will call rapidxml::parse_error_handler() function.
// //! \param type Type of node to create.
// //! \param name Name to assign to the node, or 0 to assign no name.
// //! \param value Value to assign to the node, or 0 to assign no value.
// //! \param name_size Size of name to assign, or 0 to automatically calculate size from name string.
// //! \param value_size Size of value to assign, or 0 to automatically calculate size from value string.
// //! \return Pointer to allocated node. This pointer will never be NULL.
// public xml_node<Ch> *allocate_node(node_type type, Ch name, Ch value, std.int name_size)
// {
// return allocate_node(type, name, value, name_size, 0);
// }
// public xml_node<Ch> *allocate_node(node_type type, Ch name, Ch value)
// {
// return allocate_node(type, name, value, 0, 0);
// }
// public xml_node<Ch> *allocate_node(node_type type, Ch name)
// {
// return allocate_node(type, name, 0, 0, 0);
// }
// public xml_node<Ch> *allocate_node(node_type type)
// {
// return allocate_node(type, 0, 0, 0, 0);
// }
////C++ TO C# CONVERTER NOTE: Overloaded method(s) are created above to convert the following method having default parameters:
////ORIGINAL LINE: xml_node<Ch> *allocate_node(node_type type, const Ch *name = 0, const Ch *value = 0, std::int name_size = 0, std::int value_size = 0)
// public xml_node<Ch> *allocate_node(node_type type, Ch name, Ch @value, std.int name_size, std.int value_size)
// {
// IntPtr memory = allocate_aligned(sizeof(xml_node<Ch>));
// xml_node<Ch> node = new(memory) xml_node<Ch>(type);
// if (name != null)
// {
// if (name_size > 0)
// node.name(name, name_size);
// else
// node.name(name);
// }
// if (@value != null)
// {
// if (value_size > 0)
// node.@value(@value, value_size);
// else
// node.@value(@value);
// }
// return node;
// }
// //! Allocates a new attribute from the pool, and optionally assigns name and value to it.
// //! If the allocation request cannot be accomodated, this function will throw <code>std::bad_alloc</code>.
// //! If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function
// //! will call rapidxml::parse_error_handler() function.
// //! \param name Name to assign to the attribute, or 0 to assign no name.
// //! \param value Value to assign to the attribute, or 0 to assign no value.
// //! \param name_size Size of name to assign, or 0 to automatically calculate size from name string.
// //! \param value_size Size of value to assign, or 0 to automatically calculate size from value string.
// //! \return Pointer to allocated attribute. This pointer will never be NULL.
// public xml_attribute<Ch> *allocate_attribute(Ch name, Ch value, std.int name_size)
// {
// return allocate_attribute(name, value, name_size, 0);
// }
// public xml_attribute<Ch> *allocate_attribute(Ch name, Ch value)
// {
// return allocate_attribute(name, value, 0, 0);
// }
// public xml_attribute<Ch> *allocate_attribute(Ch name)
// {
// return allocate_attribute(name, 0, 0, 0);
// }
// public xml_attribute<Ch> *allocate_attribute()
// {
// return allocate_attribute(0, 0, 0, 0);
// }
////C++ TO C# CONVERTER NOTE: Overloaded method(s) are created above to convert the following method having default parameters:
////ORIGINAL LINE: xml_attribute<Ch> *allocate_attribute(const Ch *name = 0, const Ch *value = 0, std::int name_size = 0, std::int value_size = 0)
// public xml_attribute<Ch> *allocate_attribute(Ch name, Ch @value, std.int name_size, std.int value_size)
// {
// IntPtr memory = allocate_aligned(sizeof(xml_attribute<Ch>));
// xml_attribute<Ch> attribute = new(memory) xml_attribute<Ch>;
// if (name != null)
// {
// if (name_size > 0)
// attribute.name(name, name_size);
// else
// attribute.name(name);
// }
// if (@value != null)
// {
// if (value_size > 0)
// attribute.@value(@value, value_size);
// else
// attribute.@value(@value);
// }
// return attribute;
// }
// //! Allocates a char array of given size from the pool, and optionally copies a given string to it.
// //! If the allocation request cannot be accomodated, this function will throw <code>std::bad_alloc</code>.
// //! If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function
// //! will call rapidxml::parse_error_handler() function.
// //! \param source String to initialize the allocated memory with, or 0 to not initialize it.
// //! \param size Number of characters to allocate, or zero to calculate it automatically from source string length; if size is 0, source string must be specified and null terminated.
// //! \return Pointer to allocated char array. This pointer will never be NULL.
// public Ch allocate_string(Ch[] source)
// {
// return allocate_string(source, 0);
// }
// public Ch allocate_string()
// {
// return allocate_string(0, 0);
// }
////C++ TO C# CONVERTER NOTE: Overloaded method(s) are created above to convert the following method having default parameters:
////ORIGINAL LINE: Ch *allocate_string(const Ch *source = 0, std::int size = 0)
// public Ch allocate_string(Ch[] source, std.int size)
// {
// Debug.Assert(source != null || size != null); // Either source or size (or both) must be specified
// if (size == 0)
// size = GlobalMembersProceduralSVG.measure(source) + 1;
// Ch[] result = (Ch)(allocate_aligned(size * sizeof(Ch)));
// if (source != null)
// for (std.int i = 0; i < size; ++i)
// result[i] = source[i];
// return result;
// }
// //! Clones an xml_node and its hierarchy of child nodes and attributes.
// //! Nodes and attributes are allocated from this memory pool.
// //! Names and values are not cloned, they are shared between the clone and the source.
// //! Result node can be optionally specified as a second parameter,
// //! in which case its contents will be replaced with cloned source node.
// //! This is useful when you want to clone entire document.
// //! \param source Node to clone.
// //! \param result Node to put results in, or 0 to automatically allocate result node
// //! \return Pointer to cloned node. This pointer will never be NULL.
// public xml_node<Ch> *clone_node(xml_node<Ch> source)
// {
// return clone_node(source, 0);
// }
////C++ TO C# CONVERTER NOTE: Overloaded method(s) are created above to convert the following method having default parameters:
////ORIGINAL LINE: xml_node<Ch> *clone_node(const xml_node<Ch> *source, xml_node<Ch> *result = 0)
// public xml_node<Ch> *clone_node(xml_node<Ch> source, xml_node<Ch> result)
// {
// // Prepare result node
// if (result != null)
// {
// result.remove_all_attributes();
// result.remove_all_nodes();
// result.type(source.type());
// }
// else
// result = allocate_node(source.type());
// // Clone name and value
// result.name(source.name(), source.name_size());
// result.@value(source.@value(), source.value_size());
// // Clone child nodes and attributes
// for (xml_node<Ch> child = source.first_node(); child; child = child.next_sibling())
// result.append_node(clone_node(child));
// for (xml_attribute<Ch> attr = source.first_attribute(); attr; attr = attr.next_attribute())
// result.append_attribute(allocate_attribute(attr.name(), attr.@value(), attr.name_size(), attr.value_size()));
// return result;
// }
// //! Clears the pool.
// //! This causes memory occupied by nodes allocated by the pool to be freed.
// //! Any nodes or strings allocated from the pool will no longer be valid.
// public void clear()
// {
// while (m_begin != m_static_memory)
// {
////C++ TO C# CONVERTER TODO TASK: There is no equivalent to 'reinterpret_cast' in C#:
// string previous_begin = reinterpret_cast<header *>(align(ref m_begin)).previous_begin;
// if (m_free_func != null)
// m_free_func(m_begin);
// else
// m_begin = null;
// m_begin = previous_begin;
// }
// init();
// }
// //! Sets or resets the user-defined memory allocation functions for the pool.
// //! This can only be called when no memory is allocated from the pool yet, otherwise results are undefined.
// //! Allocation function must not return invalid pointer on failure. It should either throw,
// //! stop the program, or use <code>longjmp()</code> function to pass control to other place of program.
// //! If it returns invalid pointer, results are undefined.
// //! <br><br>
// //! User defined allocation functions must have the following forms:
// //! <br><code>
// //! <br>void *allocate(std::int size);
// //! <br>void free(void *pointer);
// //! </code><br>
// //! \param af Allocation function, or 0 to restore default function
// //! \param ff Free function, or 0 to restore default function
// public void set_allocator(ref alloc_func af, ref free_func ff)
// {
// Debug.Assert(m_begin == m_static_memory && m_ptr == align(ref m_begin)); // Verify that no memory is allocated yet
// m_alloc_func = af;
// m_free_func = ff;
// }
// private class header
// {
// public string previous_begin;
// }
// private void init()
// {
// m_begin = m_static_memory;
// m_ptr = align(ref m_begin);
// m_end = m_static_memory + sizeof(m_static_memory);
// }
// private string align(ref string ptr)
// {
// std.int alignment = ((sizeof(IntPtr) - (std.int(ptr) & (sizeof(IntPtr) - 1))) & (sizeof(IntPtr) - 1));
// return ptr + alignment;
// }
// private string allocate_raw(std.int size)
// {
// // Allocate
// IntPtr memory;
// if (m_alloc_func != null) // Allocate memory using either user-specified allocation function or global operator new[]
// {
// memory = m_alloc_func(size);
// Debug.Assert(memory); // Allocator is not allowed to return 0, on failure it must either throw, stop the program or use longjmp
// }
// else
// {
// memory = new sbyte[size];
//#if RAPIDXML_NO_EXCEPTIONS
// if (!memory) // If exceptions are disabled, verify memory allocation, because new will not be able to throw bad_alloc
// RAPIDXML_PARSE_ERROR("out of memory", 0);
//#endif
// }
// return (sbyte)(memory);
// }
// private IntPtr allocate_aligned(std.int size)
// {
// // Calculate aligned pointer
// sbyte result = align(ref m_ptr);
// // If not enough memory left in current pool, allocate a new pool
// if (result + size > m_end)
// {
// // Calculate required pool size (may be bigger than RAPIDXML_DYNAMIC_POOL_SIZE)
// std.int pool_size = 64 * 1024;
// if (pool_size < size)
// pool_size = size;
// // Allocate
// std.int alloc_size = sizeof(header) + (2 * sizeof(IntPtr) - 2) + pool_size; // 2 alignments required in worst case: one for header, one for actual allocation
// sbyte raw_memory = allocate_raw(alloc_size);
// // Setup new pool in allocated memory
// sbyte pool = align(ref raw_memory);
////C++ TO C# CONVERTER TODO TASK: There is no equivalent to 'reinterpret_cast' in C#:
// header new_header = reinterpret_cast<header *>(pool);
// new_header.previous_begin = m_begin;
// m_begin = raw_memory;
// m_ptr = pool + sizeof(header);
// m_end = raw_memory + alloc_size;
// // Calculate aligned pointer again using new pool
// result = align(ref m_ptr);
// }
// // Update pool and return aligned pointer
// m_ptr = result + size;
// return result;
// }
// private string m_begin; // Start of raw memory making up current pool
// private string m_ptr; // First free byte in current pool
// private string m_end; // One past last available byte in current pool
// private string m_static_memory = new string(new char[64 * 1024]); // Static raw memory
// private alloc_func m_alloc_func; // Allocator function, or 0 if default is to be used
// private free_func m_free_func; // Free function, or 0 if default is to be used
// }
////C++ TO C# CONVERTER TODO TASK: C++ template specifiers containing defaults cannot be converted to C#:
////ORIGINAL LINE: template<class Ch = sbyte>
// ///////////////////////////////////////////////////////////////////////////
// // XML base
// //! Base class for xml_node and xml_attribute implementing common functions:
// //! name(), name_size(), value(), value_size() and parent().
// //! \param Ch Character type to use
// public class xml_base <Ch = sbyte>
// {
// ///////////////////////////////////////////////////////////////////////////
// // Construction & destruction
// // Construct a base with empty name, value and parent
// public xml_base()
// {
// m_name = 0;
// m_value = 0;
// m_parent = 0;
// }
// ///////////////////////////////////////////////////////////////////////////
// // Node data access
// //! Gets name of the node.
// //! Interpretation of name depends on type of node.
// //! Note that name will not be zero-terminated if rapidxml::parse_no_string_terminators option was selected during parse.
// //! <br><br>
// //! Use name_size() function to determine length of the name.
// //! \return Name of node, or empty string if node has no name.
////
////ORIGINAL LINE: Ch *name() const
// public Ch name()
// {
// return m_name != null ? m_name : nullstr();
// }
// //! Gets size of node name, not including terminator character.
// //! This function works correctly irrespective of whether name is or is not zero terminated.
// //! \return Size of node name, in characters.
////
////ORIGINAL LINE: std::int name_size() const
// public std.int name_size()
// {
// return m_name != null ? m_name_size : 0;
// }
// //! Gets value of node.
// //! Interpretation of value depends on type of node.
// //! Note that value will not be zero-terminated if rapidxml::parse_no_string_terminators option was selected during parse.
// //! <br><br>
// //! Use value_size() function to determine length of the value.
// //! \return Value of node, or empty string if node has no value.
////
////ORIGINAL LINE: Ch *value() const
// public Ch @value()
// {
// return m_value != null ? m_value : nullstr();
// }
// //! Gets size of node value, not including terminator character.
// //! This function works correctly irrespective of whether value is or is not zero terminated.
// //! \return Size of node value, in characters.
////
////ORIGINAL LINE: std::int value_size() const
// public std.int value_size()
// {
// return m_value != null ? m_value_size : 0;
// }
// ///////////////////////////////////////////////////////////////////////////
// // Node modification
// //! Sets name of node to a non zero-terminated string.
// //! See \ref ownership_of_strings.
// //! <br><br>
// //! Note that node does not own its name or value, it only stores a pointer to it.
// //! It will not delete or otherwise free the pointer on destruction.
// //! It is reponsibility of the user to properly manage lifetime of the string.
// //! The easiest way to achieve it is to use memory_pool of the document to allocate the string -
// //! on destruction of the document the string will be automatically freed.
// //! <br><br>
// //! Size of name must be specified separately, because name does not have to be zero terminated.
// //! Use name(const Ch *) function to have the length automatically calculated (string must be zero terminated).
// //! \param name Name of node to set. Does not have to be zero terminated.
// //! \param size Size of name, in characters. This does not include zero terminator, if one is present.
// public void name(Ch name, std.int size)
// {
////C++ TO C# CONVERTER TODO TASK: There is no equivalent to 'const_cast' in C#:
// m_name = const_cast<Ch *>(name);
// m_name_size = size;
// }
// //! Sets name of node to a zero-terminated string.
// //! See also \ref ownership_of_strings and xml_node::name(const Ch *, std::int).
// //! \param name Name of node to set. Must be zero terminated.
// public void name(Ch name)
// {
// this.name(name, GlobalMembersProceduralSVG.measure(name));
// }
// //! Sets value of node to a non zero-terminated string.
// //! See \ref ownership_of_strings.
// //! <br><br>
// //! Note that node does not own its name or value, it only stores a pointer to it.
// //! It will not delete or otherwise free the pointer on destruction.
// //! It is reponsibility of the user to properly manage lifetime of the string.
// //! The easiest way to achieve it is to use memory_pool of the document to allocate the string -
// //! on destruction of the document the string will be automatically freed.
// //! <br><br>
// //! Size of value must be specified separately, because it does not have to be zero terminated.
// //! Use value(const Ch *) function to have the length automatically calculated (string must be zero terminated).
// //! <br><br>
// //! If an element has a child node of type node_data, it will take precedence over element value when printing.
// //! If you want to manipulate data of elements using values, use parser flag rapidxml::parse_no_data_nodes to prevent creation of data nodes by the parser.
// //! \param value value of node to set. Does not have to be zero terminated.
// //! \param size Size of value, in characters. This does not include zero terminator, if one is present.
// public void @value(Ch @value, std.int size)
// {
////C++ TO C# CONVERTER TODO TASK: There is no equivalent to 'const_cast' in C#:
// m_value = const_cast<Ch *>(@value);
// m_value_size = size;
// }
// //! Sets value of node to a zero-terminated string.
// //! See also \ref ownership_of_strings and xml_node::value(const Ch *, std::int).
// //! \param value Vame of node to set. Must be zero terminated.
// public void @value(Ch @value)
// {
// this.@value(@value, GlobalMembersProceduralSVG.measure(@value));
// }
// ///////////////////////////////////////////////////////////////////////////
// // Related nodes access
// //! Gets node parent.
// //! \return Pointer to parent node, or 0 if there is no parent.
////
////ORIGINAL LINE: xml_node<Ch> *parent() const
// public xml_node<Ch> *parent()
// {
// return m_parent;
// }
// // Return empty string
////C++ TO C# CONVERTER NOTE: This was formerly a static local variable declaration (not allowed in C#):
// private static Ch zero = new Ch('\0');
// protected static Ch nullstr()
// {
////C++ TO C# CONVERTER NOTE: This static local variable declaration (not allowed in C#) has been moved just prior to the method:
//// static Ch zero = Ch('\0');
// return zero;
// }
// protected Ch m_name; // Name of node, or 0 if no name
// protected Ch m_value; // Value of node, or 0 if no value
// protected std.int m_name_size = new std.int(); // Length of node name, or undefined of no name
// protected std.int m_value_size = new std.int(); // Length of node value, or undefined if no value
// protected xml_node<Ch> m_parent; // Pointer to parent node, or 0 if none
// }
////C++ TO C# CONVERTER TODO TASK: C++ template specifiers containing defaults cannot be converted to C#:
////ORIGINAL LINE: template<class Ch = sbyte>
// //! Class representing attribute node of XML document.
// //! Each attribute has name and value strings, which are available through name() and value() functions (inherited from xml_base).
// //! Note that after parse, both name and value of attribute will point to interior of source text used for parsing.
// //! Thus, this text must persist in memory for the lifetime of attribute.
// //! \param Ch Character type to use.
// public class xml_attribute<Ch = sbyte>: xml_base<Ch>
// {
////C++ TO C# CONVERTER TODO TASK: C# has no concept of a 'friend' class:
//// friend class xml_node<Ch>;
// ///////////////////////////////////////////////////////////////////////////
// // Construction & destruction
// //! Constructs an empty attribute with the specified type.
// //! Consider using memory_pool of appropriate xml_document if allocating attributes manually.
// public xml_attribute()
// {
// }
// ///////////////////////////////////////////////////////////////////////////
// // Related nodes access
// //! Gets document of which attribute is a child.
// //! \return Pointer to document that contains this attribute, or 0 if there is no parent document.
////
////ORIGINAL LINE: xml_document<Ch> *document() const
// public xml_document<Ch> *document()
// {
// if (xml_node<Ch> *node = this.parent())
// {
// while (node.parent())
// node = node.parent();
// return node.type() == (int)node_type.node_document ? (xml_document<Ch>)(node) : 0;
// }
// else
// return 0;
// }
// //! Gets previous attribute, optionally matching attribute name.
// //! \param name Name of attribute to find, or 0 to return previous attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
// //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
// //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
// //! \return Pointer to found attribute, or 0 if not found.
// public xml_attribute<Ch> *previous_attribute(Ch name, std.int name_size)
// {
// return previous_attribute(name, name_size, true);
// }
// public xml_attribute<Ch> *previous_attribute(Ch name)
// {
// return previous_attribute(name, 0, true);
// }
// public xml_attribute<Ch> *previous_attribute()
// {
// return previous_attribute(0, 0, true);
// }
////
////ORIGINAL LINE: xml_attribute<Ch> *previous_attribute(const Ch *name = 0, std::int name_size = 0, bool case_sensitive = true) const
////C++ TO C# CONVERTER NOTE: Overloaded method(s) are created above to convert the following method having default parameters:
// public xml_attribute<Ch> *previous_attribute(Ch name, std.int name_size, bool case_sensitive)
// {
// if (name != null)
// {
// if (name_size == 0)
// name_size = GlobalMembersProceduralSVG.measure(name);
// for (xml_attribute<Ch> attribute = m_prev_attribute; attribute; attribute = attribute.m_prev_attribute)
// if (GlobalMembersProceduralSVG.compare(attribute.name(), attribute.name_size(), name, name_size, case_sensitive) != 0)
// return attribute;
// return 0;
// }
// else
// return this.m_parent ? m_prev_attribute : 0;
// }
// //! Gets next attribute, optionally matching attribute name.
// //! \param name Name of attribute to find, or 0 to return next attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
// //! \param name_size Size of name, in characters, or 0 to have size calculated automatically from string
// //! \param case_sensitive Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters
// //! \return Pointer to found attribute, or 0 if not found.
// public xml_attribute<Ch> *next_attribute(Ch name, std.int name_size)
// {
// return next_attribute(name, name_size, true);
// }
// public xml_attribute<Ch> *next_attribute(Ch name)
// {
// return next_attribute(name, 0, true);
// }
// public xml_attribute<Ch> *next_attribute()
// {
// return next_attribute(0, 0, true);
// }
////
////ORIGINAL LINE: xml_attribute<Ch> *next_attribute(const Ch *name = 0, std::int name_size = 0, bool case_sensitive = true) const
////C++ TO C# CONVERTER NOTE: Overloaded method(s) are created above to convert the following method having default parameters:
// public xml_attribute<Ch> *next_attribute(Ch name, std.int name_size, bool case_sensitive)
// {
// if (name != null)
// {
// if (name_size == 0)
// name_size = GlobalMembersProceduralSVG.measure(name);
// for (xml_attribute<Ch> attribute = m_next_attribute; attribute; attribute = attribute.m_next_attribute)
// if (GlobalMembersProceduralSVG.compare(attribute.name(), attribute.name_size(), name, name_size, case_sensitive) != 0)
// return attribute;
// return 0;
// }
// else
// return this.m_parent ? m_next_attribute : 0;
// }
// private xml_attribute<Ch> m_prev_attribute; // Pointer to previous sibling of attribute, or 0 if none; only valid if parent is non-zero
// private xml_attribute<Ch> m_next_attribute; // Pointer to next sibling of attribute, or 0 if none; only valid if parent is non-zero