-
Notifications
You must be signed in to change notification settings - Fork 1
/
NEWS
1212 lines (883 loc) · 49.5 KB
/
NEWS
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
Version 4.0.0
* Xerces-C++ 2-series (2.8.0 and earlier) is no longer supported.
* Visual Studio 2003 (7.1) is no longer supported.
* HP aCC3 (HP-UX/PA-RISC) is no longer supported.
* Oracle/Berkeley DB XML support has been removed since it no longer
supports the Xerces-C++-based document access.
* New option, --std, specifies the C++ standard that the generated code
should conform to. Valid values are c++98 (default) and c++11.
The C++ standard affects various aspects of the generated code that are
discussed in more detail in mapping-specific documentation (guides and
manuals). Overall, when C++11 is selected, the generated code relies on
the move semantics and uses std::unique_ptr instead of deprecated
std::auto_ptr. See also the documentation for the --std option in the
XSD compiler command line manual (man pages).
* New option, --fat-type-file, triggers the placement of code corresponding
to global elements into type files instead of schema files in the file-
per-type mode. This option is primarily useful when trying to minimize
the amount of object code that is linked to an executable by packaging
compiled generated code into a static (archive) library.
C++/Tree
* Support for ordered types. C++/Tree flattens nested compositors which
sometimes can result in the loss of element ordering information that
could be significant to the application. Ordered types address this
problem. For more information, refer to Section 2.8.4, "Element Order"
in the C++/Tree Mapping User Manual.
* Support for mixed content in ordered types. For more information, refer
to Section 2.13, "Mapping for Mixed Content Models" in the C++/Tree
Mapping User Manual.
* xml_schema::type represents anyType content as a DOM fragment, similar
to wildcards. For more information, refer to Section 2.5.2, "Mapping
for anyType" in the C++/Tree Mapping User Manual.
* xml_schema::simple_type represents anySimpleType content as a text
string. For more information, refer to Section 2.5.3, "Mapping for
anySimpleType" in the C++/Tree Mapping User Manual.
* Improved streaming example that now provides better XML namespace
handling and supports streaming parsing and serialization at multiple
document levels.
* New option, --generate-dep, triggers the generation of the make
dependency files (.d) for the generated C++ files. Other options
controlling dependency generation are: --generate-dep-only,
--dep-phony, --dep-target, --dep-suffix, and --dep-regex. For
details on this functionality, refer to the XSD compiler command
line manual (man pages).
* New option, --suppress-assignment, suppresses the generation of copy
assignment operators for complex types. If this option is specified,
the copy assignment operators for such types are declared private and
left unimplemented.
* Binary representation now stores string-based enumerations as integer
values corresponding to C++ enumerators instead of string literals.
* Binary representation now pools polymorphic type-id strings in an
implicit string pool. The string pool support can also be used to
pool strings in other situations. For example, you can implement
string insertion/extraction operators for your stream to pool all
strings. This can be useful if your documents contain a large number
of repetitive strings.
* New option, --polymorphic-plate, allows the creation of multiple
polymorphic map plates in the same application. For details, refer
to the XSD compiler command line manual (man pages).
* To get the DOM association in the copy of an object model tree one
now needs to explicitly pass the xml_schema::flags::keep_dom flag as
the second argument to the copy constructor or clone() function.
Version 3.3.0
* New option, --char-encoding, allows you to specify the character encoding
that should be used in the generated code. Valid values for the 'char'
character type are 'utf8' (default), 'iso8859-1' (new), 'lcp' (Xerces-C++
local code page), and 'custom' (provides support for custom encodings).
Note that if you use a non-default character encoding and include some
libxsd headers (e.g., xsd/cxx/xml/string.hxx) directly, then you will
need to first include the correct xsd/cxx/xml/char-<enc>.hxx header,
where <enc> is iso8859-1, lcp, etc. This mechanism replaces the
XSD_USE_LCP macro.
For the wchar_t character type the only valid value for this option is
'auto' and the encoding is automatically selected between UTF-16 and
UTF-32, depending on the wchar_t type size.
* When the XSD compiler is built with Xerces-C++ 3.1.0 or later, the
handling of multiple imports for the same namespace is enabled. Before,
all subsequent imports for a namespace were ignored which caused errors
in some schemas. Note that if your application has XML Schema validation
enabled, then you will also need to build it with Xerces-C++ 3.1.0 or
later to take advantage of this feature.
* Automatic mapping for the urn-style XML namespaces. The last component
in the urn name is used to derive the C++ namespace name.
* New option, --schema-file-regex, in combination with the existing
--type-file-regex, can be used to place the generated files into
subdirectories or to resolve file name conflicts in the file-per-
type mode (--file-per-type).
* Warning id's have changed to start with a letter identifying the
component issuing the warning. F - compiler frontend, D - compiler
driver, P - C++/Parser mapping, T - C++/Tree mapping.
* Strings used to match regular expressions supplied with the
--namespace-regex and --anonymous-regex options now include the file
component for the schema being compiled.
* The XSD_NO_EXPORT macro can be used to omit code generated with the
--export/import-maps and, for C++/Tree, --generate-xml-schema options
during C++ compilation. This may be useful if you would like to use
the same generated code across multiple platforms.
C++/Tree
* New option, --generate-element-type, triggers the generation of types
instead of parsing/serialization functions for root elements. This
is primarily useful to distinguish object models with the same root
type but with different root elements. For more information, refer
to the messaging example and Section 2.9.1, "Element Types" in the
C++/Tree Mapping User Manual. To support the customization of the
element type naming the --element-type-regex option has been added.
See the NAMING CONVENTION section in the compiler command line manual
(man pages) for details.
* New option, --generate-element-map, triggers the generation of a root
element map. The element map allows uniform parsing and serialization
of multiple root elements. This option can only be used together with
--generate-element-type. For more information, refer to the messaging
example and Section 2.9.2, "Element Map" in the C++/Tree Mapping
User Manual.
* Prior to this version, if the --generate-polymorphic option is
specified, the compiler treats all types as potentially polymorphic.
Now by default only type hierarchies used in substitution groups and
those explicitly declared polymorphic with the new --polymorphic-type
option are treated as polymorphic. This results in smaller and faster
generated code. If you would like to continue using the old behavior,
you will need to specify --polymorphic-type-all. For more information,
on this change see Section 2.11, "Mapping for xsi:type and Substitution
Groups" in the C++/Tree Mapping User Manual.
* New option, --generate-detach, triggers the generation of detach
functions for required elements and attributes. For optional and
sequence cardinalities the detach functions are now provided by the
respective containers even without this option. These functions, for
example, allow one to move sub-trees in the object model either within
the same tree or between different trees without copying. For more
information, refer to Section 2.8 "Mapping for Local Elements and
Attributes" in the C++/Tree Mapping User Manual.
* New option, --export-xml-schema, causes the compiler to export/import
types in the XML Schema namespace using the export symbol provided
with the --export-symbol option.
* New example, embedded, shows how to embed the binary representation of
the schema grammar into an application and then use it to parse and
validate XML documents.
* New example, compression, shows how to compress an XML document during
serialization and decompress it during parsing using the zlib library.
* New example, custom/mixed, shows how to use type customization to parse
and serialize mixed content.
* The streaming example has been extended to show how to perform stream-
oriented, partially in-memory XML processing using the C++/Tree mapping.
With the partially in-memory parsing and serialization only a part of
the object model is in memory at any given time. With this approach one
can process parts of the document as they become available as well as
handle documents that are too large to fit into memory.
* New default/fixed value initialization code. Now the default/fixed values
are parsed by the XSD compiler at compile time instead of the standard
parsing code at runtime. This will allow the compilation of schemas that
use the default/fixed values without support for XML parsing
(--suppress-parsing option).
* Empty XML Schema enumeration values are now mapped to the 'empty' C++
enumerator name instead of 'cxx'.
* XML Schema union types with members that are enumeration types are
automatically converted to equivalent enumeration types with a union
of all the members' enumerators.
Version 3.2.0
* New option, --disable-warning, disables printing of a warning with
the specified id. Specifying 'all' for the warning id disables all
warnings.
* New options, --export-maps and --import-maps, provide support for
splitting a polymorphic type hierarchy across several Win32 DLLs.
See the compiler command line manual (man pages) for details.
C++/Tree
* During serialization the generated code automatically assigns
generic prefixes (p1, p2, etc) to XML namespaces used in the
vocabulary and for which no custom prefix-namespace mapping
was provided via the xml_schema::namespace_infomap argument.
The xml_schema::namespace_infomap argument in the serialization
functions is now default-initialized to an empty map. The
xml_schema::no_namespace_mapping and xml_schema::xsi_already_in_use
exceptions have been removed.
* New example, performance, measures the performance of parsing and
serialization. This example also shows how to structure your code
to achieve the maximum performance for these two operations.
* New example, xpath, shows how to use the C++/Tree mapping together
with XPath.
* New options, --one-accessor-regex, --opt-accessor-regex,
--seq-accessor-regex, --one-modifier-regex, --opt-modifier-regex,
and --seq-modifier-regex, allow specification of transformations
for accessor and modifier function names for elements and attributes
with specific cardinalities. For more information see the NAMING
CONVENTION section in the compiler command line manual (man pages).
* Support for comparison (--generate-comparison) and printing
(--generate-ostream) of polymorphic object models.
* New serialization flag, xml_schema::flags::dont_pretty_print,
disables extra spaces and new lines that make the resulting XML
slightly bigger but easier to read.
* New example, custom/double, shows how to customize parsing and
serialization code for the xsd:double XML Schema built-in type.
It can be used as a guide on how to customize built-in XML Schema
types that are mapped to fundamental C++ types.
* Support for fractionDigits and totalDigits facets in serialization
of types derived from xsd:decimal.
* New set of compile-time macros that control how the xsd:float,
xsd:double, and xsd:decimal types are serialized. The following
macros control the format:
XSD_CXX_TREE_FLOAT_FIXED
XSD_CXX_TREE_FLOAT_SCIENTIFIC
XSD_CXX_TREE_DOUBLE_FIXED
XSD_CXX_TREE_DOUBLE_SCIENTIFIC
The following macros control the precision:
XSD_CXX_TREE_FLOAT_PRECISION_MAX
XSD_CXX_TREE_FLOAT_PRECISION
XSD_CXX_TREE_DOUBLE_PRECISION_MAX
XSD_CXX_TREE_DOUBLE_PRECISION
XSD_CXX_TREE_DECIMAL_PRECISION_MAX
XSD_CXX_TREE_DECIMAL_PRECISION
If the *_PRECISION_MAX macro is defined then the maximum number of
potentially significant decimal digits that the type can represent
is used. Otherwise, if the *_PRECISION macro is defined then its
value is used. By default the precision is set to the number of
decimal digits that the type can represent without change. For
more information on these options, refer to the following paper:
http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1822.pdf
The old macro, XSD_FP_ALL_DIGITS, that was equivalent to defining
all three *_PRECISION_MAX macros has been removed.
An alternative to using these macros is to customize the floating
point type as shown in the custom/double example.
* An additional constructor is generated in situations where a type
contains one or more required element of complex type (that is,
it itself contains elements or attributes). In this constructor,
initializers for such elements are passed as std::auto_ptr and the
newly created instance is directly initialized with and assumes
ownership of the pointed to objects. This constructor is a logical
addition to the non-copying modifiers that were introduced in the
previous version.
* Extra conversion operators in the fundamental_base class template
which is used to emulate inheritance from fundamental types are now
disabled by default since they cause problems on several compilers.
To enable them compile your code with the XSD_TREE_EXTRA_FUND_CONV
macro defined.
C++/Parser
* New options, --generate-xml-schema and --extern-xml-schema, trigger
generation of the mapping for the XML Schema namespace to a separate
header file and inclusion of that header into other generated header
files instead of generating the necessary declarations inline,
respectively. See the compiler command line manual (man pages) for
details.
* New example, performance, measures the performance of XML parsing.
This example also shows how to structure your code to achieve the
maximum performance for this operation.
* Type map files can now include comments. A comment starts with #
and ends with a new line or end of file. To specify a name that
contains # enclose it in "".
* In type map files the optional argument type now defaults to the
return type if the return type ends with * or & (that is, it is
a pointer or a reference) and 'const return type&' otherwise.
* The interface for polymorphic parsing has been simplified. Calling the
*_parser() functions multiple times to specify several parsers is no
longer supported. Instead you need to pass the xml_schema::parser_map
object which contains the parsers. For more information refer to
Section 5.4, "Support for Polymorphism" in the C++/Parser Mapping
Getting Started Guide.
* The use of virtual inheritance has been reduced which results in a
much smaller object code size (more than factor of 2 on some tests)
and faster C++ compilation with less RAM used.
* The low-level Expat-specific parsing API (parse_begin() and parse_end())
has been extended to provide XML and XML Schema error translation to
exceptions or error handler calls. See Section 7.2, "Expat Document
Parser" in the C++/Parser Mapping Getting Started Guide for more
information.
Version 3.1.0
* New option, --file-per-type, triggers generation of a separate set
of C++ files for each type defined in XML Schema. This compilation
mode is primarily useful when some of your schemas cannot be compiled
separately or have cyclic dependencies which involve inheritance.
Other new options that are useful in this compilation mode are
--type-file-regex, --type-file-regex-trace, and --file-list. See the
compiler command line manual (man pages) for more information.
* New option, --options-file, allows additional command line options
to be provided in files, with one option per line.
* New option, --reserved-name, allows insertion of additional names
with optional replacements to the list of names that should not be
used as identifiers. See the compiler command line manual (man pages)
for details.
* New options, --location-map, --location-regex, and
--location-regex-trace, allow re-mapping of schema locations
specified in the include and import elements without modifying the
schema files. See the compiler command line manual (man pages) for
more information.
* New option, --guard-prefix, allows specification of a prefix that
should be added to generated header inclusion guards.
* New option, --file-list, triggers creation of a file with a list of
generated C++ files. This option is primarily useful in the file-per-
type compilation mode (--file-per-type) to create a list of generated
C++ files, for example, as a makefile fragment. Other new options
that are useful with --file-list are --file-list-prologue,
--file-list-epilogue, and --file-list-delim. See the compiler command
line manual (man pages) for more information.
* Support for the upcoming Xerces-C++ 3.0.0 release.
C++/Tree
* New option, --generate-intellisense, triggers generation of workarounds
for IntelliSense bugs in Visual Studio 2005 (8.0). When this option is
used, the resulting code is slightly more verbose. IntelliSense in
Visual Studio 2008 (9.0) does not require these workarounds. Support
for IntelliSense in Visual Studio 2003 (7.1) is improved with this
option but is still incomplete.
* New options, --type-naming and --function-naming, allow specification
of the type and function naming conventions that should be used in the
generated code. Supported values for --type-naming are: knr (K&R), ucc
(upper-camel-case), and java. Supported values for --function-naming
are: knr (K&R), lcc (lower-camel-case), and java. For more information
see the NAMING CONVENTION section in the compiler command line manual
(man pages).
* New options, --type-regex, --accessor-regex, --modifier-regex,
--parser-regex, --serializer-regex, and --enumerator-regex, allow
specification of transformations for type, accessor function,
modifier function, parsing function, serialization function, and
enumerator names in order to produce the generated code using a
custom naming convention. For more information see the NAMING
CONVENTION section in the compiler command line manual (man pages).
* Generated list classes now provide a complete set of constructors and
conform to the standard C++ sequence interface.
* String-based types now provide two extra constructors that expect a
C string and std::string as their arguments. This allows direct
initialization of string-based types from string literals.
* New implementations of the XML Schema date/time types (date, dateTime,
duration, gDay, gMonth, gMonthDay, gYear, gYearMonth, and time) that
represent the information in the numerical form.
* New binary serialization examples: binary/boost, which shows how to
save/load the object model to/from a custom format using the Boost
serialization library as an example, and binary/xdr, which shows how to
save/load the object model to/from XDR (eXternal Data Representation)
binary format using the XDR API provided as part of Sun RPC.
* The non-copying modifier functions can now be used to assemble object
models from scratch. For more information see Section 4.4, "Creating
the Object Model from Scratch" in the C++/Tree Mapping Getting Started
Guide as well as Section 2.8, "Mapping for Local Elements and Attributes"
in the C++/Tree Mapping User Manual.
* Doxygen documentation was added to the XSD runtime for the built-in XML
Schema types, exceptions, etc. This allows linking of the generated
documentation to the XSD runtime documentation using the Doxygen tags
mechanism. The Doxygen configuration file for the XSD runtime is
provided in the documentation/cxx/tree/reference/ directory.
* Support for customization of anyType. Because anyType is a base type
for every generated type, customizing it allows one to implement custom
functionality that spans the entire type system. See the comments
example in the examples/cxx/tree/custom/ directory.
* New option, --omit-default-attributes, triggers generation of extra
checks that exclude attributes with default and fixed values from the
serialized XML documents.
* The parsing functions that used to read from DOMInputSource were changed
to use InputSource to ease support of Xerces-C++ 3 and 2 series in the
same code base.
* The parsing function that used to parse DOMDocument* was changed to
parse xml_schema::dom::auto_ptr<DOMDocument>& instead. If the keep_dom
and own_dom flags are specified then this parsing function resets the
passed automatic pointer and the returned object model assumes
ownership of the DOM document. xml_schema::dom::auto_ptr is a simple
automatic pointer for Xerces-C++ DOM with the same interface as
std::auto_ptr.
* The xml_schema::tree_node_key DOM user data key was moved to
xml_schema::dom::tree_node_key.
C++/Parser
* New option, --generate-polymorphic, triggers generation of polymorphism-
aware code. This option should be used on XML vocabularies which use
xsi:type and/or substitution groups. For more information see Section
5.4, "Support for Polymorphism" in the C++/Parser Mapping Getting
Started Guide we well as the polymorphism and polyroot examples in the
examples/cxx/parser/ directory.
* The date/time types (date, dateTime, gDay, gMonth, gMonthDay, gYear,
gYearMonth, and time) now represent time zone in the numerical form.
* In order to support parsing of polymorphic XML documents, the signatures
of the start_* functions (_start_element, _start_any_element, and
start_root_element) have changed to include a third argument of type
const ro_string<C>*. This argument contains the resolved type name and
namespace in case the xsi:type attribute was specified.
Version 3.0.0
* Anonymous type morphing (automatic type naming) is now performed by
default in both mappings. The --morph-anonymous option does not have
any effect but is preserved for backwards compatibility. A new option,
--preserve-anonymous, disables anonymous type morphing. This option is
useful together with --show-anonymous if you want to make sure your
schemas do not have any anonymous types.
* A number of bugs fixed in both C++/Tree and C++/Parser mappings.
C++/Tree
* The new C++/Tree Mapping Getting Started Guide is available in the
documentation/cxx/tree/guide/ directory.
* The type definitions for local elements and attributes in the form
name::type have been changed to name_type. For example, an element
bar in type foo with maxOccurs="unbounded" used to have its iterator
type defined as foo::bar::iterator. With this change it becomes
foo::bar_iterator. Furthermore, the container type name for sequence
elements has changed from foo::bar::container to foo::bar_sequence
and for optional elements and attributes from foo::bar::container
to foo::bar_optional. This is a backwards incompatible change and
may require application code adjustments (the C++ compiler will
pinpoint the affected places).
* New option, --generate-doxygen, triggers generation of documentation
comments suitable for extraction by the Doxygen documentation system.
Documentation from annotations is added to the comments if present in
the schema.
* New option, --generate-wildcard, triggers generation of the new
wildcard (any and anyAttribute) mapping. This mapping represents the
content matched by wildcards as DOM fragments. For more information on
the new mapping see Section 2.12, "Mapping for any and anyAttribute"
in the C++/Tree Mapping User Manual as well as the wildcard example in
the examples/cxx/tree/ directory.
* New option, --generate-comparison, triggers generation of comparison
operators (== and !=) for complex types. Comparison is performed
memberwise.
* Support for the RPC XDR binary stream in addition to ACE CDR.
* New constructor is generated for complex types with ultimate bases
that are simple types and can be default-initialized. This constructor
includes initializers for all required members but omits the initializer
for the base type. See Section 2.7, "Mapping for Complex Types" in the
C++/Tree Mapping User Manual for more information.
* Support for polymorphic binary serialization and extraction. Note that
the semantics of the --generate-insertion and --generate-extraction
options has changed. See the the compiler command line manual (man
pages) for details.
* New parsing function with the DOMDocument* argument and the own_dom
flag allow the tree to assume the ownership of the DOM document
being parsed when DOM association is requested (keep_dom flag).
See the C++/Tree Mapping User Manual for more information.
* New example, multiroot, shows how to handle XML vocabularies with
multiple root elements.
* New example, caching, shows how to parse several XML documents while
reusing the underlying XML parser and caching the schemas used for
validation.
* The mapping of built-in XML Schema type decimal has changed from
long double to double. The old mapping can be obtained by providing
a custom mapping for this type.
* The xml_schema::errors type which is used in the xml_schema::parsing
and xml_schema::serialization exceptions has been renamed to
xml_schema::diagnostics and extended to include warnings in addition
to errors.
* Serialization operators now clear the element being serialized to from
existing child nodes and attributes (except for special attributes such
as prefix-namespace mappings, etc.).
* Improved built-in type parsing, including support for normalization and
whitespace collapsing.
* Optimizations for the generated code size and compilation time,
including space optimizations for polymorphic parsing and
serialization. Optimizations for XML parsing speed.
C++/Parser
* The C++/Parser mapping have been significantly redesigned. See the new
Getting Started Guide in documentation/cxx/parser/guide/ for details.
* The new C++/Parser Mapping Getting Started Guide is available in the
documentation/cxx/parser/guide/ directory.
* The mapping now provides parser implementations for all built-in XML
Schema types. See Chapter 6, "Built-In XML Schema Type Parsers" in
the C++/Parser Mapping Getting Started Guide for more information.
* The mapping now supports automatic generation of sample parser
implementations and a test driver. The --generate-noop-impl option
triggers generation of a sample implementation with empty function
bodies. The --generate-print-impl option triggers generation of a
sample implementation that prints the data stored in XML to STDOUT.
The --generate-test-driver option trigger generation of a test driver.
For more information on this feature see the compiler command line
manual (man pages) and the generated example in the examples/cxx/parser/
directory. Other relevant options include: --force-overwrite,
--root-element-first, --root-element-last, and --root-element.
* New example, wildcard, shows how to parse the XML data matched by
XML Schema wildcards (any and anyAttribute).
* The xml_schema::document parser has been extended with overridable
virtual functions start_root_element and end_root_element to support
parsing of XML vocabularies with multiple document roots. See the
multiroot example in the examples/cxx/parser/ directory for more
information.
* The xml_schema::errors type which is used in the xml_schema::parsing
exception has been renamed to xml_schema::diagnostics and extended to
include warnings in addition to errors.
Version 2.3.1
* The compiler is now capable of translating multiple schemas with
one invocation.
* New option, --sloc-limit, allows one to limit the amount of the
generated code.
* New option, --proprietary-license, instructs the compiler not to
include the GPL banner in each generated file. Instead a short
notice about a required proprietary license is generated. You
should not use this option unless you have obtained a proprietary
license from Code Synthesis Tools CC.
* The default encoding for the 'char' character type is now UTF-8.
To get the previous behavior (local code page via the Xerces-C++
transcode functions) define the XSD_USE_LCP preprocessor macro
when compiling your source code.
C++/Tree
* The --parts option has been improved to split generated code more
evenly by analyzing the complexity of the generated schema constructs.
* Ability to customize serialization, std::ostream, and binary
insertion/extraction operators. See examples/cxx/tree/custom/wildcard
for an example on how to handle XML Schema wildcards (xsd:any and
xsd:anyAttribute) by customizing the parsing constructor and
serialization operators.
* Optimizations for the run-time memory consumption.
* Optimizations for space in the generated code.
* Number of bug fixes.
C++/Parser
* Proper handling of an xsd:any nested content. Nested elements,
attributes, and text are reported via _any_* hooks of the current
parser.
* Number of bug fixes, mostly in the generated validation code.
Version 2.3.0
* Name conflicts across type inheritance hierarchies are now detected
and resolved via name escaping.
C++/Tree
* New option, --suppress-parsing, suppresses generation of the parsing
constructors and functions. This can be used to minimize the generated
code footprint when parsing from XML is not used.
* New option, --generate-forward, triggers generation of a forward
declaration header file for types defined in the schema. A set of
--fwd-* options that control the resulting file name as well as
prologue and epilogue code are available.
* New option, --generate-xml-schema, triggers generation of the mapping
for the XML Schema namespace to a separate header file. See the man
pages for details and examples/cxx/tree/custom/calendar for an example.
* New option, --extern-xml-schema, triggers inclusion of a header
file for the XML Schema namespace instead of generating the
necessary declarations inline. See the man pages for details and
examples/cxx/tree/custom/calendar for an example.
* New options, --custom-type and --custom-type-regex, instruct the
compiler to use custom C++ type for a type defined in the schema.
The standard mapping can still be generated (with a different name)
usually to be used as a base. Built-in XML Schema types can be
customized using this mechanism. See the man pages for details and
examples/cxx/tree/custom/* for examples.
* The generated parsing constructors and serialization operators have
been changed to use the Xerces-C++ DOM elements and attributes
instead of the internal wrapper types. This should provide easier
integration with other code and libraries that use the Xerces-C++
DOM types such as Berkeley DB XML.
* New example, examples/cxx/tree/dbxml, shows how to use the C++/Tree
mapping on top of the Berkeley DB XML database.
C++/Parser
* Validation of the attribute structure in the generated code.
* Validation of the character content models including mixed content in
the generated code.
* Validation of the built-in XML Schema types.
* Optimizations for space and time in the generated code. In particular
data coping during parsing and validation was significantly reduced.
Version 2.2.0
* Detection of a version mismatch between the generated code and
the runtime.
C++/Tree
* Escaping of a global element name that conflicts with a global type
name. This is a backwards-incompatible change. Previous versions
map them to the same name.
* New options, --generate--insertion and --generate-extraction,
trigger generation of (binary) data representation stream
insertion and extraction operators, respectively. This allows
one to serialize/deserialize in-memory representation to/from
data representation streams such as XSD, CDR, etc. ACE CDR
streams are supported out of the box (see the binary example).
User-supplied streams can be used via an adaptation layer.
* New serialization flag, no_xml_declaration, instructs the XML
serialization functions to omit an XML declaration. This is useful
for streaming serialization (see the streaming example).
* Optimizations to reduce generated code size.
C++/Parser
* New options, --generate-validation and --suppress-validation,
trigger and suppress generation of the validation code,
respectively. The validation code is the implementation of the
XML Schema validation in the generated code (also known as
"perfect" parser). In this version validation of the element
structure has been implemented.
* New architecture for underlying XML parsers. This is a backwards-
incompatible change. Existing applications will have to be
modified. See examples for details.
Version 2.1.1
C++/Tree
* New option, --namespace-map, allows direct mapping of XML Schema
namespaces to C++ namespaces without the use of regular expressions.
* Further optimizations in the container code and enum mapping to
reduce generated code size.
* Number of bug fixes in the generated code.
C++/Parser
* New option, --namespace-map, allows direct mapping of XML Schema
namespaces to C++ namespaces without the use of regular expressions.
Version 2.1.0
* Automatic handling of forward inheritance. XML Schema allows
inheritance from yet undefined types while it is illegal to do
so in C++. Now the translator automatically handles forward
inheritance by re-arranging the schema during compilation.
C++/Tree
* New enum mapping with support for inheritance. Enumerators are
now parsed using binary search instead of linear search.
* Associated DOM nodes now retain "back" pointers to tree nodes.
* Optimizations to reduce generated code size.
C++/Parser
* Specialization for void. You can now use void as a hook argument
type if you don't want to pass any data between parsers.
* Support for re-use of implementations of base parsers in derived
parsers using the mixin C++ idiom. See the examples/cxx/parser/mixin
for more information.
* Support for uninitialized parser. If you don't provide a parser
for element/attribute, that element/attribute will be ignored
during parsing.
Version 2.0.0
* New cardinality calculator. This improves support for schemas that
use complex structures with repeated elements, e.g.,
<complexType name="Type">
<choice>
<sequence>
<element name="a" type="string"/>
<element name="c" type="string"/>
</sequence>
<sequence>
<element name="b" type="string"/>
<element name="c" type="string"/>
</sequence>
</choice>
</complexType>
* New identifier escaping code. With this feature xsd generates proper
code for schemas that use the same name for an element and an attribute
in the same type or use several elements/attributes with different
qualified names but with the same local name, e.g.,
<!-- base.xsd -->
<schema xmlns="http://codesynthesis.com/xmlns/test/foo"
targetNamespace="http://codesynthesis.com/xmlns/test/foo">
<element name="foo" type="int"/>
</schema>
<schema xmlns="http://codesynthesis.com/xmlns/test/bar"
xmlns:f="http://codesynthesis.com/xmlns/test/foo"
targetNamespace="http://codesynthesis.com/xmlns/test/bar">
<import namespace="http://codesynthesis.com/xmlns/test/foo"
schemaLocation="base.xsd"/>
<element name="foo" type="string"/>
<complexType name="Foo">
<sequence>
<element ref="foo"/>
<element name="foo" type="long"/>
<element ref="f:foo"/>
<element ref="f:foo"/>
</sequence>
<attribute name="foo" type="string"/>
</complexType>
</schema>
C++/Tree
* New option, --generate-polymorphic, triggers generation of
polymorphism-aware code. Before this release xsd used to always
generate polymorphism-aware code. However, it appears to be quite
wasteful in terms of the generated code size (up to 40%). You will
now need to explicitly specify this option if you use substitution
groups or xsi:type. A warning is issued if this option is not
specified but the schema makes use of substitution groups.
* New options, --root-element-first, --root-element-last,
--root-element-all, --root-element-none, and --root-element, control
generation of parsing and serialization functions. With these options
you can avoid generating extra code for global elements that are not
document roots. See the man pages for details.
* New options, --parts and -parts-suffix, allows you to split generated
source code into a number of parts. This is useful when translating
large, monolithic schemas and a C++ compiler is not able to compile
the resulting source code at once (usually due to insufficient memory).
* New option, --generate-default-ctor, triggers generation of default
constructors even for types that have required members. Required
members of an instance constructed using such a constructor are not
initialized and accessing them results in undefined behavior. Thanks
to Jean-Francois Dube <jf at magnu.polymtl.ca> for suggesting this
feature.
* New option, --generate-from-base-ctor, triggers generation of
constructors that expect an instance of a base type followed by all
required members. Thanks to Jean-Francois Dube <jf at magnu.polymtl.ca>
for suggesting this feature.
* Information scopes for attributes and elements with default/fixed values
now define the public static default_value function which allows one to
obtain the default/fixed value for the element/attribute. Thanks to
Dave Moss <david.r.moss at selex-comm.com> for suggesting this feature.
* MSVC 7.1 has a limit on the length of the "if else if" chain. This
results in ICE when compiling generated code for enumerations with
a large number of values. This version addresses this issue. Thanks
to Cyrille Chépélov <cyrille at chepelov.org> for reporting this and
suggesting a fix.
C++/Parser
* The parser construction API has changed. Now, for element 'foo',
the name of the parser modifier function is 'foo_parser'. Likewise,
operator() for setting all parsers at once has been changed to the
'parsers' function.
Version 1.9.0
C++/Tree
* The size modifier function in the base64_binary and hex_binary
built-in types automatically adjusts capacity if needed.
* More internal names (names that start with _xsd_) were made
private or protected.
C++/Parser
* Typedef for the parser base in the xml_schema namespace.
C++/Parser-E
* C++/Parser mapping optimized for embedded systems. For now it
is equivalent to 'cxx-parser --xml-parser expat'.
Version 1.8.0
* Moved to the build 0.2 series.
C++/Tree
* Support for default and fixed values in attributes. An optional
attribute with a default or fixed value is mapped to the One
cardinality class instead of the Optional cardinality class.
* Mapping for base64Binary and hexBinary has improved. Now these
types support a basic buffer abstraction and perform automatic
encoding and decoding.
* Internal names are protected. We've noticed (via bug reports) a
wide use of internal names (names that start with _xsd_) in user
code. This is not portable and instead you should use public
names. To prevent this from happening in the future we've made
all internal names protected.
C++/Parser
* Support for Expat as the underlying XML parser in addition to
Xerces-C++. This allows one to use the C++/Parser mapping in
memory-constrained environments such as embedded systems. To
select Expat instead of Xerces-C++ (default) add
'--xml-parser expat' to the command line. At the moment only
'char' (UTF-8) is supported as the base character type when
Expat is selected.
* The invalid_instance exception has been renamed to parsing.
* Generic error_handler interface has been added in addition
to Xerces-C++-specific DOMErrorHandler. It allows you to
handle parsing errors and warnings without having to deal
with Xerces-C++ specifics.
* The default error handling behavior has changed in parsing
functions. Instead of printing errors and warnings to STDERR,
the errors are now collected and thrown as part of the parsing
exception.
* In parsing functions, the name, namespace arguments order has
been reversed to be consistent with the one used in parsing
hooks.
Version 1.7.0
* Number of bug fixes in libxsd and the generated code.
C++/Tree
* Comprehensive XML Schema C++/Tree Mapping User Manual.
* Basic support for union. A simple type that is defined using
derivation by union is mapped to a C++ class that derives from
string.
* The _clone function has its arguments default-initialized.
* The invalid_instance exception has been renamed to parsing.
* Generic error_handler interface has been added in addition
to Xerces-C++-specific DOMErrorHandler. It allows you to
handle parsing/serialization errors and warnings without
having to deal with Xerces-C++ specifics. See the user
manual for more information.
* The default error handling behavior has changed in parsing
and serialization functions. Instead of printing errors and
warnings to STDERR, the errors are now collected and thrown
as part of the parsing/serialization exception. See the user
manual for more information.
* The optional and sequence containers now support operators ==,
!=, <, >, <=, and >=.
* Flags argument has been added to serialization functions. The
only flag that is currently supported is dont_initialize.
* Generated code cleanups.
C++/Parser
* Basic support for union. A simple type that is defined using
derivation by union is mapped to a C++ class template that
is just an alias for the generic parser. You are expected to
override the _characters function in your implementation.
* Properties argument to parsing functions which allows to
programmatically specify schemas for instance document
validation.
* Flags argument to parsing functions. The following flags
are supported: