# This file was created automatically by SWIG.
# Don't modify this file, modify the SWIG interface instead.
# This file is compatible with both classic and new-style classes.
import _dbxml
def _swig_setattr(self,class_type,name,value):
    if (name == "this"):
        if isinstance(value, class_type):
            self.__dict__[name] = value.this
            if hasattr(value,"thisown"): self.__dict__["thisown"] = value.thisown
            del value.thisown
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    self.__dict__[name] = value

def _swig_getattr(self,class_type,name):
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError,name

import types
try:
    _object = types.ObjectType
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


DB_AUTO_COMMIT = _dbxml.DB_AUTO_COMMIT
DB_CREATE = _dbxml.DB_CREATE
DB_DIRTY_READ = _dbxml.DB_DIRTY_READ
DB_EXCL = _dbxml.DB_EXCL
DB_NOMMAP = _dbxml.DB_NOMMAP
DB_RDONLY = _dbxml.DB_RDONLY
DB_THREAD = _dbxml.DB_THREAD
metaDataNamespace_uri = _dbxml.metaDataNamespace_uri
metaDataNamespace_prefix = _dbxml.metaDataNamespace_prefix
metaDataName_id = _dbxml.metaDataName_id
metaDataName_name = _dbxml.metaDataName_name
metaDataName_content = _dbxml.metaDataName_content
metaDataName_default = _dbxml.metaDataName_default
metaDataNamespace_prefix_debug = _dbxml.metaDataNamespace_prefix_debug
LEVEL_NONE = _dbxml.LEVEL_NONE
LEVEL_DEBUG = _dbxml.LEVEL_DEBUG
LEVEL_INFO = _dbxml.LEVEL_INFO
LEVEL_WARNING = _dbxml.LEVEL_WARNING
LEVEL_ERROR = _dbxml.LEVEL_ERROR
LEVEL_ALL = _dbxml.LEVEL_ALL
CATEGORY_NONE = _dbxml.CATEGORY_NONE
CATEGORY_INDEXER = _dbxml.CATEGORY_INDEXER
CATEGORY_QUERY = _dbxml.CATEGORY_QUERY
CATEGORY_OPTIMIZER = _dbxml.CATEGORY_OPTIMIZER
CATEGORY_DICTIONARY = _dbxml.CATEGORY_DICTIONARY
CATEGORY_CONTAINER = _dbxml.CATEGORY_CONTAINER
CATEGORY_ALL = _dbxml.CATEGORY_ALL
class XmlContainer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XmlContainer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XmlContainer, name)
    def __init__(self,*args):
        _swig_setattr(self, XmlContainer, 'this', apply(_dbxml.new_XmlContainer,args))
        _swig_setattr(self, XmlContainer, 'thisown', 1)
    def __del__(self, destroy= _dbxml.delete_XmlContainer):
        try:
            if self.thisown: destroy(self)
        except: pass
    def setPageSize(*args): return apply(_dbxml.XmlContainer_setPageSize,args)
    def open(*args): return apply(_dbxml.XmlContainer_open,args)
    def exists(*args): return apply(_dbxml.XmlContainer_exists,args)
    def isOpen(*args): return apply(_dbxml.XmlContainer_isOpen,args)
    def close(*args): return apply(_dbxml.XmlContainer_close,args)
    def setIndexSpecification(*args): return apply(_dbxml.XmlContainer_setIndexSpecification,args)
    def addIndex(*args): return apply(_dbxml.XmlContainer_addIndex,args)
    def deleteIndex(*args): return apply(_dbxml.XmlContainer_deleteIndex,args)
    def replaceIndex(*args): return apply(_dbxml.XmlContainer_replaceIndex,args)
    def upgrade(*args): return apply(_dbxml.XmlContainer_upgrade,args)
    def getIndexSpecification(*args): return apply(_dbxml.XmlContainer_getIndexSpecification,args)
    def getName(*args): return apply(_dbxml.XmlContainer_getName,args)
    def setName(*args): return apply(_dbxml.XmlContainer_setName,args)
    def putDocument(*args): return apply(_dbxml.XmlContainer_putDocument,args)
    def updateDocument(*args): return apply(_dbxml.XmlContainer_updateDocument,args)
    def remove(*args): return apply(_dbxml.XmlContainer_remove,args)
    def rename(*args): return apply(_dbxml.XmlContainer_rename,args)
    def deleteDocument(*args): return apply(_dbxml.XmlContainer_deleteDocument,args)
    def modifyDocument(*args): return apply(_dbxml.XmlContainer_modifyDocument,args)
    def getDocument(*args): return apply(_dbxml.XmlContainer_getDocument,args)
    def parseXPathExpression(*args): return apply(_dbxml.XmlContainer_parseXPathExpression,args)
    def queryWithXPath(*args): return apply(_dbxml.XmlContainer_queryWithXPath,args)
    def query(*args): return apply(_dbxml.XmlContainer_query,args)
    def dump(*args): return apply(_dbxml.XmlContainer_dump,args)
    def load(*args): return apply(_dbxml.XmlContainer_load,args)
    def verify(*args): return apply(_dbxml.XmlContainer_verify,args)
    __swig_getmethods__["setLogLevel"] = lambda x: _dbxml.XmlContainer_setLogLevel
    if _newclass:setLogLevel = staticmethod(_dbxml.XmlContainer_setLogLevel)
    __swig_getmethods__["setLogCategory"] = lambda x: _dbxml.XmlContainer_setLogCategory
    if _newclass:setLogCategory = staticmethod(_dbxml.XmlContainer_setLogCategory)
    __swig_getmethods__["get_version_major"] = lambda x: _dbxml.XmlContainer_get_version_major
    if _newclass:get_version_major = staticmethod(_dbxml.XmlContainer_get_version_major)
    __swig_getmethods__["get_version_minor"] = lambda x: _dbxml.XmlContainer_get_version_minor
    if _newclass:get_version_minor = staticmethod(_dbxml.XmlContainer_get_version_minor)
    __swig_getmethods__["get_version_patch"] = lambda x: _dbxml.XmlContainer_get_version_patch
    if _newclass:get_version_patch = staticmethod(_dbxml.XmlContainer_get_version_patch)
    __swig_getmethods__["get_version_string"] = lambda x: _dbxml.XmlContainer_get_version_string
    if _newclass:get_version_string = staticmethod(_dbxml.XmlContainer_get_version_string)
    def __repr__(self):
        return "<C XmlContainer instance at %s>" % (self.this,)

class XmlContainerPtr(XmlContainer):
    def __init__(self,this):
        _swig_setattr(self, XmlContainer, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, XmlContainer, 'thisown', 0)
        _swig_setattr(self, XmlContainer,self.__class__,XmlContainer)
_dbxml.XmlContainer_swigregister(XmlContainerPtr)
XmlContainer_setLogLevel = _dbxml.XmlContainer_setLogLevel

XmlContainer_setLogCategory = _dbxml.XmlContainer_setLogCategory

XmlContainer_get_version_major = _dbxml.XmlContainer_get_version_major

XmlContainer_get_version_minor = _dbxml.XmlContainer_get_version_minor

XmlContainer_get_version_patch = _dbxml.XmlContainer_get_version_patch

XmlContainer_get_version_string = _dbxml.XmlContainer_get_version_string


class XmlDocument(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XmlDocument, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XmlDocument, name)
    def __init__(self,*args):
        _swig_setattr(self, XmlDocument, 'this', apply(_dbxml.new_XmlDocument,args))
        _swig_setattr(self, XmlDocument, 'thisown', 1)
    def __del__(self, destroy= _dbxml.delete_XmlDocument):
        try:
            if self.thisown: destroy(self)
        except: pass
    def getID(*args): return apply(_dbxml.XmlDocument_getID,args)
    def setName(*args): return apply(_dbxml.XmlDocument_setName,args)
    def getName(*args): return apply(_dbxml.XmlDocument_getName,args)
    def setContent(*args): return apply(_dbxml.XmlDocument_setContent,args)
    def getContent(*args): return apply(_dbxml.XmlDocument_getContent,args)
    def modifyDocument(*args): return apply(_dbxml.XmlDocument_modifyDocument,args)
    def getContentAsString(*args): return apply(_dbxml.XmlDocument_getContentAsString,args)
    def setMetaData(*args): return apply(_dbxml.XmlDocument_setMetaData,args)
    def getMetaData(*args): return apply(_dbxml.XmlDocument_getMetaData,args)
    def queryWithXPath(*args): return apply(_dbxml.XmlDocument_queryWithXPath,args)
    def __repr__(self):
        return "<C XmlDocument instance at %s>" % (self.this,)

class XmlDocumentPtr(XmlDocument):
    def __init__(self,this):
        _swig_setattr(self, XmlDocument, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, XmlDocument, 'thisown', 0)
        _swig_setattr(self, XmlDocument,self.__class__,XmlDocument)
_dbxml.XmlDocument_swigregister(XmlDocumentPtr)

class XmlQueryContext(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XmlQueryContext, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XmlQueryContext, name)
    ResultDocuments = _dbxml.XmlQueryContext_ResultDocuments
    ResultValues = _dbxml.XmlQueryContext_ResultValues
    CandidateDocuments = _dbxml.XmlQueryContext_CandidateDocuments
    ResultDocumentsAndValues = _dbxml.XmlQueryContext_ResultDocumentsAndValues
    Eager = _dbxml.XmlQueryContext_Eager
    Lazy = _dbxml.XmlQueryContext_Lazy
    def __init__(self,*args):
        _swig_setattr(self, XmlQueryContext, 'this', apply(_dbxml.new_XmlQueryContext,args))
        _swig_setattr(self, XmlQueryContext, 'thisown', 1)
    def __del__(self, destroy= _dbxml.delete_XmlQueryContext):
        try:
            if self.thisown: destroy(self)
        except: pass
    def setNamespace(*args): return apply(_dbxml.XmlQueryContext_setNamespace,args)
    def getNamespace(*args): return apply(_dbxml.XmlQueryContext_getNamespace,args)
    def removeNamespace(*args): return apply(_dbxml.XmlQueryContext_removeNamespace,args)
    def clearNamespaces(*args): return apply(_dbxml.XmlQueryContext_clearNamespaces,args)
    def setVariableValue(*args): return apply(_dbxml.XmlQueryContext_setVariableValue,args)
    def setReturnType(*args): return apply(_dbxml.XmlQueryContext_setReturnType,args)
    def getReturnType(*args): return apply(_dbxml.XmlQueryContext_getReturnType,args)
    def setEvaluationType(*args): return apply(_dbxml.XmlQueryContext_setEvaluationType,args)
    def getEvaluationType(*args): return apply(_dbxml.XmlQueryContext_getEvaluationType,args)
    def setWithMetaData(*args): return apply(_dbxml.XmlQueryContext_setWithMetaData,args)
    def getWithMetaData(*args): return apply(_dbxml.XmlQueryContext_getWithMetaData,args)
    def getVariableValue(*args): return apply(_dbxml.XmlQueryContext_getVariableValue,args)
    def __repr__(self):
        return "<C XmlQueryContext instance at %s>" % (self.this,)

class XmlQueryContextPtr(XmlQueryContext):
    def __init__(self,this):
        _swig_setattr(self, XmlQueryContext, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, XmlQueryContext, 'thisown', 0)
        _swig_setattr(self, XmlQueryContext,self.__class__,XmlQueryContext)
_dbxml.XmlQueryContext_swigregister(XmlQueryContextPtr)

class XmlResults(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XmlResults, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XmlResults, name)
    def __init__(self,*args):
        _swig_setattr(self, XmlResults, 'this', apply(_dbxml.new_XmlResults,args))
        _swig_setattr(self, XmlResults, 'thisown', 1)
    def __del__(self, destroy= _dbxml.delete_XmlResults):
        try:
            if self.thisown: destroy(self)
        except: pass
    def next(*args): return apply(_dbxml.XmlResults_next,args)
    def nextDocument(*args): return apply(_dbxml.XmlResults_nextDocument,args)
    def nextDocumentAndValue(*args): return apply(_dbxml.XmlResults_nextDocumentAndValue,args)
    def __iter__(self): return self


    def reset(*args): return apply(_dbxml.XmlResults_reset,args)
    def size(*args): return apply(_dbxml.XmlResults_size,args)
    def add(*args): return apply(_dbxml.XmlResults_add,args)
    def __repr__(self):
        return "<C XmlResults instance at %s>" % (self.this,)

class XmlResultsPtr(XmlResults):
    def __init__(self,this):
        _swig_setattr(self, XmlResults, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, XmlResults, 'thisown', 0)
        _swig_setattr(self, XmlResults,self.__class__,XmlResults)
_dbxml.XmlResults_swigregister(XmlResultsPtr)

class XmlUpdateContext(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XmlUpdateContext, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XmlUpdateContext, name)
    def __init__(self,*args):
        _swig_setattr(self, XmlUpdateContext, 'this', apply(_dbxml.new_XmlUpdateContext,args))
        _swig_setattr(self, XmlUpdateContext, 'thisown', 1)
    def __del__(self, destroy= _dbxml.delete_XmlUpdateContext):
        try:
            if self.thisown: destroy(self)
        except: pass
    def __repr__(self):
        return "<C XmlUpdateContext instance at %s>" % (self.this,)

class XmlUpdateContextPtr(XmlUpdateContext):
    def __init__(self,this):
        _swig_setattr(self, XmlUpdateContext, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, XmlUpdateContext, 'thisown', 0)
        _swig_setattr(self, XmlUpdateContext,self.__class__,XmlUpdateContext)
_dbxml.XmlUpdateContext_swigregister(XmlUpdateContextPtr)

class XmlValue(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XmlValue, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XmlValue, name)
    NONE = _dbxml.XmlValue_NONE
    STRING = _dbxml.XmlValue_STRING
    NUMBER = _dbxml.XmlValue_NUMBER
    BOOLEAN = _dbxml.XmlValue_BOOLEAN
    DOCUMENT = _dbxml.XmlValue_DOCUMENT
    NODE = _dbxml.XmlValue_NODE
    VARIABLE = _dbxml.XmlValue_VARIABLE
    BINARY = _dbxml.XmlValue_BINARY
    def __init__(self,*args):
        _swig_setattr(self, XmlValue, 'this', apply(_dbxml.new_XmlValue,args))
        _swig_setattr(self, XmlValue, 'thisown', 1)
    def __del__(self, destroy= _dbxml.delete_XmlValue):
        try:
            if self.thisown: destroy(self)
        except: pass
    def getType(*args): return apply(_dbxml.XmlValue_getType,args)
    def isNumber(*args): return apply(_dbxml.XmlValue_isNumber,args)
    def isString(*args): return apply(_dbxml.XmlValue_isString,args)
    def isBoolean(*args): return apply(_dbxml.XmlValue_isBoolean,args)
    def isNode(*args): return apply(_dbxml.XmlValue_isNode,args)
    def isDocument(*args): return apply(_dbxml.XmlValue_isDocument,args)
    def isVariable(*args): return apply(_dbxml.XmlValue_isVariable,args)
    def isNull(*args): return apply(_dbxml.XmlValue_isNull,args)
    def asNumber(*args): return apply(_dbxml.XmlValue_asNumber,args)
    def asString(*args): return apply(_dbxml.XmlValue_asString,args)
    def asBoolean(*args): return apply(_dbxml.XmlValue_asBoolean,args)
    def asDocument(*args): return apply(_dbxml.XmlValue_asDocument,args)
    def equals(*args): return apply(_dbxml.XmlValue_equals,args)
    def __repr__(self):
        return "<C XmlValue instance at %s>" % (self.this,)

class XmlValuePtr(XmlValue):
    def __init__(self,this):
        _swig_setattr(self, XmlValue, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, XmlValue, 'thisown', 0)
        _swig_setattr(self, XmlValue,self.__class__,XmlValue)
_dbxml.XmlValue_swigregister(XmlValuePtr)

class XmlIndexSpecification(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XmlIndexSpecification, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XmlIndexSpecification, name)
    def __init__(self,*args):
        _swig_setattr(self, XmlIndexSpecification, 'this', apply(_dbxml.new_XmlIndexSpecification,args))
        _swig_setattr(self, XmlIndexSpecification, 'thisown', 1)
    def __del__(self, destroy= _dbxml.delete_XmlIndexSpecification):
        try:
            if self.thisown: destroy(self)
        except: pass
    def addIndex(*args): return apply(_dbxml.XmlIndexSpecification_addIndex,args)
    def deleteIndex(*args): return apply(_dbxml.XmlIndexSpecification_deleteIndex,args)
    def replaceIndex(*args): return apply(_dbxml.XmlIndexSpecification_replaceIndex,args)
    def reset(*args): return apply(_dbxml.XmlIndexSpecification_reset,args)
    def find(*args): return apply(_dbxml.XmlIndexSpecification_find,args)
    def next(*args): return apply(_dbxml.XmlIndexSpecification_next,args)
    def __iter__(self): return self


    def __repr__(self):
        return "<C XmlIndexSpecification instance at %s>" % (self.this,)

class XmlIndexSpecificationPtr(XmlIndexSpecification):
    def __init__(self,this):
        _swig_setattr(self, XmlIndexSpecification, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, XmlIndexSpecification, 'thisown', 0)
        _swig_setattr(self, XmlIndexSpecification,self.__class__,XmlIndexSpecification)
_dbxml.XmlIndexSpecification_swigregister(XmlIndexSpecificationPtr)

class XmlIndexDeclaration(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XmlIndexDeclaration, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XmlIndexDeclaration, name)
    def __del__(self, destroy= _dbxml.delete_XmlIndexDeclaration):
        try:
            if self.thisown: destroy(self)
        except: pass
    def get_uri(*args): return apply(_dbxml.XmlIndexDeclaration_get_uri,args)
    def get_name(*args): return apply(_dbxml.XmlIndexDeclaration_get_name,args)
    def get_index(*args): return apply(_dbxml.XmlIndexDeclaration_get_index,args)
    def __init__(self,*args):
        _swig_setattr(self, XmlIndexDeclaration, 'this', apply(_dbxml.new_XmlIndexDeclaration,args))
        _swig_setattr(self, XmlIndexDeclaration, 'thisown', 1)
    def __repr__(self):
        return "<C XmlIndexDeclaration instance at %s>" % (self.this,)

class XmlIndexDeclarationPtr(XmlIndexDeclaration):
    def __init__(self,this):
        _swig_setattr(self, XmlIndexDeclaration, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, XmlIndexDeclaration, 'thisown', 0)
        _swig_setattr(self, XmlIndexDeclaration,self.__class__,XmlIndexDeclaration)
_dbxml.XmlIndexDeclaration_swigregister(XmlIndexDeclarationPtr)

class XmlQueryExpression(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XmlQueryExpression, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XmlQueryExpression, name)
    def __init__(self,*args):
        _swig_setattr(self, XmlQueryExpression, 'this', apply(_dbxml.new_XmlQueryExpression,args))
        _swig_setattr(self, XmlQueryExpression, 'thisown', 1)
    def __del__(self, destroy= _dbxml.delete_XmlQueryExpression):
        try:
            if self.thisown: destroy(self)
        except: pass
    def getQueryContext(*args): return apply(_dbxml.XmlQueryExpression_getQueryContext,args)
    def getContainer(*args): return apply(_dbxml.XmlQueryExpression_getContainer,args)
    def getXPathQuery(*args): return apply(_dbxml.XmlQueryExpression_getXPathQuery,args)
    def __repr__(self):
        return "<C XmlQueryExpression instance at %s>" % (self.this,)

class XmlQueryExpressionPtr(XmlQueryExpression):
    def __init__(self,this):
        _swig_setattr(self, XmlQueryExpression, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, XmlQueryExpression, 'thisown', 0)
        _swig_setattr(self, XmlQueryExpression,self.__class__,XmlQueryExpression)
_dbxml.XmlQueryExpression_swigregister(XmlQueryExpressionPtr)

class XmlModify(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XmlModify, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XmlModify, name)
    InsertAfter = _dbxml.XmlModify_InsertAfter
    InsertBefore = _dbxml.XmlModify_InsertBefore
    Append = _dbxml.XmlModify_Append
    Update = _dbxml.XmlModify_Update
    Remove = _dbxml.XmlModify_Remove
    Rename = _dbxml.XmlModify_Rename
    Element = _dbxml.XmlModify_Element
    Attribute = _dbxml.XmlModify_Attribute
    Text = _dbxml.XmlModify_Text
    ProcessingInstruction = _dbxml.XmlModify_ProcessingInstruction
    Comment = _dbxml.XmlModify_Comment
    def __init__(self,*args):
        _swig_setattr(self, XmlModify, 'this', apply(_dbxml.new_XmlModify,args))
        _swig_setattr(self, XmlModify, 'thisown', 1)
    def __del__(self, destroy= _dbxml.delete_XmlModify):
        try:
            if self.thisown: destroy(self)
        except: pass
    def setNewEncoding(*args): return apply(_dbxml.XmlModify_setNewEncoding,args)
    def getNumModifications(*args): return apply(_dbxml.XmlModify_getNumModifications,args)
    def __repr__(self):
        return "<C XmlModify instance at %s>" % (self.this,)

class XmlModifyPtr(XmlModify):
    def __init__(self,this):
        _swig_setattr(self, XmlModify, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, XmlModify, 'thisown', 0)
        _swig_setattr(self, XmlModify,self.__class__,XmlModify)
_dbxml.XmlModify_swigregister(XmlModifyPtr)


