Free xml output software for linux

XML::Filter::Tee can send SAX events to multiple processor, with switching.

SYNOPSIS

my $t = XML::Filter::Tee->new(
{ Handler => $h0 },
{ Handler => $h1 },
{ Handler => $h2 },
...
);

## Altering the handlers list:
$t->set_handlers( $h0, $h1, $h2, $h3 );

## Controlling flow to a handler by number and by reference:
$t->disable_handler( 0 );
$t->enable_handler( 0 );

$t->disable_handler( $h0 );
$t->enable_handler( $h0 );

## Use in a SAX machine (though see L and
## L for a more convenient way to build a machine
## like this):
my $m = Machine(
[ Intake => "XML::Filter::Tee" => qw( A B ) ],
[ A => ">>log.xml" ],
[ B => *OUTPUT ],
);

XML::Filter::Tee is a SAX filter that passes each event it receives on to a list of downstream handlers.

Its like XML::Filter::SAXT in that the events are not buffered; each event is sent first to the tap, and then to the branch (this is different from XML::SAX::Dispatcher, which buffers the events). Unlike XML::Filter::SAXT, it allows its list of handlers to be reconfigured (via "set_handlers") and it allows control over which handlers are allowed to receive events. These features are designed to make XML::Filter::Tee instances more useful with SAX machines, but they to add some overhead relative to XML::Filter::SAXT.

The events are not copied, since they may be data structures that are difficult or impossibly to copy properly, like parts of a C-based DOM implementation. This means that the handlers must not alter the events or later handlers will see the alterations.

XML::Filter::Dispatcher::Compiler can compile rulesets in to code.

SYNOPSIS

use XML::Filter::Dispatcher::Compiler qw( xinline );

my $c = XML::Filter::Dispatcher::Compiler->new( ... )

my $code = $c->compile(
Package => "My::Filter",
Rules => [
a/b/c => xinline q{warn "found a/b/c"},
],
Output => "lib/My/Filter.pm", ## optional
);

Most of the options from XML::Filter::Dispatcher are accepted.

NOTE: you cannot pass code references to compile() if you want to write the $code to disk, they will not survive. If you want to eval $code, this is ok.

METHODS

xinline

Hints to X::F::D that the string is inlinable code. This is a requirement when using the compiler and is so far (v.52) ignored elswhere. In xinlined code, $self refers to the current dispatcher and $e refers to the current events data. Or you can get that yourself in $_[0] and $_[1] as in a normal SAX event handling method.

compile

Accepts options that extend and override any previously set for the duration of the compile(), including the ruleset to compile.

Bricolage, an open-source enterprise-class content management system, greatly simplifies the complex tasks of creating, publishing, and managing the vast libraries of content essential to any organization.
With advanced features such as fully-configurable workflows, customizable document types, multisite management capabilities, and comprehensive Perl-based templating support, Bricolage has been designed from the ground-up to scale to meet the demanding needs of large organizations around the world. This flexibility and scalability led eWeek to hail Bricolage as Most Impressive in 2002.
No matter what type of site you run, visitors come to your site because they are looking for content.
Main features:
- Streamline content updates by allowing authorized users to update the site directly.
- Update from any computer with a Web browser. Bricolage works in all major browsers and requires no additional software or plug-ins.
- Maintain editorial control and review through customizable workflows that require content to pass through an editor before publication.
- Restrict user privileges to only the pages and features each user needs in order to limit the potential for abuse.
- Easily revert to an older copy of a document at any time in case of an unwanted update.
- Enforce a consistent look and feel through the use of powerful templates.
- Generate server-neutral HTML or XML output that can be served by any web server on any platform.
- Automatically push content to a front-end Web server or server cluster to allow virtually unlimited scalability.
Enhancements:
Improvements
- If "Term::ReadPassword" isnt found during installation, a better
error message is displayed. [Scott]
- Added output channel name to "Could not find template" error message
in the Mason Burner. [Paul Orrock]
- The contributed Linux start script (contrib/start_scripts/linux) now
restarts the "bric_queued" server when the "restart" command is used
and the "bric_queued" server is enabled. It also now also passes a
log file name to "bric_queued" so that publishing errors can more
easily be traced. [David]
- Overriding Mason inheritance in story element templates by setting
$inherit in the "

Any::Renderer::XML Perl module can render a data structure as element-only XML.

SYNOPSIS

use Any::Renderer;

my %xml_options = ();
my %options = ( XmlOptions => %xml_options );
my $format = "XML";
my $r = new Any::Renderer ( $format, %options );

my $data_structure = [...]; # arbitrary structure code
my $string = $r->render ( $data_structure );
You can get a list of all formats that this module handles using the following syntax:
my $list_ref = Any::Renderer::XML::available_formats ();

Also, determine whether or not a format requires a template with requires_template:

my $bool = Any::Renderer::XML::requires_template ( $format );

Any::Renderer::XML renders any Perl data structure passed to it as element-only XML. For example:

perl -MAny::Renderer -e "print Any::Renderer->new(XML)->render({a => 1, b => [2,3]})"
results in:

< ?xml version="1.0" encoding="ISO-8859-1" standalone="yes"? >
< output >
< a >1< /a >
< b >2< /b >
< b >3< /b >
< /output >

The rendering process comes with all the caveats cited in the XML::Simple documentation. For example if your data structure contains binary data or ASCII control characters, then the XML document that is generated may not be well-formed.

XML::Generator::Essex is a Perl module that can generate XML with Essex.

SYNOPSIS

package My::Generator;

use XML::Generator::Essex;
@ISA = qw( XML::Generator::Essex );

use strict;

sub main { # Called by XML::Generator::Essex->generate().
my $self = shift;
}

## And, to use:

my $g = MY::Generator->new( Handler => $h );
$g->generate( ... );

Provides Essex output primitives like put() and constructors for essex events.

Methods

put

Example Whats emitted
======= ==============
put; ## (whatevers in $_: event, characters, etc)
put "text<<less