<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">package Sleepycat::DbXml;

use strict;
use warnings;

our $VERSION = '2.003';

our $strict_txn = 1 ;

sub import
{
    my $this = shift ;
    my $opt = shift ;

    $strict_txn = 0 
        if defined $opt &amp;&amp; $opt eq 'simple' ;

    require Sleepycat::Db; Sleepycat::Db-&gt;import($strict_txn ? () : 'simple');
}

package DbXml;

use 5.006001;
use strict;
use warnings;
use Carp;

require Exporter;
use AutoLoader;


our @ISA = qw(Exporter);

#our %EXPORT_TAGS = ( 'all' =&gt; [ qw(
#	
#) ] );
#
#our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );




our @EXPORT = qw();
	 

sub AUTOLOAD {
    # This AUTOLOAD is used to 'autoload' constants from the constant()
    # XS function.

    my $constname;
    our $AUTOLOAD;
    #($constname = $AUTOLOAD) =~ s/.*:://;
    $constname = $AUTOLOAD;
    croak "&amp;DbXml::constant not defined" if $constname eq 'constant';
    my ($error, $val) = DbXml::constant($constname);
    if ($error) { croak $error; }
    {
	no strict 'refs';
	# Fixed between 5.005_53 and 5.005_61
#XXX	if ($] &gt;= 5.00561) {
#XXX	    *$AUTOLOAD = sub () { $val };
#XXX	}
#XXX	else {
	    *$AUTOLOAD = sub { $val };
#XXX	}
    }
    goto &amp;$AUTOLOAD;
}

require XSLoader;
XSLoader::load('Sleepycat::DbXml', $VERSION);



*XmlContainer::AUTOLOAD = \&amp;DbXml::AUTOLOAD;
*XmlException::AUTOLOAD = \&amp;DbXml::AUTOLOAD;
*XmlIndexSpecification::AUTOLOAD = \&amp;DbXml::AUTOLOAD;
*XmlQueryContext::AUTOLOAD = \&amp;DbXml::AUTOLOAD;
*XmlValue::AUTOLOAD = \&amp;DbXml::AUTOLOAD;
*XmlModify::AUTOLOAD = \&amp;DbXml::AUTOLOAD;
*XmlIndexLookup::AUTOLOAD = \&amp;DbXml::AUTOLOAD;
*XmlEventType::AUTOLOAD = \&amp;DbXml::AUTOLOAD;

sub DbXml::DBXML_ADOPT_DBENV ; 
sub DbXml::DBXML_ALLOW_EXTERNAL_ACCESS ; 
sub DbXml::DBXML_ALLOW_AUTO_OPEN ; 
sub DbXml::DBXML_ALLOW_VALIDATION ; 
sub DbXml::DBXML_TRANSACTIONAL ; 
sub DbXml::DBXML_REVERSE_ORDER ; 
sub DbXml::DBXML_INDEX_VALUES ; 
sub DbXml::DBXML_CHKSUM ; 
sub DbXml::DBXML_ENCRYPT ; 
sub DbXml::DBXML_GEN_NAME ; 
sub DbXml::DBXML_LAZY_DOCS ; 
sub DbXml::DBXML_WELL_FORMED_ONLY ; 
sub DbXml::DBXML_INDEX_NODES ; 
sub DbXml::DBXML_NO_INDEX_NODES ; 
sub DbXml::LEVEL_NONE ; 
sub DbXml::LEVEL_DEBUG ; 
sub DbXml::LEVEL_INFO ; 
sub DbXml::LEVEL_WARNING ; 
sub DbXml::LEVEL_ERROR ; 
sub DbXml::LEVEL_ALL ; 
sub DbXml::CATEGORY_NONE ; 
sub DbXml::CATEGORY_INDEXER ; 
sub DbXml::CATEGORY_QUERY ; 
sub DbXml::CATEGORY_OPTIMIZER ; 
sub DbXml::CATEGORY_DICTIONARY ; 
sub DbXml::CATEGORY_CONTAINER ; 
sub DbXml::CATEGORY_NODESTORE ; 
sub DbXml::CATEGORY_MANAGER ; 
sub DbXml::CATEGORY_ALL ; 
sub DbXml::DBXML_VERSION_MAJOR ; 
sub DbXml::DBXML_VERSION_MINOR ; 
sub DbXml::DBXML_VERSION_PATCH ; 
#sub DbXml::StartElement;
#sub DbXml::EndElement;
#sub DbXml::Characters;
#sub DbXml::CDATA;
#sub DbXml::Comment;
#sub DbXml::Whitespace;
#sub DbXml::StartDocument;
#sub DbXml::EndDocument;
#sub DbXml::StartEntityReference;
#sub DbXml::EndEntityReference;
#sub DbXml::ProcessingInstruction;
#sub DbXml::DTD;
sub XmlContainer::WholedocContainer ; 
sub XmlContainer::NodeContainer ; 
sub XmlException::INTERNAL_ERROR ; 
sub XmlException::CONTAINER_OPEN ; 
sub XmlException::CONTAINER_CLOSED ; 
sub XmlException::NULL_POINTER ; 
sub XmlException::INDEXER_PARSER_ERROR ; 
sub XmlException::DATABASE_ERROR ; 
sub XmlException::XPATH_PARSER_ERROR ; 
sub XmlException::DOM_PARSER_ERROR ; 
sub XmlException::XPATH_EVALUATION_ERROR ; 
sub XmlException::NO_VARIABLE_BINDING ; 
sub XmlException::LAZY_EVALUATION ; 
sub XmlException::DOCUMENT_NOT_FOUND ; 
sub XmlException::CONTAINER_EXISTS ; 
sub XmlException::UNKNOWN_INDEX ; 
sub XmlException::INVALID_VALUE ; 
sub XmlException::VERSION_MISMATCH ; 
sub XmlException::CONTAINER_NOT_FOUND ; 
sub XmlException::TRANSACTION_ERROR ; 
sub XmlException::UNIQUE_ERROR ; 
sub XmlException::NO_MEMORY_ERROR ; 
sub XmlException::EVENT_ERROR ; 
sub XmlException::OPERATION_TIMEOUT ; 
sub XmlException::OPERATION_INTERRUPTED ; 
sub XmlIndexSpecification::UNIQUE_OFF ; 
sub XmlIndexSpecification::UNIQUE_ON ; 
sub XmlIndexSpecification::PATH_NONE ; 
sub XmlIndexSpecification::PATH_NODE ; 
sub XmlIndexSpecification::PATH_EDGE ; 
sub XmlIndexSpecification::NODE_NONE ; 
sub XmlIndexSpecification::NODE_ELEMENT ; 
sub XmlIndexSpecification::NODE_ATTRIBUTE ; 
sub XmlIndexSpecification::NODE_METADATA ; 
sub XmlIndexSpecification::KEY_NONE ; 
sub XmlIndexSpecification::KEY_PRESENCE ; 
sub XmlIndexSpecification::KEY_EQUALITY ; 
sub XmlIndexSpecification::KEY_SUBSTRING ; 
sub XmlQueryContext::DeadValues ; 
sub XmlQueryContext::LiveValues ; 
sub XmlQueryContext::Eager ; 
sub XmlQueryContext::Lazy ; 
sub XmlValue::NONE ; 
sub XmlValue::NODE ; 
sub XmlValue::ANY_SIMPLE_TYPE ; 
sub XmlValue::ANY_URI ; 
sub XmlValue::BASE_64_BINARY ; 
sub XmlValue::BOOLEAN ; 
sub XmlValue::DATE ; 
sub XmlValue::DATE_TIME ; 
sub XmlValue::DAY_TIME_DURATION ; 
sub XmlValue::DECIMAL ; 
sub XmlValue::DOUBLE ; 
sub XmlValue::DURATION ; 
sub XmlValue::FLOAT ; 
sub XmlValue::G_DAY ; 
sub XmlValue::G_MONTH ; 
sub XmlValue::G_MONTH_DAY ; 
sub XmlValue::G_YEAR ; 
sub XmlValue::G_YEAR_MONTH ; 
sub XmlValue::HEX_BINARY ; 
sub XmlValue::NOTATION ; 
sub XmlValue::QNAME ; 
sub XmlValue::STRING ; 
sub XmlValue::TIME ; 
sub XmlValue::YEAR_MONTH_DURATION ; 
sub XmlValue::UNTYPED_ATOMIC ; 
sub XmlValue::BINARY ; 
sub XmlValue::ELEMENT_NODE ; 
sub XmlValue::ATTRIBUTE_NODE ; 
sub XmlValue::TEXT_NODE ; 
sub XmlValue::CDATA_SECTION_NODE ; 
sub XmlValue::ENTITY_REFERENCE_NODE ; 
sub XmlValue::ENTITY_NODE ; 
sub XmlValue::PROCESSING_INSTRUCTION_NODE ; 
sub XmlValue::COMMENT_NODE ; 
sub XmlValue::DOCUMENT_NODE ; 
sub XmlValue::DOCUMENT_TYPE_NODE ; 
sub XmlValue::DOCUMENT_FRAGMENT_NODE ; 
sub XmlValue::NOTATION_NODE ; 
sub XmlModify::Element ; 
sub XmlModify::Attribute ; 
sub XmlModify::Text ; 
sub XmlModify::ProcessingInstruction ; 
sub XmlModify::Comment ; 
sub XmlIndexLookup::NONE ; 
sub XmlIndexLookup::EQ ; 
sub XmlIndexLookup::GT ; 
sub XmlIndexLookup::GTE ; 
sub XmlIndexLookup::LT ; 
sub XmlIndexLookup::LTE ; 
sub XmlEventType::StartElement ;
sub XmlEventType::EndElement ;
sub XmlEventType::Characters ;
sub XmlEventType::CDATA ;
sub XmlEventType::Comment ;
sub XmlEventType::Whitespace ;
sub XmlEventType::StartDocument ;
sub XmlEventType::EndDocument ;
sub XmlEventType::StartEntityReference ;
sub XmlEventType::EndEntityReference ;
sub XmlEventType::ProcessingInstruction ;
sub XmlEventType::DTD ;


package XmlValue;


our %TypeNameMapping = (
   XmlValue::NONE	=&gt; 'NONE',
   XmlValue::NODE	=&gt; 'NODE',
   XmlValue::ANY_SIMPLE_TYPE	=&gt; 'ANY_SIMPLE_TYPE',
   XmlValue::ANY_URI	=&gt; 'ANY_URI',
   XmlValue::BASE_64_BINARY	=&gt; 'BASE_64_BINARY',
   XmlValue::BOOLEAN	=&gt; 'BOOLEAN',
   XmlValue::DATE	=&gt; 'DATE',
   XmlValue::DATE_TIME	=&gt; 'DATE_TIME',
   XmlValue::DAY_TIME_DURATION	=&gt; 'DAY_TIME_DURATION',
   XmlValue::DECIMAL	=&gt; 'DECIMAL',
   XmlValue::DOUBLE	=&gt; 'DOUBLE',
   XmlValue::DURATION	=&gt; 'DURATION',
   XmlValue::FLOAT	=&gt; 'FLOAT',
   XmlValue::G_DAY	=&gt; 'G_DAY',
   XmlValue::G_MONTH	=&gt; 'G_MONTH',
   XmlValue::G_MONTH_DAY	=&gt; 'G_MONTH_DAY',
   XmlValue::G_YEAR	=&gt; 'G_YEAR',
   XmlValue::G_YEAR_MONTH	=&gt; 'G_YEAR_MONTH',
   XmlValue::HEX_BINARY	=&gt; 'HEX_BINARY',
   XmlValue::NOTATION	=&gt; 'NOTATION',
   XmlValue::QNAME	=&gt; 'QNAME',
   XmlValue::STRING	=&gt; 'STRING',
   XmlValue::TIME	=&gt; 'TIME',
   XmlValue::YEAR_MONTH_DURATION	=&gt; 'YEAR_MONTH_DURATION',
   XmlValue::UNTYPED_ATOMIC	=&gt; 'UNTYPED_ATOMIC',
   XmlValue::BINARY	=&gt; 'BINARY',
);



package DbXml;

{

    my @txnids = (

	    [ 'XmlManager', 'createContainer',	1, 5],
	    [ 'XmlManager', 'openContainer',	1, 3],
	    [ 'XmlManager', 'removeContainer',	1, 2],
	    [ 'XmlManager', 'renameContainer',	2, 3],
	    [ 'XmlManager', 'reindexContainer',	2, 4],
	    [ 'XmlManager', 'prepare',	1, 3],
	    [ 'XmlManager', 'query',	1, 4],

	    [ 'XmlContainer', 'setIndexSpecification',1, 3],
	    [ 'XmlContainer', 'getIndexSpecification',0, 2],
	    [ 'XmlContainer', 'addDefaultIndex',	1, 3],
	    [ 'XmlContainer', 'deleteDefaultIndex',	1, 3],
	    [ 'XmlContainer', 'replaceDefaultIndex',	1, 3],
	    [ 'XmlContainer', 'addIndex',	3, 5],
	    [ 'XmlContainer', 'deleteIndex',	4, 5],
	    [ 'XmlContainer', 'replaceIndex',	4, 5],
	    [ 'XmlContainer', 'getDocument',	1, 3],
	    [ 'XmlContainer', 'updateDocument',	1, 3],
	    [ 'XmlContainer', 'getAllDocuments',	0, 2],
	    [ 'XmlContainer', 'getNumDocuments',	0, 1],

	    [ 'XmlIndexLookup', 'execute',	1, 3],

	    );
	
    foreach (@txnids)
    {
	my ($pkg, $name, $from, $to) = @{ $_ } ;

        my $sub = &lt;&lt;'EOM' ;
            sub PACKAGE::NAME
            {
                my $THIS = shift ;
    
                croak "PACKAGE::NAME needs between FROM and TO parameters\n" 
                    if @_ &lt; FROM || @_ &gt; TO;
    
                ($Db::_filename, $Db::_line) = (caller)[1,2];
    
                if ($Sleepycat::DbXml::strict_txn
		    || @_ &amp;&amp; !defined $_[0] 
		    || ref $_[0] &amp;&amp; UNIVERSAL::isa($_[0], "XmlTransaction")) {
                    $THIS-&gt;_NAME(@_) ;	    
                }
                else {
                    $THIS-&gt;_NAME(undef, @_) ;	    
                }	   
            }
EOM

        $sub =~ s/PACKAGE/$pkg/g ;
        $sub =~ s/NAME/$name/g ;
        $sub =~ s/FROM/$from/g ;
        $sub =~ s/TO/$to/g ;
        eval $sub;
    }

}

sub printVersionInfo
{
    my ($major, $minor, $patch) = (0,0,0) ;
    print "perl  : $]\n" ;
    print "dbxml : " . dbxml_version($major, $minor, $patch) . "\n" ;
    print "db    : " . DbEnv::version($major, $minor, $patch) . "\n";
    print "xerces: " . xerces_version() . "\n";

}

package XmlManager ;

use Carp;

package XmlResults ;

use Carp;


package XmlContainer ;

use Carp;

sub deleteDocument
{
    my $THIS = shift ;

    unless ($Sleepycat::DbXml::strict_txn ||
        (! defined $_[0] || ref $_[0] &amp;&amp; UNIVERSAL::isa($_[0], "XmlTransaction")))
        {
           unshift @_, undef ;
        
        }

    croak "deleteDocument needs between 2 and 3 parameters\n" 
        if @_ &lt; 2 || @_ &gt; 3;


    if (ref $_[1] &amp;&amp; UNIVERSAL::isa($_[1], "XmlDocument")) {
        $THIS-&gt;deleteDocument_1(@_) ;
    }
    else {
        $THIS-&gt;deleteDocument_2(@_) ;	    
    }	   
}

sub putDocument
{
    my $THIS = shift ;


    unless ($Sleepycat::DbXml::strict_txn ||
        (! defined $_[0] || ref $_[0] &amp;&amp; UNIVERSAL::isa($_[0], "XmlTransaction")))
        {
           unshift @_, undef ;
        
        }

    croak "putDocument needs between 1 and 4 parameters\n" 
        if @_ &lt; 1 || @_ &gt; 5;


    local $Carp::CarpLevel = 1 ;
    if (ref $_[1] &amp;&amp; UNIVERSAL::isa($_[1], "XmlDocument")) {
        $THIS-&gt;_putDocument_1(@_) ;
    }
    else {
        $THIS-&gt;_putDocument_2(@_) ;	    
    }	   
}

sub lookupIndex
{
    my $THIS = shift ;

    unless ($Sleepycat::DbXml::strict_txn ||
        (! defined $_[0] || ref $_[0] &amp;&amp; UNIVERSAL::isa($_[0], "XmlTransaction")))
        {
           unshift @_, undef ;
        
        }

    croak "lookupIndex needs between 6 and 9 parameters\n" 
        if @_ &lt; 6 || @_ &gt; 9;


    if (@_ &lt;= 7) {
        $THIS-&gt;_lookupIndex_1(@_) ;
    }
    else {
        $THIS-&gt;_lookupIndex_2(@_) ;	    
    }	   
}

sub lookupStatistics
{
    my $THIS = shift ;

    unless ($Sleepycat::DbXml::strict_txn ||
        (! defined $_[0] || ref $_[0] &amp;&amp; UNIVERSAL::isa($_[0], "XmlTransaction")))
        {
           unshift @_, undef ;
        
        }

    croak "lookupStatistics needs between 3 and 7 parameters\n" 
        if @_ &lt; 3 || @_ &gt; 7;


    if (@_ &lt; 6) {
        $THIS-&gt;_lookupStatistics_1(@_) ;
    }
    else {
        $THIS-&gt;_lookupStatistics_2(@_) ;	    
    }	   
}

package XmlException ;

our @ISA = qw(std::exception);

sub catch
{
    return $@
        if (ref($@) &amp;&amp; UNIVERSAL::isa($@, "XmlException"));

    return undef ;
}	

#package std::exception ;
#
#sub catch
#{
#    return $@
#        if (ref($@) &amp;&amp; UNIVERSAL::isa($@, "std::exception"));
#
#    return undef ;
#}	

package XmlDocument ;

use Carp;

*AUTOLOAD = \&amp;DbXml::AUTOLOAD;
use UNIVERSAL qw( isa ) ;

use overload '""' =&gt; \&amp;_asString,
            'cmp' =&gt; \&amp;_cmp,
            ;

sub _asString
{
    my $THIS = shift ;
    return $THIS-&gt;getContent() ;
}

sub _cmp
{
    my $THIS = shift ;
    my $THAT = shift ;
    return isa $THIS, 'XmlDocument' ? $THIS-&gt;getContent() : $THIS cmp 
           isa $THAT, 'XmlDocument' ? $THAT-&gt;getContent() : $THAT ;
}


package XmlQueryExpression;

use Carp;

sub execute
{
    my $THIS = shift ;

    unless ($Sleepycat::DbXml::strict_txn ||
        (! defined $_[0] || ref $_[0] &amp;&amp; UNIVERSAL::isa($_[0], "XmlTransaction")))
        {
           unshift @_, undef ;
        
        }

    croak "XmlQueryExpression::execute needs beween 1 and 4 parameters\n" unless @_ &gt;= 1 &amp;&amp; @_ &lt;= 4 ;

    if ((@_ == 4 || @_ == 3) &amp;&amp;
        ref $_[2] &amp;&amp; UNIVERSAL::isa($_[2], "XmlQueryContext") ) 
    {
        push @_, 0 if @_ == 3 ;    
        $THIS-&gt;_execute1(@_) ;	    
    }
    elsif ((@_ == 2 || @_ == 3) &amp;&amp;
           ref $_[1] &amp;&amp; UNIVERSAL::isa($_[1], "XmlQueryContext"))
    {
        push @_, 0 if @_ == 2 ;    
        $THIS-&gt;_execute2(@_) ;	    
    }	   
    else {
        croak "XmlQueryExpression::execute -- parameters incorrect type\n" 
    }
}

package XmlValue ;

use Carp;
use UNIVERSAL qw( isa ) ;

use overload '""' =&gt; \&amp;_asString,
            'cmp' =&gt; \&amp;_cmp,
             ;

sub _cmp
{
    my $THIS = shift ;
    my $THAT = shift ;
    return isa $THIS, 'XmlValue' ? $THIS-&gt;asString() : $THIS cmp 
           isa $THAT, 'XmlValue' ? $THAT-&gt;asString() : $THAT ;
}

sub _asString
{
    my $THIS = shift ;
    return $THIS-&gt;asString() ;
}

sub _getTypeName
{
    my $THIS = shift ;
    my $type = $THIS-&gt;getType(@_);
    #return $TypeNameMapping{$type} || 'Unknown';
    return defined $TypeNameMapping{$type} 
                  ?  $TypeNameMapping{$type} 
                  :  'Unknown' ;
}

sub dump
{
    my $THIS = shift ;
    my $type = $THIS-&gt;getType(@_);
    my $name = $THIS-&gt;_getTypeName();
    print "Type is $name ($type)" ;

    if ($type == XmlValue::BOOLEAN  || 
	$type == XmlValue::DECIMAL   || 
	$type == XmlValue::STRING   || 
	$type == XmlValue::NODE     || 
	$type == XmlValue::DOUBLE  )
        { print ", value is '". $THIS-&gt;asString . "'\n" }
    else
        { print "\n" }
	
}

package XmlModify;

use Carp;

sub execute
{
    my $THIS = shift ;

    unless ($Sleepycat::DbXml::strict_txn ||
        (! defined $_[0] || ref $_[0] &amp;&amp; UNIVERSAL::isa($_[0], "XmlTransaction")))
        {
           unshift @_, undef ;
        
        }

    croak "execute needs beween 3 and 4 parameters\n" unless @_ &gt;= 3 &amp;&amp; @_ &lt;= 4 ;

    if ( ref $_[1] &amp;&amp; UNIVERSAL::isa($_[1], "XmlResults") &amp;&amp;
        ref $_[2] &amp;&amp; UNIVERSAL::isa($_[2], "XmlQueryContext")  &amp;&amp;
        ref $_[3] &amp;&amp; UNIVERSAL::isa($_[3], "XmlUpdateContext") ) 
    {
        $THIS-&gt;_execute2(@_) ;	    
    }	   
    else 
    {
        $THIS-&gt;_execute1(@_) ;	    
    }
}
package DbtPtr;

use Carp;
our @ISA = qw(Dbt);

sub DESTROY
{
    my $class = shift ;

}


package DbXml ;

1;
__END__
</pre></body></html>