import SOAP-WSDL 1.27 from CPAN

git-cpan-module:   SOAP-WSDL
git-cpan-version:  1.27
git-cpan-authorid: MKUTTER
git-cpan-file:     authors/id/M/MK/MKUTTER/SOAP-WSDL-1.27.tar.gz

lib/SOAP/WSDL/XSD/Builtin.pm

@@ -1,36 +0,0 @@
-package SOAP::WSDL::XSD::Builtin;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable;
-use base qw(SOAP::WSDL::Base);
-
-sub serialize {
-    my ($self, $name, $value, $opt) = @_;
-    my $xml;
-    $opt->{ indent } ||= "";
-    $opt->{ attributes } ||= [];
-
-    $xml .= $opt->{ indent } if ($opt->{ readable });
-    $xml .= '<' . join ' ', $name, @{ $opt->{ attributes } };
-    if ( $opt->{ autotype }) {
-        my $ns = $self->get_targetNamespace();
-        my %prefix_of = reverse %{ $opt->{ namespace } };
-        my $prefix = $prefix_of{ $ns }
-            || die 'No prefix found for namespace '. $ns;
-        $xml .= ' type="' . $prefix . ':'
-          . $self->get_name() . '"' if ($self->get_name() );
-    }
-
-    if (defined $value) {
-        $xml .= '>';
-        $xml .= "$value";
-        $xml .= '</' . $name . '>' ;
-    }
-    else {
-        $xml .= '/>';
-    }
-    $xml .= "\n" if ($opt->{ readable });
-    return $xml;
-}
-
-1;

lib/SOAP/WSDL/XSD/ComplexType.pm

@@ -1,125 +0,0 @@
-package SOAP::WSDL::XSD::ComplexType;
-use strict;
-use warnings;
-use Carp;
-use Class::Std::Fast::Storable;
-use Scalar::Util qw(blessed);
-use base qw/SOAP::WSDL::Base/;
-
-our $VERSION=q{2.00_25};
-
-my %annotation_of   :ATTR(:name<annotation> :default<()>);
-my %element_of      :ATTR(:name<element>    :default<()>);
-my %flavor_of       :ATTR(:name<flavor>     :default<()>);
-my %base_of         :ATTR(:name<base>       :default<()>);
-my %itemType_of     :ATTR(:name<itemType>   :default<()>);
-my %enumeration_of  :ATTR(:name<enumeration>   :default<()>);
-my %abstract_of     :ATTR(:name<abstract>   :default<()>);
-my %mixed_of        :ATTR(:name<mixed>      :default<()>);      # default is false
-
-# is set to simpleContent/complexContent
-my %content_model_of    :ATTR(:name<contentModel>   :default<NONE>);
-
-sub get_variety; *get_variety = \&get_flavor;
-
-sub push_element {
-    my $self = shift;
-    my $element = shift;
-    if ($flavor_of{ ident $self } eq 'all')
-    {
-        $element->set_minOccurs(0) if not defined ($element->get_minOccurs);
-        $element->set_maxOccurs(1) if not defined ($element->get_maxOccurs);
-    }
-    elsif ($flavor_of{ ident $self } eq 'sequence')
-    {
-        $element->set_minOccurs(1) if not defined ($element->get_minOccurs);
-        $element->set_maxOccurs(1) if not defined ($element->get_maxOccurs);
-    }
-    push @{ $element_of{ ident $self } }, $element;
-}
-
-sub set_restriction {
-    my $self = shift;
-    my $element = shift;
-    $flavor_of{ ident $self } = 'restriction';
-    $base_of{ ident $self } = $element->{ Value };
-}
-
-sub set_extension {
-    my $self = shift;
-    my $element = shift;
-    $flavor_of{ ident $self } = 'extension';
-    $base_of{ ident $self } = $element->{ Value };
-}
-
-sub init {
-    my $self = shift;
-    my @args = @_;
-    $self->SUPER::init( @args );
-}
-
-sub serialize {
-    my ($self, $name, $value, $opt) = @_;
-
-    $opt->{ indent } ||= q{};
-    $opt->{ attributes } ||= [];
-    my $flavor = $self->get_flavor();
-    my $xml = ($opt->{ readable }) ? $opt->{ indent } : q{};    # add indentation
-
-
-    if ( $opt->{ qualify } ) {
-        $opt->{ attributes } = [ ' xmlns="' . $self->get_targetNamespace .'"' ];
-        delete $opt->{ qualify };
-    }
-
-
-    $xml .= join q{ } , "<$name" , @{ $opt->{ attributes } };
-    delete $opt->{ attributes };                                # don't propagate...
-
-    if ( $opt->{ autotype }) {
-      my $ns = $self->get_targetNamespace();
-      # reverse namespace by prefix hash
-      my %prefix_of = reverse %{ $opt->{ namespace } };
-      my $prefix = $prefix_of{ $ns }
-        || die 'No prefix found for namespace '. $ns;
-      $xml .= join q{}, " type=\"$prefix:", $self->get_name(), '" '
-        if ($self->get_name() );
-    }
-    $xml .= '>';
-    $xml .= "\n" if ( $opt->{ readable } );                 # add linebreak
-    if ( ($flavor eq "sequence") or ($flavor eq "all") ) {
-        $opt->{ indent } .= "\t";
-        for my $element (@{ $self->get_element() }) {
-            # might be list - listify
-            $value = [ $value ] if not ref $value eq 'ARRAY';
-
-            for my $single_value (@{ $value }) {
-                my $element_value;
-                if (blessed $single_value) {
-                    my $method = 'get_' . $element->get_name();
-                    $element_value = $single_value->$method();
-                }
-                else {
-                    $element_value = $single_value->{ $element->get_name() };
-                }
-                $element_value = [ $element_value ]
-                    if not ref $element_value eq 'ARRAY';
-
-                $xml .= join q{}
-                    , map { $element->serialize( undef, $_, $opt ) }
-                       @{ $element_value };
-            }
-        }
-        $opt->{ indent } =~s/\t$//;
-    }
-    else {
-      die "sorry, we just handle all and sequence types yet...";
-    }
-    $xml .= $opt->{ indent } if ( $opt->{ readable } ); # add indentation
-    $xml .= '</' . $name . '>';
-    $xml .= "\n" if ($opt->{ readable } );              # add linebreak
-    return $xml;
-}
-
-1;
-

lib/SOAP/WSDL/XSD/Element.pm

@@ -1,107 +0,0 @@
-package SOAP::WSDL::XSD::Element;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable;
-use base qw(SOAP::WSDL::Base);
-
-our $VERSION=q{2.00_25};
-
-my %annotation_of   :ATTR(:name<annotation> :default<()>);
-my %simpleType_of   :ATTR(:name<simpleType> :default<()>);
-my %complexType_of  :ATTR(:name<complexType> :default<()>);
-my %facet_of        :ATTR(:name<facet>      :default<()>);
-my %type_of         :ATTR(:name<type>       :default<()>);
-my %abstract_of     :ATTR(:name<abstract>   :default<()>);
-my %block_of        :ATTR(:name<block>      :default<()>);
-my %default_of      :ATTR(:name<default>    :default<()>);
-my %final_of        :ATTR(:name<final>      :default<()>);
-my %fixed_of        :ATTR(:name<fixed>      :default<()>);
-my %form_of         :ATTR(:name<form>       :default<()>);
-my %maxOccurs_of    :ATTR(:name<maxOccurs>  :default<()>);
-my %minOccurs_of    :ATTR(:name<minOccurs>  :default<()>);
-my %nillable_of     :ATTR(:name<nillable>   :default<()>);
-my %ref_of          :ATTR(:name<ref>        :default<()>);
-my %substitutionGroup_of :ATTR(:name<substitutionGroup> :default<()>);
-
-sub first_simpleType {
-    my $result_ref = $simpleType_of{ ident shift };
-    return if not $result_ref;
-    return $result_ref if (not ref $result_ref eq 'ARRAY');
-    return $result_ref->[0];
-}
-
-sub first_complexType {
-    my $result_ref = $complexType_of{ ident shift };
-    return if not $result_ref;
-    return $result_ref if (not ref $result_ref eq 'ARRAY');
-    return $result_ref->[0];
-}
-
-# serialize type instead...
-sub serialize {
-    my ($self, $name, $value, $opt) = @_;
-    my $type;
-    my $typelib = $opt->{ typelib };
-    my %ns_map = %{ $opt->{ namespace } };
-    my $ident = ident $self;
-
-    # abstract elements may only be serialized via ref - and then we have a
-    # name...
-    die "cannot serialize abstract element" if $abstract_of{ $ident }
-        and not $name;
-
-    # TODO: implement final and substitutionGroup - maybe never implement
-    # substitutionGroup ?
-
-    $name ||= $self->get_name();
-
-    if ( $opt->{ qualify } ) {
-        $opt->{ attributes } = [ ' xmlns="' . $self->get_targetNamespace .'"' ];
-    }
-
-
-    # set default and fixed - fixed overrides everything,
-    # default only empty (undefined) values
-    if (not defined $value)     {
-      $value = $default_of{ ident $self } if $default_of{ ident $self };
-    }
-    $value = $fixed_of{ ident $self } if $fixed_of{ ident $self };
-
-    # TODO check nillable and serialize empty data correctly
-
-    # return if minOccurs is 0 and we have no value
-    if (defined $minOccurs_of{ ident $self }
-        and $minOccurs_of{ ident $self } == 0) {
-        return q{} if not defined $value;
-    }
-
-    # handle direct simpleType and complexType here
-    if ($type = $self->first_simpleType() ) {             # simpleType
-        return $type->serialize( $name, $value, $opt );
-    }
-    elsif ($type = $self->first_complexType() ) {           # complexType
-        return $type->serialize( $name, $value, $opt );
-    }
-    elsif (my $ref_name = $ref_of{ $ident }) {              # ref
-        my ($prefix, $localname) = split /:/ , $ref_name;
-        my $ns = $ns_map{ $prefix };
-        $type = $typelib->find_element( $ns, $localname );
-        die "no element for ref $prefix:$localname" if (not $type);
-        return $type->serialize( $name, $value, $opt );
-    }
-
-    # lookup type
-    my ($prefix, $localname) = split /:/ , $self->get_type();
-    my $ns = $ns_map{ $prefix };
-    $type = $typelib->find_type(
-        $ns, $localname
-    );
-
-    # safety check
-    die "no type for $prefix:$localname $ns_map{$prefix}" if (not $type);
-
-    return $type->serialize( $name, $value, $opt );
-}
-
-1;
-

lib/SOAP/WSDL/XSD/Schema.pm

@@ -1,75 +0,0 @@
-package SOAP::WSDL::XSD::Schema;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable;
-use base qw(SOAP::WSDL::Base);
-
-our $VERSION=q{2.00_25};
-
-# child elements
-my %type_of :ATTR(:name<type> :default<[]>);
-my %element_of :ATTR(:name<element> :default<[]>);
-my %group_of :ATTR(:name<group> :default<[]>);
-
-# attributes
-my %attributeFormDefault_of :ATTR(:name<attributeFormDefault> :default<()>);
-my %blockDefault_of :ATTR(:name<blockDefault> :default<()>);
-my %elementFormDefault_of :ATTR(:name<elementFormDefault> :default<()>);
-my %finalDefault_of :ATTR(:name<finalDefault> :default<()>);
-my %version_of :ATTR(:name<version> :default<()>);
-
-# id
-# name
-# targetNamespace inherited from Base
-# xmlns
-
-#
-#  attributeFormDefault = (qualified | unqualified) : unqualified
-#  blockDefault = (#all | List of (extension | restriction | substitution))  : ''
-#  elementFormDefault = (qualified | unqualified) : unqualified
-#  finalDefault = (#all | List of (extension | restriction | list | union))  : ''
-#  id = ID
-#  targetNamespace = anyURI
-#  version = token
-#  xml:lang = language
-#
-#
-# alias type with all variants
-# AUTOMETHOD is WAY too slow..
-{
-    no strict qw/refs/;
-    for my $name (qw(simpleType complexType) ) {
-        *{ "set_$name" } = \&set_type;
-        *{ "get_$name" } = \&get_type;
-        *{ "push_$name" } = \&push_type;
-        *{ "find_$name" } = \&find_type;
-    }
-}
-
-sub push_type {
-    # use $_[n] for performance -
-    # we're called on each and every type inside WSDL
-    push @{ $type_of{ ident $_[0]} }, $_[1];
-}
-
-sub find_element {
-    my ($self, @args) = @_;
-    my @found_at = grep {
-        $_->get_targetNamespace() eq $args[0] &&
-        $_->get_name() eq $args[1]
-    }
-    @{ $element_of{ ident $self } };
-    return $found_at[0];
-}
-
-sub find_type {
-    my ($self, @args) = @_;
-    my @found_at = grep {
-        $_->get_targetNamespace() eq $args[0] &&
-        $_->get_name() eq $args[1]
-    }
-    @{ $type_of{ ident $self } };
-    return $found_at[0];
-}
-
-1;

lib/SOAP/WSDL/XSD/Schema/Builtin.pm

@@ -1,97 +0,0 @@
-package SOAP::WSDL::XSD::Schema::Builtin;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable;
-use SOAP::WSDL::XSD::Schema;
-use SOAP::WSDL::XSD::Builtin;
-use base qw(SOAP::WSDL::XSD::Schema);
-
-# all builtin types - add validation (e.g. content restrictions) later...
-my %BUILTINS = (
-    'string' => {},
-    'boolean' => {},
-    'decimal' => {},
-    'dateTime' => {},
-    'float' => {},
-    'double' => {},
-    'duration' => {},
-    'time' => {},
-    'date' => {},
-    'gYearMonth' => {},
-    'gYear' => {},
-    'gMonthDay' => {},
-    'gDay' => {},
-    'gMonth' => {},
-    'hexBinary' => {},
-    'base64Binary' => {},
-    'anyURI' => {},
-    'QName' => {},
-    'NOTATION' => {},
-    'integer' => {},
-    'nonPositiveInteger' => {},
-    'nonNegativeInteger' => {},
-    'positiveInteger' => {},
-    'negativeInteger' => {},
-    'long' => {},
-    'int' => {},
-    'unsignedInt' => {},
-    'short' => {},
-    'unsignedShort' => {},
-    'byte' => {},
-    'unsignedByte' => {},
-    'normalizedString' => {},
-    'token' => {},
-    'NMTOKEN' => {},
-);
-
-sub START {
-    my $self = shift;
-    my @args = @_;
-
-    while (my ($name, $value) = each %BUILTINS )
-    {
-        $self->push_type( SOAP::WSDL::XSD::Builtin->new({
-                name => $name,
-                targetNamespace => 'http://www.w3.org/2001/XMLSchema',
-            } )
-        );
-    }
-    return $self;
-}
-
-1;
-
-
-=pod
-
-=head1 NAME
-
-SOAP:WSDL::XSD::Schema::Builtin - Provides builtin XML Schema datatypes for parsing WSDL
-
-=head1 DESCRIPTION
-
-Used internally by SOAP::WSDL's WSDL parser.
-
-See <SOAP::WSDL::XSD::Typelib::Builtin|SOAP::WSDL::XSD::Typelib::Builtin> for
-SOAP::WSDL::XSD's builtin XML Schema datatypes.
-
-=head1 LICENSE AND COPYRIGHT
-
-Copyright (c) 2007 Martin Kutter. All rights reserved.
-
-This file is part of SOAP-WSDL. You may distribute/modify it under
-the same terms as perl itself
-
-=head1 AUTHOR
-
-Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
-
-=head1 REPOSITORY INFORMATION
-
- $Rev: 412 $
- $LastChangedBy: kutterma $
- $Id: Builtin.pm 412 2007-11-27 22:57:52Z kutterma $
- $HeadURL: http://soap-wsdl.svn.sourceforge.net/svnroot/soap-wsdl/SOAP-WSDL/trunk/lib/SOAP/WSDL/XSD/Schema/Builtin.pm $
- 
-=cut
-

lib/SOAP/WSDL/XSD/SimpleType.pm

@@ -1,103 +0,0 @@
-package SOAP::WSDL::XSD::SimpleType;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable;
-use base qw(SOAP::WSDL::Base);
-
-our $VERSION=q{2.00_25};
-
-my %annotation_of   :ATTR(:name<annotation>     :default<()>);
-my %base_of         :ATTR(:name<base>           :default<()>);
-my %itemType_of     :ATTR(:name<itemType>       :default<()>);
-# is set to simpleContent/complexContent
-# my %content_model_of    :ATTR(:name<contentModel>   :default<()>);
-
-# TODO rename flavor to content_model to be consistent with the XML Schema
-# specs - though flavor is the cooler name..
-# set to restriction|list|union|enumeration
-my %flavor_of       :ATTR(:name<flavor>         :default<()>);
-
-# for simpleType containing atomic simple types
-my %type_of         :ATTR(:name<type>           :default<()>);
-
-sub get_simpleType; *get_simpleType = \&get_type;
-sub set_simpleType; *set_simpleType = \&set_type;
-
-sub get_variety; *get_variety = \&get_flavor;
-
-sub set_restriction {
-    my $self = shift;
-    my @attributes = @_;
-    $self->set_flavor( 'restriction' );
-    for (@attributes) {
-        next if (not $_->{ LocalName } eq 'base');
-        $self->set_base( $_->{ Value } );
-    }
-}
-
-sub set_list {
-    my $self = shift;
-    my @attributes = @_;
-    $self->set_flavor( 'list' );
-    for (@attributes) {
-        next if (not $_->{ LocalName } eq 'itemType');
-        $self->set_itemType( $_->{ Value } );
-    }
-}
-
-sub set_union {
-    my $self = shift;
-    my @attributes = @_;
-    $self->set_flavor( 'union' );
-    for (@attributes) {
-        next if (not $_->{ LocalName } eq 'memberTypes');
-        $self->set_base( [ split /\s/, $_->{ Value } ] );
-    }
-}
-
-sub serialize {
-    my $self = shift;
-    my $name = shift;
-    my $value = shift;
-    my $opt = shift;
-    my $ident = ident $self;
-
-    $opt->{ attributes } ||= [];
-    $opt->{ indent } ||= q{};
-
-    return $self->_serialize_single($name, $value , $opt)
-      if ( $flavor_of{ $ident } eq 'restriction'
-        or $flavor_of{ $ident } eq 'union'
-        or $flavor_of{ $ident } eq 'enumeration');
-
-    if ($flavor_of{ $ident } eq 'list' )
-    {
-        $value ||= [];
-        $value = [ $value ] if ( ref( $value) ne 'ARRAY' );
-        return $self->_serialize_single($name, join( q{ }, @{ $value } ), $opt);
-    }
-}
-
-sub _serialize_single {
-    my ($self, $name, $value, $opt) = @_;
-    my $xml = '';
-    $xml .= $opt->{ indent } if ($opt->{ readable });       # add indentation
-    $xml .= '<' . join ' ', $name, @{ $opt->{ attributes } };
-    if ( $opt->{ autotype }) {
-        # reverse namespace by prefix hash
-        my %prefix_of = reverse %{ $opt->{ namespace } };
-        my $ns = $self->get_targetNamespace();
-        my $prefix = $prefix_of{ $ns }
-           || die 'No prefix found for namespace '. $ns;
-        $xml .= ' type="' . $prefix . ':' . $self->get_name() .'"';
-    }
-
-    # nillabel ?
-    return $xml .'/>' if not defined $value;
-
-    $xml .= join q{}, '>' , $value , '</' , $name , '>';
-    $xml .= "\n" if ($opt->{ readable });
-    return $xml;
-}
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin.pm

@@ -1,419 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable;
-
-our $VERSION=q{2.00_25};
-
-use SOAP::WSDL::XSD::Typelib::Builtin::anyType;
-use SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType;
-use SOAP::WSDL::XSD::Typelib::Builtin::anyURI;
-use SOAP::WSDL::XSD::Typelib::Builtin::base64Binary;
-use SOAP::WSDL::XSD::Typelib::Builtin::boolean;
-use SOAP::WSDL::XSD::Typelib::Builtin::byte;
-use SOAP::WSDL::XSD::Typelib::Builtin::date;
-use SOAP::WSDL::XSD::Typelib::Builtin::dateTime;
-use SOAP::WSDL::XSD::Typelib::Builtin::decimal;
-use SOAP::WSDL::XSD::Typelib::Builtin::double;
-use SOAP::WSDL::XSD::Typelib::Builtin::duration;
-use SOAP::WSDL::XSD::Typelib::Builtin::ENTITY;
-use SOAP::WSDL::XSD::Typelib::Builtin::float;
-use SOAP::WSDL::XSD::Typelib::Builtin::gDay;
-use SOAP::WSDL::XSD::Typelib::Builtin::gMonth;
-use SOAP::WSDL::XSD::Typelib::Builtin::gMonthDay;
-use SOAP::WSDL::XSD::Typelib::Builtin::gYear;
-use SOAP::WSDL::XSD::Typelib::Builtin::gYearMonth;
-use SOAP::WSDL::XSD::Typelib::Builtin::hexBinary;
-use SOAP::WSDL::XSD::Typelib::Builtin::ID;
-use SOAP::WSDL::XSD::Typelib::Builtin::IDREF;
-use SOAP::WSDL::XSD::Typelib::Builtin::IDREFS;
-use SOAP::WSDL::XSD::Typelib::Builtin::int;
-use SOAP::WSDL::XSD::Typelib::Builtin::integer;
-use SOAP::WSDL::XSD::Typelib::Builtin::language;
-use SOAP::WSDL::XSD::Typelib::Builtin::list;
-use SOAP::WSDL::XSD::Typelib::Builtin::long;
-use SOAP::WSDL::XSD::Typelib::Builtin::Name;
-use SOAP::WSDL::XSD::Typelib::Builtin::NCName;
-use SOAP::WSDL::XSD::Typelib::Builtin::negativeInteger;
-use SOAP::WSDL::XSD::Typelib::Builtin::NMTOKEN;
-use SOAP::WSDL::XSD::Typelib::Builtin::NMTOKENS;
-use SOAP::WSDL::XSD::Typelib::Builtin::nonNegativeInteger;
-use SOAP::WSDL::XSD::Typelib::Builtin::nonPositiveInteger;
-use SOAP::WSDL::XSD::Typelib::Builtin::normalizedString;
-use SOAP::WSDL::XSD::Typelib::Builtin::NOTATION;
-use SOAP::WSDL::XSD::Typelib::Builtin::positiveInteger;
-use SOAP::WSDL::XSD::Typelib::Builtin::QName;
-use SOAP::WSDL::XSD::Typelib::Builtin::short;
-use SOAP::WSDL::XSD::Typelib::Builtin::string;
-use SOAP::WSDL::XSD::Typelib::Builtin::time;
-use SOAP::WSDL::XSD::Typelib::Builtin::token;
-use SOAP::WSDL::XSD::Typelib::Builtin::unsignedByte;
-use SOAP::WSDL::XSD::Typelib::Builtin::unsignedInt;
-use SOAP::WSDL::XSD::Typelib::Builtin::unsignedLong;
-use SOAP::WSDL::XSD::Typelib::Builtin::unsignedShort;
-
-1;
-
-__END__
-
-=pod
-
-=head1 NAME
-
-SOAP::WSDL::XSD::Typelib::Builtin - Built-in XML Schema datatypes
-
-=head1 DESCRIPTION
-
-The SOAP::WSDL::XSD::Typelib::Builtin hierarchy implements all builtin types
-from the XML schema specification.
-
-All XML schema derived types inherit from
-SOAP::WSDL::XSD::Typelib::Builtin::anyType.
-
-These basic type classes are most useful when used as element or simpleType
-base classes.
-
-Using SOAP::WSDL::XSD::Typelib::Builtin uses all of the builtin datatype
-classes.
-
-All builtin types feature common behaviour described below in
-L</OVERLOADED OPERATORS>
-
-=head1 EXAMPLES
-
- my $bool = SOAP::WSDL::XSD::Typelib::Builtin::bool->new({ value => 0} );
- print $bool;    # prints "true"
-
- # implements <simpleType name="MySimpleType">
- #               <list itemType="xsd:string" />
- #            </simpleType>
- package MySimpleType;
- use SOAP::WSDL::XSD::Typelib::Builtin;
- use SOAP::WSDL::XSD::Typelib::SimpleType;
- 
- use base qw(SOAP::WSDL::XSD::Typelib::SimpleType
-    SOAP::WSDL::XSD::Typelib::Builtin::list
-    SOAP::WSDL::XSD::Typelib::Builtin::string
- );
- 1;
-
- # somewhere else
- my $list = MySimpleType->new({ value => [ 'You', 'shall', 'overcome' ] });
- print $list;   # prints "You shall overcome"
-
-=head1 CLASS HIERARCHY
-
-This is the inheritance graph for builtin types.
-
-Types with [] marker describe types derived via the item in [] in the XML
-Schema specs.
-
-Derivation is implemented via multiple inheritance with the derivation method
-as first item in the base class list.
-
- anyType
- - anySimpleType
-     - duration
-     - dateTime
-     - date
-     - time
-     - gYearMonth
-     - gYear
-     - gMonthDay
-     - gDay
-     - gMonth
-     - boolean
-     - base64Binary
-     - hexBinary
-     - float
-     - decimal
-         - integer
-         - nonPositiveInteger
-             - negativeInteger
-         - nonNegativeInteger
-             - positiveInteger
-             - unsignedLong
-             - unsignedInt
-             - unsignedShort
-             - unsignedByte
-         - long
-             - int
-                 - short
-                     - byte
-     - double
-     - anyURI
-     - NOTATION
-     - string
-          - normalizedString
-              - language
-              - Name
-                  - NCName
-                      - ID
-                      - IDREF
-                          - IDREFS [list]
-                      - ENTITY
-              - token
-                  - NMTOKEN
-                      - NMTOKENS [list]
-
-=head1 OVERLOADED OPERATORS
-
-Overloading is implemented via Class::Std's trait mechanism.
-
-The following behaviours apply:
-
-=over
-
-=item * string context
-
-All classes use the C<serialize> method for stringification.
-
-=item * bool context
-
-All classes derived from anySimpleType return their value in bool context
-
-=item * numeric context
-
-The boolean class returns 0 or 1 in numeric context.
-
-decimal, float and double (and derived classes) return their value in
-numeric context.
-
-=item * arrayification (@{})
-
-When accessed as a list ref, objects of all classes return a list ref with
-the object itself as single element.
-
-This is most useful for writing loops without additional conversions,
-especially in mini-languages found in templating systems or the like, which
-may not natively support converting to list refs.
-
-Instead of writing something like
-
- my $value = $complexType->get_ELEMENT;
- $value = ref $value eq 'ARRAY' ? $value : [ $value ];
- for (@{ $value }) { ... }
-
-you can just write
-
- for (@{ $complexType->get_ELEMENT }) {...}
-
-Note that complexTypes with undef elements still return undef when accessing
-an undefined element, so when an element may be empty you still have to write
-something like:
-
- my $value = $complexType->get_ELEMENT();
- if (defined $value) {
-     for (@{ $value }) {
-         ...
-     }
- }
-
-=back
-
-=head1 Subclasses
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::anyType
-
-Base class for all types
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType
-
-Base class for all simple types
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::anyURI
-
-Type representing URIs
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::boolean
-
-Represents boolean data.
-
-Serializes to "true" or "false".
-
-Everything true in perl and not "false" is deserialized as true.
-
-Returns true/false in boolean context.
-
-Returns 1 / 0 in numeric context.
-
-boolean objects have a special method for deleteing their value, because
-calling C<setl_value(undef)> results in the value being set to false.
-
- $obj->delete_value();
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::byte
-
-byte integer objects.
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::date
-
-date values are automatically converted into XML date strings during setting:
-
- YYYY-MM-DD+zz:zz
-
-The time zone is set to the local time zone if not included.
-
-All input variants supported by Date::Parse are supported. You may even pass
-in dateTime strings - the time part will be ignored. Note that
-set_value is around 100 times slower when setting non-XML-time strings
-
-When setting dates before the beginning of the epoch (negative UNIX timestamp),
-you should use the XML date string format for setting dates. The behaviour of
-Date::Parse for dates before the epoch is system dependent.
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::dateTime
-
-dateTime values are automatically converted into XML dateTime strings during setting:
-
- YYYY-MM-DDThh:mm:ss.nnnnnnn+zz:zz
-
-The fraction of seconds (nnnnnnn) part is optional. Fractions of seconds may
-be given with arbitrary precision
-
-The fraction of seconds part is excluded in converted values, as it would always be 0.
-
-All input variants supported by Date::Parse are supported. Note that
-set_value is around 100 times slower when setting non-XML-time strings
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::decimal
-
-decimal is the base of all non-float numbers
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::double
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::duration
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::ENTITY
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::float
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::gDay
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::gMonth
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::gMonthDay
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::gYear
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::gYearMonth
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::hexBinary
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::ID
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::IDREF
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::IDREFS
-
-List of SOAP::WSDL::XSD::Typelib::Builtin::IDREF objects.
-
-Derived by SOAP::WSDL::XSD::Typelib::Builtin::list.
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::int
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::integer
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::language
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::list
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::long
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::Name
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::NCName
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::negativeInteger
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::nonNegativeInteger
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::nonPositiveInteger
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::normalizedString
-
-Tab, newline and carriage return characters are replaced by whitespace in
-set_value.
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::NOTATION
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::positiveInteger
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::QName
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::short
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::string
-
-String values are XML-escaped on serialization.
-
-The following characters are escaped: <, >, &
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::time
-
-time values are automatically converted into XML time strings during setting:
-
- hh:mm:ss.nnnnnnn+zz:zz
- hh:mm:ss+zz:zz
-
-The time zone is set to the local time zone if not included. The optional
-nanoseconds part is not included in converted values, as it would always be 0.
-
-All input variants supported by Date::Parse are supported. You may even pass
-in dateTime strings - the date part will be ignored. Note that
-set_value is around 100 times slower when setting non-XML-time strings.
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::token
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::unsignedByte
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::unsignedInt
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::unsignedLong
-
-=head2 SOAP::WSDL::XSD::Typelib::Builtin::unsignedShort
-
-=head1 CAVEATS
-
-=over
-
-=item * set_value
-
-In contrast to Class::Std-generated mutators (setters), set_value does
-not return the last value.
-
-This is for speed reasons: SOAP::WSDL never needs to know the last value
-when calling set_calue, but calls it over and over again...
-
-=back
-
-=head1 BUGS AND LIMITATIONS
-
-=over
-
-=item * Thread safety
-
-SOAP::WSDL::XSD::Typelib::Builtin uses Class::Std::Fast::Storable which uses
-Class::Std. Class::Std is not thread safe, so
-SOAP::WSDL::XSD::Typelib::Builtin is neither.
-
-=item * XML Schema facets
-
-No facets are implemented yet.
-
-=back
-
-=head1 AUTHOR
-
-Replace whitespace by @ in e-mail address.
-
- Martin Kutter E<gt>martin.kutter fen-net.deE<lt>
-
-=head1 LICENSE AND COPYRIGHT
-
-Copyright 2004-2007 Martin Kutter.
-
-This file is part of SOAP-WSDL. You may distribute/modify it under the
-same terms as perl itself
-
-=cut

lib/SOAP/WSDL/XSD/Typelib/Builtin/ENTITY.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::ENTITY;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::NCName);
-Class::Std::initialize();
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/ID.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::ID;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::NCName);
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/IDREF.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::IDREF;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::ID);
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/IDREFS.pm

@@ -1,9 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::IDREFS;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable;
-use base qw(
-    SOAP::WSDL::XSD::Typelib::Builtin::list
-    SOAP::WSDL::XSD::Typelib::Builtin::IDREF);
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/NCName.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::NCName;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::Name);
-Class::Std::initialize();
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/NMTOKEN.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::NMTOKEN;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::token);
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/NMTOKENS.pm

@@ -1,8 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::NMTOKENS;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::list
-      SOAP::WSDL::XSD::Typelib::Builtin::NMTOKEN);
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/NOTATION.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::NOTATION;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/Name.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::Name;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::token);
-Class::Std::initialize();
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/QName.pm

@@ -1,8 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::QName;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-1;
-

lib/SOAP/WSDL/XSD/Typelib/Builtin/anySimpleType.pm

@@ -1,56 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anyType);
-
-my %value_of :ATTR(:get<value> :init_arg<value> :default<()>);
-
-# don't you never dare to play with this !
-our $___value = \%value_of;
-
-## use $_[n] for speed - we get called zillions of times...
-# and we don't need to return the last value...
-sub set_value { $value_of{ ${ $_[0] } } = $_[1] }
-
-# use $_[n] for speed.
-# This is less readable, but notably faster.
-#
-# use postfix-if for speed. This is slightly faster, as it saves
-# perl from creating a pad (variable context).
-#
-# The methods below may get called zillions of times, so
-# every little statement matters...
-
-sub serialize {
-    no warnings qw(uninitialized);
-    $_[1]->{ nil } = 1 if not defined $value_of{ ${$_[0]} };
-    return join q{}
-        , $_[0]->start_tag($_[1], $value_of{ ${$_[0]} })
-        , $value_of{ ${$_[0]} }
-        , $_[0]->end_tag($_[1]);
-}
-
-sub as_string :STRINGIFY {
-    return $value_of { ${ $_[0] } };
-}
-
-sub as_bool :BOOLIFY {
-    return $value_of { ${ $_[0] } };
-}
-
-my $ID_GENERATOR_REF = Class::Std::Fast::ID_GENERATOR_REF();
-my $OBJECT_CACHE_REF = Class::Std::Fast::OBJECT_CACHE_REF();
-
-sub new {
-    my $self = pop @{ $OBJECT_CACHE_REF->{ $_[0] } };
-    $self = bless \(my $o = Class::Std::Fast::ID()), $_[0]
-        if not defined $self;
-    $value_of{ $$self } = $_[1]->{ value }
-        if (($#_) && exists $_[1]->{ value });
-    return $self;
-}
-
-Class::Std::Fast::initialize();   # make :BOOLIFY overloading serializable
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/anyType.pm

@@ -1,38 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::anyType;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none';
-
-sub get_xmlns { 'http://www.w3.org/2001/XMLSchema' };
-
-# use $_[1] for performance
-sub start_tag {
-    return q{} if not $#_;          # return if no second argument ($opt)
-    if ($_[1]->{ name }) {
-        return "<$_[1]->{name} />" if $_[1]->{ empty };
-        return "<$_[1]->{name} >";
-    }
-    return q{};
-}
-
-# use $_[1] for performance
-sub end_tag {
-    return $_[1] && defined $_[1]->{ name }
-        ? "</$_[1]->{name} >"
-        : q{};
-};
-
-sub serialize { q{} };
-
-sub serialize_qualified :STRINGIFY {
-    return $_[0]->serialize( { qualified => 1 } );
-}
-
-sub as_list :ARRAYIFY {
-    return [ $_[0] ];
-}
-
-Class::Std::initialize();           # make :STRINGIFY overloading serializable
-
-1;
-

lib/SOAP/WSDL/XSD/Typelib/Builtin/anyURI.pm

@@ -1,8 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::anyURI;
-use strict;
-use warnings;
-
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/base64Binary.pm

@@ -1,9 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::base64Binary;
-use strict;
-use warnings;
-
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-1;
-

lib/SOAP/WSDL/XSD/Typelib/Builtin/boolean.pm

@@ -1,43 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::boolean;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-
-our $VERSION='2.00_23';
-
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-sub serialize {
-    $_[1] ||= {};
-    my $value =$_[0]->get_value();
-    return $_[0]->start_tag({ %{$_[1]}, nil => 1})
-            if not defined $value;
-    return join q{}
-        , $_[0]->start_tag($_[1])
-        , $value && $value ne 'false' ? 'true' : 'false'
-        , $_[0]->end_tag($_[1]);
-}
-
-sub as_string :STRINGIFY {
-    my $value = $_[0]->get_value();
-    return q{} if not defined $value;
-    return ($value && $value ne 'false') ? 1 : 0;
-}
-
-sub as_num :NUMERIFY :BOOLIFY {
-    my $value = $_[0]->get_value();
-    return ($value && $value ne 'false') ? 1 : 0;
-}
-
-sub set_value {
-    $_[0]->SUPER::set_value( defined $_[1]
-        ? ($_[1] ne 'false' && ($_[1]) )
-            ? 1 : 0
-        : 0);
-}
-
-sub delete_value { $_[0]->SUPER::set_value(undef) }
-
-Class::Std::Fast::initialize();   # make :BOOLIFY overloading serializable
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/byte.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::byte;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::short);
-Class::Std::initialize();
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/date.pm

@@ -1,52 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::date;
-use strict;
-use warnings;
-use Date::Parse;
-use Date::Format;
-
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-sub set_value {
-    # use set_value from base class if we have a XML-DateTime format
-    #2037-12-31+01:00
-    if (
-        $_[1] =~ m{ ^\d{4} \- \d{2} \- \d{2}
-            (:? [\+\-] \d{2} \: \d{2} )$
-        }xms
-    ) {
-        $_[0]->SUPER::set_value($_[1])
-    }
-    # converting a date is hard work: It needs a timezone, because
-    # 2007-12-30+12:00 and 2007-12-31-12:00 mean the same day - just in
-    # different locations.
-    # strftime actually prints out the correct date, but always prints the
-    # local timezone with %z.
-    # So, if our timezone is not 0, we strftime it without timezone and
-    # append it by hand by the following formula:
-    # The timezone hours are the int (timesone seconds / 3600)
-    # The timezone minutes (if someone ever specifies something like that)
-    # are int( (seconds % 3600) / 60 )
-    # say, int( (seconds modulo 3600) / 60 )
-    #
-    # If we have no timezone (meaning the timezone is
-    else {
-        # strptime sets empty values to undef - and strftime doesn't like that...
-        my @time_from =  strptime($_[1]);
-        my $time_zone_seconds = $time_from[6];
-        @time_from = map { (! defined $_) ? 0 : $_ } @time_from;
-#        use Data::Dumper;
-#        warn Dumper \@time_from, sprintf('%+03d%02d', $time_from[6] / 3600, $time_from[6] % 60 );
-        my $time_str = defined $time_zone_seconds
-          ? strftime( '%Y-%m-%d', @time_from )
-            . sprintf('%+03d%02d', int($time_from[6] / 3600), int ( ($time_from[6] % 3600) / 60 ) )
-          : do {
-              strftime( '%Y-%m-%d%z', @time_from );
-          };
-        substr $time_str, -2, 0, ':';
-        $_[0]->SUPER::set_value($time_str);
-    }
-}
-
-1;
-

lib/SOAP/WSDL/XSD/Typelib/Builtin/dateTime.pm

@@ -1,35 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::dateTime;
-use strict;
-use warnings;
-use Date::Parse;
-use Date::Format;
-use Time::Zone;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-sub set_value {
-    # use set_value from base class if we have a XML-DateTime format
-    #2037-12-31T00:00:00.0000000+01:00
-    return $_[0]->SUPER::set_value($_[1]) if not $_[1];
-    return $_[0]->SUPER::set_value($_[1]) if (
-        $_[1] =~ m{ ^\d{4} \- \d{2} \- \d{2}
-            T \d{2} \: \d{2} \: \d{2} (:? \. \d{1,7} )?
-            [\+\-] \d{2} \: \d{2} $
-        }xms
-    );
-    no warnings qw(uninitialized);
-    # strptime sets empty values to undef - and strftime doesn't like that...
-    my @time_from = map { ! defined $_ ? 0 : $_ } strptime($_[1]);
-
-    undef $time_from[$#time_from];
-
-    my $time_str = do { # no warnings;
-        strftime( '%Y-%m-%dT%H:%M:%S%z', @time_from );
-    };
-
-    # insert : in timezone info
-    substr $time_str, -2, 0, ':';
-    $_[0]->SUPER::set_value($time_str);
-}
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/decimal.pm

@@ -1,13 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::decimal;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-sub as_num :NUMERIFY :BOOLIFY {
-    return $_[0]->get_value();
-}
-
-Class::Std::Fast::initialize();   # make :NUMERIFY :BOOLIFY overloading serializable
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/double.pm

@@ -1,13 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::double;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-sub as_num :NUMERIFY {
-    return $_[0]->get_value();
-}
-
-Class::Std::initialize();   # make :NUMERIFY overloading serializable
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/duration.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::duration;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/float.pm

@@ -1,14 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::float;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-sub as_num :NUMERIFY {
-    return $_[0]->get_value();
-}
-
-Class::Std::initialize();   # make :NUMERIFY overloading serializable
-
-1;
-

lib/SOAP/WSDL/XSD/Typelib/Builtin/gDay.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::gDay;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/gMonth.pm

@@ -1,9 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::gMonth;
-use strict;
-use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/gMonthDay.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::gMonthDay;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/gYear.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::gYear;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/gYearMonth.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::gYearMonth;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/hexBinary.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::hexBinary;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/int.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::int;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::long);
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/integer.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::integer;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::decimal);
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/language.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::language;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::token);
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/list.pm

@@ -1,43 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::list;
-use strict;
-use warnings;
-
-sub serialize {
-    my ($self, $opt) = @_;
-    $opt = {} if not $opt;
-    my $value = $self->get_value();
-    return $self->start_tag({ %$opt, nil => 1 }) if not defined $value;
-    $value = [ $value ] if not ref $value;
-    return join q{}, $self->start_tag($opt, $value)
-        , join( q{ }, @{ $value } )
-        , $self->end_tag($opt, $value);
-}
-1;
-
-__END__
-
-=pod
-
-=head1 NAME
-
-SOAP::WSDL::XSD::Typelib::Builtin::list - list derivation base class
-
-=head1 DESCRIPTION
-
-To derive from some class by list, just inherit from list.
-
-Make sure SOAP::WSDL::XSD::Typelib::Builtin::list is before the type
-to derive from in the @ISA list.
-
-=head1 LICENSE AND COPYRIGHT
-
-Copyright (c) 2007 Martin Kutter. All rights reserved.
-
-This file is part of SOAP-WSDL. You may distribute/modify it under
-the same terms as perl itself
-
-=head1 AUTHOR
-
-Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
-
-=cut

lib/SOAP/WSDL/XSD/Typelib/Builtin/long.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::long;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::integer);
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/negativeInteger.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::negativeInteger;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::nonPositiveInteger);
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/nonNegativeInteger.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::nonNegativeInteger;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::integer);
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/nonPositiveInteger.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::nonPositiveInteger;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::integer);
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/normalizedString.pm

@@ -1,14 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::normalizedString;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::string);
-
-# replace all \t, \r, \n by \s
-sub set_value {
-    my $value = $_[1];
-    $value =~ s{ [\r\n\t]+ }{ }xmsg if defined($value);
-    $_[0]->SUPER::set_value($value);
-}
-Class::Std::initialize();
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/positiveInteger.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::positiveInteger;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::nonNegativeInteger);
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/short.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::short;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::int);
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/string.pm

@@ -1,37 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::string;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-my %char2entity = (
-    q{&} => q{&},
-    q{<} => q{&lt;},
-    q{>} => q{&gt;},
-    q{"} => q{&quot;},
-    q{'} => q{&apos;},
-);
-
-sub serialize {
-    $_[1] ||= {};
-
-    my $value = $_[0]->get_value();
-
-    return $_[0]->start_tag({ %{ $_[1] }, nil => 1})
-        if not defined $value;
-
-    # HTML::Entities does the same - and more, thus it's around 1/3 slower...
-    $value =~ s{([&<>"'])}{$char2entity{$1}}xgmso;
-
-    return join q{}, $_[0]->start_tag($_[1], $value)
-        #, encode_entities( $value, q{&<>"'} )
-        , $value
-        , $_[0]->end_tag($_[1]);
-}
-
-sub as_bool :BOOLIFY {
-    return $_[0]->get_value();
-}
-
-Class::Std::initialize;
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/time.pm

@@ -1,44 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::time;
-use strict;
-use warnings;
-use Date::Parse;
-use Date::Format;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-our $VERSION='2.00_25';
-
-sub set_value {
-    # use set_value from base class if we have a XML-Time format
-    # 00:00:00.0000000+01:00
-    if (
-        $_[1] =~ m{ ^ \d{2} \: \d{2} \: \d{2} (:? \. \d{1,7} )?
-            [\+\-] \d{2} \: \d{2} $
-        }xms
-    ) {
-        $_[0]->SUPER::set_value($_[1])
-    }
-    # use a combination of strptime and strftime for converting the date
-    # Unfortunately, strftime outputs the time zone as [+-]0000, whereas XML
-    # whants it as [+-]00:00
-    # We leave out the optional nanoseconds part, as it would always be empty.
-    else {
-        # strptime sets empty values to undef - and strftime doesn't like that...
-        # we even need to set it to 1 to prevent a "Day '0' out of range 1..31" warning..
-
-        # we need to set the current date for correct TZ conversion -
-        # could be daylight savings time
-        my @now = localtime;
-        my @time_from = map { my $alternative = shift @now;
-            ! defined $_
-                ? $alternative
-                : $_ } strptime($_[1]);
-        undef $time_from[-1];
-        my $time_str = strftime( '%H:%M:%S%z', @time_from );
-        substr $time_str, -2, 0, ':';
-        $_[0]->SUPER::set_value($time_str);
-
-    }
-}
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/token.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::token;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::normalizedString);
-Class::Std::initialize();
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/unsignedByte.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::unsignedByte;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::unsignedShort);
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/unsignedInt.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::unsignedInt;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::unsignedLong);
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/unsignedLong.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::unsignedLong;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::nonNegativeInteger);
-
-1;

lib/SOAP/WSDL/XSD/Typelib/Builtin/unsignedShort.pm

@@ -1,7 +0,0 @@
-package SOAP::WSDL::XSD::Typelib::Builtin::unsignedShort;
-use strict;
-use warnings;
-use Class::Std::Fast::Storable constructor => 'none', cache => 1;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::unsignedInt);
-
-1;

lib/SOAP/WSDL/XSD/Typelib/ComplexType.pm

@@ -1,432 +0,0 @@
-#!/usr/bin/perl
-package SOAP::WSDL::XSD::Typelib::ComplexType;
-use strict;
-use warnings;
-use Carp;
-use SOAP::WSDL::XSD::Typelib::Builtin;
-use Scalar::Util qw(blessed refaddr);
-require Class::Std::Fast::Storable;
-
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anyType);
-
-our $VERSION = '2.00_27';
-
-my %ELEMENTS_FROM;
-my %ATTRIBUTES_OF;
-my %CLASSES_OF;
-
-# don't you ever dare to use this !
-our $___attributes_of_ref = \%ATTRIBUTES_OF;
-
-# STORABLE_ methods for supporting Class::Std::Fast::Storable.
-# We could also handle them via AUTOMETHOD,
-# but AUTOMETHOD should always croak...
-# Do we really need this ?
-# ... looks like we do...
-sub STORABLE_freeze_pre {}
-sub STORABLE_freeze_post {}
-sub STORABLE_thaw_pre {}
-sub STORABLE_thaw_post {}
-
-# for error reporting. Eases working with data objects...
-sub AUTOMETHOD {
-    my ($self, $ident, @args_from) = @_;
-
-    my $class = ref $self || $self or die "Cannot call AUTOMETHOD as function";
-    confess "Can't locate object method \"$_\" via package \"$class\". \n"
-        . "Valid methods are: "
-        . join(', ', map { ("get_$_" , "set_$_") } keys %{ $ATTRIBUTES_OF{ $class } })
-        . "\n"
-}
-
-sub as_hash_ref {
-    my $self = shift;
-    my $attributes_ref = $ATTRIBUTES_OF{ ref $self };
-    my $ident = ident $self;
-
-    my $hash_of_ref = {};
-    foreach my $attribute (keys %{ $attributes_ref }) {
-        next if not defined $attributes_ref->{ $attribute }->{ $ident };
-        my $value = $attributes_ref->{ $attribute }->{ $ident };
-
-        $hash_of_ref->{ $attribute } = blessed $value
-            ? $value->isa('SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType')
-                ? $value
-                : $value->as_hash_ref()
-            : ref $value eq 'ARRAY'
-                ? [
-                    map {
-                        $_->isa('SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType')
-                            ? $_
-                            : $_->as_hash_ref()
-                    } @{ $value }
-                ]
-                : die "Neither blessed obj nor list ref";
-    };
-
-    return $hash_of_ref;
-}
-
-# we store per-class elements.
-# call as __PACKAGE__->_factory
-sub _factory {
-    my $class = shift;
-    $ELEMENTS_FROM{ $class } = shift;
-    $ATTRIBUTES_OF{ $class } = shift;
-    $CLASSES_OF{ $class } = shift;
-
-    no strict qw(refs);
-    no warnings qw(redefine);
-
-    while (my ($name, $attribute_ref) = each %{ $ATTRIBUTES_OF{ $class } } ) {
-        my $type = $CLASSES_OF{ $class }->{ $name }
-            or croak "No class given for $name";
-
-        # require all types here
-        $type->isa('UNIVERSAL')
-            or eval "require $type"
-                or croak $@;
-
-        # check now, so we don't need to do it later.
-        # $is_list is used in the methods created. Filling it now means
-        # we don't have to check it every time the method is called, but
-        # can just use $is_list, which will hold the value assigned to
-        # it when the method was created.
-        my $is_list = $type->isa('SOAP::WSDL::XSD::Typelib::Builtin::list');
-
-        #  The set_$name method below looks rather weird,
-        # but is optimized for performance.
-        #
-        #  We could use sub calls for sure, but these are much slower. And
-        # the logic is not that easy:
-        #
-        #  we accept:
-        #  a) objects
-        #  b) scalars
-        #  c) list refs
-        #  d) hash refs
-        #  e) mixed stuff of all of the above, so we have to set our child to
-        #    a) value if it's an object
-        #    b) New object of expected class with value for simple values
-        #    c 1) New object with value for list values and list type
-        #    c 2) List ref of new objects with value for list values and
-        #         non-list type
-        #    c + e 1) List ref of objects for list values (list of objects)
-        #             and non-list type
-        #    c + e 2) List ref of new objects for list values (list of hashes)
-        #             and non-list type where the hash ref is passed to new as
-        #             argument
-        #    d) New object with values passed to new for HASH references
-        #
-        #  We throw an error on
-        #  a) list refs of list refs - don't know what to do with this (maybe
-        #     use for lists of list types ?)
-        #  b) wrong object types
-        #  c) non-blessed non-ARRAY/HASH references - if you can define semantics
-        #     for GLOB or SCALAR references, feel free to add them.
-        #  d) we should also die for non-blessed non-ARRAY/HASH references in
-        #     lists but don't do yet - oh my !
-
-        *{ "$class\::set_$name" } = sub {
-            my $is_ref = ref $_[1];
-            $attribute_ref->{ ${ $_[0] } } = ($is_ref)
-                ? ($is_ref eq 'ARRAY')
-                    ? $is_list                             # remembered from outside closure
-                        ? $type->new({ value => $_[1] })   # it's a list element - can take list ref as value
-                        : [ map {                          # it's not a list element - set value to list of objects
-                            ref $_
-                              ? ref $_ eq 'HASH'
-                                  ? $type->new($_)
-                                  : ref $_ eq $type
-                                      ? $_
-                                      : croak "cannot use " . ref($_) . " reference as value for $name - $type required"
-                              : $type->new({ value => $_ })
-                            } @{ $_[1] }
-                         ]
-                    : $is_ref eq 'HASH'
-                        ?  $type->new( $_[1] )
-
-                        # neither ARRAY nor HASH - probably an object...
-                        :  ($is_ref eq $type)               # of required type ? ->isa would be a better test...
-                            ? $_[1]                         # use it
-                            : die croak "cannot use $is_ref reference as value for $name - $type required"
-
-                # not $is_ref
-                : $type->new({ value => $_[1] });
-            return;
-        };
-
-        *{ "$class\::add_$name" } = sub {
-            warn "attempting to add empty value to " . ref $_[0]
-                if not defined $_[1];
-
-            # first call
-            # test for existance, not for definedness
-            if (not exists $attribute_ref->{ ${ $_[0]} }) {
-                $attribute_ref->{ ${ $_[0]} } = $_[1];
-                return;
-            }
-
-            if (not ref $attribute_ref->{ ${ $_[0]} } eq 'ARRAY') {
-                # second call: listify previous value if it's no list and add current
-                $attribute_ref->{ ${ $_[0]} } = [  $attribute_ref->{ ${ $_[0]} }, $_[1] ];
-                return;
-            }
-
-            # second and following: add to list
-            push @{ $attribute_ref->{ ${ $_[0]} } }, $_[1];
-            return;
-        };
-
-        # TODO: remove this alias - we don't use it, and it's pretty much
-        # misleading...
-        *{ "$class\::$name" } = *{ "$class\::add_$name" };
-    }
-
-    # TODO Could be moved as normal method into base class, e.g. here.
-    # Hmm. let's see...
-    *{ "$class\::new" } = sub {
-        my $self = bless \(my $o = Class::Std::Fast::ID()), $_[0];
-        # We're working on @_ for speed.
-        # Normally, the first line would look like this:
-        # my ($self, $ident, $args_of) = @_;
-        #
-        # The hanging side comment show you what would be there, then.
-
-        # iterate over keys of arguments
-        # and call set appropriate field in clase
-        map { ($ATTRIBUTES_OF{ $class }->{ $_ })
-            ? do {
-                 my $method = "set_$_";
-                 $self->$method( $_[1]->{ $_ } );               # ( $args_of->{ $_ } );
-           }
-           : $_ =~ m{ \A              # beginning of string
-                      xmlns           # xmlns
-                }xms
-                ? do {}
-                : do { use Data::Dumper;
-                     croak "unknown field $_ in $class. Valid fields are:\n"
-                     . join(', ', @{ $ELEMENTS_FROM{ $class } }) . "\n"
-                     . "Structure given:\n" . Dumper @_ };
-        } keys %{ $_[1] };                                      # %$args_of;
-        return $self;
-    };
-
-
-    # this serialize method works fine for <all> and <sequence>
-    # complextypes, as well as for <restriction><all> or
-    # <restriction><sequence>.
-    # But what about choice, extension ?
-    *{ "$class\::_serialize" } = sub {
-        my $ident = ${ $_[0]};
-        # return concatenated return value of serialize call of all
-        # elements retrieved from get_elements expanding list refs.
-        # get_elements is inlined for performance.
-        return join q{} , map {
-            my $element = $ATTRIBUTES_OF{ $class }->{ $_ }->{ $ident };
-
-            # do we have some content
-            if (defined $element) {
-                $element = [ $element ]
-                    if not ref $element eq 'ARRAY';
-                my $name = $_;
-
-                map {
-                    # serialize element elements with their own serializer
-                    # but name them like they're named here.
-                    if ( $_->isa( 'SOAP::WSDL::XSD::Typelib::Element' ) ) {
-                            $_->serialize( { name => $name } );
-                    }
-                    # serialize complextype elments (of other types) with their
-                    # serializer, but add element tags around.
-                    else {
-                        join q{}, $_->start_tag({ name => $name })
-                            , $_->serialize()
-                            , $_->end_tag({ name => $name });
-                    }
-                } @{ $element }
-            }
-            else {
-                 q{};
-            }
-        } (@{ $ELEMENTS_FROM{ $class } });
-    };
-
-    *{ "$class\::serialize" } = sub {
-            $_[1] ||= {};   # maybe even replace by assigning a constant var
-
-            # do we have a empty element ?
-            return $_[0]->start_tag({ %{ $_[1] }, empty => 1 })
-                if not defined $ELEMENTS_FROM{ $class } or not @{ $ELEMENTS_FROM{ $class } };
-            return join q{}, $_[0]->start_tag($_[1]),
-                    $_[0]->_serialize(), $_[0]->end_tag();
-    }
-
-}
-
-1;
-
-__END__
-
-=pod
-
-=head1 NAME
-
-SOAP::WSDL::XSD::Typelib::ComplexType - Base class for complexType node classes
-
-=head1 Subclassing
-
-To subclass, write a package like this:
-
- package MyComplexType;
- use Class::Std::Fast::Storable constructor => 'none';
- use base qw(SOAP::WSDL::XSD::Typelib::ComplexType);
- 
- # we only need the :get attribute qualifier.
- # set and init_arg are automatically created by
- # SOAP::WSDL::XSD::Typelib::ComplexType
- my %first_attr_of   :ATTR(:get<first_attr>  :default<()>);
- my %second_attr_of  :ATTR(:get<second_attr> :default<()>);
- my %third_attr_of   :ATTR(:get<third_attr>  :default<()>);
- 
- # the order of elements in a complexType
- my @elements_from = qw(first_attr second_attr third_attr);
- 
- # references to the private hashes
- my %attribute_of = (
-    first_attr  => \%first_attr_of,
-    second_attr => \%second_attr_of,
-    third_attr  => \%third_attr_of,
- );
- 
- # classes_of: Classes the child elements should be of
- my %classes_of = (
-    first_attr  => 'My::FirstElement',
-    second_attr => 'My::SecondElement',
-    third_attr  => 'My::ThirdElement',
- );
-
- # call _factory
- __PACKAGE__->_factory(
-    \@elements_from,
-    \%attributes_of,
-    \%classes_of,
- );
-
- 1;
-
-When subclassing, the following methods are created in the subclass:
-
-=head2 new
-
-Constructor. For your convenience, new will accept data for the object's
-properties in the following forms:
-
- hash refs
- 1) of scalars
- 2) of list refs
- 3) of hash refs
- 4) of objects
- 5) mixed stuff of all of the above
-
-new() will set the data via the set_FOO methods to the object's element
-properties.
-
-Data passed to new must comply to the object's structure or new() will
-complain. Objects passed must be of the expected type, or new() will
-complain, too.
-
-Examples:
-
- my $obj = MyClass->new({ MyName => $value });
- 
- my $obj = MyClass->new({
-     MyName => {
-         DeepName => $value,
-     },
-     MySecondName => $value,
- });
- 
- my $obj = MyClass->new({
-     MyName => [
-        { DeepName => $value },
-        { DeepName => $other_value },
-     ],
-     MySecondName => $object,
-     MyThirdName => [ $object1, $object2 ],
- });
-
-The new() method from Class::Std will be overridden, so you should not rely
-on it's behaviour.
-
-Your START and BUILD methods are called, but the class' inheritance tree is
-not traversed.
-
-=head2 set_FOO
-
-A mutator method for every element property.
-
-For your convenience, the set_FOO methods will accept all kind of data you
-can think of (and all combinations of them) as input - with the exception
-of GLOBS and filehandles.
-
-This means you may set element properties by passing
-
- a) objects
- b) scalars
- c) list refs
- d) hash refs
- e) mixed stuff of all of the above
-
-Examples are similar to the examples provided for new() above.
-
-=head2 as_hash_ref
-
-Returns a hash ref representation of the complexType object
-
-=head1 Bugs and limitations
-
-=over
-
-=item * Incomplete API
-
-Not all variants of XML Schema ComplexType definitions are supported yet.
-
-Variants known to work are:
-
- sequence
- all
- complexContent containing sequence/all definitions
-
-=item * Thread safety
-
-SOAP::WSDL::XSD::Typelib::Builtin::ComplexType uses Class::Std::Fast::Storable which uses
-Class::Std. Class::Std is not thread safe, so
-SOAP::WSDL::XSD::Typelib::Builtin::ComplexType is neither.
-
-=item * XML Schema facets
-
-No facets are implemented yet.
-
-=back
-
-=head1 LICENSE AND COPYRIGHT
-
-Copyright 2007 Martin Kutter.
-
-This file is part of SOAP-WSDL. You may distribute/modify it under the same
-terms as perl itself
-
-=head1 AUTHOR
-
-Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
-
-=head1 REPOSITORY INFORMATION
-
- $Rev: 477 $
- $LastChangedBy: kutterma $
- $Id: ComplexType.pm 477 2007-12-24 10:23:52Z kutterma $
- $HeadURL: http://soap-wsdl.svn.sourceforge.net/svnroot/soap-wsdl/SOAP-WSDL/trunk/lib/SOAP/WSDL/XSD/Typelib/ComplexType.pm $
-
-=cut
-

lib/SOAP/WSDL/XSD/Typelib/Element.pm

@@ -1,182 +0,0 @@
-#!/usr/bin/perl
-package SOAP::WSDL::XSD::Typelib::Element;
-use strict;
-
-our $VERSION=q{2.00_27};
-
-my %NAME;
-my %NILLABLE;
-my %REF;
-my %MIN_OCCURS;
-my %MAX_OCCURS;
-
-# TODO replace by generated methods?
-#
-# Class data - remember, we're the base class for a class factory or for
-# generated code...
-# use BLOCK: for scoping
-BLOCK: {
-    my %method_lookup = (
-        _name => \%NAME,
-        _nillable => \%NILLABLE,
-        _ref => \%REF,
-        _minOccurs => \%MIN_OCCURS,
-        _maxOccurs => \%MAX_OCCURS,
-    );
-
-    no strict qw(refs);
-    while (my ($name, $value) = each %method_lookup ) {
-        *{ "__set$name" } = sub {
-            my $class = ref $_[0] || $_[0] or die "Cannot call __set$name without parameter";
-            $value->{ $class } = $_[1];
-        };
-        *{ "__get$name" } = sub {
-            my $class = ref $_[0] || $_[0] or die "Cannot call __get$name as function";
-            return $value->{ $class };
-        };
-    }
-};
-
-# use $_[0] and $_[1] for speed.
-
-sub start_tag {
-    # my ($self, $opt, $value) = @_;
-    my $ending = ($_[1]->{ empty }) ? '/>' : '>';
-    my @attr_from = ();
-
-    if ($_[1]->{ nil }) {
-        return q{} if not $NILLABLE{ ref $_[0] };
-        push @attr_from, 'xsi:nil="true"';
-        $ending = '/>';
-    }
-    if ($_[1]->{qualified}) {
-        push @attr_from, 'xmlns="' . $_[0]->get_xmlns . '"';
-    }
-
-    # do we need to check for name ? Element ref="" should have it's own
-    # start_tag. If we don't need to check, we can speed things up
-    return join q{ }, "<$_[1]->{ name }" , @attr_from , $ending if $_[1]->{ name };
-    return join q{ }, "<$NAME{ ref $_[0]}" , @attr_from , $ending;
-}
-
-# use $_[0] and $_[1] for speed.
-#
-# read it as:
-#
-# my ($self, $opt)  = @_;
-# my $class = ref $self;
-# return "</$opt->{name}>" if $opt->{name};
-# return "</"$NAME{$class}>";
-#
-# do we need to check for name ? Element ref="" should have it's own
-# end_tag. If we don't need to check, we can speed things up by defining
-# end tag with () prototype - perl will inline it for us if we do...
-sub end_tag {
-    return "</$_[1]->{name}>" if $_[1]->{name};
-    return "</$NAME{ ref $_[0] }>";
-}
-
-1;
-
-=pod
-
-=head1 NAME
-
-SOAP::WSDL::XSD::Typelib::Element - element base clase
-
-=head1 SYNOPSIS
-
-This example creates a class for this XML schema definition:
-
- <element name="MyElement" type="xsd:string" nillable="1"
-   minOccurs="1" maxOccurs="1"/>
-
- package MyElement;
- use strict;
- use Class::Std::Fast::Storable constructor => 'none';
- use base (
-    'SOAP::WSDL::XSD::Typelib::Element',
-    'SOAP::WSDL::XSD::Typelib::Builtin::string',
- );
-
- __PACKAGE__->__set_name('MyElementName');
- __PACKAGE__->__set_nillable(1);
- __PACKAGE__->__set_minOccurs(1);
- __PACKAGE__->__set_maxOccurs(1);
- __PACKAGE__->__set_ref(0);
-
-Now we create this XML schema definition type class:
-
- <element name="MyElement2" ref="tns:MyElement"/>
- 
- package MyElement2;
- use strict;
- use Class::Std::Fast::Storable constructor => 'none';
- use base (
-    'SOAP::WSDL::XSD::Typelib::Element',
-    'MyElement'
- );
-
- __PACKAGE__->__set_name('MyElementName');
- __PACKAGE__->__set_nillable(0);
- __PACKAGE__->__set_ref(1);
-
-=head1 NOTES
-
-=over
-
-=item * type="Foo"
-
-Implemented via inheritance.
-
-=item * ref="Foo"
-
-Implemented via inheritance, too. Calling
-
-__PACKAGE__->__set_ref(1) is highly encouraged, though it has no
-effect yet - it will probably be needed for serialization to XML
-Schema definitions some day.
-
-=back
-
-=head1 BUGS AND LIMITATIONS
-
-=over
-
-=item * minOccurs maxOccurs not implemented
-
-These attributes are not yet supported, though they may be set as class
-properties via __PACKAGE__->__set_FOO methods.
-
-=item * 'http://www.w3.org/2001/XMLSchema-instance prefix is hardcoded
-
-The prefix for 'http://www.w3.org/2001/XMLSchema-instance (used as namespace
-for the {http://www.w3.org/2001/XMLSchema-instance}nil="true" attribute
-is hardcoded as 'xsi'.
-
-You should definitly provide your XML envelope generator with the same prefix
-namespace combination (Default for SOAP::WSDL::Envelope).
-
-=back
-
-=head1 LICENSE AND COPYRIGHT
-
-Copyright 2004-2007 Martin Kutter.
-
-This file is part of SOAP-WSDL. You may distribute/modify it under the same
-terms as perl itself
-
-=head1 AUTHOR
-
-Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
-
-=head1 REPOSITORY INFORMATION
-
- $Rev: 477 $
- $LastChangedBy: kutterma $
- $Id: Element.pm 477 2007-12-24 10:23:52Z kutterma $
- $HeadURL: http://soap-wsdl.svn.sourceforge.net/svnroot/soap-wsdl/SOAP-WSDL/trunk/lib/SOAP/WSDL/XSD/Typelib/Element.pm $
-
-=cut
-
-

lib/SOAP/WSDL/XSD/Typelib/SimpleType.pm

@@ -1,138 +0,0 @@
-#!/usr/bin/perl
-package SOAP::WSDL::XSD::Typelib::SimpleType;
-use strict;
-use SOAP::WSDL::XSD::Typelib::Builtin;
-
-package SOAP::WSDL::XSD::Typelib::SimpleType::restriction;
-use strict;
-use SOAP::WSDL::XSD::Typelib::Builtin;
-use base qw(SOAP::WSDL::XSD::Typelib::SimpleType);
-
-1;
-__END__
-
-=pod
-
-=head1 NAME
-
-SOAP::WSDL::XSD::Typelib::SimpleType - simpleType base class
-
-=head1 DESCRIPTION
-
-This module implements a base class for designing simple type classes
-modelling XML Schema simpleType definitions.
-
-=head1 SYNOPSIS
-
-    # example simpleType derived by restriction
-    # XSD would be:
-    # <simpleType name="MySimpleType">
-    #    <restriction base="xsd:string" />
-    # </simpleType>
-    package MySimpleType;
-    use Class::Std::Fast::Storable constructor => 'none';
-    # restriction base implemented via inheritance
-    use SOAP::WSDL::XSD::Typelib::Builtin;
-    use SOAP::WSDL::XSD::Typelib::SimpleType;
-    use base qw(
-        # derive by restriction
-        'SOAP::WSDL::XSD::Typelib::SimpleType::restriction',
-        # restriction base
-        'SOAP::WSDL::XSD::Typelib::Builtin::string'
-    );
-
-    # example simpleType derived by list.
-    # XSD would be:
-    # <simpleType name="MySimpleListType">
-    #    <list itemTipe="xsd:string" />
-    # </simpleType>
-    package MySimpleListType;
-    use Class::Std::Fast::Storable constructor => 'none';
-    # restriction base implemented via inheritance
-    use SOAP::WSDL::XSD::Typelib::Builtin;
-    use base ('SOAP::WSDL::XSD::Typelib::SimpleType',
-        'SOAP::WSDL::XSD::Typelib::Builtin::list',        # derive by list
-        'SOAP::WSDL::XSD::Typelib::Builtin::string'       # list itemType
-    );
-
-=head1 How to write your own simple type
-
-Writing a simple type class is easy - all you have to do is setting up the
-base classes correctly.
-
-The following rules apply:
-
-=over
-
-=item * simpleType derived via list
-
-simpleType classes derived via list must inherit from these classes in
-exactly this order:
-
- SOAP::WSDL::XSD::Typelib::SimpleType
- SOAP::WSDL::XSD::Typelib::Builtin::list         # derive by list
- The::List::ItemType::Class                      # list itemType
-
-The::List::ItemType::Class can either be a builtin class (see
-SOAP::WSDL::XSD::Builtin) or another simpleType class (any other class
-implementing the right methods is supported too, but not for the
-faint of heart).
-
-=item * simpleType derived via restriction
-
-simpleType classes derived via restriction must inherit from these classes in
-exactly this order:
-
- SOAP::WSDL::XSD::Typelib::SimpleType               # you may leave out this
- SOAP::WSDL::XSD::Typelib::SimpleType::restriction  # derive by retriction
- The::Restriction::Base::Class                      # resytriction base
-
-The::Restriction::Base::Class can either be a builtin class (see
-SOAP::WSDL::XSD::Builtin) or another simpleType class.
-
-The slight inconsistency between the these variants is caused by the
-restriction element, which has different meanings for simpleType and
-complexType definitions.
-
-=back
-
-=head1 BUGS AND LIMITATIONS
-
-=over
-
-=item * Thread safety
-
-SOAP::WSDL::XSD::Typelib::SimpleType uses Class::Std::Fast::Storable which uses
-Class::Std. Class::Std is not thread safe, so
-SOAP::WSDL::XSD::Typelib::SimpleType is neither.
-
-=item * union
-
-union simple types are not supported yet.
-
-=item * XML Schema facets
-
-No facets are implemented yet.
-
-=back
-
-=head1 LICENSE AND COPYRIGHT
-
-Copyright 2004-2007 Martin Kutter.
-
-This file is part of SOAP-WSDL. You may distribute/modify it under the same
-terms as perl itself
-
-=head1 AUTHOR
-
-Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
-
-=head1 REPOSITORY INFORMATION
-
- $Rev: 477 $
- $LastChangedBy: kutterma $
- $Id: SimpleType.pm 477 2007-12-24 10:23:52Z kutterma $
- $HeadURL: http://soap-wsdl.svn.sourceforge.net/svnroot/soap-wsdl/SOAP-WSDL/trunk/lib/SOAP/WSDL/XSD/Typelib/SimpleType.pm $
-
-=cut
-