NAME

       XML::Parser::Lite - Lightweight pure-perl XML Parser (based on regexps)

SYNOPSIS

         use XML::Parser::Lite;

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

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

DESCRIPTION

       This module 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 experimental 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.

       The new() method returns the object called on when called as object method.  This
       behaviour was inherited from SOAP::Lite, which XML::Parser::Lite was split out from.  This
       means that the following effectively 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: @_\n" },
               Char => sub { shift; print "char: @_\n" },
               End => sub { shift; print "end: @_\n" },
           }
        );

       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

       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

   XMLDecl
       See XML::Parser for details

   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 - a full-blown XML Parser, on which XML::Parser::Lite is based.  Requires a C
       compiler and the expat XML parser.

       XML::Parser::LiteCopy - a fork in XML::Parser::Lite::Tree.

       YAX - another pure-perl module for XML parsing.

       XML::Parser::REX - another module that parses XML with regular expressions.

COPYRIGHT

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

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

       Copyright (C) 2013-2015 Fred Moyer. 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.

AUTHORS

       Paul Kulchenko (paulclinger@yahoo.com)

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

       Fred Moyer (fred@redhotpenguin.com)

       Additional handlers supplied by Adam Leggett.

CONTRIBUTORS

       David Steinbrunner (dsteinbrunner@pobox.com)

       Neil Bowers (neil@bowers.com)

       Paul Cochrane (paul@liekut.de)