Search icon CANCEL
Arrow left icon
Explore Products
Best Sellers
New Releases
Books
Videos
Audiobooks
Learning Hub
Conferences
Free Learning
Arrow right icon
Arrow up icon
GO TO TOP
Delphi Cookbook

You're reading from   Delphi Cookbook 50 hands-on recipes to master the power of Delphi for cross-platform and mobile development on Windows, Mac OS X, Android, and iOS

Arrow left icon
Product type Paperback
Published in Sep 2014
Publisher
ISBN-13 9781783559589
Length 328 pages
Edition 1st Edition
Languages
Arrow right icon
Author (1):
Arrow left icon
Daniele Teti Daniele Teti
Author Profile Icon Daniele Teti
Daniele Teti
Arrow right icon
View More author details
Toc

Table of Contents (9) Chapters Close

Preface 1. Delphi Basics FREE CHAPTER 2. Become a Delphi Language Ninja 3. Going Cross Platform with FireMonkey 4. The Thousand Faces of Multithreading 5. Putting Delphi on the Server 6. Riding the Mobile Revolution with FireMonkey 7. Using Specific Platform Features Index

Manipulating and transforming XML documents

XML stands for eXtensible Markup Language (http://en.wikipedia.org/wiki/XML) and is designed to represent, transport, and store hierarchical data in trees of nodes. You can use XML to communicate with different systems to store configuration files, complex entities, and so on. All of these use a standard and powerful format. Delphi has had good support for XML for more than a decade now.

Getting ready

All the basic XML-related activities can be summarized with the following points:

  • Generating XML data
  • Parsing XML data
  • Parsing XML data and modifying it

In this recipe, we will see how to do all these activities.

How to do it…

  1. Create a new VCL application and drop three TButton and a TMemo. Align all the buttons as a toolbar at the top of the form and the memo to the remaining form client area.
  2. From left- to right-hand side, name the buttons as btnGenerateXML, btnModifyXML, and btnParseXML.
  3. The real work on the XML will be done by the TXMLDocument component. So, drop one instance of the form and set its DOMVendor property to ADOM XML v4.
  4. We'll use static data as our data source. A simple matrix is enough for this recipe. Just after the implementation section of the unit, write the following code:
    type
      TCarInfo = (
       Manufacturer = 1, 
       Name = 2, 
       Currency = 3, 
       Price = 4);
    
    var
      Cars: array [1 .. 4] of 
             array [Manufacturer .. Price] of string = (
              (
                'Ferrari','360 Modena','EUR', '250,000'
               ),
              (
                'Ford', 'Mustang', 'USD', '80,000'
              ),
              (
                'Lamborghini', 'Countach', 'EUR','300,000'
               ),
               (
                 'Chevrolet', 'Corvette', 'USD', '100,000'
                )
              ); 
  5. We will use a TMemo component to display the XML and the data. To keep things clear, create on the form a public property called XML and map its setter and getter methods to the Memo1.Lines.Text property. Use the following code:
    //…other form methods declaration 
    private
      procedure SetXML(const Value: String);
      function GetXML: String;
    public
      property Xml: String read GetXML write SetXML;
    end;
    
    //…then in the implementation section
    function TMainForm.GetXML: String;
    begin
      Result := Memo1.Lines.Text;
    end;
    
    procedure TMainForm.SetXML(const Value: String);
    begin
      Memo1.Lines.Text := Value;
    end;
    
  6. Now, create event handlers for each button. For the btnGenerateXML button, write the following code:
    procedure TMainForm.btnGenerateXMLClick(Sender: TObject);
    var
      RootNode, Car, CarPrice: IXMLNode;
      i: Integer;
      s: String;
    begin
      XMLDocument1.Active := True;
      try
        XMLDocument1.Version := '1.0';
        RootNode := XMLDocument1.AddChild('cars');
        for i := Low(Cars) to High(Cars) do
        begin
          Car := XMLDocument1.CreateNode('car');
          Car.AddChild('manufacturer').Text := 
              Cars[i][TCarInfo.Manufacturer];
          Car.AddChild('name').Text := 
              Cars[i][TCarInfo.Name];
          CarPrice := Car.AddChild('price');
          CarPrice.Attributes['currency'] := 
             Cars[i][TCarInfo.Currency];
          CarPrice.Text := Cars[i][TCarInfo.Price];
          RootNode.ChildNodes.Add(Car);
        end;
        XMLDocument1.SaveToXML(s);
        Xml := s;
      finally
        XMLDocument1.Active := False;
      end;
    end;
    
  7. Now we've to write the code to change the XML. In the btnModifyXML click event handler, write the following code:
    procedure TMainForm.btnModifyXMLClick(Sender: TObject);
    var
      Car, CarPrice: IXMLNode;
      s: string;
    begin
      XMLDocument1.LoadFromXML(Xml);
      try
        Xml := '';
        Car := XMLDocument1.CreateNode('car');
        Car.AddChild('manufacturer').Text := 'Hennessey';
        Car.AddChild('name').Text := 'Venom GT';
        CarPrice := Car.AddChild('price');
        CarPrice.Attributes['currency'] := 'USD';
        CarPrice.Text := '600,000';
        XMLDocument1.DocumentElement.ChildNodes.Add(Car);
        XMLDocument1.SaveToXML(s);
        Xml := s;
      finally
        XMLDocument1.Active := False;
      end;
    end;
    
  8. Write the following code under the btnParseXML click event handler:
    procedure TMainForm.btnParseXMLClick(Sender: TObject);
    var
      CarsList: IDOMNodeList;
      CurrNode: IDOMNode;
      childidx, i: Integer;
      CarName, CarManufacturer, CarPrice, CarCurrencyType: string;
    begin
      XMLDocument1.LoadFromXML(Xml);
      try
        Xml := '';
        CarsList := XMLDocument1.
             DOMDocument.getElementsByTagName('car');
        for i := 0 to CarsList.length - 1 do
        begin
          CarName := '';  CarManufacturer := '';
          CarPrice := '';  CarCurrencyType := '';
          for childidx := 0 to 
             CarsList[i].ChildNodes.length - 1 do
          begin
            CurrNode := CarsList[i].ChildNodes[childidx];
            if CurrNode.nodeName.Equals('name') then
              CarName := CurrNode.firstChild.nodeValue;
            if CurrNode.nodeName.Equals('manufacturer') then
              CarManufacturer := CurrNode.firstChild.nodeValue;
            if CurrNode.nodeName.Equals('price') then
            begin
              CarPrice := CurrNode.firstChild.nodeValue;
              CarCurrencyType := 
                CurrNode.Attributes.
                getNamedItem('currency').nodeValue;
            end;
          end;
          Xml := Xml +
            'Name = ' + CarName + sLineBreak +
            'Manufacturer = ' + CarManufacturer + sLineBreak +
            'Price = ' + 
                    CarPrice + CarCurrencyType + sLineBreak +
            '-----' + sLineBreak;
        end;
      finally
        XMLDocument1.Active := False;
      end;
    end;
    
  9. Run the application by hitting F9 (or navigate to Run | Run).
  10. Click on the btnGenerateXML button and you should see some XML data in the memo.
  11. Click on the btnModifyXML button and you should see some more XML in the memo.
  12. Click on the last button and you should see the same data as before, but in normal text representation.
  13. After the third click, you should see something like the following screenshot:
    How to do it…

    Text representation of the XML data generated and modified

How it works…

  • The first button generates the XML representation of the data in our matrix. We've used some car information as sample data.

    Note

    Note that the prices of the cars are not real.

  • To create an XML, there are three fundamental TXMLDocument methods:
    • XMLNode := XMLDocument1.CreateNode('node');
    • XMLNode.AddChild('childnode');
    • XMLNode.Attributes['attrname'] := 'attrvalue';
  • There are other very useful methods but these are the basics of XML generation.
  • The btnModifyXML button loaded the XML into the memo and appended some other data (another car) to the list. Then, it updated the memo with the new updated XML. The following are the most important lines to note:
    //Create a node without adding it to the DOM
    Car := XMLDocument1.CreateNode('car'); 
    
    //fill Car XMLNode… and finally add it to the DOM 
    //as child of the root node
    XMLDocument1.DocumentElement.ChildNodes.Add(Car);
  • The code under the btnParseXMLClick event handler allows you to read the data in the XML tree as simple text.

There's more...

There are many things to say about XML ecospace. There are XML engines that provide facilities to search data in an XML tree (XPath), validate an XML using another XML (XML Schema or DTD), transform an XML into another kind of format using another XML (XSLT), and for many others uses (http://en.wikipedia.org/wiki/List_of_XML_markup_languages). The good thing is that, just like XML itself, the DOM object is also standardized, so every library that is compliant to the standard has the same methods, from Delphi to JavaScript and from Python to C#.

TXMLDocument allows you to select the DOMVendor implementation. By default, there are three implementations available:

  • MSXML: This is from Microsoft and implemented as a COM object. This supports XML transformations and is available only on Windows (so no Android, iOS, or Mac OS X).
  • ADOM XML: This is an open source Delphi implementation and does not support transformations. This is available on all the supported Delphi platforms, so if you plan to write XML handling code on a mobile or Mac, this is the way to go.
  • XSLT: This allows you to transform an XML into something else, using another XML as a stylesheet. The following function loads an XML and an XSLT from two string variables. Then, use the XSLT document to transform the XML document. The following code shows the details:
    function Transform(XMLData: string; XSLT: string): WideString;
    var
      XML: IXMLDocument;
      XSL: IXMLDocument;
    begin
      XML := LoadXMLData(XMLData);
      XSL := LoadXMLData(XSLT);
      XML.DocumentElement.TransformNode(XSL.DocumentElement, Result)
    end;
    

    This function doesn't know about the output format because it is defined by the XSLT document. The result could be an XML, an HTML, a CSV, or a plain text, or whatever the XSLT defines, the code doesn't change.

    XSLT can be really useful—go to http://www.w3schools.com/xsl/xsl_languages.asp for further details about the language.

You have been reading a chapter from
Delphi Cookbook
Published in: Sep 2014
Publisher:
ISBN-13: 9781783559589
Register for a free Packt account to unlock a world of extra content!
A free Packt account unlocks extra newsletters, articles, discounted offers, and much more. Start advancing your knowledge today.
Unlock this book and the full library FREE for 7 days
Get unlimited access to 7000+ expert-authored eBooks and videos courses covering every tech area you can think of
Renews at $19.99/month. Cancel anytime