Filewatcher File Search File Search
Content Search
» » » » » libxml-smart-perl_1.6.9-3_all.deb » Content »
pkg://libxml-smart-perl_1.6.9-3_all.deb:74948/usr/share/man/man3/  info  control  downloads

libxml-smart-perl - Perl module for access to parsed XML trees…  more info»


XML::Smart::TutorUser3Contributed Perl DocuXML::Smart::Tutorial(3pm)

       XML::Smart::Tutorial - Tutorial and examples for XML::Smart.

       This document is a tutorial for XML::Smart and shows some
       examples of usual things.

Working with contents:
       In XML::Smart the key CONTENT is reserved and shouldn't be
       used directly, since XML::Smart will deal with the convertion
       of arguments to node contents, including multiple node
       contents autimatically.

   What happens when you set a value:
         $xml->{root}{foo} = 'simple value' ;

       Here foo will be a normal argument/attribute value, and will
       generate this XML data:

         <root foo="simple value"/>

       But if you insert some tag or lines in the values by default
       XML::Smart will convert it to a node content:

         $xml->{root}{foo} = "line0\nlien1\nline2\n" ;

       And will generate that XML data:


       But what you can do if you want to force some type, let's
       say, have a node content with a simple value:

         $xml->{root}{foo} = 'simple value' ;
         $xml->{root}{foo}->set_node(1) ;

       And will generate that XML data:

           <foo>simple value</foo>

   Multiple contents:
       When you have interpolated content/data you need to work in a
       different. Let's say that you load this XML data:

         <tag1 arg="1"/>

       If you access directly the root key as string you will get
       all the content parts grouped.  So, this code:

         my $xml = new XML::Smart(q`
         <tag1 arg="1"/>
         `,'smart') ;

         print "#$xml->{root}#" ;

       Will print that:



       To access each part of the content independently you should
       use an array that receive the method content():

         my @content = $xml->{root}->content ;

         print "#$content[0]#\n" ;

       And this will print that:


       Now to set the multiple content values you should use the
       method content() with 2 arguments:

         $xml->{root}->content(0,'new content') ;

       And now the XML data produced will be:

         <root>new content<tag1 arg="1"/>

       If you use the method content() with only one argument it
       will remove all the multiple contents and will set the new
       value in the place of the 1st content.

Setting the XML Parser.
       By defaul XML::Smart will use XML::Parser or
       XML::Smart::Parser (in this order of preference) to load a
       XML data.

       To force or define by your self the parser you can use the
       2nd argument option when creating a XML::Smart object:

         my $xml = new XML::Smart( 'some.xml' , 'XML::Parser' ) ;

         ## and

         my $xml = new XML::Smart( 'some.xml' , 'XML::Smart::Parser' ) ;

       XML::Smart also has an extra parser, XML::Smart::HTMLParser,
       that can be used to load HTML as XML, or to load wild XML

         my $xml = new XML::Smart( 'some.xml' , 'XML::Smart::HTMLParser' ) ;

       Aliases for the parser options:

         SMART|REGEXP   => XML::Smart::Parser
         HTML           => XML::Smart::HTMLParser

       So, you can use as:

         my $xml = new XML::Smart( 'some.xml' , 'smart' ) ;
         my $xml = new XML::Smart( 'some.xml' , 'html' ) ;

Customizing the Parser.
       You can customize the way that the parser will treat the XML

   Forcing nodes/tags and arguments/attributes to lowercase or
         ## For lower case:

         my $xml = new XML::Smart( 'some.xml' ,
         lowtag => 1 ,
         lowarg => 1 ,
         ) ;

         ## For uper case:

         my $xml = new XML::Smart( 'some.xml' ,
         upertag => 1 ,
         uperarg => 1 ,
         ) ;

   Loading arguments without values (flags) as a TRUE boolean:
       ** Note, this option will work only when the XML is parsed by
       XML::Smart::HTMLParser, since only it accept arguments
       without values!

         my $xml = new XML::Smart(
         '<root><foo arg1="" flag></root>' ,
         'XML::Smart::HTMLParser' ,
         arg_single => 1 ,
         ) ;

       Here's the tree of the example above:

         'root' => {
                     'foo' => {
                                'flag' => 1,
                                'arg1' => ''

   Customizing the parse events:
       XML::Smart can redirect the parsing process to personalized

         my $xml = XML::Smart->new( 'some.xml' ,
         on_start => \&on_start ,
         on_char  => \&on_char ,
         on_end   => \&on_end ,
         ) ;

         sub on_start {
           my ( $tag , $pointer , $pointer_back ) = @_ ;
           $pointer->{$tag}{type_user} = 1 if $tag =~ /(?:name|age)/ ;

         sub on_char {
           my ( $tag , $pointer , $pointer_back , $content) = @_ ;
           $$content =~ s/\s+/ /gs ;

         sub on_end {
           my ( $tag , $pointer , $pointer_back ) = @_ ;
           $pointer->{$tag}{type_extra} = 1 if $tag =~ /(?:more|tel|address)/ ;

       Graciliano M. P. <>

       I will appreciate any type of feedback (include your opinions
       and/or suggestions). ;-P

       Enjoy and thanks for who are enjoying this tool and have sent
       e-mails! ;-P

       This document was written in ePod (easy-POD), than converted
       to POD, and from here you know the way.

perl v5.10.1                 2004-12-08    XML::Smart::Tutorial(3pm)
Results 1 - 1 of 1
Help - FTP Sites List - Software Dir.
Search over 15 billion files
© 1997-2017