dinislage/SOAP-WSDL
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

import SOAP-WSDL 2.00.01 from CPAN

Browse Source 
git-cpan-module:   SOAP-WSDL
git-cpan-version:  2.00.01
git-cpan-authorid: MKUTTER
git-cpan-file:     authors/id/M/MK/MKUTTER/SOAP-WSDL-2.00.01.tar.gz
This commit is contained in:
Martin Kutter
2009-12-12 19:48:32 -08:00
committed by Michael G. Schwern
parent 0cbf981665
commit 745ce925c1
111 changed files with 1106 additions and 673 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/SOAP/WSDL/Generator/Iterator/WSDL11.pm
+4 -2
View File
@@ -2,6 +2,8 @@ package SOAP::WSDL::Generator::Iterator::WSDL11;
use strict; use warnings;
use Class::Std::Fast;
use version; our $VERSION = qv('2.00.01');
my %definitions_of :ATTR(:name<definitions> :default<[]>);
my %nodes_of :ATTR(:name<nodes> :default<[]>);
@@ -242,8 +244,8 @@ The nodes are returned in the order denoted in the following example:
</service>
</definitions>
You should not rely too much on this order - it may change. Even though, the
current order will probably remain, but the nodes currently skipped might
You should not rely too much on this order - it may change. Even though the
current order will probably remain, the nodes currently skipped might
be returned somewhere along the path.
lib/SOAP/WSDL/Generator/PrefixResolver.pm
+42 -10
View File
@@ -3,20 +3,26 @@ use strict; use warnings;
use Class::Std::Fast::Storable;
use version; our $VERSION = qv('2.00.01');
my %namespace_prefix_map_of :ATTR(:name<namespace_prefix_map> :default<{}>);
my %namespace_map_of :ATTR(:name<namespace_map> :default<{}>);
my %prefix_of :ATTR(:name<prefix> :default<{}>);
sub resolve_prefix {
my ($self, $type, $namespace, $element) = @_;
return $prefix_of{ $$self }->{ $type }
if not defined($namespace);
return $namespace_prefix_map_of{ $$self }->{ $namespace }
|| ( ($namespace_map_of{ $$self }->{ $namespace })
? join ('::', $prefix_of{ $$self }->{ $type }, $namespace_map_of{ $$self }->{ $namespace })
: $prefix_of{ $$self }->{ $type }
);
my $prefix;
if (not defined($namespace)) {
$prefix = $prefix_of{ $$self }->{ $type }
}
else {
$prefix = $namespace_prefix_map_of{ $$self }->{ $namespace }
|| ( ($namespace_map_of{ $$self }->{ $namespace })
? join ('::', $prefix_of{ $$self }->{ $type }, $namespace_map_of{ $$self }->{ $namespace })
: $prefix_of{ $$self }->{ $type }
);
}
return "${prefix}::";
}
1;
@@ -67,7 +73,7 @@ Subclasses must implement the following methods:
# ...
}
resolve_prefix is expected to return a (perl class) prefis. It is called with
resolve_prefix is expected to return a (perl class) prefix. It is called with
the following parameters:
NAME DESCRIPTION
@@ -80,7 +86,7 @@ You usually just need type and namespace for prefix resolving. node is
provided for rather funky setups, where you have to choose different prefixes
based on type names or whatever.
Note that node may be of any of the following classes:
Node may be of any of the following classes:
SOAP::WSDL::Service
SOAP::WSDL::XSD::Attribute
@@ -90,8 +96,34 @@ Note that node may be of any of the following classes:
Note that both namespace and node may be undef - you should test for
definedness before doing anything fancy with them.
If you want your prefixes to represent perl class hierarchies, they should
end with '::'.
Example:
Imagine you're generating interfaces for the Acme Pet Shop. Acme Corp. has
set up their datatypes to be global across all interfaces (and products), while
elements are local to the product (the Pet Shop in the example).
All elements are in the urn:Acme namespace.
In addition, there are types in the namespace urn:Acme:Goods, which should go
into the same namespace as types, but be prefixed with 'Goods_'
You may want prefixes (roughly) like this:
Interfaces: Acme::Client::PetShop::
Server: Acme::Server::PetShop::
Types: Acme::Types::
Types (Goods): Acme::Types::Goods_
Elements: Acme::Elements::PetShop::
Typemaps: Acme::Typemaps::PetShop::
=back
=head1 BUGS AND LIMITATIONS
You cannot suffix your types by some rule yet...
=head1 LICENSE AND COPYRIGHT
Copyright 2008 Martin Kutter.
lib/SOAP/WSDL/Generator/Template.pm
+1 -1
View File
@@ -5,7 +5,7 @@ use Class::Std::Fast::Storable;
use Carp;
use SOAP::WSDL::Generator::PrefixResolver;
use version; our $VERSION = qv(2.00_33);
use version; our $VERSION = qv('2.00.01');
my %tt_of :ATTR(:get<tt>);
my %definitions_of :ATTR(:name<definitions> :default<()>);
lib/SOAP/WSDL/Generator/Template/Plugin/XSD.pm
+14 -31
View File
@@ -4,6 +4,8 @@ use warnings;
use Carp qw(confess);
use Class::Std::Fast::Storable constructor => 'none';
use version; our $VERSION = qv('2.00.01');
my %namespace_prefix_map_of :ATTR(:name<namespace_prefix_map> :default<{}>);
my %namespace_map_of :ATTR(:name<namespace_map> :default<{}>);
my %prefix_of :ATTR(:name<prefix> :default<()>);
@@ -14,9 +16,6 @@ sub load { # called as MyPlugin->load($context)
my ($class, $context, @arg_from) = @_;
my $stash = $context->stash();
my $self = bless \do { my $o = Class::Std::Fast::ID() }, $class;
# $self->set_namespace_map( $stash->{ context }->{ namespace_map });
# $self->set_namespace_prefix_map( $stash->{ context }->{ namespace_prefix_map });
# $self->set_prefix( $stash->{ context }->{ prefix });
$self->set_prefix_resolver( $stash->{ context }->{ prefix_resolver });
return $self; # returns 'MyPlugin'
}
@@ -27,9 +26,6 @@ sub new {
my ($class, $arg_ref) = @_;
my $self = bless \do { my $o = Class::Std::Fast::ID() }, $class;
# $self->set_namespace_map( $arg_ref->{ namespace_map });
# $self->set_namespace_prefix_map( $arg_ref->{ namespace_prefix_map });
# $self->set_prefix( $arg_ref->{ prefix });
$self->set_prefix_resolver( $arg_ref->{ prefix_resolver });
return $self; # returns 'MyPlugin'
}
@@ -38,10 +34,10 @@ sub _get_prefix {
my ($self, $type, $node) = @_;
my $namespace = defined ($node)
? ref($node)
? $node->get_targetNamespace
? $node->get_targetNamespace()
: $node
: undef;
return $self->get_prefix_resolver->resolve_prefix(
return $self->get_prefix_resolver()->resolve_prefix(
$type,
$namespace,
ref($node)
@@ -50,27 +46,16 @@ sub _get_prefix {
);
}
#sub _get_prefix {
# my ($self, $type, $namespace) = @_;
# return $prefix_of{ $$self }->{ $type }
# if not defined($namespace);
# return $namespace_prefix_map_of{ $$self }->{ $namespace }
# || ( ($namespace_map_of{ $$self }->{ $namespace })
# ? join ('::', $prefix_of{ $$self }->{ $type }, $namespace_map_of{ $$self }->{ $namespace })
# : $prefix_of{ $$self }->{ $type }
# );
#}
sub create_xsd_name {
my ($self,$element) = @_;
my $name = $self->_resolve_prefix($element) . '::'
. $element->get_name();
my ($self,$node) = @_;
my $name = $self->_resolve_prefix($node) #. '::'
. $node->get_name();
return $self->perl_name( $name );
}
sub create_typemap_name {
my ($self, $node) = @_;
my $name = $self->_get_prefix('typemap') . '::'
my $name = $self->_get_prefix('typemap') #. '::'
. $node->get_name();
return $self->perl_name( $name );
}
@@ -79,10 +64,9 @@ sub create_server_name {
my ($self, $server, $port) = @_;
my $port_name = $port->get_name();
$port_name =~s{\A (?:.+)\. ([^\.]+) \z}{$1}x;
my $name = join('::',
my $name = join( q{},
$self->_get_prefix('server', $server),
$server->get_name(),
$port_name
join( '::', $server->get_name(), $port_name)
);
return $self->perl_name( $name );
}
@@ -91,10 +75,9 @@ sub create_interface_name {
my ($self, $server, $port) = @_;
my $port_name = $port->get_name();
$port_name =~s{\A (?:.+)\. ([^\.]+) \z}{$1}x;
my $name = join('::',
my $name = join( q{},
$self->_get_prefix('interface', $server),
$server->get_name(),
$port_name
join( '::', $server->get_name(), $port_name )
);
return $self->perl_name( $name );
}
@@ -121,8 +104,8 @@ sub _resolve_prefix {
sub perl_name {
my $self = shift;
my $name = shift;
$name =~s{[\-]}{_}xmsg;
$name =~s{[\.]}{::}xmsg;
$name =~s{\-}{_}xmsg;
$name =~s{\.}{::}xmsg;
return $name;
}
lib/SOAP/WSDL/Generator/Template/XSD.pm
+42 -34
View File
@@ -5,15 +5,15 @@ use Class::Std::Fast::Storable;
use File::Basename;
use File::Spec;
our $VERSION = q{2.00_27};
use version; our $VERSION = qv('2.00.01');
use SOAP::WSDL::Generator::Visitor::Typemap;
use SOAP::WSDL::Generator::Visitor::Typelib;
use SOAP::WSDL::Generator::Template::Plugin::XSD;
use base qw(SOAP::WSDL::Generator::Template);
my %output_of :ATTR(:name<output> :default<()>);
my %typemap_of :ATTR(:name<typemap> :default<({})>);
my %output_of :ATTR(:name<output> :default<()>);
my %typemap_of :ATTR(:name<typemap> :default<({})>);
sub BUILD {
my ($self, $ident, $arg_ref) = @_;
@@ -47,6 +47,29 @@ sub BUILD {
);
}
# construct object on call to allow late binding of prefix_resolver class
# and namespace maps (not used yet)
sub get_name_resolver {
my $self = shift;
return SOAP::WSDL::Generator::Template::Plugin::XSD->new({
prefix_resolver => $self->get_prefix_resolver_class()->new({
namespace_prefix_map => {
'http://www.w3.org/2001/XMLSchema' => 'SOAP::WSDL::XSD::Typelib::Builtin',
},
namespace_map => {
},
prefix => {
attribute => $self->get_attribute_prefix,
interface => $self->get_interface_prefix,
element => $self->get_element_prefix,
server => $self->get_server_prefix,
type => $self->get_type_prefix,
typemap => $self->get_typemap_prefix,
}
})
});
}
sub generate {
my $self = shift;
my $opt = shift;
@@ -73,7 +96,7 @@ sub _generate_interface {
my $self = shift;
my $arg_ref = shift;
my $template_name = delete $arg_ref->{ template_name };
my $prefix_method = delete $arg_ref->{ prefix_method };
my $name_method = delete $arg_ref->{ name_method };
for my $service (@{ $self->get_definitions->get_service }) {
for my $port (@{ $service->get_port() }) {
# Skip ports without (known) address
@@ -85,10 +108,11 @@ sub _generate_interface {
my $output = $arg_ref->{ output }
? $arg_ref->{ output }
: $self->_generate_filename(
$self->can($prefix_method)->($self),
$service->get_name(),
$port_name,
);
$self->get_name_resolver()->can($name_method)->(
$self->get_name_resolver(),
$service,
$port,
));
print "Creating interface class $output\n";
$self->_process($template_name,
@@ -105,14 +129,14 @@ sub _generate_interface {
sub generate_server {
my ($self, $arg_ref) = @_;
$arg_ref->{ template_name } = 'Server.tt';
$arg_ref->{ prefix_method } = 'get_server_prefix';
$arg_ref->{ name_method } = 'create_server_name';
$self->_generate_interface($arg_ref);
}
sub generate_client {
my ($self, $arg_ref) = @_;
$arg_ref->{ template_name } = 'Interface.tt';
$arg_ref->{ prefix_method } = 'get_interface_prefix';
$arg_ref->{ name_method } = 'create_interface_name';
$self->_generate_interface($arg_ref);
}
sub generate_interface;
@@ -133,22 +157,7 @@ sub generate_typemap {
'Fault/detail' => 'SOAP::WSDL::XSD::Typelib::Builtin::string',
%{ $typemap_of{ident $self }},
},
resolver => SOAP::WSDL::Generator::Template::Plugin::XSD->new({
prefix_resolver => $self->get_prefix_resolver_class()->new({
namespace_prefix_map => {
'http://www.w3.org/2001/XMLSchema' => 'SOAP::WSDL::XSD::Typelib::Builtin',
},
namespace_map => {
},
prefix => {
interface => $self->get_interface_prefix,
element => $self->get_element_prefix,
server => $self->get_server_prefix,
type => $self->get_type_prefix,
typemap => $self->get_typemap_prefix,
}
})
}),
resolver => $self->get_name_resolver(),
});
use SOAP::WSDL::Generator::Iterator::WSDL11;
@@ -163,7 +172,7 @@ sub generate_typemap {
my $output = $arg_ref->{ output }
? $arg_ref->{ output }
: $self->_generate_filename( $self->get_typemap_prefix(), $service->get_name() );
: $self->_generate_filename( $self->get_name_resolver()->create_typemap_name($service) );
print "Creating typemap class $output\n";
$self->_process('Typemap.tt',
{
@@ -176,8 +185,7 @@ sub generate_typemap {
}
sub _generate_filename :PRIVATE {
my ($self, @parts) = @_;
my $name = join '::', @parts;
my ($self, $name) = @_;
$name =~s{ \. }{::}xmsg;
$name =~s{ \- }{_}xmsg;
$name =~s{ :: }{/}xmsg;
@@ -188,7 +196,7 @@ sub visit_XSD_Attribute {
my ($self, $attribute) = @_;
my $output = defined $output_of{ ident $self }
? $output_of{ ident $self }
: $self->_generate_filename( $self->get_attribute_prefix(), $attribute->get_name() );
: $self->_generate_filename( $self->get_name_resolver()->create_xsd_name($attribute) );
$self->_process('attribute.tt', { attribute => $attribute } , $output);
}
@@ -196,7 +204,7 @@ sub visit_XSD_Element {
my ($self, $element) = @_;
my $output = defined $output_of{ ident $self }
? $output_of{ ident $self }
: $self->_generate_filename( $self->get_element_prefix(), $element->get_name() );
: $self->_generate_filename( $self->get_name_resolver()->create_xsd_name($element) );
$self->_process('element.tt', { element => $element } , $output);
}
@@ -204,7 +212,7 @@ sub visit_XSD_SimpleType {
my ($self, $type) = @_;
my $output = defined $output_of{ ident $self }
? $output_of{ ident $self }
: $self->_generate_filename( $self->get_type_prefix(), $type->get_name() );
: $self->_generate_filename( $self->get_name_resolver()->create_xsd_name($type) );
$self->_process('simpleType.tt', { simpleType => $type } , $output);
}
@@ -212,8 +220,8 @@ sub visit_XSD_ComplexType {
my ($self, $type) = @_;
my $output = defined $output_of{ ident $self }
? $output_of{ ident $self }
: $self->_generate_filename( $self->get_type_prefix(), $type->get_name() );
: $self->_generate_filename( $self->get_name_resolver()->create_xsd_name($type) );
$self->_process('complexType.tt', { complexType => $type } , $output);
}
1;
1;
lib/SOAP/WSDL/Generator/Template/XSD/Interface/Body.tt
+2 -2
View File
@@ -15,8 +15,8 @@
@parts = map {
my $part = $_;
(grep {
my ($ns, $lname) = $def->expand( $_ );
($lname eq $part->get_name)
# my ($ns, $lname) = $def->expand( $_ );
($_ eq $part->get_name)
} @body_part_from
)
? do {
lib/SOAP/WSDL/Generator/Template/XSD/Interface/Header.tt
+4 -3
View File
@@ -11,10 +11,11 @@
my $def = $stash->{ definitions };
my $type_prefix = $stash->{ type_prefix };
my $element_prefix = $stash->{ element_prefix };
my ($ns, $lname) = $def->expand( $item->get_part() );
#my ($ns, $lname) = $def->expand( $item->get_part() );
my $part_name = $item->get_part();
my ($part) = grep {
$_->get_name eq $lname
&& $_->get_targetNamespace eq $ns } @{ $message->get_part( ) };
$_->get_name eq $part_name
} @{ $message->get_part( ) };
my $part_class = do {
my $name;
($name = $part->get_element)
lib/SOAP/WSDL/Generator/Template/XSD/Interface/POD/Operation.tt
-1
View File
@@ -7,4 +7,3 @@
port_op.get_documentation %]
$interface->[% operation.get_name %]([% INCLUDE Interface/POD/Message.tt %] );
lib/SOAP/WSDL/Generator/Template/XSD/Server.tt
+2 -2
View File
@@ -36,7 +36,7 @@ sub START {
}
sub handle {
$transport_of{ ${ shift @_ } }->handle(@_);
$transport_of{ ${ $_[0] } }->handle(@_[1..$#_]);
}
1;
@@ -102,4 +102,4 @@ implementing the SOAP Service methods listed below.
Generated by SOAP::WSDL on [% PERL %]print scalar localtime() [% END %]
=pod
=cut
lib/SOAP/WSDL/Generator/Template/XSD/Server/POD/Operation.tt
+39 -6
View File
@@ -3,15 +3,48 @@
[% head3 %] [% operation.get_name %]
[% type = definitions.find_portType( binding.expand( binding.get_type ) );
port_op = type.find_operation( definitions.get_targetNamespace, operation.get_name );
port_op.get_documentation %]
[% type = definitions.find_portType( binding.expand( binding.get_type ) );
port_op = '';
FOREACH port_op = type.get_operation();
IF (port_op.get_name == operation.get_name);
LAST;
END;
END;
input_message_name = port_op.first_input.get_message();
output_message_name = port_op.first_output.get_message();
input_message = definitions.find_message(port_op.first_input.expand(input_message_name));
output_message = definitions.find_message(port_op.first_output.expand(output_message_name));
input_parts = input_message.get_part();
output_parts = output_message.get_part();
# port_op.get_documentation
%]
sub [% operation.get_name %] {
my ($self, $body, $header) = @_;
# body is a ??? object - sorry, POD not implemented yet
# header is a ??? object - sorry, POD not implemented yet
[%
IF (input_parts.size() > 1); -%]
# body is a list ref of the following objects:
# [
# sorry - POD support not implemented yet
# ]
[% ELSE;
input_element = definitions.first_types.find_element(input_parts.0.expand(input_parts.0.get_element));
IF (input_element);
class = XSD.create_xsd_name( input_element );
ELSE;
input_type = definitions.first_types.find_type(input_parts.0.expand(input_parts.0.get_type));
class = XSD.create_xsd_name( input_type );
END;
-%]
# body is a [% class %] object
[%-
END;
%]
# header is a ??? object - sorry, POD support not implemented yet
# do something with body and header...
return [% INCLUDE Server/POD/Message.tt %]
lib/SOAP/WSDL/Generator/Template/XSD/complexType/POD/attributeSet.tt
+4 -1
View File
@@ -15,7 +15,10 @@ get_/set_ methods:
=over
[% FOREACH element = complexType.get_attribute -%]
[% FOREACH element = complexType.get_attribute;
WHILE element.get_ref;
element = definitions.first_types.find_attribute(element.expand( element.get_ref ));
END; -%]
=item * [% element.get_name %]
[%- IF (element.get_annotation && element.get_annotation.0.get_documentation) %]
lib/SOAP/WSDL/Generator/Template/XSD/complexType/attributeSet.tt
+16 -6
View File
@@ -3,18 +3,27 @@ package [% XSD.create_xmlattr_name(complexType) %];
use base qw(SOAP::WSDL::XSD::Typelib::AttributeSet);
{ # BLOCK to scope variables
[% FOREACH element = complexType.get_attribute %]
[% FOREACH element = complexType.get_attribute;
WHILE element.get_ref;
element = definitions.first_types.find_attribute(element.expand( element.get_ref ));
END; %]
my %[% element.get_name %]_of :ATTR(:get<[% element.get_name %]>);
[%- END %]
__PACKAGE__->_factory(
[ qw(
[%- FOREACH element = complexType.get_attribute %]
[%- FOREACH element = complexType.get_attribute;
WHILE element.get_ref;
element = definitions.first_types.find_attribute(element.expand( element.get_ref ));
END; %]
[% element.get_name -%]
[% END %]
) ],
{
[% FOREACH element = complexType.get_attribute -%]
[% FOREACH element = complexType.get_attribute;
WHILE element.get_ref;
element = definitions.first_types.find_attribute(element.expand( element.get_ref ));
END; %]
[% element.get_name %] => \%[% element.get_name %]_of,
[% END -%]
},
@@ -26,10 +35,11 @@ __PACKAGE__->_factory(
[% element.get_name %] => '[% XSD.create_xsd_name(element_type) %]',
[%
ELSIF (ref = element.get_ref);
attribute = definitions.first_types.find_attribute( complexType.expand(ref) );
# element_type = definitions.get_types.0.find_type(complexType.expand( attribute.get_type ));
WHILE element.get_ref;
element = definitions.first_types.find_attribute(element.expand( element.get_ref ));
END;
%]
[% attribute.get_name %] => '[% XSD.create_xsd_name(attribute) %]',
[% element.get_name %] => '[% XSD.create_xsd_name(element) %]',
[% ELSIF (element.first_simpleType);
THROW NOT_IMPLEMENTED , "Attributes with atomic simpleType definition are not implemented yet";
atomic_types.${ element.get_name } = element.first_simpleType;
lib/SOAP/WSDL/Generator/Template/XSD/element.tt
+4 -1
View File
@@ -8,7 +8,10 @@ use warnings;
sub get_xmlns { '[% element.get_targetNamespace %]' }
__PACKAGE__->__set_name('[% element.get_name %]');
__PACKAGE__->__set_nillable([% element.get_nillable %]);
__PACKAGE__->__set_nillable([% IF (element.get_nillable);
IF (element.get_nillable != 'false'); %]1[% ELSE %]0[% END;
END;
%]);
__PACKAGE__->__set_minOccurs([% element.get_minOccurs %]);
__PACKAGE__->__set_maxOccurs([% element.get_maxOccurs %]);
__PACKAGE__->__set_ref([% IF element.get_ref; %]'[% element.get_ref %]'[% END %]);
lib/SOAP/WSDL/Generator/Visitor.pm
+9 -9
View File
@@ -3,7 +3,7 @@ use strict;
use warnings;
use Class::Std::Fast::Storable;
our $VERSION = q{2.00_25};
use version; our $VERSION = qv('2.00.01');
my %definitions_of :ATTR(:name<definitions> :default<()>);
my %type_prefix_of :ATTR(:name<type_prefix> :default<()>);
@@ -66,13 +66,13 @@ tree of objects.
A Visitor's methods are called using the so-called double dispatch technique.
To allow double dispatching, the Visitor implements one method for every class
ro be handled, whereas every class implements just one method (commonly named
to be handled, whereas every class implements just one method (commonly named
"access"), which does nothing more than calling a method on the reference
given, with the self object as parameter.
If all this sounds strange, maybe an example helps. Imagine you had a list of
person objects and wanted to print out a list of their names (or address
stamps or everything elseyou like). This can easily be implemented with a
stamps or everything else you like). This can easily be implemented with a
Visitor:
package PersonVisitor;
@@ -107,7 +107,7 @@ Visitor:
Person name is Vlissides
While using this pattern for just printing a list may look a bit over-sized,
but it may become handy if you need multiple output formats and different
it may become handy if you need multiple output formats and different
classes to operate on.
The main benefits using visitors are:
@@ -188,8 +188,8 @@ mimicing .NET's .asmx example pages.
All these behaviours could well be (and have historically been) implemented in
the classes holding the WSDL data. This made these classes rather bloated, and
made it hard to change behaviour (like, supporting SOAP Headers,
supporting atomic types and other features which were missing from early
made it hard to change behaviour (like supporting SOAP Headers,
supporting atomic types, and other features which were missing from early
versions of SOAP::WSDL).
Implementing these behaviours in Visitor classes eases adding new behaviours,
@@ -203,7 +203,7 @@ schema implementation.
SOAP::WSDL::Base defines an accept method which expects a Visitor as only
parameter.
The method visit_Foo_Bar is called on the visitor, whith the self object as
The method visit_Foo_Bar is called on the visitor, with the self object as
parameter.
The actual method name is constructed this way:
@@ -224,7 +224,7 @@ visit_XSD_ComplexType is called on the visitor.
=head2 Writing your own visitor
SOAP::WSDL eases writing your own visitor. This might be required if you need
some special output format from a WSDL file, or want to feed your own
some special output format from a WSDL file or want to feed your own
serializer/deserializer pair with custom configuration data. Or maybe you want
to generate C# code from it...
@@ -273,7 +273,7 @@ The SOAP::WSDL::Generator::Visitor implementations include part of their own
Iterator (which means they know how to find the next objects to visit). You
may or may not choose to implement a separate Iterator.
Letting a visitor implementing it's own Iterator visit a WSDL definition is as
Letting a visitor implementing its own Iterator visit a WSDL definition is as
easy as writing something like this:
my $visitor = MyVisitor->new();
lib/SOAP/WSDL/Generator/Visitor/Typelib.pm
+1
View File
@@ -5,6 +5,7 @@ use base qw(SOAP::WSDL::Generator::Visitor
SOAP::WSDL::Generator::Template
);
use version; our $VERSION = qv('2.00.01');
1;
lib/SOAP/WSDL/Generator/Visitor/Typemap.pm
+4 -14
View File
@@ -5,7 +5,7 @@ use Class::Std::Fast::Storable;
use base qw(SOAP::WSDL::Generator::Visitor);
our $VERSION = q{2.00_25};
use version; our $VERSION = qv('2.00.01');
my %path_of :ATTR(:name<path> :default<[]>);
my %typemap_of :ATTR(:name<typemap> :default<()>);
@@ -41,7 +41,7 @@ sub add_element_path {
sub process_referenced_type {
my ( $self, $ns, $localname ) = @_;
return if not $localname;
my $ident = ident $self;
# get type's class name
@@ -65,8 +65,7 @@ sub process_atomic_type {
my ( $self, $type, $callback ) = @_;
return if not $type;
my $ident = ident $self;
$callback->( $self, $type ) if $callback;
$callback->( $self, $type );
return $self;
}
@@ -97,9 +96,6 @@ sub visit_XSD_Element {
# warn "simpleType " . $element->get_name();
my @path = @{ $path_of{ ${ $self } } };
my $typeclass = $self->get_resolver()->create_subpackage_name($element);
# my $typeclass = defined ($parent)
# ? join q{::_}, $parent , $element->get_name()
# : join q{::}, $self->resolver()->get_element_prefix( $element->get_targetNamespace), $element->get_name();
$self->set_typemap_entry($typeclass);
$typeclass =~s{\.}{::}g;
$typeclass =~s{\-}{_}g;
@@ -108,14 +104,11 @@ sub visit_XSD_Element {
# for atomic and complex types , and ref elements
my $typeclass = $self->get_resolver()->create_subpackage_name($element);
# my $typeclass = join q{::}, $self->get_resolver()->get_element_prefix( $element->get_targetNamespace), $element->get_name();
# $typeclass =~s{\.}{::}g;
# $typeclass =~s{\-}{_}g;
$self->set_typemap_entry($typeclass);
$self->process_atomic_type( $element->first_complexType()
, sub { $_[1]->_accept($_[0]) } )
&& last;
&& last SWITCH;
# TODO: add element ref handling
};
@@ -125,9 +118,6 @@ sub visit_XSD_Element {
if (not defined($parent)) {
# for atomic and complex types , and ref elements
my $typeclass = $self->get_resolver()->create_xsd_name($element);
# my $typeclass = join q{::}, $self->get_resolver()->get_element_prefix($element->get_targetNamespace), $element->get_name();
# $typeclass =~s{\.}{::}g;
# $typeclass =~s{\-}{_}g;
$self->set_typemap_entry($typeclass);
}