import SOAP-WSDL 2.00_25 from CPAN

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

lib/SOAP/WSDL/XSD/Builtin.pm

@@ -1,7 +1,7 @@
 package SOAP::WSDL::XSD::Builtin;
 use strict;
 use warnings;
-use Class::Std::Storable;
+use Class::Std::Fast::Storable;
 use base qw(SOAP::WSDL::Base);
 
 sub serialize {
@@ -14,7 +14,8 @@ sub serialize {
     $xml .= '<' . join ' ', $name, @{ $opt->{ attributes } };
     if ( $opt->{ autotype }) {
         my $ns = $self->get_targetNamespace();
-        my $prefix = $opt->{ namespace }->{ $ns }
+        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() );

lib/SOAP/WSDL/XSD/ComplexType.pm

@@ -2,11 +2,11 @@ package SOAP::WSDL::XSD::ComplexType;
 use strict;
 use warnings;
 use Carp;
-use Class::Std::Storable;
+use Class::Std::Fast::Storable;
 use Scalar::Util qw(blessed);
 use base qw/SOAP::WSDL::Base/;
 
-our $VERSION='2.00_17';
+our $VERSION=q{2.00_25};
 
 my %annotation_of   :ATTR(:name<annotation> :default<()>);
 my %element_of      :ATTR(:name<element>    :default<()>);
@@ -78,7 +78,9 @@ sub serialize {
 
     if ( $opt->{ autotype }) {
       my $ns = $self->get_targetNamespace();
-      my $prefix = $opt->{ namespace }->{ $ns }
+      # 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() );

lib/SOAP/WSDL/XSD/Element.pm

@@ -1,10 +1,10 @@
 package SOAP::WSDL::XSD::Element;
 use strict;
 use warnings;
-use Class::Std::Storable;
+use Class::Std::Fast::Storable;
 use base qw(SOAP::WSDL::Base);
 
-our $VERSION='2.00_22';
+our $VERSION=q{2.00_25};
 
 my %annotation_of   :ATTR(:name<annotation> :default<()>);
 my %simpleType_of   :ATTR(:name<simpleType> :default<()>);
@@ -42,7 +42,7 @@ sub serialize {
     my ($self, $name, $value, $opt) = @_;
     my $type;
     my $typelib = $opt->{ typelib };
-    my %ns_map = reverse %{ $opt->{ namespace } };
+    my %ns_map = %{ $opt->{ namespace } };
     my $ident = ident $self;
 
     # abstract elements may only be serialized via ref - and then we have a

lib/SOAP/WSDL/XSD/Schema.pm

@@ -1,9 +1,11 @@
 package SOAP::WSDL::XSD::Schema;
 use strict;
 use warnings;
-use Class::Std::Storable;
+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<[]>);

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

@@ -1,7 +1,7 @@
 package SOAP::WSDL::XSD::Schema::Builtin;
 use strict;
 use warnings;
-use Class::Std::Storable;
+use Class::Std::Fast::Storable;
 use SOAP::WSDL::XSD::Schema;
 use SOAP::WSDL::XSD::Builtin;
 use base qw(SOAP::WSDL::XSD::Schema);
@@ -88,9 +88,9 @@ Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
 
 =head1 REPOSITORY INFORMATION
 
- $Rev: 391 $
+ $Rev: 412 $
  $LastChangedBy: kutterma $
- $Id: Builtin.pm 391 2007-11-17 21:56:13Z 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,10 +1,10 @@
 package SOAP::WSDL::XSD::SimpleType;
 use strict;
 use warnings;
-use Class::Std::Storable;
+use Class::Std::Fast::Storable;
 use base qw(SOAP::WSDL::Base);
 
-our $VERSION='2.00_17';
+our $VERSION=q{2.00_25};
 
 my %annotation_of   :ATTR(:name<annotation>     :default<()>);
 my %base_of         :ATTR(:name<base>           :default<()>);
@@ -84,8 +84,10 @@ sub _serialize_single {
     $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 = $opt->{ namespace }->{ $ns }
+        my $prefix = $prefix_of{ $ns }
            || die 'No prefix found for namespace '. $ns;
         $xml .= ' type="' . $prefix . ':' . $self->get_name() .'"';
     }

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

@@ -1,9 +1,9 @@
 package SOAP::WSDL::XSD::Typelib::Builtin;
 use strict;
 use warnings;
-use Class::Std::Storable;
+use Class::Std::Fast::Storable;
 
-our $VERSION="2.00_17";
+our $VERSION=q{2.00_25};
 
 use SOAP::WSDL::XSD::Typelib::Builtin::anyType;
 use SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType;
@@ -393,7 +393,7 @@ when calling set_calue, but calls it over and over again...
 
 =item * Thread safety
 
-SOAP::WSDL::XSD::Typelib::Builtin uses Class::Std::Storable which uses
+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.
 

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

@@ -1,25 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::ENTITY;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::NCName);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-};
-
+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 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::ID;
 use strict;
 use warnings;
-use Class::Std::Storable;
+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 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::IDREF;
 use strict;
 use warnings;
-use Class::Std::Storable;
+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,7 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::IDREFS;
 use strict;
 use warnings;
-use Class::Std::Storable;
+use Class::Std::Fast::Storable;
 use base qw(
     SOAP::WSDL::XSD::Typelib::Builtin::list
     SOAP::WSDL::XSD::Typelib::Builtin::IDREF);

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

@@ -1,25 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::NCName;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::Name);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-}
-
+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,26 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::NMTOKEN;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::token);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-}
+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,26 +1,8 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::NMTOKENS;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::list
+use Class::Std::Fast::Storable constructor => 'none', cache => 1;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::list
       SOAP::WSDL::XSD::Typelib::Builtin::NMTOKEN);
 
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-}
-
 1;

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

@@ -1,26 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::NOTATION;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-}
-
+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,25 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::Name;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::token);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-};
-
+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,27 +1,8 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::QName;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-
-}
+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,17 +1,17 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType;
 use strict;
 use warnings;
-
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anyType);
-}
+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{ ident $_[0] } = $_[1] }
+sub set_value { $value_of{ ${ $_[0] } } = $_[1] }
 
 # use $_[n] for speed.
 # This is less readable, but notably faster.
@@ -24,19 +24,33 @@ sub set_value { $value_of{ ident $_[0] } = $_[1] }
 
 sub serialize {
     no warnings qw(uninitialized);
-    my $ident = ident $_[0];
-    $_[1]->{ nil } = 1 if not defined $value_of{ $ident };
+    $_[1]->{ nil } = 1 if not defined $value_of{ ${$_[0]} };
     return join q{}
-        , $_[0]->start_tag($_[1], $value_of{ $ident })
-        , $value_of{ $ident }
+        , $_[0]->start_tag($_[1], $value_of{ ${$_[0]} })
+        , $value_of{ ${$_[0]} }
         , $_[0]->end_tag($_[1]);
 }
 
-sub as_bool :BOOLIFY {
-    return $value_of { ident $_[0] };
+sub as_string :STRINGIFY {
+    return $value_of { ${ $_[0] } };
 }
 
-Class::Std::initialize();   # make :BOOLIFY overloading serializable
+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,7 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::anyType;
 use strict;
 use warnings;
-use Class::Std::Storable;
+use Class::Std::Fast::Storable constructor => 'none';
 
 sub get_xmlns { 'http://www.w3.org/2001/XMLSchema' };
 

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

@@ -2,24 +2,7 @@ package SOAP::WSDL::XSD::Typelib::Builtin::anyURI;
 use strict;
 use warnings;
 
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-}
+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

@@ -2,36 +2,8 @@ package SOAP::WSDL::XSD::Typelib::Builtin::base64Binary;
 use strict;
 use warnings;
 
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-
-}
-
-# XML Schema facets. We don't know how to implement them yet, but they're
-# here, just in case you wanted to know.
-#my %length_of           :ATTR(:name<length> :default<()>);
-#my %minLength_of        :ATTR(:name<minLength> :default<()>);
-#my %maxLength_of        :ATTR(:name<maxLength> :default<()>);
-#my %pattern_of          :ATTR(:name<pattern> :default<()>);
-#my %enumeration_of      :ATTR(:name<enumeration> :default<()>);
-#my %whiteSpace_of       :ATTR(:name<whiteSpace> :default<()>);
+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,58 +1,43 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::boolean;
 use strict;
 use warnings;
-use Class::Std::Storable;
+use Class::Std::Fast::Storable constructor => 'none', cache => 1;
 
-our $VERSION='2.00_17';
+our $VERSION='2.00_23';
 
-my %value_of            :ATTR(:get<value> :init_attr<value> :default<()>);
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-#    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-}
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
 
 sub serialize {
-    my ($self, $opt) = @_;
-    my $ident = ident $self;
-    $opt ||= {};
-    return $self->start_tag({ %$opt, nil => 1})
-            if not defined $value_of{ $ident };
+    $_[1] ||= {};
+    my $value =$_[0]->get_value();
+    return $_[0]->start_tag({ %{$_[1]}, nil => 1})
+            if not defined $value;
     return join q{}
-        , $self->start_tag($opt)
-        , $value_of{ $ident } ? 'true' : 'false'
-        , $self->end_tag($opt);
+        , $_[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 {
-    return $_[0]->get_value();
+    my $value = $_[0]->get_value();
+    return ($value && $value ne 'false') ? 1 : 0;
 }
 
 sub set_value {
-    my ($self, $value) = @_;
-    $value_of{ ident $self } = defined $value
-        ? ($value ne 'false' && ($value) )
+    $_[0]->SUPER::set_value( defined $_[1]
+        ? ($_[1] ne 'false' && ($_[1]) )
             ? 1 : 0
-        : 0;
+        : 0);
 }
 
-sub delete_value { undef $value_of{ ident $_[0] }; return }
+sub delete_value { $_[0]->SUPER::set_value(undef) }
 
-Class::Std::initialize();   # make :BOOLIFY overloading serializable
+Class::Std::Fast::initialize();   # make :BOOLIFY overloading serializable
 
 1;

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

@@ -1,26 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::byte;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::short);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-
-}
-
+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,30 +1,11 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::date;
 use strict;
 use warnings;
-
 use Date::Parse;
 use Date::Format;
 
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-
-}
+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

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

@@ -1,47 +1,15 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::dateTime;
 use strict;
 use warnings;
-use Class::Std::Storable;
-use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
 use Date::Parse;
 use Date::Format;
-
-
-# XML Schema facets. We don't know how to implement them yet, but they're
-# here, just in case you wanted to know.
-#
-#my %pattern_of          :ATTR(:name<pattern> :default<()>);
-#my %enumeration_of      :ATTR(:name<enumeration> :default<()>);
-#my %whiteSpace_of       :ATTR(:name<whiteSpace> :default<()>);
-#my %maxInclusive_of     :ATTR(:name<maxInclusive> :default<()>);
-#my %maxExclusive_of     :ATTR(:name<maxExclusive> :default<()>);
-#my %minInclusive_of     :ATTR(:name<minInclusive> :default<()>);
-#my %minExclusive_of     :ATTR(:name<minExclusive> :default<()>);
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-}
+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 if not $_[1];
+    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} )?
@@ -51,7 +19,7 @@ sub set_value {
 
     # strptime sets empty values to undef - and strftime doesn't like that...
     my @time_from = map { ! defined $_ ? 0 : $_ } strptime($_[1]);
-    return if not (@time_from);
+
     undef $time_from[$#time_from];
 
     my $time_str = strftime( '%Y-%m-%dT%H:%M:%S%z', @time_from );

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

@@ -1,32 +1,13 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::decimal;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-
-}
+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::initialize();   # make :NUMERIFY :BOOLIFY overloading serializable
+Class::Std::Fast::initialize();   # make :NUMERIFY :BOOLIFY overloading serializable
 
 1;

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

@@ -1,26 +1,8 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::double;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-}
+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();

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

@@ -1,25 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::duration;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-
-};
+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,27 +1,8 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::float;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-
-};
+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();

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

@@ -1,26 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::gDay;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-
-};
+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

@@ -3,24 +3,7 @@ use strict;
 use warnings;
 
 # Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-
-};
+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,26 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::gMonthDay;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-
-};
+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,26 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::gYear;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-
-};
+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,25 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::gYearMonth;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-
-};
+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,25 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::hexBinary;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-};
+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,26 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::int;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::long);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-
-};
+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,32 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::integer;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::decimal);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-
-};
-
-sub as_num :NUMERIFY {
-    return $_[0]->get_value();
-}
-
-Class::Std::initialize();       # make :NUMERIFY overloading serializable
+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,26 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::language;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::token);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-
-};
+use Class::Std::Fast::Storable;
+use base qw(SOAP::WSDL::XSD::Typelib::Builtin::token);
 
 1;

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

@@ -1,10 +1,10 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::list;
 use strict;
 use warnings;
-use Class::Std::Storable;
 
 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;

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

@@ -1,25 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::long;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::integer);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-};
+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,25 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::negativeInteger;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::nonPositiveInteger);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-}
+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,25 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::nonNegativeInteger;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::integer);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-}
+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,26 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::nonPositiveInteger;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::integer);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-}
-
+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,33 +1,14 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::normalizedString;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::string);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-
-};
+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);
+    $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,25 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::positiveInteger;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::nonNegativeInteger);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-}
+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,25 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::short;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::int);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-}
+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,51 +1,37 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::string;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-
-}
+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{&qout;},
+    q{"} => q{&quot;},
     q{'} => q{&apos;},
 );
 
 sub serialize {
-    my ($self, $opt) = @_;
-    my $ident = ident $self;
-    $opt ||= {};
-    my $value = $self->get_value();
-    return $self->start_tag({ %{ $opt }, nil => 1})
+    $_[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{}, $self->start_tag($opt, $value)
+    return join q{}, $_[0]->start_tag($_[1], $value)
         #, encode_entities( $value, q{&<>"'} )
         , $value
-        , $self->end_tag($opt);
+        , $_[0]->end_tag($_[1]);
 }
 
+sub as_bool :BOOLIFY {
+    return $_[0]->get_value();
+}
+
+Class::Std::initialize;
 1;

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

@@ -3,28 +3,10 @@ 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_18';
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-}
+our $VERSION='2.00_25';
 
 sub set_value {
     # use set_value from base class if we have a XML-Time format
@@ -59,5 +41,4 @@ sub set_value {
     }
 }
 
-
 1;

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

@@ -1,24 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::token;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::normalizedString);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-}
+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,25 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::unsignedByte;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::unsignedShort);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-}
+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,25 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::unsignedInt;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::unsignedLong);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-}
+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,24 +1,7 @@
 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);
 
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::nonNegativeInteger);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-}
 1;

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

@@ -1,25 +1,7 @@
 package SOAP::WSDL::XSD::Typelib::Builtin::unsignedShort;
 use strict;
 use warnings;
-
-# Speed up. Class::Std::new is slow - and we don't need it's functionality...
-BEGIN {
-    use Class::Std::Storable;
-    use base qw(SOAP::WSDL::XSD::Typelib::Builtin::unsignedInt);
-
-    no warnings qw(redefine);
-    no strict qw(refs);
-
-    # Yes, I know it's ugly - but this is the fastest constructor to write
-    # for Class::Std-Style inside out objects..
-    *{ __PACKAGE__ . '::new' } = sub {
-        my $self = bless \do { my $foo } , shift;
-        if (@_) {
-            $self->set_value( $_[0]->{ value } )
-                if exists $_[0]->{ value }
-        }
-        return $self;
-    };
-}
+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

@@ -5,17 +5,20 @@ use warnings;
 use Carp;
 use SOAP::WSDL::XSD::Typelib::Builtin;
 use Scalar::Util qw(blessed refaddr);
-use Class::Std::Storable;
+require Class::Std::Fast::Storable;
 
 use base qw(SOAP::WSDL::XSD::Typelib::Builtin::anyType);
 
-our $VERSION = '2.00_24';
+our $VERSION = '2.00_25';
 
 my %ELEMENTS_FROM;
 my %ATTRIBUTES_OF;
 my %CLASSES_OF;
 
-# STORABLE_ methods for supporting Class::Std::Storable.
+# 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 ?
@@ -46,6 +49,7 @@ sub _factory {
 
     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";
@@ -97,7 +101,7 @@ sub _factory {
 
         *{ "$class\::set_$name" } = sub {
             my $is_ref = ref $_[1];
-            $attribute_ref->{ ident $_[0] } = ($is_ref)
+            $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
@@ -125,25 +129,24 @@ sub _factory {
         };
 
         *{ "$class\::add_$name" } = sub {
-            my $ident = ident $_[0];
             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->{ $ident }) {
-                $attribute_ref->{ $ident } = $_[1];
+            if (not exists $attribute_ref->{ ${ $_[0]} }) {
+                $attribute_ref->{ ${ $_[0]} } = $_[1];
                 return;
             }
 
-            if (not ref $attribute_ref->{ $ident } eq 'ARRAY') {
+            if (not ref $attribute_ref->{ ${ $_[0]} } eq 'ARRAY') {
                 # second call: listify previous value if it's no list and add current
-                $attribute_ref->{ $ident } = [  $attribute_ref->{ $ident }, $_[1] ];
+                $attribute_ref->{ ${ $_[0]} } = [  $attribute_ref->{ ${ $_[0]} }, $_[1] ];
                 return;
             }
 
             # second and following: add to list
-            push @{ $attribute_ref->{ $ident } }, $_[1];
+            push @{ $attribute_ref->{ ${ $_[0]} } }, $_[1];
             return;
         };
 
@@ -155,7 +158,7 @@ sub _factory {
     # 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), $_[0];
+        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) = @_;
@@ -187,7 +190,7 @@ sub _factory {
     # <restriction><sequence>.
     # But what about choice, extension ?
     *{ "$class\::_serialize" } = sub {
-        my $ident = ident $_[0];
+        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.
@@ -248,7 +251,7 @@ SOAP::WSDL::XSD::Typelib::ComplexType - Base class for complexType node classes
 To subclass, write a package like this:
 
  package MyComplexType;
- use Class::Std::Storable
+ use Class::Std::Fast::Storable constructor => 'none';
  use base qw(SOAP::WSDL::XSD::Typelib::ComplexType);
  
  # we only need the :get attribute qualifier.
@@ -365,9 +368,9 @@ Variants known to work are:
 
 =item * Thread safety
 
-SOAP::WSDL::XSD::Typelib::Builtin uses Class::Std::Storable which uses
+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 is neither.
+SOAP::WSDL::XSD::Typelib::Builtin::ComplexType is neither.
 
 =item * XML Schema facets
 
@@ -388,9 +391,9 @@ Martin Kutter E<lt>martin.kutter fen-net.deE<gt>
 
 =head1 REPOSITORY INFORMATION
 
- $Rev: 391 $
+ $Rev: 412 $
  $LastChangedBy: kutterma $
- $Id: ComplexType.pm 391 2007-11-17 21:56:13Z kutterma $
+ $Id: ComplexType.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/Typelib/ComplexType.pm $
 
 =cut

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

@@ -2,7 +2,7 @@
 package SOAP::WSDL::XSD::Typelib::Element;
 use strict;
 
-our $VERSION = '2.00_24';
+our $VERSION=q{2.00_25};
 
 my %NAME;
 my %NILLABLE;
@@ -93,7 +93,7 @@ This example creates a class for this XML schema definition:
 
  package MyElement;
  use strict;
- use Class::Std::Storable;
+ use Class::Std::Fast::Storable constructor => 'none';
  use base (
     'SOAP::WSDL::XSD::Typelib::Element',
     'SOAP::WSDL::XSD::Typelib::Builtin::string',
@@ -111,7 +111,7 @@ Now we create this XML schema definition type class:
  
  package MyElement2;
  use strict;
- use Class::Std::Storable;
+ use Class::Std::Fast::Storable constructor => 'none';
  use base (
     'SOAP::WSDL::XSD::Typelib::Element',
     'MyElement'

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

@@ -1,12 +1,10 @@
 #!/usr/bin/perl
 package SOAP::WSDL::XSD::Typelib::SimpleType;
 use strict;
-use Class::Std::Storable;
 use SOAP::WSDL::XSD::Typelib::Builtin;
 
 package SOAP::WSDL::XSD::Typelib::SimpleType::restriction;
 use strict;
-use Class::Std::Storable;
 use SOAP::WSDL::XSD::Typelib::Builtin;
 use base qw(SOAP::WSDL::XSD::Typelib::SimpleType);
 
@@ -32,7 +30,7 @@ modelling XML Schema simpleType definitions.
     #    <restriction base="xsd:string" />
     # </simpleType>
     package MySimpleType;
-    use Class::Std::Storable;
+    use Class::Std::Fast::Storable constructor => 'none';
     # restriction base implemented via inheritance
     use SOAP::WSDL::XSD::Typelib::Builtin;
     use SOAP::WSDL::XSD::Typelib::SimpleType;
@@ -49,7 +47,7 @@ modelling XML Schema simpleType definitions.
     #    <list itemTipe="xsd:string" />
     # </simpleType>
     package MySimpleListType;
-    use Class::Std::Storable;
+    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',
@@ -104,7 +102,7 @@ complexType definitions.
 
 =item * Thread safety
 
-SOAP::WSDL::XSD::Typelib::SimpleType uses Class::Std::Storable which uses
+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.