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::FAQ(3User Contributed Perl DocumentaXML::Smart::FAQ(3pm)

       XML::Smart::FAQ - Frequently Asked Questions about

       This is the Frequently Asked Questions list for XML::Smart.

       For new questions send an e-mail to the author, but please,
       read first all the F.A.Q.

   Do I need to install XML::Parser to can use XML::Smart?
       No! XML::Smart already comes with 2 independent parsers,
       XML::Smart::Parser and XML::Smart::HTMLParser.

       If XML::Parser is found XML::Smart will use it by default,
       and the 2nd options will be XML::Smart::Parser.

       Note that for complex parsing XML::Parser is recommended, but
       XML::Smart::Parser will work fine too.

   What is the best version of XML::Smart to install?
       Is always the last! Always take a look for new versions
       before aks for help on XML::Smart.

       Note that internally XML::Smart is complex, since the main
       idea of it is to remove the complexity from the hand of the
       programmer.  Actually the idea is to enable the Perl
       programmer to use and create XML data without really know the
       XML format.

   Where can I learn about XML?

   How to apply a DTD to a XML::Smart object tree?
       Take a look in the method apply_dtd(). Example of use:

         <!DOCTYPE cds [
         <!ELEMENT cds (album+)>
         <!ATTLIST cds
                   creator  CDATA
                   date     CDATA #REQUIRED
         <!ELEMENT album (artist , tracks+)>
         <!ELEMENT artist (#PCDATA)>
         <!ELEMENT tracks (#PCDATA)>

       This will format automatically elements, attributes, etc...

   How XML::Smart works?
       To create XML::Smart, first I have created the module
       Object::MultiType.  With it you can have an object that works
       at the same time as a HASH, ARRAY, SCALAR, CODE & GLOB. So
       you can do things like this with the same object:

         $obj = Object::MultiType->new() ;

         $obj->{key} ;
         $obj->[0] ;
         $obj->method ;

         @l = @{$obj} ;
         %h = %{$obj} ;

         &$obj(args) ;

         print $obj "send data\n" ;

       Seems to be crazy, and can be more if you use tie() inside
       it, and this is what XML::Smart does.

       For XML::Smart, the access in the Hash and Array way paste
       through tie(). In other words, you have a tied HASH and tied
       ARRAY inside it. This tied Hash and Array work together, soo
       you can access a Hash key as the index 0 of an Array, or
       access an index 0 as the Hash key:

         %hash = (
         key => ['a','b','c']
         ) ;

         $hash->{key}    ## return $hash{key}[0]
         $hash->{key}[0] ## return $hash{key}[0]
         $hash->{key}[1] ## return $hash{key}[1]

         ## Inverse:

         %hash = ( key => 'a' ) ;

         $hash->{key}    ## return $hash{key}
         $hash->{key}[0] ## return $hash{key}
         $hash->{key}[1] ## return undef

       The best thing of this new resource is to avoid wrong access
       to the data and warnings when you try to access a Hash having
       an Array (and the inverse). Thing that generally make the
       script die().

       Once having an easy access to the data, you can use the same
       resource to create data!  For example:

         ## Previous data:
           <server address="" os="linux" type="conectiva" version="9.0"/>

         ## Now you have {address} as a normal key with a string inside:

         ## And to add a new address, the key {address} need to be an ARRAY ref!
         ## So, XML::Smart make the convertion: ;-P
         $XML->{hosts}{server}{address}[1] = '' ;

         ## Adding to a list that you don't know the size:
         push(@{$XML->{hosts}{server}{address}} , '') ;

         ## The data now:
           <server os="linux" type="conectiva" version="9.0"/>

       Than after changing your XML tree using the Hash and Array
       resources you just get the data remade (through the Hash tree
       inside the object):

         my $xmldata = $XML->data ;

       But note that XML::Smart always return an object! Even when
       you get a final key. So this actually returns another object,
       pointhing (inside it) to the key:

         $addr = $XML->{hosts}{server}{address}[0] ;

         ## Since $addr is an object you can TRY to access more data:
         $addr->{foo}{bar} ; ## This doens't make warnings! just return UNDEF.

         ## But you can use it like a normal SCALAR too:

         print "$addr\n" ;

         $addr .= ':80' ; ## After this $addr isn't an object any more, just a SCALAR!

   When I generate the XML data new lines (\n) are added to the
       You should use the options for the method data() and save()
       to not add identation to the generated data:

         $XML->data( noident => 1 ) ;

         ## or better:

         $XML->data( nospace => 1 ) ;

   Your question is not here?
       Just send me an e-mail. ;-P

       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::FAQ(3pm)
Results 1 - 1 of 1
Help - FTP Sites List - Software Dir.
Search over 15 billion files
© 1997-2017