GNU.WIKI: The GNU/Linux Knowledge Base

  [HOME] [PHP Manual] [HowTo] [ABS] [MAN1] [MAN2] [MAN3] [MAN4] [MAN5] [MAN6] [MAN7] [MAN8] [MAN9]

  [0-9] [Aa] [Bb] [Cc] [Dd] [Ee] [Ff] [Gg] [Hh] [Ii] [Jj] [Kk] [Ll] [Mm] [Nn] [Oo] [Pp] [Qq] [Rr] [Ss] [Tt] [Uu] [Vv] [Ww] [Xx] [Yy] [Zz]


       XML::AutoWriter - DOCTYPE based XML output


          use XML::Doctype         NAME => a, SYSTEM_ID => 'a.dtd' ;
          use XML::AutoWriter qw( :all :dtd_tags ) ;
          # a.dtd contains:
          #   <!ELEMENT a ( b1, b2?, b3* ) >
          #      <!ATTLIST   a aa1 CDATA       #REQUIRED >
          #   <!ELEMENT b1 ( c1 ) >
          #   <!ELEMENT b2 ( c2 ) >
          b1 ;                # Emits <a><b1>
          c2( attr=>"val" ) ; # Emits </b1><b2><c2 attr="val">
          endAllTags ;        # Emits </c2></b2></a>

          ## If you've got an XML::Doctype object handy:
          use XML::AutoWriter qw( :dtd_tags ), DOCTYPE => $doctype ;

          ## If you've saved a preparsed DTD as a perl module
          use FooML::Doctype::v1_0001 ;
          use XML::AutoWriter qw( :dtd_tags ) ;

          ## Or as a normal perl object:
          $writer = XML::AutoWriter->new( ... ) ;
          $writer->startTag( 'b1' ) ;
          $writer->startTag( 'c2' ) ;
          $writer->end ;


       Alpha.  Use and patch, don't depend on things not changing drastically.

       Many methods supplied by XML::Writer are not yet supplied here.


       This module subclasses XML::ValidWriter and provides automatic start
       and end tag generation, allowing you to emit only the 'important' tags.

       See XML::ValidWriter for the details on all functions not documented

   XML::Writer API compatibility
       Much of the interface is patterned after XML::Writer so that it can
       possibly be used as a drop-in replacement.  It will take awhile before
       this module emulates enough of XML::Writer to be a drop-in replacement
       in situations where the more advanced XML::Writer methods are used.

   Automatic start tags
       Automatic start tag creation is done when emitting a start tag that is
       not allowed to be a child of the currently open tag but is allowed to
       be contained in the currently open tag's subset.  In this case, the
       minimal number of start tags necessary to allow All start tags between
       the current tag and the desired tag are automatically emitted with no

   Automatic end tags
       If start tag autogeneration fails, then end tag autogeneration is
       attempted.  startTag() scans the stack of currently open tags trying to
       close as few as possible before start tag autogeneration suceeds.

       Explicit end tags may be emitted to prevent unwanted automatic start
       tags, and, in the future, warnings or errors will be available in place
       of automatic start and end tag creation.


       All of the routines in this module can be called as either functions or
       methods unless otherwise noted.

       To call these routines as functions use either the DOCTYPE or :dtd_tags
       options in the parameters to the use statement:

          use XML::AutoWriter DOCTYPE => XML::Doctype->new( ... ) ;
          use XML::AutoWriter qw( :dtd_tags ) ;

       This associates an XML::AutoWriter and an XML::Doctype with the
       package.  These are used by the routines when called as functions.

              $writer = XML::AutoWriter->new( DTD => $dtd, OUTPUT => \*FH ) ;

           Creates an XML::AutoWriter.

           All other parameters are passed to the XML::ValidWriter base class

              characters( 'yabba dabba dooo' ) ;
              $writer->characters( 'yabba dabba dooo' ) ;

           If the currently open tag cannot contain #PCDATA, then start tag
           autogeneration will be attempted, followed by end tag

           Start tag autogeneration takes place even if you pass in only '',
           or even (), the empty list.

              endTag ;
              endTag( 'a' ) ;
              $writer->endTag ;
              $writer->endTag( 'a' ) ;

           Prints one or more end tags.  The tag name is optional and defaults
           to the most recently emitted start tag if not present.

           This will emit as many close tags as necessary to close the
           supplied tag name, or will emit an error if the tag name specified
           is not open in the output document.

              startTag( 'a', attr => val ) ;  # use default XML::AutoWriter for
                                              # current package.
              $writer->startTag( 'a', attr => val ) ;

           Emits a named start tag with optional attributes.  If the named tag
           cannot be a child of the most recently started tag, then any tags
           that need to be opened between that one and the named tag are

           If the named tag cannot be enclosed within the most recently opened
           tag, no matter how deep, then startTag() tries to end as few
           started tags as necessary to allow the named tag to be emitted
           within a tag already on the stack.

           This warns (once) if no <?xml?> declaration has been emitted.  It
           does not check to see if a <!DOCTYPE...> has been emitted.  It dies
           if an attempt is made to emit a second root element.


       Barrie Slaymaker <>


       This module is Copyright 2000, 2005, 2009 Barrie Slaymaker.  Some
       rights reserved.

       This module is licensed under your choice of the Artistic, BSD or
       General Public License.

  All copyrights belong to their respective owners. Other content (c) 2014-2018, GNU.WIKI. Please report site errors to
Page load time: 0.138 seconds. Last modified: November 04 2018 12:49:43.