XML::Parser::LiteCopy(3pm)				User Contributed Perl Documentation				XML::Parser::LiteCopy(3pm)

NAME

       XML::Parser::LiteCopy - Lightweight regexp-based XML parser

SYNOPSIS

	 use XML::Parser::LiteCopy;

	 $p1 = new XML::Parser::LiteCopy;
	 $p1->setHandlers(
	   Start => sub { shift; print "start: @_
" },
	   Char => sub { shift; print "char: @_
" },
	   End => sub { shift; print "end: @_
" },
	 );
	 $p1->parse('<foo id="me">Hello World!</foo>');

	 $p2 = new XML::Parser::LiteCopy
	   Handlers => {
	     Start => sub { shift; print "start: @_
" },
	     Char => sub { shift; print "char: @_
" },
	     End => sub { shift; print "end: @_
" },
	   }
	 ;
	 $p2->parse('<foo id="me">Hello <bar>cruel</bar> World!</foo>');

DESCRIPTION

       This Perl implements an XML parser with a interface similar to XML::Parser. Though not all callbacks are supported, you should be able to
       use it in the same way you use XML::Parser. Due to using experimantal regexp features it'll work only on Perl 5.6 and above and may behave
       differently on different platforms.

       Note that you cannot use regular expressions or split in callbacks. This is due to a limitation of perl's regular expression implementation
       (which is not re-entrant).

SUBROUTINES
/METHODS
   new
       Constructor.

       As (almost) all SOAP::Lite constructors, new() returns the object called on when called as object method. This means that the following
       effectifely is a no-op if $obj is a object:

	$obj = $obj->new();

       New accepts a single named parameter, "Handlers" with a hash ref as value:

	my $parser = XML::Parser::Lite->new(
	   Handlers => {
	       Start => sub { shift; print "start: @_
" },
	       Char => sub { shift; print "char: @_
" },
	       End => sub { shift; print "end: @_
" },
	   }
	);

       The handlers given will be passed to setHandlers.

   setHandlers
       Sets (or resets) the parsing handlers. Accepts a hash with the handler names and handler code references as parameters. Passing "undef"
       instead of a code reference replaces the handler by a no-op.

       The following handlers can be set:

	Init
	Start
	Char
	End
	Final
	CData
	Doctype
	Comment
	PI

       All other handlers are ignored.

       Calling setHandlers without parameters resets all handlers to no-ops.

   parse
       Parses the XML given. In contrast to XML::Parser's parse method, parse() only parses strings.

Handler methods
   Init
       Called before parsing starts. You should perform any necessary initializations in Init.

   Start
       Called at the start of each XML node. See XML::Parser for details.

   Char
       Called for each character sequence. May be called multiple times for the characters contained in an XML node (even for every single
       character).  Your implementation has to make sure that it captures all characters.

   End
       Called at the end of each XML node. See XML::Parser for details

   Comment
       See XML::Parser for details

   PI
       See XMLDecl in XML::Parser for details, but also includes other processing instructions

   Doctype
       See XML::Parser for details

   Final
       Called at the end of the parsing process. You should perform any necessary cleanup here.

SEE ALSO

	XML::Parser

COPYRIGHT

       Copyright (C) 2000-2007 Paul Kulchenko. All rights reserved.

       Copyright (C) 2008 Martin Kutter. All rights reserved.

       Copyright (C) 2009 Cal Henderson. All rights reserved.

       This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

       This parser is based on "shallow parser" http://www.cs.sfu.ca/~cameron/REX.html Copyright (c) 1998, Robert D. Cameron.

AUTHOR

       Paul Kulchenko (paulclinger@yahoo.com)

       Martin Kutter (martin.kutter@fen-net.de)

       Additional handlers supplied by Adam Leggett.

       Further modifications by Cal Henderson.

perl v5.12.3							    2011-06-05						XML::Parser::LiteCopy(3pm)