XML-SAX-Base
view release on metacpan or search on metacpan
BuildSAXBase.pl view on Meta::CPAN
end_document => [qw(ContentHandler DocumentHandler Handler)],
start_element => [qw(ContentHandler DocumentHandler Handler)],
end_element => [qw(ContentHandler DocumentHandler Handler)],
characters => [qw(ContentHandler DocumentHandler Handler)],
processing_instruction => [qw(ContentHandler DocumentHandler Handler)],
ignorable_whitespace => [qw(ContentHandler DocumentHandler Handler)],
set_document_locator => [qw(ContentHandler DocumentHandler Handler)],
start_prefix_mapping => [qw(ContentHandler Handler)],
end_prefix_mapping => [qw(ContentHandler Handler)],
skipped_entity => [qw(ContentHandler Handler)],
start_cdata => [qw(DocumentHandler LexicalHandler Handler)],
end_cdata => [qw(DocumentHandler LexicalHandler Handler)],
comment => [qw(DocumentHandler LexicalHandler Handler)],
entity_reference => [qw(DocumentHandler Handler)],
notation_decl => [qw(DTDHandler Handler)],
unparsed_entity_decl => [qw(DTDHandler Handler)],
element_decl => [qw(DeclHandler Handler)],
attlist_decl => [qw(DTDHandler Handler)],
doctype_decl => [qw(DTDHandler Handler)],
xml_decl => [qw(DTDHandler Handler)],
entity_decl => [qw(DTDHandler Handler)],
attribute_decl => [qw(DeclHandler Handler)],
BuildSAXBase.pl view on Meta::CPAN
=item * ignorable_whitespace
=item * set_document_locator
=item * start_prefix_mapping
=item * end_prefix_mapping
=item * skipped_entity
=item * start_cdata
=item * end_cdata
=item * comment
=item * entity_reference
=item * notation_decl
=item * unparsed_entity_decl
=item * element_decl
=item * ignorable_whitespace
=item * set_document_locator
=item * start_prefix_mapping
=item * end_prefix_mapping
=item * skipped_entity
=item * start_cdata
=item * end_cdata
=item * comment
=item * entity_reference
=item * notation_decl
=item * unparsed_entity_decl
=item * element_decl
lib/XML/SAX/Base.pm view on Meta::CPAN
}
return $res;
}
else {
$self->{Methods}->{'start_prefix_mapping'} = sub { };
}
}
}
sub end_cdata {
my $self = shift;
if (defined $self->{Methods}->{'end_cdata'}) {
$self->{Methods}->{'end_cdata'}->(@_);
}
else {
my $method;
my $callbacks;
if (exists $self->{ParseOptions}) {
$callbacks = $self->{ParseOptions};
}
else {
$callbacks = $self;
}
if (0) { # dummy to make elsif's below compile
}
elsif (defined $callbacks->{'DocumentHandler'} and $method = $callbacks->{'DocumentHandler'}->can('end_cdata') ) {
my $handler = $callbacks->{'DocumentHandler'};
$self->{Methods}->{'end_cdata'} = sub { $method->($handler, @_) };
return $method->($handler, @_);
}
elsif (defined $callbacks->{'LexicalHandler'} and $method = $callbacks->{'LexicalHandler'}->can('end_cdata') ) {
my $handler = $callbacks->{'LexicalHandler'};
$self->{Methods}->{'end_cdata'} = sub { $method->($handler, @_) };
return $method->($handler, @_);
}
elsif (defined $callbacks->{'Handler'} and $method = $callbacks->{'Handler'}->can('end_cdata') ) {
my $handler = $callbacks->{'Handler'};
$self->{Methods}->{'end_cdata'} = sub { $method->($handler, @_) };
return $method->($handler, @_);
}
elsif (defined $callbacks->{'DocumentHandler'}
and $callbacks->{'DocumentHandler'}->can('AUTOLOAD')
and $callbacks->{'DocumentHandler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')
)
{
my $res = eval { $callbacks->{'DocumentHandler'}->end_cdata(@_) };
if ($@) {
die $@;
}
else {
# I think there's a buggette here...
# if the first call throws an exception, we don't set it up right.
# Not fatal, but we might want to address it.
my $handler = $callbacks->{'DocumentHandler'};
$self->{Methods}->{'end_cdata'} = sub { $handler->end_cdata(@_) };
}
return $res;
}
elsif (defined $callbacks->{'LexicalHandler'}
and $callbacks->{'LexicalHandler'}->can('AUTOLOAD')
and $callbacks->{'LexicalHandler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')
)
{
my $res = eval { $callbacks->{'LexicalHandler'}->end_cdata(@_) };
if ($@) {
die $@;
}
else {
# I think there's a buggette here...
# if the first call throws an exception, we don't set it up right.
# Not fatal, but we might want to address it.
my $handler = $callbacks->{'LexicalHandler'};
$self->{Methods}->{'end_cdata'} = sub { $handler->end_cdata(@_) };
}
return $res;
}
elsif (defined $callbacks->{'Handler'}
and $callbacks->{'Handler'}->can('AUTOLOAD')
and $callbacks->{'Handler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')
)
{
my $res = eval { $callbacks->{'Handler'}->end_cdata(@_) };
if ($@) {
die $@;
}
else {
# I think there's a buggette here...
# if the first call throws an exception, we don't set it up right.
# Not fatal, but we might want to address it.
my $handler = $callbacks->{'Handler'};
$self->{Methods}->{'end_cdata'} = sub { $handler->end_cdata(@_) };
}
return $res;
}
else {
$self->{Methods}->{'end_cdata'} = sub { };
}
}
}
sub processing_instruction {
my $self = shift;
if (defined $self->{Methods}->{'processing_instruction'}) {
$self->{Methods}->{'processing_instruction'}->(@_);
}
lib/XML/SAX/Base.pm view on Meta::CPAN
}
return $res;
}
else {
$self->{Methods}->{'end_element'} = sub { };
}
}
}
sub start_cdata {
my $self = shift;
if (defined $self->{Methods}->{'start_cdata'}) {
$self->{Methods}->{'start_cdata'}->(@_);
}
else {
my $method;
my $callbacks;
if (exists $self->{ParseOptions}) {
$callbacks = $self->{ParseOptions};
}
else {
$callbacks = $self;
}
if (0) { # dummy to make elsif's below compile
}
elsif (defined $callbacks->{'DocumentHandler'} and $method = $callbacks->{'DocumentHandler'}->can('start_cdata') ) {
my $handler = $callbacks->{'DocumentHandler'};
$self->{Methods}->{'start_cdata'} = sub { $method->($handler, @_) };
return $method->($handler, @_);
}
elsif (defined $callbacks->{'LexicalHandler'} and $method = $callbacks->{'LexicalHandler'}->can('start_cdata') ) {
my $handler = $callbacks->{'LexicalHandler'};
$self->{Methods}->{'start_cdata'} = sub { $method->($handler, @_) };
return $method->($handler, @_);
}
elsif (defined $callbacks->{'Handler'} and $method = $callbacks->{'Handler'}->can('start_cdata') ) {
my $handler = $callbacks->{'Handler'};
$self->{Methods}->{'start_cdata'} = sub { $method->($handler, @_) };
return $method->($handler, @_);
}
elsif (defined $callbacks->{'DocumentHandler'}
and $callbacks->{'DocumentHandler'}->can('AUTOLOAD')
and $callbacks->{'DocumentHandler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')
)
{
my $res = eval { $callbacks->{'DocumentHandler'}->start_cdata(@_) };
if ($@) {
die $@;
}
else {
# I think there's a buggette here...
# if the first call throws an exception, we don't set it up right.
# Not fatal, but we might want to address it.
my $handler = $callbacks->{'DocumentHandler'};
$self->{Methods}->{'start_cdata'} = sub { $handler->start_cdata(@_) };
}
return $res;
}
elsif (defined $callbacks->{'LexicalHandler'}
and $callbacks->{'LexicalHandler'}->can('AUTOLOAD')
and $callbacks->{'LexicalHandler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')
)
{
my $res = eval { $callbacks->{'LexicalHandler'}->start_cdata(@_) };
if ($@) {
die $@;
}
else {
# I think there's a buggette here...
# if the first call throws an exception, we don't set it up right.
# Not fatal, but we might want to address it.
my $handler = $callbacks->{'LexicalHandler'};
$self->{Methods}->{'start_cdata'} = sub { $handler->start_cdata(@_) };
}
return $res;
}
elsif (defined $callbacks->{'Handler'}
and $callbacks->{'Handler'}->can('AUTOLOAD')
and $callbacks->{'Handler'}->can('AUTOLOAD') ne (UNIVERSAL->can('AUTOLOAD') || '')
)
{
my $res = eval { $callbacks->{'Handler'}->start_cdata(@_) };
if ($@) {
die $@;
}
else {
# I think there's a buggette here...
# if the first call throws an exception, we don't set it up right.
# Not fatal, but we might want to address it.
my $handler = $callbacks->{'Handler'};
$self->{Methods}->{'start_cdata'} = sub { $handler->start_cdata(@_) };
}
return $res;
}
else {
$self->{Methods}->{'start_cdata'} = sub { };
}
}
}
#-------------------------------------------------------------------#
# Class->new(%options)
#-------------------------------------------------------------------#
sub new {
my $proto = shift;
lib/XML/SAX/Base.pm view on Meta::CPAN
=item * ignorable_whitespace
=item * set_document_locator
=item * start_prefix_mapping
=item * end_prefix_mapping
=item * skipped_entity
=item * start_cdata
=item * end_cdata
=item * comment
=item * entity_reference
=item * notation_decl
=item * unparsed_entity_decl
=item * element_decl
t/01simpledriver.t view on Meta::CPAN
$self->SUPER::start_document;
$self->SUPER::start_element;
$self->SUPER::characters;
$self->SUPER::processing_instruction;
$self->SUPER::end_prefix_mapping;
$self->SUPER::start_prefix_mapping;
$self->SUPER::set_document_locator;
$self->SUPER::xml_decl;
$self->SUPER::ignorable_whitespace;
$self->SUPER::skipped_entity;
$self->SUPER::start_cdata;
$self->SUPER::end_cdata;
$self->SUPER::comment;
$self->SUPER::entity_reference;
$self->SUPER::unparsed_entity_decl;
$self->SUPER::element_decl;
$self->SUPER::attlist_decl;
$self->SUPER::doctype_decl;
$self->SUPER::entity_decl;
$self->SUPER::attribute_decl;
$self->SUPER::internal_entity_decl;
$self->SUPER::external_entity_decl;
t/01simpledriver.t view on Meta::CPAN
sub ignorable_whitespace {
my ($self, $wtf) = @_;
$self->{_cnt}++;
}
sub skipped_entity {
my ($self, $wtf) = @_;
$self->{_cnt}++;
}
sub start_cdata {
my ($self, $wtf) = @_;
$self->{_cnt}++;
}
sub end_cdata {
my ($self, $wtf) = @_;
$self->{_cnt}++;
}
sub comment {
my ($self, $wtf) = @_;
$self->{_cnt}++;
}
sub entity_reference {
t/02simplefilter.t view on Meta::CPAN
$self->SUPER::start_document;
$self->SUPER::start_element;
$self->SUPER::characters;
$self->SUPER::processing_instruction;
$self->SUPER::end_prefix_mapping;
$self->SUPER::start_prefix_mapping;
$self->SUPER::set_document_locator;
$self->SUPER::xml_decl;
$self->SUPER::ignorable_whitespace;
$self->SUPER::skipped_entity;
$self->SUPER::start_cdata;
$self->SUPER::end_cdata;
$self->SUPER::comment;
$self->SUPER::entity_reference;
$self->SUPER::unparsed_entity_decl;
$self->SUPER::element_decl;
$self->SUPER::attlist_decl;
$self->SUPER::doctype_decl;
$self->SUPER::entity_decl;
$self->SUPER::attribute_decl;
$self->SUPER::internal_entity_decl;
$self->SUPER::external_entity_decl;
t/02simplefilter.t view on Meta::CPAN
sub ignorable_whitespace {
my ($self, $wtf) = @_;
$self->{_cnt}++;
}
sub skipped_entity {
my ($self, $wtf) = @_;
$self->{_cnt}++;
}
sub start_cdata {
my ($self, $wtf) = @_;
$self->{_cnt}++;
}
sub end_cdata {
my ($self, $wtf) = @_;
$self->{_cnt}++;
}
sub comment {
my ($self, $wtf) = @_;
$self->{_cnt}++;
}
sub entity_reference {
t/06lexhdriver.t view on Meta::CPAN
package Driver;
use base qw(XML::SAX::Base);
sub parse {
my $self = shift;
my %events = %main::events;
$self->SUPER::comment($events{comment});
$self->SUPER::start_dtd($events{start_dtd});
$self->SUPER::end_dtd($events{end_dtd});
$self->SUPER::start_cdata($events{start_cdata});
$self->SUPER::end_cdata($events{end_cdata});
$self->SUPER::start_entity($events{start_entity});
$self->SUPER::end_entity($events{end_entity});
# return $self->SUPER::result(1);
}
1;
# basic single class SAX Handler
package SAXAutoload;
use vars qw($AUTOLOAD);
t/12sax2multiclass.t view on Meta::CPAN
$self->SUPER::end_document($events{end_document});
$self->SUPER::notation_decl($events{notation_decl});
$self->SUPER::unparsed_entity_decl($events{unparsed_entity_decl});
$self->SUPER::xml_decl($events{xml_decl});
$self->SUPER::attlist_decl($events{attlist_decl});
$self->SUPER::doctype_decl($events{doctype_decl});
$self->SUPER::entity_decl($events{entity_decl});
$self->SUPER::comment($events{comment});
$self->SUPER::start_dtd($events{start_dtd});
$self->SUPER::end_dtd($events{end_dtd});
$self->SUPER::start_cdata($events{start_cdata});
$self->SUPER::end_cdata($events{end_cdata});
$self->SUPER::start_entity($events{start_entity});
$self->SUPER::end_entity($events{end_entity});
$self->SUPER::element_decl($events{element_decl});
$self->SUPER::attribute_decl($events{attribute_decl});
$self->SUPER::internal_entity_decl($events{internal_entity_decl});
$self->SUPER::external_entity_decl($events{external_entity_decl});
$self->SUPER::warning($events{warning});
$self->SUPER::error($events{error});
$self->SUPER::fatal_error($events{fatal_error});
$self->SUPER::resolve_entity($events{resolve_entity});
t/events.pl view on Meta::CPAN
set_document_locator => {Name => 'huh'},
end_element => {Name => 'foo:root',
LocalName => 'root',
Prefix => 'foo'
},
end_prefix_mapping => {Prefix => 'foo',
NamespaceURI => 'http://localhost/foo'
},
xml_decl => {Version => '1.0'},
start_cdata => {},
end_cdata => {},
comment => {Data => 'i am a comment'},
entity_reference => {Bogus => 1},
notation_decl => {Name => 'entname',
PublicID => 'huh?'
},
unparsed_entity_decl => {Name => 'entname',
PublicID => 'huh?',
NotationName => 'notname'
},
element_decl => {Name => 'elname',
( run in 0.307 second using v1.01-cache-2.11-cpan-454fe037f31 )