Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
XML::Smart::FAQ(3)    User Contributed Perl Documentation   XML::Smart::FAQ(3)

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

       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	content!
       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!

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

perl v5.32.1			  2004-12-08		    XML::Smart::FAQ(3)


Want to link to this manual page? Use this URL:

home | help