Tutorial for xml_io_tools Package

By Jarek Tuszynski

Package xml_io_tools can read XML files into MATLAB struct and writes MATLAB data types to XML files with help of simple interface to MATLAB's xmlwrite and xmlread functions.

Two function to simplify reading and writing XML files from MATLAB:

Contents

This package can:

This package does not:

Change History

Licence

The package is distributed under MIT License

format compact; % viewing preference
clear variables;
type('license.txt')

Copyright (c) 2007, Jaroslaw Tuszynski
All rights reserved.

Redistribution and use in source and binary forms, with or without 
modification, are permitted provided that the following conditions are 
met:

    * Redistributions of source code must retain the above copyright 
      notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright 
      notice, this list of conditions and the following disclaimer in 
      the documentation and/or other materials provided with the distribution
      
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
POSSIBILITY OF SUCH DAMAGE.

Write XML file based on a Struct using "xml_write"

Any MATLAB data struct can be saved to XML file.

MyTree=[];
MyTree.MyNumber = 13;
MyTree.MyString = 'Hello World';
xml_write('test.xml', MyTree);
type('test.xml')

<?xml version="1.0" encoding="utf-8"?>
<a>[0 0]</a>

Read XML file producing a Struct using "xml_read"

[tree treeName] = xml_read ('test.xml');
disp([treeName{1} ' ='])
gen_object_display(tree)

MyTree =
    MyNumber: [13]
    MyString: 'Hello World'

"Pref.XmlEngine" flag in "xml_write"

Occasionaly some operations are performed better by Apache Xerces XML engine than default xmlread function. That is why xml_write provide an option for choosing the underlaying xml engine. Code below performs the same operation as the previous section but using Apache Xerces XML engine. Notice that in this case name of root element was passed as variable and not extracted from the variable name.

Pref=[]; Pref.XmlEngine = 'Xerces';  % use Xerces xml generator directly
xml_write('test.xml', MyTree, 'TreeOfMine', Pref);
type('test.xml')

<?xml version="1.0" encoding="UTF-8"?>
<TreeOfMine>
    <MyNumber>13</MyNumber>
    <MyString>Hello World</MyString>
</TreeOfMine>

Writing Struct with MATLAB arrays

MyTree=[];
MyTree.Num_1x1 = 13;
MyTree.Vec_1x3 = [1 2 3];
MyTree.Vec_4x1 = [1; 2; 3; 4];
MyTree.Mat_2x2 = [1, 2; 3, 4];         % 2D Matrix
MyTree.Cube_3D = reshape(1:8,[2 2 2]); % 3D array
MyTree.String1 = '[2003 10 30]';       % array with    [] brackets
MyTree.String2 =  '2003 10 30';        % array without [] brackets
xml_write('test.xml', MyTree);
type('test.xml')

<?xml version="1.0" encoding="utf-8"?>
<MyTree>
   <Num_1x1>13</Num_1x1>
   <Vec_1x3>[1 2 3]</Vec_1x3>
   <Vec_4x1>[1; 2; 3; 4]</Vec_4x1>
   <Mat_2x2>[1 2; 3 4]</Mat_2x2>
   <Cube_3D>1 2 3 4 5 6 7 8</Cube_3D>
   <String1>[2003 10 30]</String1>
   <String2>2003 10 30</String2>
</MyTree>

Read Struct with MATLAB arrays

Notice that 'Cube_3D' did not preserve original dimentions

[tree treeName] = xml_read ('test.xml');
disp([treeName{1} ' ='])
gen_object_display(tree)

MyTree =
    Num_1x1: [13]
    Vec_1x3: [1  2  3]
    Vec_4x1: [4x1 double]
    Mat_2x2: [2x2 double]
    Cube_3D: [1  2  3  4  5  6  7  8]
    String1: [2003    10    30]
    String2: [2003    10    30]

"Pref.StructItem" flag in "xml_write"

Create a simple structure with arrays of struct's

MyTree = [];
MyTree.a(1).b = 'jack';
MyTree.a(2).b = 'john';
gen_object_display(MyTree)

    a: [1x2 struct]
       b: 'jack'

       b: 'john'

Write XML with "StructItem = true" (default). Notice single 'a' section and multiple 'item' sub-sections. Those subsections are used to store array elements

wPref.StructItem = true;
xml_write('test.xml', MyTree, 'MyTree',wPref);
type('test.xml')
fprintf('\nxml_read output:\n')
gen_object_display(xml_read ('test.xml'))

<?xml version="1.0" encoding="utf-8"?>
<MyTree>
   <a>
      <item>
         <b>jack</b>
      </item>
      <item>
         <b>john</b>
      </item>
   </a>
</MyTree>

xml_read output:
    a: [2x1 struct]
       b: 'jack'

       b: 'john'

Write XML with "StructItem = false". Notice multiple 'a' sections

wPref.StructItem = false;
xml_write('test.xml', MyTree, 'MyTree',wPref);
type('test.xml')
fprintf('\nxml_read output:\n')
gen_object_display(xml_read ('test.xml'))

<?xml version="1.0" encoding="utf-8"?>
<MyTree>
   <a>
      <b>jack</b>
   </a>
   <a>
      <b>john</b>
   </a>
</MyTree>

xml_read output:
    a: [2x1 struct]
       b: 'jack'

       b: 'john'

Notice that xml_read function produced the same struct when reading both files

Potential problems with "StructItem = true":

wPref.StructItem = true;
MyTree1 = []; MyTree1.a.b    = 'jack';
MyTree2 = []; MyTree2.a(1).b = 'jack';
MyTree3 = []; MyTree3.a(2).b = 'jack';
xml_write('test.xml', MyTree1, [], wPref); type('test.xml');
xml_write('test.xml', MyTree2, [], wPref); type('test.xml');
xml_write('test.xml', MyTree3, [], wPref); type('test.xml');

<?xml version="1.0" encoding="utf-8"?>
<MyTree1>
   <a>
      <b>jack</b>
   </a>
</MyTree1>

<?xml version="1.0" encoding="utf-8"?>
<MyTree2>
   <a>
      <b>jack</b>
   </a>
</MyTree2>

<?xml version="1.0" encoding="utf-8"?>
<MyTree3>
   <a>
      <item>
         <b/>
      </item>
      <item>
         <b>jack</b>
      </item>
   </a>
</MyTree3>

Notice that MyTree1 and MyTree2 produce identical files with no 'items', while MyTree2 and MyTree3 produce very different file structures. It was pointed out to me that files produced from MyTree2 and MyTree3 can not belong to the same schema, which can be a problem. The solution is to use cells.

wPref.CellItem = true;
wPref.NoCells  = true;
MyTree2 = []; MyTree2.a{1}.b = 'jack';
MyTree3 = []; MyTree3.a{2}.b = 'jack';
xml_write('test.xml', MyTree2, [], wPref); type('test.xml');
xml_write('test.xml', MyTree3, [], wPref); type('test.xml');

<?xml version="1.0" encoding="utf-8"?>
<MyTree2>
   <a>
      <item>
         <b>jack</b>
      </item>
   </a>
</MyTree2>

<?xml version="1.0" encoding="utf-8"?>
<MyTree3>
   <a>
      <item/>
      <item>
         <b>jack</b>
      </item>
   </a>
</MyTree3>

"Pref.CellItem" flag in "xml_write"

Create a simple structure with cell arrays

MyTree = [];
MyTree.a = {'jack', 'john'};
disp(MyTree)

    a: {'jack'  'john'}

Write XML with "CellItem = true" (default). Notice single 'a' section and multiple 'item' sections

Pref=[]; Pref.CellItem = true;
xml_write('test.xml', MyTree, 'MyTree',Pref);
type('test.xml')
fprintf('\nxml_read output:\n');
disp(xml_read ('test.xml'))

<?xml version="1.0" encoding="utf-8"?>
<MyTree>
   <a>
      <item>jack</item>
      <item>john</item>
   </a>
</MyTree>

xml_read output:
    a: {'jack'  'john'}

Write XML with "CellItem = false". Notice multiple 'a' sections

Pref=[]; Pref.CellItem = false;
xml_write('test.xml', MyTree, 'MyTree',Pref);
type('test.xml')
fprintf('\nxml_read output:\n');
disp(xml_read ('test.xml'))

<?xml version="1.0" encoding="utf-8"?>
<MyTree>
   <a>jack</a>
   <a>john</a>
</MyTree>

xml_read output:
    a: {'jack'  'john'}

Notice that xml_read function produced the same struct when reading both files

"Pref.NoCells" flag in "xml_read"

Create a cell/struct mixture object

MyTree = [];
MyTree.a{1}.b = 'jack';
MyTree.a{2}.b = [];
MyTree.a{2}.c = 'john';
gen_object_display(MyTree);

    a: [1x2 cell] = 
       b: 'jack'

       b: [0x0 double]
       c: 'john'

Save it to xml file

Pref=[]; Pref.CellItem = false;
xml_write('test.xml', MyTree, 'MyTree',Pref);
type('test.xml')

<?xml version="1.0" encoding="utf-8"?>
<MyTree>
   <a>
      <b>jack</b>
   </a>
   <a>
      <b/>
      <c>john</c>
   </a>
</MyTree>

Read above file with "Pref.NoCells=true" (default) - output is quite different then input By default program is trying to convert everything to struct's and arrays of structs. In case arrays of structs all the structs in array need to have the same fields, and if they are not than MATLAB creates empty fields.

Pref=[]; Pref.NoCells=true;
gen_object_display(xml_read('test.xml', Pref))

    a: [2x1 struct]
       b: 'jack'
       c: [0x0 double]

       b: [0x0 double]
       c: 'john'

Read above file with "Pref.NoCells=false" - now input and output are the same Cell arrays of structs allow structs in array to have different fields.

Pref=[]; Pref.NoCells=false;
gen_object_display(xml_read('test.xml', Pref))

    a: [1x2 cell] = 
       b: 'jack'

       b: [0x0 double]
       c: 'john'

"Pref.ItemName" flag in "xml_write"

Create a cell/struct mixture object

MyTree = [];
MyTree.a{1}.b = 'jack';
MyTree.a{2}.c = 'john';
gen_object_display(MyTree);

    a: [1x2 cell] = 
       b: 'jack'

       c: 'john'

Save it to xml file, using 'item' notation but with different name

Pref=[];
Pref.CellItem = true;
Pref.ItemName = 'MyItem';
xml_write('test.xml', MyTree, 'MyTree',Pref);
type('test.xml')

<?xml version="1.0" encoding="utf-8"?>
<MyTree>
   <a>
      <MyItem>
         <b>jack</b>
      </MyItem>
      <MyItem>
         <c>john</c>
      </MyItem>
   </a>
</MyTree>

"Pref.ItemName" flag in "xml_read"

Read above file with default settings ("Pref.ItemName = 'item'") The results do not match the original structure

Pref=[]; Pref.NoCells  = false;
gen_object_display(xml_read('test.xml', Pref))

    a: [1x1 struct]
       MyItem: [1x2 cell] = 
               b: 'jack'

               c: 'john'

Read above file with "Pref.ItemName = 'MyItem'" - now saved and read MATLAB structures are the same

Pref=[];
Pref.ItemName = 'MyItem';
Pref.NoCells  = false;
gen_object_display(xml_read('test.xml', Pref))

    a: [1x2 cell] = 
       b: 'jack'

       c: 'john'

"Pref.CellItem" flag in "xml_read"

"Pref.ItemName" is used to create xml files with clearly marked arrays "Pref.CellItem" flag in "xml_read" ensures that they are always read as arrays by forcing output to stay in cell format. In cell format s{1} is different than s, while s(1) is indistinguishable from s.

Create a test file

MyTree = [];
MyTree.a1{1}.b = 'jack'; % a1 - single struct
MyTree.a2{1}.b = 'jack'; % a2 - cell array of structs with the same fields
MyTree.a2{2}.b = 'john';
MyTree.a3{1}.b = 'jack'; % a3 - cell array of structs with the different fields
MyTree.a3{2}.c = 'john';
Pref=[];
Pref.CellItem = true;
Pref.Debug = true;
xml_write('test.xml', MyTree, 'MyTree',Pref);
type('test.xml')

<?xml version="1.0" encoding="utf-8"?>
<MyTree>
   <a1>
      <item>
         <b>jack</b>
      </item>
   </a1>
   <a2>
      <item>
         <b>jack</b>
      </item>
      <item>
         <b>john</b>
      </item>
   </a2>
   <a3>
      <item>
         <b>jack</b>
      </item>
      <item>
         <c>john</c>
      </item>
   </a3>
</MyTree>

Read above file with "Pref.CellItem = true" (default) All outputs are in cell format

Pref=[];
Pref.NoCells  = false;  % allow cell output
Pref.CellItem = true;   % keep 'item' arrays as cells
gen_object_display(xml_read('test.xml', Pref))

    a1: [1x1 cell] = 
        b: 'jack'

    a2: [1x1 cell] = 
            [1x1 struct]    [1x1 struct]

    a3: [1x1 cell] = 
            [1x1 struct]    [1x1 struct]

Read above file with "Pref.CellItem = false" Outputs format is determined by content

Pref=[];
Pref.NoCells  = false; % allow cell output
Pref.CellItem = false; % allow 'item' arrays to beheave like other fields
gen_object_display(xml_read('test.xml', Pref))

    a1: [1x1 struct]
        b: 'jack'
    a2: [2x1 struct]
        b: 'jack'

        b: 'john'

    a3: [1x2 cell] = 
        b: 'jack'

        c: 'john'

Read above file with "Pref.CellItem = false" and "Pref.NoCells = true" All outputs are in struct format

Pref=[];
Pref.NoCells  = true;  % don't allow cell output
Pref.CellItem = false; % allow 'item' arrays to beheave like other fields
gen_object_display(xml_read('test.xml', Pref))

    a1: [1x1 struct]
        b: 'jack'
    a2: [2x1 struct]
        b: 'jack'

        b: 'john'

    a3: [2x1 struct]
        b: 'jack'
        c: [0x0 double]

        b: [0x0 double]
        c: 'john'

"Pref.Str2Num" flag in xml_read

Create a cell/struct mixture object

MyTree = [];
MyTree.str     = 'sphere';
MyTree.num1    =  123;
MyTree.num2    = '123';
MyTree.num3    = '[Inf,NaN]';
MyTree.calc    = '1+2+3+4';
MyTree.func    = 'sin(pi)/2';
MyTree.String1 = '[2003 10 30]';
MyTree.String2 = '2003 10 30';   % array resembling date
MyTree.ISO8601 = '2003-10-30';   % date in ISO 8601 format
MyTree.US_date = '2003/10/30';   % US style date format
MyTree.complex = '2003i-10e-30'; % complex number resembling a date
gen_object_display(MyTree);

        str: 'sphere'
       num1: [123]
       num2: '123'
       num3: '[Inf,NaN]'
       calc: '1+2+3+4'
       func: 'sin(pi)/2'
    String1: '[2003 10 30]'
    String2: '2003 10 30'
    ISO8601: '2003-10-30'
    US_date: '2003/10/30'
    complex: '2003i-10e-30'

Save it to xml file

xml_write('test.xml', MyTree);
type('test.xml')

<?xml version="1.0" encoding="utf-8"?>
<MyTree>
   <str>sphere</str>
   <num1>123</num1>
   <num2>123</num2>
   <num3>[Inf,NaN]</num3>
   <calc>1+2+3+4</calc>
   <func>sin(pi)/2</func>
   <String1>[2003 10 30]</String1>
   <String2>2003 10 30</String2>
   <ISO8601>2003-10-30</ISO8601>
   <US_date>2003/10/30</US_date>
   <complex>2003i-10e-30</complex>
</MyTree>

Read above file with default settings ("Pref.Str2Num = true" or "Pref.Str2Num = 'smart'"). Under this setting all strings that look like numbers are converted to numbers, except for strings that are recognized by MATLAB 'datenum' function as dates

gen_object_display(xml_read('test.xml'))

        str: 'sphere'
       num1: [123]
       num2: [123]
       num3: [Inf  NaN]
       calc: [10]
       func: 'sin(pi)/2'
    String1: [2003    10    30]
    String2: [2003    10    30]
    ISO8601: '2003-10-30'
    US_date: '2003/10/30'
    complex: [-1e-029+2003i]

Note that all the fields of 'MyTree' can be converted to numbers (even 'sphere') but by default the function is trying to 'judge' if a string should be converted to a number or not

MyCell = {'sphere','1+2+3+4','sin(pi)/2','2003 10 30','2003-10-30','2003/10/30','2003i-10e-30'};
cellfun(@str2num, MyCell, 'UniformOutput', false)

ans = 
  Columns 1 through 6
    [21x21 double]    [10]    [6.1232e-017]    [1x3 double]    [1963]    [6.6767]
  Column 7
    [-1.0000e-029 +2.0030e+003i]

Read above file with "Pref.Str2Num = false" or "Pref.Str2Num = 'never'" to keep all the fields in string format

Pref=[]; Pref.Str2Num = false;
gen_object_display(xml_read('test.xml', Pref))

        str: 'sphere'
       num1: '123'
       num2: '123'
       num3: '[Inf,NaN]'
       calc: '1+2+3+4'
       func: 'sin(pi)/2'
    String1: '[2003 10 30]'
    String2: '2003 10 30'
    ISO8601: '2003-10-30'
    US_date: '2003/10/30'
    complex: '2003i-10e-30'

Read above file with "Pref.Str2Num = always" to convert all strings that look like numbers to numbers note the likelly unintendet conversion of 'ISO8601'

Pref=[]; Pref.Str2Num   = 'always';
gen_object_display(xml_read('test.xml', Pref))

        str: 'sphere'
       num1: [123]
       num2: [123]
       num3: [Inf  NaN]
       calc: [10]
       func: 'sin(pi)/2'
    String1: [2003    10    30]
    String2: [2003    10    30]
    ISO8601: [1963]
    US_date: '2003/10/30'
    complex: [-1e-029+2003i]

Notice that all three settings will produce the same output for "num1" and "num2" and there is no way to reproduce the original "MyTree" structure.

"Pref.PreserveSpace" flag in xml_write

Create a struct with strings

MyTree=[];
MyTree.Empty     = '';
MyTree.OneSpace  = ' ';
MyTree.TwoSpaces = '  ';
MyTree.String1   = ' Hello      World ';

Write XML with "PreserveSpace = false" (default).

Pref=[]; Pref.PreserveSpace = false; % (default setting)
xml_write('test.xml', MyTree, [], Pref);
type('test.xml')

<?xml version="1.0" encoding="utf-8"?>
<MyTree>
   <Empty/>
   <OneSpace/>
   <TwoSpaces/>
   <String1>Hello World</String1>
</MyTree>

Write XML with "PreserveSpace = true".

Pref=[]; Pref.PreserveSpace = true;
xml_write('test.xml', MyTree, [], Pref);
type('test.xml')

<?xml version="1.0" encoding="utf-8"?>
<MyTree>
   <Empty/>
   <OneSpace> </OneSpace>
   <TwoSpaces>  </TwoSpaces>
   <String1> Hello      World </String1>
</MyTree>

"Pref.PreserveSpace" flag in xml_read

Read file while using "PreserveSpace = false" (default).

Pref=[]; Pref.PreserveSpace = false; % (default setting)
gen_object_display(xml_read('test.xml',Pref))

        Empty: [0x0 double]
     OneSpace: [0x0 double]
    TwoSpaces: [0x0 double]
      String1: 'Hello      World'

Read file while using "PreserveSpace = true".

Pref=[]; Pref.PreserveSpace = true;
gen_object_display(xml_read('test.xml',Pref))

        Empty: [0x0 double]
     OneSpace: ' '
    TwoSpaces: '  '
      String1: ' Hello      World '

Write XML files with ATTRIBUTEs

In order to add node attributes a special ATTRIBUTE field is used. ATTRIBUTEs have to be of simple types like numbers or strings (not struct or cells). Attributes are easy to attach to structs nodes like MyTree below.

MyTree=[];
MyTree.MyNumber = 13;
MyTree.MyString = 'Hello World'; % simple case
MyTree.ATTRIBUTE.Num = 2;
xml_write('test.xml', MyTree);
type('test.xml')

<?xml version="1.0" encoding="utf-8"?>
<MyTree Num="2">
   <MyNumber>13</MyNumber>
   <MyString>Hello World</MyString>
</MyTree>

In case when one needs to attach attributes to nodes which are not structs (for example strings, numbers or calls) then special CONTENT field needs to be used to make the node a struct node.

MyTree=[];
MyTree.MyNumber = 13;
MyTree.MyString.CONTENT = 'Hello World'; % simple case
MyTree.MyString.ATTRIBUTE.Num = 2;
xml_write('test.xml', MyTree);
type('test.xml')

<?xml version="1.0" encoding="utf-8"?>
<MyTree>
   <MyNumber>13</MyNumber>
   <MyString Num="2">Hello World</MyString>
</MyTree>

"Pref.Str2Num" flag in file with ATTRIBUTEs

Create a cell/struct mixture object

MyTree = [];
MyTree.X.ATTRIBUTE.str     = 'sphere';
MyTree.X.ATTRIBUTE.num1    =  123;
MyTree.X.ATTRIBUTE.num2    = '123';
MyTree.X.ATTRIBUTE.num3    = '[Inf,NaN]';
MyTree.X.ATTRIBUTE.calc    = '1+2+3+4';
MyTree.X.ATTRIBUTE.func    = 'sin(pi)/2';
MyTree.X.ATTRIBUTE.String1 = '[2003 10 30]';
MyTree.X.ATTRIBUTE.String2 = '2003 10 30';   % array resembling date
MyTree.X.ATTRIBUTE.ISO8601 = '2003-10-30';   % date in ISO 8601 format
MyTree.X.ATTRIBUTE.US_date = '2003/10/30';   % US style date format
MyTree.X.ATTRIBUTE.complex = '2003i-10e-30'; % complex number resembling a date
gen_object_display(MyTree);

    X: [1x1 struct]
       ATTRIBUTE: [1x1 struct]
                      str: 'sphere'
                     num1: [123]
                     num2: '123'
                     num3: '[Inf,NaN]'
                     calc: '1+2+3+4'
                     func: 'sin(pi)/2'
                  String1: '[2003 10 30]'
                  String2: '2003 10 30'
                  ISO8601: '2003-10-30'
                  US_date: '2003/10/30'
                  complex: '2003i-10e-30'

Save it to xml file

xml_write('test.xml', MyTree);
type('test.xml')

<?xml version="1.0" encoding="utf-8"?>
<MyTree>
   <X ISO8601="2003-10-30" String1="[2003 10 30]" String2="2003 10 30" US_date="2003/10/30" calc="1+2+3+4" complex="2003i-10e-30" func="sin(pi)/2" num1="123" num2="123" num3="[Inf,NaN]" str="sphere"/>
</MyTree>

Read above file with default settings ("Pref.Str2Num = true" or "Pref.Str2Num = 'smart'"). Under this setting all strings that look like numbers are converted to numbers, except for strings that are recognized by MATLAB 'datenum' function as dates

gen_object_display(xml_read('test.xml'))

    X: [1x1 struct]
         CONTENT: [0x0 double]
       ATTRIBUTE: [1x1 struct]
                  ISO8601: '2003-10-30'
                  String1: '[2003 10 30]'
                  String2: '2003 10 30'
                  US_date: '2003/10/30'
                     calc: '1+2+3+4'
                  complex: [-1e-029+2003i]
                     func: 'sin(pi)/2'
                     num1: [123]
                     num2: [123]
                     num3: '[Inf,NaN]'
                      str: 'sphere'

Read above file with "Pref.Str2Num = false" or "Pref.Str2Num = 'never'" to keep all the fields in string format

Pref=[]; Pref.Str2Num = false;
gen_object_display(xml_read('test.xml', Pref))

    X: [1x1 struct]
         CONTENT: [0x0 double]
       ATTRIBUTE: [1x1 struct]
                  ISO8601: '2003-10-30'
                  String1: '[2003 10 30]'
                  String2: '2003 10 30'
                  US_date: '2003/10/30'
                     calc: '1+2+3+4'
                  complex: '2003i-10e-30'
                     func: 'sin(pi)/2'
                     num1: '123'
                     num2: '123'
                     num3: '[Inf,NaN]'
                      str: 'sphere'

Read above file with "Pref.Str2Num = always" to convert all strings that look like numbers to numbers

Pref=[]; Pref.Str2Num   = 'always';
gen_object_display(xml_read('test.xml', Pref))

    X: [1x1 struct]
         CONTENT: [0x0 double]
       ATTRIBUTE: [1x1 struct]
                  ISO8601: '2003-10-30'
                  String1: '[2003 10 30]'
                  String2: '2003 10 30'
                  US_date: '2003/10/30'
                     calc: '1+2+3+4'
                  complex: [-1e-029+2003i]
                     func: 'sin(pi)/2'
                     num1: [123]
                     num2: [123]
                     num3: '[Inf,NaN]'
                      str: 'sphere'

Notice that all three settings will produce the same output for "num1" and "num2" and there is no way to reproduce the original "MyTree" structure.

Write XML files with COMMENTs

Insertion of Comments is done with help of special COMMENT field. Note that MATLAB's xmlwrite is less readable due to lack of end-of-line characters around comment section.

MyTree=[];
MyTree.COMMENT = 'This is a comment';
MyTree.MyNumber = 13;
MyTree.MyString.CONTENT = 'Hello World';
xml_write('test.xml', MyTree);
type('test.xml')

<?xml version="1.0" encoding="utf-8"?>
<MyTree><!--This is a comment-->
   <MyNumber>13</MyNumber>
   <MyString>Hello World</MyString>
</MyTree>

Same operation using Apache Xerces XML engine gives the same result

Pref=[]; Pref.XmlEngine = 'Xerces';  % use Xerces xml generator directly
xml_write('test.xml', MyTree, 'MyTree', Pref);
type('test.xml')

<?xml version="1.0" encoding="UTF-8"?>
<MyTree>
    <!--This is a comment-->
    <MyNumber>13</MyNumber>
    <MyString>Hello World</MyString>
</MyTree>

Comments in XML top level (method #1) This method uses cell array

MyTree=[];
MyTree.MyNumber = 13;
MyTree.MyString = 'Hello World';
xml_write('test.xml', MyTree, {'MyTree', [], 'This is a global comment'});
type('test.xml')

<?xml version="1.0" encoding="utf-8"?><!--This is a global comment-->
<MyTree>
   <MyNumber>13</MyNumber>
   <MyString>Hello World</MyString>
</MyTree>

Same operation using Apache Xerces XML engine gives even nicer results.

Pref=[]; Pref.XmlEngine = 'Xerces';  % use Xerces xml generator directly
xml_write('test.xml', MyTree, {'MyTree', [], 'This is a global comment'}, Pref);
type('test.xml')

<?xml version="1.0" encoding="UTF-8"?>
<!--This is a global comment-->
<MyTree>
    <MyNumber>13</MyNumber>
    <MyString>Hello World</MyString>
</MyTree>

Comments in XML top level (method #2) This method adds an extra top layer to the struct 'tree' and sets "Pref.RootOnly = false", which informs the function about the extra layer. Notice that RootName is also saved as a part of the 'tree', and does not have to be passed in separately.

MyTree=[];
MyTree.COMMENT = 'This is a global comment';
MyTree.MyTest.MyNumber = 13;
MyTree.MyTest.MyString = 'Hello World';
Pref=[]; Pref.RootOnly = false;
xml_write('test.xml', MyTree, [], Pref);
type('test.xml')

<?xml version="1.0" encoding="utf-8"?><!--This is a global comment-->
<MyTest>
   <MyNumber>13</MyNumber>
   <MyString>Hello World</MyString>
</MyTest>

Same operation using Apache Xerces XML engine

Pref=[]; Pref.XmlEngine = 'Xerces';  % use Xerces xml generator directly
Pref.RootOnly  = false;
xml_write('test.xml', MyTree, [], Pref);
type('test.xml')

<?xml version="1.0" encoding="UTF-8"?>
<!--This is a global comment-->
<MyTest>
    <MyNumber>13</MyNumber>
    <MyString>Hello World</MyString>
</MyTest>

Write XML files with PROCESSING_INSTRUCTIONs

Insertion of Processing Instructions is done through use of special PROCESSING_INSTRUCTION field, which stores the instruction string. The string has to be in 'target data' format separated by space.

MyTree=[];
MyTree.PROCESSING_INSTRUCTION = 'xml-stylesheet type="a" href="foo"';
MyTree.MyNumber = 13;
MyTree.MyString = 'Hello World';
xml_write('test.xml', MyTree);
type('test.xml')

<?xml version="1.0" encoding="utf-8"?>
<MyTree><?xml-stylesheet type="a" href="foo"?>
   <MyNumber>13</MyNumber>
   <MyString>Hello World</MyString>
</MyTree>

Same operation using Apache Xerces XML engine

Pref=[]; Pref.XmlEngine = 'Xerces';  % use Xerces xml generator directly
xml_write('test.xml', MyTree, 'MyTree', Pref);
type('test.xml')

<?xml version="1.0" encoding="UTF-8"?>
<MyTree><?xml-stylesheet type="a" href="foo"?>
    <MyNumber>13</MyNumber>
    <MyString>Hello World</MyString>
</MyTree>

PROCESSING_INSTRUCTIONs in XML top level (method #1) This method uses cell array

MyTree=[];
MyTree.MyNumber = 13;
MyTree.MyString = 'Hello World';
xml_write('test.xml', MyTree, {'MyTree', 'xml-stylesheet type="a" href="foo"'});
type('test.xml')

<?xml version="1.0" encoding="utf-8"?><?xml-stylesheet type="a" href="foo"?>
<MyTree>
   <MyNumber>13</MyNumber>
   <MyString>Hello World</MyString>
</MyTree>

Same operation using Apache Xerces XML engine

Pref=[]; Pref.XmlEngine = 'Xerces';  % use Xerces xml generator directly
xml_write('test.xml', MyTree, {'MyTree', 'xml-stylesheet type="a" href="foo"'}, Pref);
type('test.xml')

<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="a" href="foo"?>
<MyTree>
    <MyNumber>13</MyNumber>
    <MyString>Hello World</MyString>
</MyTree>

PROCESSING_INSTRUCTIONs in XML top level (method #2) This method adds an extra top layer to the struct 'tree' and sets pref.RootOnly=false, which informs the function about the extra layer. Notice that RootName is also saved as a part of the 'tree', and does not have to be passed in separately.

MyTree=[];
MyTree.PROCESSING_INSTRUCTION =  'xml-stylesheet type="a" href="foo"';
MyTree.MyTest.MyNumber = 13;
MyTree.MyTest.MyString = 'Hello World';
Pref=[]; Pref.RootOnly = false;
xml_write('test.xml', MyTree, [], Pref);
type('test.xml')

<?xml version="1.0" encoding="utf-8"?><?xml-stylesheet type="a" href="foo"?>
<MyTest>
   <MyNumber>13</MyNumber>
   <MyString>Hello World</MyString>
</MyTest>

Same operation using Apache Xerces XML engine

Pref=[]; Pref.XmlEngine = 'Xerces';  % use Xerces xml generator directly
Pref.RootOnly  = false;
xml_write('test.xml', MyTree, 'MyTree', Pref);
type('test.xml')

<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="a" href="foo"?>
<MyTest>
    <MyNumber>13</MyNumber>
    <MyString>Hello World</MyString>
</MyTest>

Write XML files with CDATA Sections

"In an XML document a CDATA (Character DATA) section is a section of element content that is marked for the parser to interpret as only character data, not markup." (from Wikipedia) To insert CDATA Sections one use special CDATA_SECTION field, which stores the instruction string. Note that MATLAB's xmlwrite created wrong xml code for CDATA section

MyTree=[];
MyTree.CDATA_SECTION = '<A>txt</A>';
MyTree.MyNumber = 13;
MyTree.MyString = 'Hello World';
xml_write('test.xml', MyTree);
type('test.xml')

<?xml version="1.0" encoding="utf-8"?>
<MyTree>&lt;A&gt;txt&lt;/A&gt;<MyNumber>13</MyNumber>
   <MyString>Hello World</MyString>
</MyTree>

Same operation using Apache Xerces XML engine produces correct results

Pref=[]; Pref.XmlEngine = 'Xerces';  % use Xerces xml generator directly
xml_write('test.xml', MyTree, 'MyTree', Pref);
type('test.xml')

<?xml version="1.0" encoding="UTF-8"?>
<MyTree><![CDATA[<A>txt</A>]]><MyNumber>13</MyNumber>
    <MyString>Hello World</MyString>
</MyTree>

Write XML files with special characters in TAG names

The input to xml_write requires that all tags one wants in XML document have to be encoded as field names of MATLAB's struct's. Matlab has a lot of restrictions on variable names. This section is about XML tags with names not allowed as MATLAB variables, or more specifically with characters allowed as xml tag names but not allowed as MATLAB variable names. Characters like that can be replaced by their hexadecimal representation just as it is done by genvarname function. Alternative way of writing the first example is:

MyTree=[];
MyTree.('MyNumber') = 13;               % same as MyTree.MyNumber = 13;
MyTree.MyString.CONTENT = 'Hello World';
MyTree.MyString.ATTRIBUTE.('Num') = 2;  % same as MyTree.MyString.ATTRIBUTE.Num = 2;
xml_write('test.xml', MyTree);
type('test.xml')

<?xml version="1.0" encoding="utf-8"?>
<MyTree>
   <MyNumber>13</MyNumber>
   <MyString Num="2">Hello World</MyString>
</MyTree>

This approach fails for some characters like dash '-', colon ':', and international characters.

MyTree=[];
try
  MyTree.('My-Number') = 13;
  MyTree.MyString.CONTENT = 'Hello World';
  MyTree.MyString.ATTRIBUTE.('Num_ö') = 2;
catch  %#ok<CTCH>
  err = lasterror; %#ok<LERR>
  disp(err.message);
end

Invalid field name: 'My-Number'.

It can be overcome by replacing offending characters with their hexadecimal representation. That can be done manually or with use of genvarname function. Note that MATLAB 'type' function does not show correctly 'ö' letter in xml file, but opening the file in editor shows that it is correct.

MyTree=[];
MyTree.(genvarname('My-Number')) = 13;
MyTree.MyString.CONTENT = 'Hello World';
MyTree.MyString.ATTRIBUTE.Num_0xF6 = 2;
gen_object_display(MyTree);
xml_write('test.xml', MyTree);
type('test.xml')

    My0x2DNumber: [13]
        MyString: [1x1 struct]
                    CONTENT: 'Hello World'
                  ATTRIBUTE: [1x1 struct]
                             Num_0xF6: [2]

<?xml version="1.0" encoding="utf-8"?>
<MyTree>
   <My-Number>13</My-Number>
   <MyString Num_ö="2">Hello World</MyString>
</MyTree>

Also two of the characters '-' and ':' can be encoded by a special strings: '_DASH_' and '_COLON_' respectively

MyTree=[];
MyTree.My_DASH_Number = 13;
MyTree.MyString.CONTENT = 'Hello World';
MyTree.MyString.ATTRIBUTE.Num0xF6 = 2;
xml_write('test.xml', MyTree);
type('test.xml')

<?xml version="1.0" encoding="utf-8"?>
<MyTree>
   <My-Number>13</My-Number>
   <MyString Numö="2">Hello World</MyString>
</MyTree>

Write XML files with Namespaces

No extra special fields are needed to define XML namespaces, only colon character written using '0x3A' or '_COLON_'. Below is an example of a namespace definition

MyTree=[];
MyTree.f_COLON_child.ATTRIBUTE.xmlns_COLON_f = 'http://www.foo.com';
MyTree.f_COLON_child.f_COLON_MyNumber = 13;
MyTree.f_COLON_child.f_COLON_MyString = 'Hello World';
xml_write('test.xml', MyTree, 'MyTree');
type('test.xml')

<?xml version="1.0" encoding="utf-8"?>
<MyTree>
   <f:child xmlns:f="http://www.foo.com">
      <f:MyNumber>13</f:MyNumber>
      <f:MyString>Hello World</f:MyString>
   </f:child>
</MyTree>

Same operation using Apache Xerces XML engine

Pref=[]; Pref.XmlEngine = 'Xerces';  % use Xerces xml generator directly
xml_write('test.xml', MyTree, 'f_COLON_MyTree', Pref);
type('test.xml')

<?xml version="1.0" encoding="UTF-8"?>
<f:MyTree>
    <f:child xmlns:f="http://www.foo.com">
        <f:MyNumber>13</f:MyNumber>
        <f:MyString>Hello World</f:MyString>
    </f:child>
</f:MyTree>

"Pref.KeepNS" flag in "xml_read"

Thise option allow keeping or exclusion of namespaces in tag names. By default the namespace data is kept but it produces much longer field names in the output structure. Ignoring namespace will produce more readible output. Perform default read of file with namespace

tree = xml_read('test.xml');
gen_object_display(tree);

    f_COLON_child: [1x1 struct]
                   f_COLON_MyNumber: [13]
                   f_COLON_MyString: 'Hello World'
                          ATTRIBUTE: [1x1 struct]
                                     xmlns_COLON_f: 'http://www.foo.com'

Now the same operation with KeepNS = false.

Pref=[]; Pref.KeepNS = false; % do not read attributes
tree = xml_read('test.xml', Pref);
gen_object_display(tree);

    child: [1x1 struct]
            MyNumber: [13]
            MyString: 'Hello World'
           ATTRIBUTE: [1x1 struct]
                      f: 'http://www.foo.com'

Read XML files with special node types

Display and read the file, then show the data structure. Note that MATLAB 'type' function shows 'ö' letter incorrectly as 'A¶' in xml file, but opening the file in editor shows that it is correct.

fprintf('Test xml file:\n');
type('test_file.xml')

Test xml file:

<?xml version="1.0" encoding="utf-8" ?> 
<?xml-stylesheet type="text/css" href="foo.css"?>
<!-- This is a Global Comment -->
<aaa xmlns:xsi="http://www.foo.org">
  <?ProcInst type="local processing instruction"?>
  <!-- local comment 1 -->
  bbb
  <!-- local comment 2 -->
  ccc
  <matrix bad-name='fff'>
    5e3+2*i, Inf
    NaN,     pi
  </matrix>
  <ee_e> ee_e </ee_e>
  <ff-f> ff-f </ff-f>
  <ggög> ggög </ggög>
  <![CDATA[
    Here <ddd>xml</ddd> tags are treated as ...
    ... text
	]]>
</aaa>

Read only the Root Element (default)

[tree GlobalTextNodes] = xml_read('test_file.xml');
fprintf('Global Data (Root name, Global Processing Instructions and Global Comments):\n');
disp(GlobalTextNodes')
fprintf('\nStructure read from the file (uncludes COMMENT and CDATA sections):\n');
gen_object_display(tree);

Global Data (Root name, Global Processing Instructions and Global Comments):
    'aaa'
    'xml-stylesheet type="text/css" href="foo.css"'
    'This is a Global Comment'

Structure read from the file (uncludes COMMENT and CDATA sections):
    PROCESSING_INSTRUCTION: 'ProcInst type="local processing instruction"'
                   COMMENT: [1x2 cell] = 
                            local comment 1

                            local comment 2

                   CONTENT: [1x2 cell] = 
                            bbb

                            ccc

                    matrix: [1x1 struct]
                              CONTENT: [2x2 double]
                            ATTRIBUTE: [1x1 struct]
                                       bad_DASH_name: 'fff'
                      ee_e: 'ee_e'
                 ff_DASH_f: 'ff-f'
                   gg0xF6g: 'ggög'
             CDATA_SECTION: 'Here <ddd>xml</ddd> tags are treated as ...
    ... text'
                 ATTRIBUTE: [1x1 struct]
                            xmlns_COLON_xsi: 'http://www.foo.org'

Read the whole tree including global Comments and Processing Instructions

Pref=[]; Pref.RootOnly = false;
[tree GlobalTextNodes] = xml_read('test_file.xml', Pref);
fprintf('Global Data (Root name, Global Processing Instructions and Global Comments):\n');
disp(GlobalTextNodes')
fprintf('\nStructure read from the file (uncludes COMMENT and CDATA sections):\n');
gen_object_display(tree);

Global Data (Root name, Global Processing Instructions and Global Comments):
    'aaa'
    'xml-stylesheet type="text/css" href="foo.css"'
    'This is a Global Comment'

Structure read from the file (uncludes COMMENT and CDATA sections):
    PROCESSING_INSTRUCTION: 'xml-stylesheet type="text/css" href="foo.css"'
                   COMMENT: 'This is a Global Comment'
                       aaa: [1x1 struct]
                            PROCESSING_INSTRUCTION: 'ProcInst type="local processing instruction"'
                                           COMMENT: [1x2 cell] = 
                                                    local comment 1

                                                    local comment 2

                                           CONTENT: [1x2 cell] = 
                                                    bbb

                                                    ccc

                                            matrix: [1x1 struct]
                                                      CONTENT: [2x2 double]
                                                    ATTRIBUTE: [1x1 struct]
                                                               bad_DASH_name: 'fff'
                                              ee_e: 'ee_e'
                                         ff_DASH_f: 'ff-f'
                                           gg0xF6g: 'ggög'
                                     CDATA_SECTION: 'Here <ddd>xml</ddd> tags are treated as ...
    ... text'
                                         ATTRIBUTE: [1x1 struct]
                                                    xmlns_COLON_xsi: 'http://www.foo.org'

"Pref.ReadAttr" flag in "xml_read"

Those option allow exclusion of attributes

Pref=[]; Pref.ReadAttr = false; % do not read attributes
tree = xml_read('test_file.xml', Pref);
gen_object_display(tree);

    PROCESSING_INSTRUCTION: 'ProcInst type="local processing instruction"'
                   COMMENT: [1x2 cell] = 
                            local comment 1

                            local comment 2

                   CONTENT: [1x2 cell] = 
                            bbb

                            ccc

                    matrix: [2x2 double]
                      ee_e: 'ee_e'
                 ff_DASH_f: 'ff-f'
                   gg0xF6g: 'ggög'
             CDATA_SECTION: 'Here <ddd>xml</ddd> tags are treated as ...
    ... text'

"Pref.ReadSpec" flag in "xml_read"

Those option allow exclusion of special nodes, like comments, processing instructions, CData sections, etc.

Pref=[]; Pref.ReadSpec = false; % do not read special node types
tree = xml_read('test_file.xml', Pref);
gen_object_display(tree);

      CONTENT: [1x2 cell] = 
               bbb

               ccc

       matrix: [1x1 struct]
                 CONTENT: [2x2 double]
               ATTRIBUTE: [1x1 struct]
                          bad_DASH_name: 'fff'
         ee_e: 'ee_e'
    ff_DASH_f: 'ff-f'
      gg0xF6g: 'ggög'
    ATTRIBUTE: [1x1 struct]
               xmlns_COLON_xsi: 'http://www.foo.org'

"Pref.RootOnly" flag in "xml_read"

As it was shown in previous examples RootOnly parameter can be used to capture global (top level) special nodes (like COMMENTs and PROCESSING_INSTRUCTIONs) which are ignored by default

Pref=[]; Pref.RootOnly = false; % do not read special node types
tree = xml_read('test_file.xml', Pref);
gen_object_display(tree);

    PROCESSING_INSTRUCTION: 'xml-stylesheet type="text/css" href="foo.css"'
                   COMMENT: 'This is a Global Comment'
                       aaa: [1x1 struct]
                            PROCESSING_INSTRUCTION: 'ProcInst type="local processing instruction"'
                                           COMMENT: [1x2 cell] = 
                                                    local comment 1

                                                    local comment 2

                                           CONTENT: [1x2 cell] = 
                                                    bbb

                                                    ccc

                                            matrix: [1x1 struct]
                                                      CONTENT: [2x2 double]
                                                    ATTRIBUTE: [1x1 struct]
                                                               bad_DASH_name: 'fff'
                                              ee_e: 'ee_e'
                                         ff_DASH_f: 'ff-f'
                                           gg0xF6g: 'ggög'
                                     CDATA_SECTION: 'Here <ddd>xml</ddd> tags are treated as ...
    ... text'
                                         ATTRIBUTE: [1x1 struct]
                                                    xmlns_COLON_xsi: 'http://www.foo.org'

"Pref.RootOnly" flag in "xml_write"

Writing previously read tree with default "Pref.RootOnly = true" gives wrong output file

Pref=[]; Pref.RootOnly = true; % do not read special node types
xml_write('test.xml', tree, [], Pref);
fprintf('Test xml file:\n');
type('test.xml')

Test xml file:

<?xml version="1.0" encoding="utf-8"?>
<tree><?xml-stylesheet type="text/css" href="foo.css"?><!--This is a Global Comment-->
   <aaa xmlns:xsi="http://www.foo.org"><?ProcInst type="local processing instruction"?><!--local comment 1--><!--local comment 2-->
      <item>bbb</item>
      <item>ccc</item>
      <matrix bad-name="fff">[5000+i*2 Inf; NaN 3.14159265358979]</matrix>
      <ee_e>ee_e</ee_e>
      <ff-f>ff-f</ff-f>
      <ggög>ggög</ggög>Here &lt;ddd&gt;xml&lt;/ddd&gt; tags are treated as ...
    ... text</aaa>
</tree>

Writing the same tree with "Pref.RootOnly = false" gives correct output

Pref=[]; Pref.RootOnly = false; % do not read special node types
xml_write('test.xml', tree, [], Pref);
fprintf('Test xml file:\n');
type('test.xml')

Test xml file:

<?xml version="1.0" encoding="utf-8"?><?xml-stylesheet type="text/css" href="foo.css"?><!--This is a Global Comment-->
<aaa xmlns:xsi="http://www.foo.org"><?ProcInst type="local processing instruction"?><!--local comment 1--><!--local comment 2-->
   <item>bbb</item>
   <item>ccc</item>
   <matrix bad-name="fff">[5000+i*2 Inf; NaN 3.14159265358979]</matrix>
   <ee_e>ee_e</ee_e>
   <ff-f>ff-f</ff-f>
   <ggög>ggög</ggög>Here &lt;ddd&gt;xml&lt;/ddd&gt; tags are treated as ...
    ... text</aaa>

"Pref.NumLevels" flag in "xml_read"

This parameter allows user to skip parts of the tree in order to save time and memory. Usefull only in a rare case when a small portion of large XML file is needed.

Create test tile

MyTree = [];
MyTree.Level1 = 1;
MyTree.Level1_.Level2 = 2;
MyTree.Level1_.Level2_.Level3 = 3;
MyTree.Level1_.Level2_.Level3_.Level4 = 4;
xml_write('test.xml', MyTree);
fprintf('Test xml file:\n');
type('test.xml')

Test xml file:

<?xml version="1.0" encoding="utf-8"?>
<MyTree>
   <Level1>1</Level1>
   <Level1_>
      <Level2>2</Level2>
      <Level2_>
         <Level3>3</Level3>
         <Level3_>
            <Level4>4</Level4>
         </Level3_>
      </Level2_>
   </Level1_>
</MyTree>

Use Default ("Pref.NumLevels = infinity") setting

tree = xml_read('test.xml');
gen_object_display(tree);

     Level1: [1]
    Level1_: [1x1 struct]
              Level2: [2]
             Level2_: [1x1 struct]
                       Level3: [3]
                      Level3_: [1x1 struct]
                               Level4: [4]

Limit the read to only 2 levels

Pref=[]; Pref.NumLevels = 2;
tree = xml_read('test.xml', Pref);
gen_object_display(tree);

     Level1: [1]
    Level1_: [1x1 struct]
              Level2: [2]
             Level2_: [0x0 double]

Create DOM object based on a Struct using "xml_write"

Create Struct tree

MyTree=[];
MyTree.MyNumber = 13;
MyTree.MyString = 'Hello World';

Convert Struct to DOM object using xml_write

DOM = xml_write([], MyTree);
xmlwrite('test.xml', DOM);   % Save DOM object using MATLAB function
type('test.xml')

<?xml version="1.0" encoding="utf-8"?>
<MyTree>
   <MyNumber>13</MyNumber>
   <MyString>Hello World</MyString>
</MyTree>

Convert DOM object to Struct using "xml_read"

DOM = xmlread('test.xml');       % Read DOM object using MATLAB function
[tree treeName] = xml_read(DOM); % Convert DOM object to Struct
disp([treeName{1} ' ='])
gen_object_display(tree)

MyTree =
    MyNumber: [13]
    MyString: 'Hello World'

Write XML file based on a DOM using "xml_write_xerces"

xmlwrite_xerces('test.xml', DOM); % Save DOM object using Xerces library
type('test.xml')

<?xml version="1.0" encoding="UTF-8"?>
<MyTree>
    <MyNumber>13</MyNumber>
    <MyString>Hello World</MyString>
</MyTree>

Write XML to string instead of a file

DOM = xml_write([], MyTree);
str = xmlwrite(DOM);
disp(str)

<?xml version="1.0" encoding="utf-8"?>
<MyTree>
   <MyNumber>13</MyNumber>
   <MyString>Hello World</MyString>
</MyTree>

Write XML file with embedded binary data encoded as Base64

fid = fopen('football.jpg', 'rb');
raw = fread(fid, 'uint8');                % read image file as a raw binary
fclose(fid);

MyTree=[];
MyTree.Size = 13;
MyTree.MyString = 'Hello World'; % simple case
MyTree.MyImage.ATTRIBUTE.EncodingMIMEType = 'base64';
MyTree.MyImage.CONTENT = base64encode(raw);% perform base64 encoding of the binary data
xml_write('test.xml', MyTree);             % write xml file

Read XML file with embedded binary data encoded as Base64

tree = xml_read('test.xml', Pref);         % read xml file
raw  = base64decode(tree.MyImage.CONTENT); % convert xml image to raw binary
fid = fopen('MyFootball.jpg', 'wb');
fwrite(fid, raw, 'uint8');                 % dumb the raw binary to the hard disk
fclose(fid);
I = imread('MyFootball.jpg');              % read it as an image
imshow(I);

Published with MATLAB® 7.7