<?xml version="1.0"?>
<doc>
    <assembly>
        <name>/home/patrick/workspaces/db4o_build/db4obuild/dist/mono/dll/db4o</name>
    </assembly>
    <members>
        <member name="T:com.db4o.ext.ObjectInfo">
            <summary>
            interface to the internal reference that an ObjectContainer
            holds for a stored object.
            </summary>
            <remarks>
            interface to the internal reference that an ObjectContainer
            holds for a stored object.
            </remarks></member>
        <member name="M:com.db4o.ext.ObjectInfo.getObject">
            <summary>returns the object that is referenced.</summary>
            <remarks>
            returns the object that is referenced.
            <br /><br />This method may return null, if the object has
            been garbage collected.
            </remarks>
            <returns>
            the referenced object or null, if the object has
            been garbage collected.
            </returns></member>
        <member name="M:com.db4o.ext.ObjectInfo.getUUID">
            <summary>returns a UUID representation of the referenced object.</summary>
            <remarks>
            returns a UUID representation of the referenced object.
            UUID generation has to be turned on, in order to be able
            to use this feature:
            <see cref="M:com.db4o.config.Configuration.generateUUIDs">com.db4o.config.Configuration.generateUUIDs
            	</see></remarks>
            <returns>the UUID of the referenced object.</returns></member>
        <member name="M:com.db4o.ext.ObjectInfo.getVersion">
            <summary>
            returns the transaction serial number ("version") the
            referenced object was stored with last.
            </summary>
            <remarks>
            returns the transaction serial number ("version") the
            referenced object was stored with last.
            Version number generation has to be turned on, in order to
            be able to use this feature:
            <see cref="M:com.db4o.config.Configuration.generateVersionNumbers">com.db4o.config.Configuration.generateVersionNumbers
            	</see></remarks>
            <returns>the version number.</returns></member>
        <member name="T:com.db4o.query.Evaluation">
            <summary>for implementation of callback evaluations.</summary>
            <remarks>
            for implementation of callback evaluations.
            <br /><br />
            To constrain a
            <see cref="T:com.db4o.query.Query">com.db4o.query.Query</see>
            node with your own callback
            <code>Evaluation</code>, construct an object that implements the
            <code>Evaluation</code> interface and register it by passing it
            to
            <see cref="M:com.db4o.query.Query.constrain">com.db4o.query.Query.constrain</see>
            .
            <br /><br />
            Evaluations are called as the last step during query execution,
            after all other constraints have been applied. Evaluations in higher
            level
            <see cref="T:com.db4o.query.Query">com.db4o.query.Query</see>
            nodes in the query graph are called first.
            <br /><br />Java client/server only:<br />
            db4o first attempts to use Java Serialization to allow to pass final
            variables to the server. Please make sure that all variables that are
            used within the evaluate() method are Serializable. This may include
            the class an anonymous Evaluation object is created in. If db4o is
            not successful at using Serialization, the Evaluation is transported
            to the server in a db4o MemoryFile. In this case final variables can
            not be restored.
            </remarks></member>
        <member name="M:com.db4o.query.Evaluation.evaluate(com.db4o.query.Candidate)">
            <summary>
            callback method during
            <see cref="M:com.db4o.query.Query.execute">query execution</see>
            .
            </summary>
            <param name="candidate">reference to the candidate persistent object.</param></member>
        <member name="T:com.db4o.config.ObjectConstructor">
            <summary>interface to allow instantiating objects by calling specific constructors.
            	</summary>
            <remarks>
            interface to allow instantiating objects by calling specific constructors.
            <br /><br /><b>Examples: ../com/db4o/samples/translators.</b><br /><br />
            By writing classes that implement this interface, it is possible to
            define which constructor is to be used during the instantiation of a stored object.
            <br /><br />
            Before starting a db4o session, translator classes that implement the
            <code>ObjectConstructor</code> or
            <see cref="T:com.db4o.config.ObjectTranslator">ObjectTranslator</see>
            need to be registered.<br /><br />
            Example:<br /><code>
            Configuration config = Db4o.configure();<br />
            ObjectClass oc = config.objectClass("package.className");<br />
            oc.translate(new FooTranslator());</code><br /><br /></remarks></member>
        <member name="M:com.db4o.config.ObjectConstructor.onInstantiate(com.db4o.ObjectContainer,System.Object)">
            <summary>db4o calls this method when a stored object needs to be instantiated.</summary>
            <remarks>
            db4o calls this method when a stored object needs to be instantiated.
            <br /><br /></remarks>
            <param name="container">the ObjectContainer used</param>
            <param name="storedObject">
            the object stored with
            <see cref="M:com.db4o.config.ObjectTranslator.onStore">ObjectTranslator.onStore</see>
            .
            </param>
            <returns>the instantiated object.</returns></member>
        <member name="P:Cecil.FlowAnalysis.ControlFlow.IInstructionData.StackBefore">
            <summary>
            Stack height before the execution of the related instruction.
            </summary></member>
        <member name="P:Cecil.FlowAnalysis.ControlFlow.IInstructionData.StackAfter">
            <summary>
            Stack height after the execution of the related instruction.
            </summary></member>
        <member name="T:com.db4o.TypeHandler4">
            <exclude></exclude></member>
        <member name="M:com.db4o.TypeHandler4.readArray(System.Object,com.db4o.YapWriter)">
            <summary>performance optimized read (only used for byte[] so far)</summary></member>
        <member name="M:com.db4o.TypeHandler4.writeArray(System.Object,com.db4o.YapWriter)">
            <summary>performance optimized write (only used for byte[] so far)</summary></member>
        <member name="T:com.db4o.ext.ExtObjectContainer">
            <summary>
            extended functionality for the
            <see cref="T:com.db4o.ObjectContainer">ObjectContainer</see>
            interface.
            <br /><br />Every db4o
            <see cref="T:com.db4o.ObjectContainer">ObjectContainer</see>
            always is an <code>ExtObjectContainer</code> so a cast is possible.<br /><br /><see cref="M:com.db4o.ObjectContainer.ext">com.db4o.ObjectContainer.ext</see>
            is a convenient method to perform the cast.<br /><br />
            The ObjectContainer functionality is split to two interfaces to allow newcomers to
            focus on the essential methods.
            </summary></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.backup(System.String)">
            <summary>backs up a database file of an open ObjectContainer.</summary>
            <remarks>
            backs up a database file of an open ObjectContainer.
            <br /><br />While the backup is running, the ObjectContainer can continue to be
            used. Changes that are made while the backup is in progress, will be applied to
            the open ObjectContainer and to the backup.<br /><br />
            While the backup is running, the ObjectContainer should not be closed.<br /><br />
            If a file already exists at the specified path, it will be overwritten.<br /><br /></remarks>
            <param name="path">a fully qualified path</param></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.bind(System.Object,System.Int64)">
            <summary>binds an object to an internal object ID.</summary>
            <remarks>
            binds an object to an internal object ID.
            <br /><br />This method uses the ID parameter to load the
            correspondig stored object into memory and replaces this memory
            reference with the object parameter. The method may be used to replace
            objects or to reassociate an object with it's stored instance
            after closing and opening a database file. A subsequent call to
            <see cref="M:com.db4o.ObjectContainer.set">set(Object)</see>
            is
            necessary to update the stored object.<br /><br /><b>Requirements:</b><br />- The ID needs to be a valid internal object ID,
            previously retrieved with
            <see cref="M:com.db4o.ext.ExtObjectContainer.getID">getID(Object)</see>
            .<br />
            - The object parameter needs to be of the same class as the stored object.<br /><br /></remarks>
            <seealso cref="M:com.db4o.ext.ExtObjectContainer.getID">com.db4o.ext.ExtObjectContainer.getID
            	</seealso>
            <param name="obj">the object that is to be bound</param>
            <param name="id">the internal id the object is to be bound to</param></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.collections">
            <summary>
            returns the
            <see cref="T:com.db4o.types.Db4oCollections">com.db4o.types.Db4oCollections</see>
            interface to create or modify database-aware
            collections for this
            <see cref="T:com.db4o.ObjectContainer">com.db4o.ObjectContainer</see>
            .<br /><br /></summary>
            <returns>
            the
            <see cref="T:com.db4o.types.Db4oCollections">com.db4o.types.Db4oCollections</see>
            interface for this
            <see cref="T:com.db4o.ObjectContainer">com.db4o.ObjectContainer</see>
            .
            </returns></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.configure">
            <summary>returns the Configuration context for this ObjectContainer.</summary>
            <remarks>
            returns the Configuration context for this ObjectContainer.
            <br /><br />
            Upon opening an ObjectContainer with any of the factory methods in the
            <see cref="T:com.db4o.Db4o">Db4o class</see>
            , the global
            <see cref="T:com.db4o.config.Configuration">Configuration</see>
            context
            is copied into the ObjectContainer. The
            <see cref="T:com.db4o.config.Configuration">Configuration</see>
            can be modified individually for
            each ObjectContainer without any effects on the global settings.<br /><br /></remarks>
            <returns>
                <see cref="T:com.db4o.config.Configuration">Configuration</see>
            the Configuration
            context for this ObjectContainer
            </returns>
            <seealso cref="M:com.db4o.Db4o.configure">com.db4o.Db4o.configure</seealso></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.getByID(System.Int64)">
            <summary>returns the stored object for an internal ID.</summary>
            <remarks>
            returns the stored object for an internal ID.
            <br /><br />This is the fastest method for direct access to objects. Internal
            IDs can be obtained with
            <see cref="M:com.db4o.ext.ExtObjectContainer.getID">getID(Object)</see>
            .
            Objects will not be activated by this method. They will be returned in the
            activation state they are currently in, in the local cache.<br /><br /></remarks>
            <param name="ID">the internal ID</param>
            <returns>
            the object associated with the passed ID or <code>null</code>,
            if no object is associated with this ID in this <code>ObjectContainer</code>.
            </returns>
            <seealso cref="M:com.db4o.config.Configuration.activationDepth">Why activation?</seealso></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.getByUUID(com.db4o.ext.Db4oUUID)">
            <summary>
            returns a stored object for a
            <see cref="T:com.db4o.ext.Db4oUUID">com.db4o.ext.Db4oUUID</see>
            .
            <br /><br />
            This method is intended for replication and for long-term
            external references to objects. To get a
            <see cref="T:com.db4o.ext.Db4oUUID">com.db4o.ext.Db4oUUID</see>
            for an
            object use
            <see cref="M:com.db4o.ext.ExtObjectContainer.getObjectInfo">com.db4o.ext.ExtObjectContainer.getObjectInfo
            	</see>
            and
            <see cref="M:com.db4o.ext.ObjectInfo.getUUID">com.db4o.ext.ObjectInfo.getUUID</see>
            .<br /><br />
            Objects will not be activated by this method. They will be returned in the
            activation state they are currently in, in the local cache.<br /><br /></summary>
            <param name="uuid">the UUID</param>
            <returns>the object for the UUID</returns>
            <seealso cref="M:com.db4o.config.Configuration.activationDepth">Why activation?</seealso></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.getID(System.Object)">
            <summary>returns the internal unique object ID.</summary>
            <remarks>
            returns the internal unique object ID.
            <br /><br />db4o assigns an internal ID to every object that is stored. IDs are
            guaranteed to be unique within one <code>ObjectContainer</code>.
            An object carries the same ID in every db4o session. Internal IDs can
            be used to look up objects with the very fast
            <see cref="M:com.db4o.ext.ExtObjectContainer.getByID">getByID</see>
            method.<br /><br />
            Internal IDs will change when a database is defragmented. Use
            <see cref="M:com.db4o.ext.ExtObjectContainer.getObjectInfo">com.db4o.ext.ExtObjectContainer.getObjectInfo
            	</see>
            ,
            <see cref="M:com.db4o.ext.ObjectInfo.getUUID">com.db4o.ext.ObjectInfo.getUUID</see>
            and
            <see cref="M:com.db4o.ext.ExtObjectContainer.getByUUID">com.db4o.ext.ExtObjectContainer.getByUUID
            	</see>
            for long-term external references to
            objects.<br /><br /></remarks>
            <param name="obj">any object</param>
            <returns>
            the associated internal ID or <code>0</code>, if the passed
            object is not stored in this <code>ObjectContainer</code>.
            </returns></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.getObjectInfo(System.Object)">
            <summary>
            returns the
            <see cref="T:com.db4o.ext.ObjectInfo">com.db4o.ext.ObjectInfo</see>
            for a stored object.
            <br /><br />This method will return null, if the passed
            object is not stored to this <code>ObjectContainer</code>.<br /><br /></summary>
            <param name="obj">the stored object</param>
            <returns>
            the
            <see cref="T:com.db4o.ext.ObjectInfo">com.db4o.ext.ObjectInfo</see></returns></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.identity">
            <summary>
            returns the
            <see cref="T:com.db4o.ext.Db4oDatabase">com.db4o.ext.Db4oDatabase</see>
            object for this ObjectContainer.
            </summary>
            <returns></returns></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.isActive(System.Object)">
            <summary>tests if an object is activated.</summary>
            <remarks>
            tests if an object is activated.
            <br /><br /><code>isActive</code> returns <code>false</code> if an object is not
            stored within the <code>ObjectContainer</code>.<br /><br /></remarks>
            <param name="obj">to be tested<br /><br /></param>
            <returns>
                <code>true</code> if the passed object is active.</returns></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.isCached(System.Int64)">
            <summary>tests if an object with this ID is currently cached.</summary>
            <remarks>
            tests if an object with this ID is currently cached.
            <br /><br /></remarks>
            <param name="ID">the internal ID</param></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.isClosed">
            <summary>tests if this <code>ObjectContainer</code> is closed.</summary>
            <remarks>
            tests if this <code>ObjectContainer</code> is closed.
            <br /><br /></remarks>
            <returns>
                <code>true</code> if this <code>ObjectContainer</code> is closed.</returns></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.isStored(System.Object)">
            <summary>tests if an object is stored in this <code>ObjectContainer</code>.</summary>
            <remarks>
            tests if an object is stored in this <code>ObjectContainer</code>.
            <br /><br /></remarks>
            <param name="obj">to be tested<br /><br /></param>
            <returns>
                <code>true</code> if the passed object is stored.</returns></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.knownClasses">
            <summary>
            returns all class representations that are known to this
            ObjectContainer because they have been used or stored.
            </summary>
            <remarks>
            returns all class representations that are known to this
            ObjectContainer because they have been used or stored.
            </remarks>
            <returns>
            all class representations that are known to this
            ObjectContainer because they have been used or stored.
            </returns></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.Lock">
            <summary>returns the main synchronisation lock.</summary>
            <remarks>
            returns the main synchronisation lock.
            <br /><br />
            Synchronize over this object to ensure exclusive access to
            the ObjectContainer.<br /><br />
            Handle the use of this functionality with extreme care,
            since deadlocks can be produced with just two lines of code.
            </remarks>
            <returns>Object the ObjectContainer lock object</returns></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.migrateFrom(com.db4o.ObjectContainer)">
            <summary>aids migration of objects between ObjectContainers.</summary>
            <remarks>
            aids migration of objects between ObjectContainers.
            <br /><br />When objects are migrated from one ObjectContainer to another, it is
            desirable to preserve virtual object attributes such as the object version number
            or the UUID. Use this method to signal to an ObjectContainer that it should read
            existing version numbers and UUIDs from another ObjectContainer. This method should
            also be used during the Defragment. It is included in the default
            implementation supplied in Defragment.java/Defragment.cs.<br /><br /></remarks>
            <param name="objectContainer">
            the
            <see cref="T:com.db4o.ObjectContainer">com.db4o.ObjectContainer</see>
            objects are to be migrated
            from or <code>null</code> to denote that migration is completed.
            </param></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.peekPersisted(System.Object,System.Int32,System.Boolean)">
            <summary>
            returns a transient copy of a persistent object with all members set
            to the values that are currently stored to the database.
            </summary>
            <remarks>
            returns a transient copy of a persistent object with all members set
            to the values that are currently stored to the database.
            <br /><br />
            The returned objects have no connection to the database.<br /><br />
            With the <code>committed</code> parameter it is possible to specify,
            whether the desired object should contain the committed values or the
            values that were set by the running transaction with
            <see cref="M:com.db4o.ObjectContainer.set">com.db4o.ObjectContainer.set</see>
            .
            <br /><br />A possible usecase for this feature:<br />
            An application might want to check all changes applied to an object
            by the running transaction.<br /><br /></remarks>
            <param name="_object">the object that is to be cloned</param>
            <param name="depth">the member depth to which the object is to be instantiated</param>
            <param name="committed">whether committed or set values are to be returned</param>
            <returns>the object</returns></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.purge">
            <summary>unloads all clean indices from memory and frees unused objects.</summary>
            <remarks>
            unloads all clean indices from memory and frees unused objects.
            <br /><br />Call commit() and purge() consecutively to achieve the best
            result possible. This method can have a negative impact
            on performance since indices will have to be reread before further
            inserts, updates or queries can take place.
            </remarks></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.purge(System.Object)">
            <summary>unloads a specific object from the db4o reference mechanism.</summary>
            <remarks>
            unloads a specific object from the db4o reference mechanism.
            <br /><br />db4o keeps references to all newly stored and
            instantiated objects in memory, to be able to manage object identities.
            <br /><br />With calls to this method it is possible to remove an object from the
            reference mechanism, to allow it to be garbage collected. You are not required to
            call this method in the .NET and JDK 1.2 versions, since objects are
            referred to by weak references and garbage collection happens
            automatically.<br /><br />An object removed with  <code>purge(Object)</code> is not
            "known" to the <code>ObjectContainer</code> afterwards, so this method may also be
            used to create multiple copies of  objects.<br /><br /><code>purge(Object)</code> has
            no influence on the persistence state of objects. "Purged" objects can be
            reretrieved with queries.<br /><br /></remarks>
            <param name="obj">the object to be removed from the reference mechanism.</param></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.reflector">
            <summary>Return the reflector currently being used by db4objects.</summary>
            <remarks>Return the reflector currently being used by db4objects.</remarks>
            <returns>the current Reflector.</returns></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.refresh(System.Object,System.Int32)">
            <summary>refreshs all members on a stored object to the specified depth.</summary>
            <remarks>
            refreshs all members on a stored object to the specified depth.
            <br /><br />If a member object is not activated, it will be activated by this method.
            <br /><br />The isolation used is READ COMMITTED. This method will read all objects
            and values that have been committed by other transactions.<br /><br /></remarks>
            <param name="obj">the object to be refreshed.</param>
            <param name="depth">
            the member
            <see cref="M:com.db4o.config.Configuration.activationDepth">depth</see>
            to which refresh is to cascade.
            </param></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.releaseSemaphore(System.String)">
            <summary>releases a semaphore, if the calling transaction is the owner.</summary>
            <remarks>releases a semaphore, if the calling transaction is the owner.</remarks>
            <param name="name">the name of the semaphore to be released.</param></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.replicationBegin(com.db4o.ObjectContainer,com.db4o.replication.ReplicationConflictHandler)">
            <summary>
            prepares for replication with another
            <see cref="T:com.db4o.ObjectContainer">com.db4o.ObjectContainer</see>
            .
            <br /><br />An
            <see cref="T:com.db4o.ObjectContainer">com.db4o.ObjectContainer</see>
            can only be involved in a replication
            process with one other
            <see cref="T:com.db4o.ObjectContainer">com.db4o.ObjectContainer</see>
            at the same time.<br /><br />
            The returned
            <see cref="T:com.db4o.replication.ReplicationProcess">com.db4o.replication.ReplicationProcess
            	</see>
            interface provides methods to commit
            and to cancel the replication process.
            <br /><br />This ObjectContainer will be "peerA" for the
            returned ReplicationProcess. The other ObjectContainer will be "peerB".
            </summary>
            <param name="peerB">
            the
            <see cref="T:com.db4o.ObjectContainer">com.db4o.ObjectContainer</see>
            to replicate with.
            </param>
            <param name="conflictHandler">
            the conflict handler for this ReplicationProcess.
            Conflicts occur
            whenever
            <see cref="M:com.db4o.replication.ReplicationProcess.replicate">com.db4o.replication.ReplicationProcess.replicate
            	</see>
            is called with an
            object that was modified in both ObjectContainers since the last
            replication run between the two. Upon a conflict the
            <see cref="M:com.db4o.replication.ReplicationConflictHandler.resolveConflict">com.db4o.replication.ReplicationConflictHandler.resolveConflict
            	</see>
            method will be called in the conflict handler.
            </param>
            <returns>
            the
            <see cref="T:com.db4o.replication.ReplicationProcess">com.db4o.replication.ReplicationProcess
            	</see>
            interface for this replication process.
            </returns></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.set(System.Object,System.Int32)">
            <summary>deep update interface to store or update objects.</summary>
            <remarks>
            deep update interface to store or update objects.
            <br /><br />In addition to the normal storage interface,
            <see cref="M:com.db4o.ObjectContainer.set">ObjectContainer#set(Object)</see>
            ,
            this method allows a manual specification of the depth, the passed object is to be updated.<br /><br /></remarks>
            <param name="obj">the object to be stored or updated.</param>
            <param name="depth">the depth to which the object is to be updated</param>
            <seealso cref="M:com.db4o.ObjectContainer.set">com.db4o.ObjectContainer.set</seealso></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.setSemaphore(System.String,System.Int32)">
            <summary>attempts to set a semaphore.</summary>
            <remarks>
            attempts to set a semaphore.
            <br /><br />
            Semaphores are transient multi-purpose named flags for
            <see cref="T:com.db4o.ObjectContainer">ObjectContainers</see>
            .
            <br /><br />
            A transaction that successfully sets a semaphore becomes
            the owner of the semaphore. Semaphores can only be owned
            by a single transaction at one point in time.<br /><br />
            This method returns true, if the transaction already owned
            the semaphore before the method call or if it successfully
            acquires ownership of the semaphore.<br /><br />
            The waitForAvailability parameter allows to specify a time
            in milliseconds to wait for other transactions to release
            the semaphore, in case the semaphore is already owned by
            another transaction.<br /><br />
            Semaphores are released by the first occurence of one of the
            following:<br />
            - the transaction releases the semaphore with
            <see cref="M:com.db4o.ext.ExtObjectContainer.releaseSemaphore">com.db4o.ext.ExtObjectContainer.releaseSemaphore
            	</see><br /> - the transaction is closed with
            <see cref="M:com.db4o.ObjectContainer.close">com.db4o.ObjectContainer.close</see><br /> - C/S only: the corresponding
            <see cref="T:com.db4o.ObjectServer">com.db4o.ObjectServer</see>
            is
            closed.<br /> - C/S only: the client
            <see cref="T:com.db4o.ObjectContainer">com.db4o.ObjectContainer</see>
            looses the connection and is timed
            out.<br /><br /> Semaphores are set immediately. They are independant of calling
            <see cref="M:com.db4o.ObjectContainer.commit">com.db4o.ObjectContainer.commit</see>
            or
            <see cref="M:com.db4o.ObjectContainer.rollback">com.db4o.ObjectContainer.rollback</see>
            .<br /><br /><b>Possible usecases
            for semaphores:</b><br /> - prevent other clients from inserting a singleton at the same time.
            A suggested name for the semaphore:  "SINGLETON_" + Object#getClass().getName().<br />  - lock
            objects. A suggested name:   "LOCK_" +
            <see cref="M:com.db4o.ext.ExtObjectContainer.getID">getID(Object)</see><br /> -
            generate a unique client ID. A suggested name:  "CLIENT_" +
            System.currentTimeMillis().<br /><br /></remarks>
            <param name="name">the name of the semaphore to be set</param>
            <param name="waitForAvailability">
            the time in milliseconds to wait for other
            transactions to release the semaphore. The parameter may be zero, if
            the method is to return immediately.
            </param>
            <returns>
            boolean flag
            <br /><code>true</code>, if the semaphore could be set or if the
            calling transaction already owned the semaphore.
            <br /><code>false</code>, if the semaphore is owned by another
            transaction.
            </returns></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.storedClass(System.Object)">
            <summary>
            returns a
            <see cref="T:com.db4o.ext.StoredClass">com.db4o.ext.StoredClass</see>
            meta information object.
            <br /><br />
            There are three options how to use this method.<br />
            Any of the following parameters are possible:<br />
            - a fully qualified classname.<br />
            - a Class object.<br />
            - any object to be used as a template.<br /><br /></summary>
            <param name="clazz">class name, Class object, or example object.<br /><br /></param>
            <returns>
            an instance of an
            <see cref="T:com.db4o.ext.StoredClass">com.db4o.ext.StoredClass</see>
            meta information object.
            </returns></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.storedClasses">
            <summary>
            returns an array of all
            <see cref="T:com.db4o.ext.StoredClass">com.db4o.ext.StoredClass</see>
            meta information objects.
            </summary></member>
        <member name="M:com.db4o.ext.ExtObjectContainer.version">
            <summary>returns the current transaction serial number.</summary>
            <remarks>
            returns the current transaction serial number.
            <br /><br />This serial number can be used to query for modified objects
            and for replication purposes.
            </remarks>
            <returns>the current transaction serial number.</returns></member>
        <member name="T:com.db4o.config.ObjectAttribute">
            <summary>generic interface to allow returning an attribute of an object.</summary>
            <remarks>generic interface to allow returning an attribute of an object.</remarks></member>
        <member name="M:com.db4o.config.ObjectAttribute.attribute(System.Object)">
            <summary>generic method to return an attribute of a parent object.</summary>
            <remarks>generic method to return an attribute of a parent object.</remarks>
            <param name="parent">the parent object</param>
            <returns>Object - the attribute</returns></member>
        <member name="T:com.db4o.query.Query">
            <summary>handle to a node in a S.O.D.A.</summary>
            <remarks>
            handle to a node in a S.O.D.A. query graph.
            <br /><br />
            A node in the query graph can represent multiple
            classes, one class or an attribute of a class.<br /><br />The graph
            is automatically extended with attributes of added constraints
            (see
            <see cref="M:com.db4o.query.Query.constrain">com.db4o.query.Query.constrain</see>
            ) and upon calls to
            <see cref="M:com.db4o.query.Query.descend">com.db4o.query.Query.descend</see>
            that request nodes that do not yet exist.
            <br /><br />
            References to joined nodes in the query graph can be obtained
            by "walking" along the nodes of the graph with the method
            <see cref="M:com.db4o.query.Query.descend">com.db4o.query.Query.descend</see>
            .
            <br /><br /><see cref="M:com.db4o.query.Query.execute">com.db4o.query.Query.execute</see>
            evaluates the entire graph against all persistent objects.
            <br /><br /><see cref="M:com.db4o.query.Query.execute">com.db4o.query.Query.execute</see>
            can be called from any
            <see cref="T:com.db4o.query.Query">com.db4o.query.Query</see>
            node
            of the graph. It will return an
            <see cref="T:com.db4o.ObjectSet">com.db4o.ObjectSet</see>
            filled with
            objects of the class/classes that the node, it was called from,
            represents.<br /><br /><b>Note:<br /><see cref="T:com.db4o.query.Predicate">Native queries</see>
            are the recommended main query
            interface of db4o.</b></remarks></member>
        <member name="M:com.db4o.query.Query.constrain(System.Object)">
            <summary>adds a constraint to this node.</summary>
            <remarks>
            adds a constraint to this node.
            <br /><br />
            If the constraint contains attributes that are not yet
            present in the query graph, the query graph is extended
            accordingly.
            <br /><br />
            Special behaviour for:
            <ul>
                    <li> class
            <see cref="T:j4o.lang.Class">j4o.lang.Class</see>
            : confine the result to objects of one
            class or to objects implementing an interface.</li>
                    <li> interface
            <see cref="T:com.db4o.query.Evaluation">com.db4o.query.Evaluation</see>
            : run
            evaluation callbacks against all candidates.</li>
                </ul></remarks>
            <param name="constraint">the constraint to be added to this Query.</param>
            <returns>
                <see cref="T:com.db4o.query.Constraint">com.db4o.query.Constraint</see>
            a new
            <see cref="T:com.db4o.query.Constraint">com.db4o.query.Constraint</see>
            for this
            query node or <code>null</code> for objects implementing the
            <see cref="T:com.db4o.query.Evaluation">com.db4o.query.Evaluation</see>
            interface.
            </returns></member>
        <member name="M:com.db4o.query.Query.constraints">
            <summary>
            returns a
            <see cref="T:com.db4o.query.Constraints">com.db4o.query.Constraints</see>
            object that holds an array of all constraints on this node.
            </summary>
            <returns>
                <see cref="T:com.db4o.query.Constraints">com.db4o.query.Constraints</see>
            on this query node.
            </returns></member>
        <member name="M:com.db4o.query.Query.descend(System.String)">
            <summary>returns a reference to a descendant node in the query graph.</summary>
            <remarks>
            returns a reference to a descendant node in the query graph.
            <br /><br />If the node does not exist, it will be created.
            <br /><br />
            All classes represented in the query node are tested, whether
            they contain a field with the specified field name. The
            descendant Query node will be created from all possible candidate
            classes.
            </remarks>
            <param name="fieldName">path to the descendant.</param>
            <returns>
            descendant
            <see cref="T:com.db4o.query.Query">com.db4o.query.Query</see>
            node
            </returns></member>
        <member name="M:com.db4o.query.Query.execute">
            <summary>
            executes the
            <see cref="T:com.db4o.query.Query">com.db4o.query.Query</see>
            .
            </summary>
            <returns>
                <see cref="T:com.db4o.ObjectSet">com.db4o.ObjectSet</see>
            - the result of the
            <see cref="T:com.db4o.query.Query">com.db4o.query.Query</see>
            .
            </returns></member>
        <member name="M:com.db4o.query.Query.orderAscending">
            <summary>
            adds an ascending ordering criteria to this node of
            the query graph.
            </summary>
            <remarks>
            adds an ascending ordering criteria to this node of
            the query graph. Multiple ordering criteria will be applied
            in the order they were called.
            </remarks>
            <returns>
            this
            <see cref="T:com.db4o.query.Query">com.db4o.query.Query</see>
            object to allow the chaining of method calls.
            </returns></member>
        <member name="M:com.db4o.query.Query.orderDescending">
            <summary>
            adds a descending order criteria to this node of
            the query graph.
            </summary>
            <remarks>
            adds a descending order criteria to this node of
            the query graph. Multiple ordering criteria will be applied
            in the order they were called.
            </remarks>
            <returns>
            this
            <see cref="T:com.db4o.query.Query">com.db4o.query.Query</see>
            object to allow the chaining of method calls.
            </returns></member>
        <member name="P:Cecil.FlowAnalysis.ActionFlow.IActionFlowGraph.ControlFlowGraph">
            <summary>
            The control flow graph upon which this action flow graph
            was built.
            </summary></member>
        <member name="P:Cecil.FlowAnalysis.ActionFlow.IActionFlowGraph.Blocks">
            <summary>
            Action blocks.
            </summary></member>
        <member name="M:Cecil.FlowAnalysis.ActionFlow.IActionFlowGraph.IsBranchTarget(Cecil.FlowAnalysis.ActionFlow.IActionBlock)">
            <summary>
            Checks if the specified block is the target of
            a branch or conditional branch block (only the Then path
            is considered).
            </summary>
            <param name="block">a block</param>
            <returns>true if the block is the target of a branch</returns></member>
        <member name="T:com.db4o.reflect.ReflectMethod">
            <summary>representation for java.lang.reflect.Method.</summary>
            <remarks>
            representation for java.lang.reflect.Method.
            <br /><br />See the respective documentation in the JDK API.
            </remarks>
            <seealso cref="T:com.db4o.reflect.Reflector">com.db4o.reflect.Reflector</seealso></member>
        <member name="T:com.db4o.reflect.ReflectConstructor">
            <summary>representation for java.lang.reflect.Constructor.</summary>
            <remarks>
            representation for java.lang.reflect.Constructor.
            <br /><br />See the respective documentation in the JDK API.
            </remarks>
            <seealso cref="T:com.db4o.reflect.Reflector">com.db4o.reflect.Reflector</seealso></member>
        <member name="T:com.db4o.Db4oTypeImpl">
            <summary>marker interface for special db4o datatypes</summary></member>
        <member name="T:com.db4o.ext.Db4oCallback">
            <summary>generic callback interface.</summary>
            <remarks>generic callback interface.</remarks></member>
        <member name="M:com.db4o.ext.Db4oCallback.callback(System.Object)">
            <summary>the callback method</summary>
            <param name="obj">the object passed to the callback method</param></member>
        <member name="T:com.db4o.ext.ExtObjectSet">
            <summary>
            extended functionality for the
            <see cref="T:com.db4o.ObjectSet">ObjectSet</see>
            interface.
            <br /><br />Every db4o
            <see cref="T:com.db4o.ObjectSet">ObjectSet</see>
            always is an ExtObjectSet so a cast is possible.<br /><br /><see cref="M:com.db4o.ObjectSet.ext">com.db4o.ObjectSet.ext</see>
            is a convenient method to perform the cast.<br /><br />
            The ObjectSet functionality is split to two interfaces to allow newcomers to
            focus on the essential methods.
            </summary></member>
        <member name="M:com.db4o.ext.ExtObjectSet.getIDs">
            <summary>returns an array of internal IDs that correspond to the contained objects.
            	</summary>
            <remarks>
            returns an array of internal IDs that correspond to the contained objects.
            <br /><br /></remarks>
            <seealso cref="M:com.db4o.ext.ExtObjectContainer.getID">com.db4o.ext.ExtObjectContainer.getID
            	</seealso>
            <seealso cref="M:com.db4o.ext.ExtObjectContainer.getByID">com.db4o.ext.ExtObjectContainer.getByID
            	</seealso></member>
        <member name="M:com.db4o.ext.ExtObjectSet.get(System.Int32)">
            <summary>returns the item at position [index] in this ObjectSet.</summary>
            <remarks>
            returns the item at position [index] in this ObjectSet.
            <br /><br />
            The object will be activated.
            </remarks>
            <param name="index">the index position in this ObjectSet.</param>
            <returns>the activated object.</returns></member>
        <member name="T:com.db4o.inside.ix.Indexable4">
            <exclude></exclude></member>
        <member name="T:com.db4o.Readable">
            <exclude></exclude></member>
        <member name="T:com.db4o.config.Configuration">
            <summary>configuration interface.</summary>
            <remarks>
            configuration interface.
            <br /><br />This interface contains methods to configure db4o.<br /><br />
            The global Configuration context is available with
            <see cref="M:com.db4o.Db4o.configure">com.db4o.Db4o.configure</see>
            .
            When an ObjectContainer or ObjectServer is opened, the global Configuration
            context is cloned and copied into the ObjectContainer/ObjectServer.
            That means every ObjectContainer/ObjectServer gets it's own copy of
            configuration settings.<br /><br /><b>Most configuration settings should be set before opening an
            ObjectContainer/ObjectServer</b>.
            <br /><br />Some configuration settings can be modified on an open
            ObjectContainer/ObjectServer. The local Configuration context is
            available with
            <see cref="M:com.db4o.ext.ExtObjectContainer.configure">com.db4o.ext.ExtObjectContainer.configure
            	</see>
            and
            <see cref="M:com.db4o.ext.ExtObjectServer.configure">com.db4o.ext.ExtObjectServer.configure
            	</see>
            .
            </remarks></member>
        <member name="M:com.db4o.config.Configuration.activationDepth(System.Int32)">
            <summary>sets the activation depth to the specified value.</summary>
            <remarks>
            sets the activation depth to the specified value.
            <br /><br /><b>Why activation?</b><br />
            When objects are instantiated from the database, the instantiation of member
            objects needs to be limited to a certain depth. Otherwise a single object
            could lead to loading the complete database into memory, if all objects where
            reachable from a single root object.<br /><br />
            db4o uses the concept "depth", the number of field-to-field hops an object
            is away from another object. <b>The preconfigured "activation depth" db4o uses
            in the default setting is 5.</b><br /><br />Whenever an application iterates through the
            <see cref="T:com.db4o.ObjectSet">ObjectSet</see>
            of a query result, the result objects
            will be activated to the configured activation depth.<br /><br />
            A concrete example with the preconfigured activation depth of 5:<br /><pre>
            // Object foo is the result of a query, it is delivered by the ObjectSet
            Object foo = objectSet.next();</pre>
            foo.member1.member2.member3.member4.member5 will be a valid object<br />
            foo, member1, member2, member3 and member4 will be activated<br />
            member5 will be deactivated, all of it's members will be null<br />
            member5 can be activated at any time by calling
            <see cref="M:com.db4o.ObjectContainer.activate">ObjectContainer#activate(member5, depth)
            	</see>
            .
            <br /><br />
            Note that raising the global activation depth will consume more memory and
            have negative effects on the performance of first-time retrievals. Lowering
            the global activation depth needs more individual activation work but can
            increase performance of queries.<br /><br /><see cref="M:com.db4o.ObjectContainer.deactivate">ObjectContainer#deactivate(Object, depth)
            	</see>
            can be used to manually free memory by deactivating objects.<br /><br /></remarks>
            <param name="depth">the desired global activation depth.</param>
            <seealso cref="M:com.db4o.config.ObjectClass.maximumActivationDepth">configuring classes individually
            	</seealso></member>
        <member name="M:com.db4o.config.Configuration.automaticShutDown(System.Boolean)">
            <summary>turns automatic shutdown of the engine on and off.</summary>
            <remarks>
            turns automatic shutdown of the engine on and off.
            <br /><br />Depending on the JDK, db4o uses one of the following
            two methods to shut down, if no more references to the ObjectContainer
            are being held or the JVM terminates:<br />
            - JDK 1.3 and above: <code>Runtime.addShutdownHook()</code><br />
            - JDK 1.2 and below: <code>System.runFinalizersOnExit(true)</code> and code
            in the finalizer.<br /><br />
            Some JVMs have severe problems with both methods. For these rare cases the
            autoShutDown feature may be turned off.<br /><br />
            The default and recommended setting is <code>true</code>.<br /><br /></remarks>
            <param name="flag">whether db4o should shut down automatically.</param></member>
        <member name="M:com.db4o.config.Configuration.blockSize(System.Int32)">
            <summary>sets the storage data blocksize for new ObjectContainers.</summary>
            <remarks>
            sets the storage data blocksize for new ObjectContainers.
            <br /><br />The standard setting is 1 allowing for a maximum
            database file size of 2GB. This value can be increased
            to allow larger database files, although some space will
            be lost to padding because the size of some stored objects
            will not be an exact multiple of the block size. A
            recommended setting for large database files is 8, since
            internal pointers have this length.
            </remarks>
            <param name="bytes">the size in bytes from 1 to 127</param></member>
        <member name="M:com.db4o.config.Configuration.callbacks(System.Boolean)">
            <summary>turns callback methods on and off.</summary>
            <remarks>
            turns callback methods on and off.
            <br /><br />Callbacks are turned on by default.<br /><br />
            A tuning hint: If callbacks are not used, you can turn this feature off, to
            prevent db4o from looking for callback methods in persistent classes. This will
            increase the performance on system startup.<br /><br /></remarks>
            <param name="flag">false to turn callback methods off</param>
            <seealso cref="T:com.db4o.ext.ObjectCallbacks">Using callbacks</seealso></member>
        <member name="M:com.db4o.config.Configuration.callConstructors(System.Boolean)">
            <summary>
            advises db4o to try instantiating objects with/without calling
            constructors.
            </summary>
            <remarks>
            advises db4o to try instantiating objects with/without calling
            constructors.
            <br /><br />
            Not all JDKs / .NET-environments support this feature. db4o will
            attempt, to follow the setting as good as the enviroment supports.
            In doing so, it may call implementation-specific features like
            sun.reflect.ReflectionFactory#newConstructorForSerialization on the
            Sun Java 1.4.x/5 VM (not available on other VMs) and
            FormatterServices.GetUninitializedObject() on
            the .NET framework (not available on CompactFramework).
            This setting may also be overridden for individual classes in
            <see cref="M:com.db4o.config.ObjectClass.callConstructor">com.db4o.config.ObjectClass.callConstructor
            	</see>
            .
            <br /><br />The default setting depends on the features supported by your current environment.
            <br /><br /></remarks>
            <param name="flag">
            - specify true, to request calling constructors, specify
            false to request <b>not</b> calling constructors.
            </param>
            <seealso cref="M:com.db4o.config.ObjectClass.callConstructor">com.db4o.config.ObjectClass.callConstructor
            	</seealso></member>
        <member name="M:com.db4o.config.Configuration.classActivationDepthConfigurable(System.Boolean)">
            <summary>
            turns
            <see cref="M:com.db4o.config.ObjectClass.maximumActivationDepth">individual class activation depth configuration
            	</see>
            on
            and off.
            <br /><br />This feature is turned on by default.<br /><br /></summary>
            <param name="flag">
            false to turn the possibility to individually configure class
            activation depths off
            </param>
            <seealso cref="M:com.db4o.config.Configuration.activationDepth">Why activation?</seealso></member>
        <member name="M:com.db4o.config.Configuration.detectSchemaChanges(System.Boolean)">
            <summary>
            tuning feature: configures whether db4o checks all persistent classes upon system
            startup, for added or removed fields.
            </summary>
            <remarks>
            tuning feature: configures whether db4o checks all persistent classes upon system
            startup, for added or removed fields.
            <br /><br />In a production environment this setting can be set to <code>false</code>,
            if all necessary classes have been stored to the database file and none of them
            have been modified since the last use.
            <br /><br />Default value:<br /><code>true</code></remarks>
            <param name="flag">the desired setting</param></member>
        <member name="M:com.db4o.config.Configuration.disableCommitRecovery">
            <summary>turns commit recovery off.</summary>
            <remarks>
            turns commit recovery off.
            <br /><br />db4o uses a two-phase commit algorithm. In a first step all intended
            changes are written to a free place in the database file, the "transaction commit
            record". In a second step the
            actual changes are performed. If the system breaks down during commit, the
            commit process is restarted when the database file is opened the next time.
            On very rare occasions (possibilities: hardware failure or editing the database
            file with an external tool) the transaction commit record may be broken. In this
            case, this method can be used to try to open the database file without commit
            recovery. The method should only be used in emergency situations after consulting
            db4o support.
            </remarks></member>
        <member name="M:com.db4o.config.Configuration.discardFreeSpace(System.Int32)">
            <summary>
            tuning feature: configures the minimum size of free space slots in the database file
            that are to be reused.
            </summary>
            <remarks>
            tuning feature: configures the minimum size of free space slots in the database file
            that are to be reused.
            <br /><br />When objects are updated or deleted, the space previously occupied in the
            database file is marked as "free", so it can be reused. db4o maintains two lists
            in RAM, sorted by address and by size. Adjacent entries are merged. After a large
            number of updates or deletes have been executed, the lists can become large, causing
            RAM consumption and performance loss for maintenance. With this method you can
            specify an upper bound for the byte slot size to discard.
            <br /><br />Pass <code>Integer.MAX_VALUE</code> to this method to discard all free slots for
            the best possible startup time.<br /><br />
            The downside of setting this value: Database files will necessarily grow faster.
            <br /><br />Default value:<br /><code>0</code> all space is reused
            </remarks>
            <param name="byteCount">Slots with this size or smaller will be lost.</param>
            <deprecated>please call Db4o.configure().freespace().discardSmallerThan()</deprecated></member>
        <member name="M:com.db4o.config.Configuration.encrypt(System.Boolean)">
            <summary>configures the use of encryption.</summary>
            <remarks>
            configures the use of encryption.
            <br /><br />This method needs to be called <b>before</b> a database file
            is created with the first
            <see cref="M:com.db4o.Db4o.openFile">Db4o.openFile()</see>
            .
            <br /><br />If encryption is set to true,
            you need to supply a password to seed the encryption mechanism.<br /><br />
            db4o database files keep their encryption format after creation.<br /><br /></remarks>
            <param name="flag">
            true for turning encryption on, false for turning encryption
            off.
            </param>
            <seealso cref="M:com.db4o.config.Configuration.password">com.db4o.config.Configuration.password
            	</seealso></member>
        <member name="M:com.db4o.config.Configuration.exceptionsOnNotStorable(System.Boolean)">
            <summary>configures whether Exceptions are to be thrown, if objects can not be stored.
            	</summary>
            <remarks>
            configures whether Exceptions are to be thrown, if objects can not be stored.
            <br /><br />db4o requires the presence of a constructor that can be used to
            instantiate objects. If no default public constructor is present, all
            available constructors are tested, whether an instance of the class can
            be instantiated. Null is passed to all constructor parameters.
            The first constructor that is successfully tested will
            be used throughout the running db4o session. If an instance of the class
            can not be instantiated, the object will not be stored. By default,
            execution will continue without any message or error. This method can
            be used to configure db4o to throw an
            <see cref="T:com.db4o.ext.ObjectNotStorableException">ObjectNotStorableException</see>
            if an object can not be stored.
            <br /><br />
            The default for this setting is <b>false</b>.<br /><br /></remarks>
            <param name="flag">true to throw Exceptions if objects can not be stored.</param></member>
        <member name="M:com.db4o.config.Configuration.flushFileBuffers(System.Boolean)">
            <summary>configures file buffers to be flushed during transaction commits.</summary>
            <remarks>
            configures file buffers to be flushed during transaction commits.
            <br /><br />
            db4o uses a resume-commit-on-crash strategy to ensure ACID transactions.
            When a transaction commits,<br />
            - (1) a list "pointers that are to be modified" is written to the database file,<br />
            - (2) the database file is switched into "in-commit" mode, <br />
            - (3) the pointers are actually modified in the database file,<br />
            - (4) the database file is switched to "not-in-commit" mode.<br />
            If the system is halted by a hardware or power failure <br />
            - before (2)<br />
            all objects will be available as before the commit<br />
            - between (2) and (4)
            the commit is restarted when the database file is opened the next time, all pointers
            will be read from the "pointers to be modified" list and all of them will be modified
            to the state they are intended to have after commit<br />
            - after (4)
            no work is necessary, the transaction is committed.
            <br /><br />
            In order for the above to be 100% failsafe, the order of writes to the
            storage medium has to be obeyed. On operating systems that use in-memory
            file caching, the OS cache may revert the order of writes to optimize
            file performance. db4o can enforce the correct order by flushing file
            buffers after every single one of the above steps during transaction
            commit. Flush calls have a strong impact on performance. This is why
            the default setting for this configuration switch is false. On operating
            systems that cache file access, this configuration has to be set to true
            to ensure ACID transactions for hardware-, power- or operating system failures.
            </remarks>
            <param name="flag">true for flushing file buffers</param></member>
        <member name="M:com.db4o.config.Configuration.freespace">
            <summary>returns the freespace configuration interface</summary>
            <returns>the freespace configuration interface</returns></member>
        <member name="M:com.db4o.config.Configuration.generateUUIDs(System.Int32)">
            <summary>configures db4o to generate UUIDs for stored objects.</summary>
            <remarks>configures db4o to generate UUIDs for stored objects.</remarks>
            <param name="setting">
            one of the following values:<br />
            -1 - off<br />
            1 - configure classes individually<br />
            Integer.MAX_Value - on for all classes
            </param></member>
        <member name="M:com.db4o.config.Configuration.generateVersionNumbers(System.Int32)">
            <summary>configures db4o to generate version numbers for stored objects.</summary>
            <remarks>configures db4o to generate version numbers for stored objects.</remarks>
            <param name="setting">
            one of the following values:<br />
            -1 - off<br />
            1 - configure classes individually<br />
            Integer.MAX_Value - on for all classes
            </param></member>
        <member name="M:com.db4o.config.Configuration.getMessageSender">
            <summary>returns the MessageSender for this Configuration context.</summary>
            <remarks>returns the MessageSender for this Configuration context.</remarks>
            <returns>MessageSender</returns></member>
        <member name="M:com.db4o.config.Configuration.internStrings(System.Boolean)">
            <summary>Configures db4o to call intern() on strings upon retrieval.</summary>
            <remarks>Configures db4o to call intern() on strings upon retrieval.</remarks>
            <param name="doIntern">intern strings on retrieval if true, don't otherwise</param></member>
        <member name="M:com.db4o.config.Configuration.io(com.db4o.io.IoAdapter)">
            <summary>allows to configure db4o to use a customized byte IO adapter.</summary>
            <remarks>
            allows to configure db4o to use a customized byte IO adapter.
            <br /><br />Derive from the abstract class
            <see cref="T:com.db4o.io.IoAdapter">com.db4o.io.IoAdapter</see>
            to
            write your own. Possible usecases could be improved performance
            with a native library, mirrored write to two files or
            read-on-write fail-safety control.<br /><br />Sample IoAdapters
            are supplied with the distribution as source code.
            </remarks>
            <param name="adapter">- the IoAdapter</param></member>
        <member name="M:com.db4o.config.Configuration.markTransient(System.String)">
            <summary>allows to mark fields as transient with custom attributes.</summary>
            <remarks>
            allows to mark fields as transient with custom attributes.
            <br /><br />.NET only: Call this method with the attribute name that you
            wish to use to mark fields as transient. Multiple transient attributes
            are possible by calling this method multiple times with different
            attribute names.<br /><br /></remarks>
            <param name="attributeName">
            - the fully qualified name of the attribute, including
            it's namespace
            </param></member>
        <member name="M:com.db4o.config.Configuration.messageLevel(System.Int32)">
            <summary>sets the detail level of db4o messages.</summary>
            <remarks>
            sets the detail level of db4o messages. Messages will be output to the
            configured output
            <see cref="T:j4o.io.PrintStream">PrintStream</see>
            .
            <br /><br />
            Level 0 - no messages<br />
            Level 1 - open and close messages<br />
            Level 2 - messages for new, update and delete<br />
            Level 3 - messages for activate and deactivate<br /><br /></remarks>
            <param name="level">integer from 0 to 3</param>
            <seealso cref="M:com.db4o.config.Configuration.setOut">com.db4o.config.Configuration.setOut
            	</seealso></member>
        <member name="M:com.db4o.config.Configuration.lockDatabaseFile(System.Boolean)">
            <summary>can be used to turn the database file locking thread off.</summary>
            <remarks>
            can be used to turn the database file locking thread off.
            <br /><br />Since Java does not support file locking up to JDK 1.4,
            db4o uses an additional thread per open database file to prohibit
            concurrent access to the same database file by different db4o
            sessions in different VMs.<br /><br />
            To improve performance and to lower ressource consumption, this
            method provides the possibility to prevent the locking thread
            from being started.<br /><br /><b>Caution!</b><br />If database file
            locking is turned off, concurrent write access to the same
            database file from different JVM sessions will <b>corrupt</b> the
            database file immediately.<br /><br /> This method
            has no effect on open ObjectContainers. It will only affect how
            ObjectContainers are opened.<br /><br />
            The default setting is <code>true</code>.<br /><br /></remarks>
            <param name="flag">
                <code>false</code> to turn database file locking off.</param></member>
        <member name="M:com.db4o.config.Configuration.objectClass(System.Object)">
            <summary>
            returns an
            <see cref="T:com.db4o.config.ObjectClass">ObjectClass</see>
            object
            to configure the specified class.
            <br /><br />
            The clazz parameter can be any of the following:<br />
            - a fully qualified classname as a String.<br />
            - a Class object.<br />
            - any other object to be used as a template.<br /><br /></summary>
            <param name="clazz">class name, Class object, or example object.<br /><br /></param>
            <returns>
            an instance of an
            <see cref="T:com.db4o.config.ObjectClass">ObjectClass</see>
            object for configuration.
            </returns></member>
        <member name="M:com.db4o.config.Configuration.optimizeNativeQueries(System.Boolean)">
            <summary>
            If set to true, db4o will try to optimize native queries
            dynamically at query execution time, otherwise it will
            run native queries in unoptimized mode as SODA evaluations.
            </summary>
            <remarks>
            If set to true, db4o will try to optimize native queries
            dynamically at query execution time, otherwise it will
            run native queries in unoptimized mode as SODA evaluations.
            On the Java platform the jars needed for native query
            optimization (db4o-X.x-nqopt.jar, bloat-X.x.jar) have to be
            on the classpath at runtime for this
            switch to have effect.
            <br /><br />The default setting is <code>true</code>.
            </remarks>
            <param name="optimizeNQ">
            true, if db4o should try to optimize
            native queries at query execution time, false otherwise
            </param></member>
        <member name="M:com.db4o.config.Configuration.optimizeNativeQueries">
            <summary>
            indicates whether Native Queries will be optimized
            dynamically.
            </summary>
            <remarks>
            indicates whether Native Queries will be optimized
            dynamically.
            </remarks>
            <returns>
            boolean indicates whether Native Queries will be optimized
            dynamically.
            </returns>
            <seealso cref="M:com.db4o.config.Configuration.optimizeNativeQueries">com.db4o.config.Configuration.optimizeNativeQueries
            	</seealso></member>
        <member name="M:com.db4o.config.Configuration.password(System.String)">
            <summary>protects the database file with a password.</summary>
            <remarks>
            protects the database file with a password.
            <br /><br />To set a password for a database file, this method needs to be
            called <b>before</b> a database file is created with the first
            <see cref="M:com.db4o.Db4o.openFile">Db4o.openFile()</see>
            .
            <br /><br />All further attempts to open
            the file, are required to set the same password.<br /><br />The password
            is used to seed the encryption mechanism, which makes it impossible
            to read the database file without knowing the password.<br /><br /></remarks>
            <param name="pass">the password to be used.</param></member>
        <member name="M:com.db4o.config.Configuration.readOnly(System.Boolean)">
            <summary>turns readOnly mode on and off.</summary>
            <remarks>
            turns readOnly mode on and off.
            <br /><br />This method configures the mode in which subsequent calls to
            <see cref="M:com.db4o.Db4o.openFile">Db4o.openFile()</see>
            will open files.
            <br /><br />Readonly mode allows to open an unlimited number of reading
            processes on one database file. It is also convenient
            for deploying db4o database files on CD-ROM.<br /><br />If mixed access
            using many readOnly and one readWrite session is used, there is no
            guarantee that the data in the readOnly sessions will be kept up-to-date.
            <br /><br /></remarks>
            <param name="flag">
                <code>true</code> for configuring readOnly mode for subsequent
            calls to
            <see cref="M:com.db4o.Db4o.openFile">Db4o.openFile()</see>
            .
            </param></member>
        <member name="M:com.db4o.config.Configuration.reflectWith(com.db4o.reflect.Reflector)">
            <summary>configures the use of a specially designed reflection implementation.</summary>
            <remarks>
            configures the use of a specially designed reflection implementation.
            <br /><br />
            db4o internally uses java.lang.reflect.* by default. On platforms that
            do not support this package, customized implementations may be written
            to supply all the functionality of the interfaces in the com.db4o.reflect
            package. This method can be used to install a custom reflection
            implementation.
            </remarks></member>
        <member name="M:com.db4o.config.Configuration.refreshClasses">
            <summary>forces analysis of all Classes during a running session.</summary>
            <remarks>
            forces analysis of all Classes during a running session.
            <br /><br />
            This method may be useful in combination with a modified ClassLoader and
            allows exchanging classes during a running db4o session.<br /><br />
            Calling this method on the global Configuration context will refresh
            the classes in all db4o sessions in the running VM. Calling this method
            in an ObjectContainer Configuration context, only the classes of the
            respective ObjectContainer will be refreshed.<br /><br /></remarks>
            <seealso cref="M:com.db4o.config.Configuration.setClassLoader">com.db4o.config.Configuration.setClassLoader
            	</seealso></member>
        <member name="M:com.db4o.config.Configuration.reserveStorageSpace(System.Int64)">
            <summary>tuning feature only: reserves a number of bytes in database files.</summary>
            <remarks>
            tuning feature only: reserves a number of bytes in database files.
            <br /><br />The global setting is used for the creation of new database
            files. Continous calls on an ObjectContainer Configuration context
            (see
            <see cref="M:com.db4o.ext.ExtObjectContainer.configure">com.db4o.ext.ExtObjectContainer.configure
            	</see>
            ) will
            continually allocate space.
            <br /><br />The allocation of a fixed number of bytes at one time
            makes it more likely that the database will be stored in one
            chunk on the mass storage. Less read/write head movevement can result
            in improved performance.<br /><br /><b>Note:</b><br /> Allocated space will be lost on abnormal termination
            of the database engine (hardware crash, VM crash). A Defragment run
            will recover the lost space. For the best possible performance, this
            method should be called before the Defragment run to configure the
            allocation of storage space to be slightly greater than the anticipated
            database file size.
            <br /><br /> Default configuration: 0<br /><br /></remarks>
            <param name="byteCount">the number of bytes to reserve</param></member>
        <member name="M:com.db4o.config.Configuration.setBlobPath(System.String)">
            <summary>
            configures the path to be used to store and read
            Blob data.
            </summary>
            <remarks>
            configures the path to be used to store and read
            Blob data.
            <br /><br /></remarks>
            <param name="path">the path to be used</param></member>
        <member name="M:com.db4o.config.Configuration.setClassLoader(j4o.lang.ClassLoader)">
            <summary>configures db4o to use a custom ClassLoader.</summary>
            <remarks>
            configures db4o to use a custom ClassLoader.
            <br /><br /></remarks>
            <param name="classLoader">the ClassLoader to be used</param></member>
        <member name="M:com.db4o.config.Configuration.setMessageRecipient(com.db4o.messaging.MessageRecipient)">
            <summary>sets the MessageRecipient to receive Client Server messages.</summary>
            <remarks>
            sets the MessageRecipient to receive Client Server messages.
            <br /><br /></remarks>
            <param name="messageRecipient">the MessageRecipient to be used</param></member>
        <member name="M:com.db4o.config.Configuration.setOut(j4o.io.PrintStream)">
            <summary>
            Assigns a
            <see cref="T:j4o.io.PrintStream">PrintStream</see>
            where db4o is to print its event messages.
            <br /><br />Messages are useful for debugging purposes and for learning
            to understand, how db4o works. The message level can be raised with
            <see cref="M:com.db4o.config.Configuration.messageLevel">Db4o.configure().messageLevel()
            	</see>
            to produce more detailed messages.
            <br /><br />Use <code>setOut(System.out)</code> to print messages to the
            console.<br /><br /></summary>
            <param name="outStream">the new <code>PrintStream</code> for messages.</param>
            <seealso cref="M:com.db4o.config.Configuration.messageLevel">com.db4o.config.Configuration.messageLevel
            	</seealso></member>
        <member name="M:com.db4o.config.Configuration.singleThreadedClient(System.Boolean)">
            <summary>
            configures the client messaging system to be single threaded
            or multithreaded.
            </summary>
            <remarks>
            configures the client messaging system to be single threaded
            or multithreaded.
            <br /><br />Recommended settings:<br />
            - <code>true</code> for low ressource systems.<br />
            - <code>false</code> for best asynchronous performance and fast
            GUI response.
            <br /><br />Default value:<br />
            - .NET Compactframework: <code>true</code><br />
            - all other plaforms: <code>false</code><br /><br /></remarks>
            <param name="flag">the desired setting</param></member>
        <member name="M:com.db4o.config.Configuration.testConstructors(System.Boolean)">
            <summary>
            tuning feature: configures whether db4o should try to instantiate one instance
            of each persistent class on system startup.
            </summary>
            <remarks>
            tuning feature: configures whether db4o should try to instantiate one instance
            of each persistent class on system startup.
            <br /><br />In a production environment this setting can be set to <code>false</code>,
            if all persistent classes have public default constructors.
            <br /><br />Default value:<br /><code>true</code></remarks>
            <param name="flag">the desired setting</param></member>
        <member name="M:com.db4o.config.Configuration.timeoutClientSocket(System.Int32)">
            <summary>
            configures the time a client waits for a message
            response from the server.
            </summary>
            <remarks>
            configures the time a client waits for a message
            response from the server.
            <br /><br />Default value: 300000ms (5 minutes)<br /><br /></remarks>
            <param name="milliseconds">time in milliseconds</param></member>
        <member name="M:com.db4o.config.Configuration.timeoutServerSocket(System.Int32)">
            <summary>configures the timeout of the serverside socket.</summary>
            <remarks>
            configures the timeout of the serverside socket.
            <br /><br />All server connection threads jump out of the
            socket read statement on a regular interval to check
            if the server was shut down. Use this method to configure
            the duration of the interval.<br /><br />
            Default value: 5000ms (5 seconds)<br /><br /></remarks>
            <param name="milliseconds">time in milliseconds</param></member>
        <member name="M:com.db4o.config.Configuration.timeoutPingClients(System.Int32)">
            <summary>
            configures the delay time after which the server starts pinging
            connected clients to check the connection.
            </summary>
            <remarks>
            configures the delay time after which the server starts pinging
            connected clients to check the connection.
            <br /><br />If no client messages are received by the server for the
            configured interval, the server sends a "PING" message to the
            client and wait's for an "OK" response. After 5 unsuccessful
            attempts, the client connection is closed.
            <br /><br />This value may need to be increased for single-threaded
            clients, since they can't respond instantaneously.
            <br /><br />Default value: 180000ms (3 minutes)<br /><br /></remarks>
            <param name="milliseconds">time in milliseconds</param>
            <seealso cref="M:com.db4o.config.Configuration.singleThreadedClient"></seealso></member>
        <member name="M:com.db4o.config.Configuration.unicode(System.Boolean)">
            <summary>configures the storage format of Strings.</summary>
            <remarks>
            configures the storage format of Strings.
            <br /><br />This method needs to be called <b>before</b> a database file
            is created with the first
            <see cref="M:com.db4o.Db4o.openFile">Db4o.openFile()</see>
            .
            db4o database files keep their string format after creation.<br /><br />
            Turning Unicode support off reduces the file storage space for strings
            by factor 2 and improves performance.<br /><br />
            Default setting: <b>true</b><br /><br /></remarks>
            <param name="flag">
                <code>true</code> for turning Unicode support on, <code>false</code> for turning
            Unicode support off.
            </param></member>
        <member name="M:com.db4o.config.Configuration.updateDepth(System.Int32)">
            <summary>specifies the global updateDepth.</summary>
            <remarks>
            specifies the global updateDepth.
            <br /><br />see the documentation of
            <see cref="M:com.db4o.ObjectContainer.set">ObjectContainer.set()</see>
            for further details.<br /><br />
            The value be may be overridden for individual classes.<br /><br />
            The default setting is 1: Only the object passed to
            <see cref="M:com.db4o.ObjectContainer.set">ObjectContainer.set()</see>
            will be updated.<br /><br /></remarks>
            <param name="depth">the depth of the desired update.</param>
            <seealso cref="M:com.db4o.config.ObjectClass.updateDepth">com.db4o.config.ObjectClass.updateDepth
            	</seealso>
            <seealso cref="M:com.db4o.config.ObjectClass.cascadeOnUpdate">com.db4o.config.ObjectClass.cascadeOnUpdate
            	</seealso>
            <seealso cref="T:com.db4o.ext.ObjectCallbacks">Using callbacks</seealso></member>
        <member name="M:com.db4o.config.Configuration.weakReferences(System.Boolean)">
            <summary>turns weak reference management on or off.</summary>
            <remarks>
            turns weak reference management on or off.
            <br /><br />
            This method must be called before opening a database.
            <br /><br />
            Performance may be improved by running db4o without using weak
            references durring memory management at the cost of higher
            memory consumption or by alternatively implementing a manual
            memory management scheme using
            <see cref="M:com.db4o.ext.ExtObjectContainer.purge">com.db4o.ext.ExtObjectContainer.purge
            	</see><br /><br />Setting the value to <code>false</code> causes db4o to use hard
            references to objects, preventing the garbage collection process
            from disposing of unused objects.
            <br /><br />The default setting is <code>true</code>.
            <br /><br />Ignored on JDKs before 1.2.
            </remarks></member>
        <member name="M:com.db4o.config.Configuration.weakReferenceCollectionInterval(System.Int32)">
            <summary>configures the timer for WeakReference collection.</summary>
            <remarks>
            configures the timer for WeakReference collection.
            <br /><br />The default setting is 1000 milliseconds.
            <br /><br />Configure this setting to zero to turn WeakReference
            collection off.
            <br /><br />Ignored on JDKs before 1.2.<br /><br /></remarks>
            <param name="milliseconds">the time in milliseconds</param></member>
        <member name="T:com.db4o.inside.replication.Db4oReplicationReferenceProvider">
            <exclude></exclude></member>
        <member name="T:com.db4o.reflect.ReflectClass">
            <summary>representation for java.lang.Class.</summary>
            <remarks>
            representation for java.lang.Class.
            <br /><br />See the respective documentation in the JDK API.
            </remarks>
            <seealso cref="T:com.db4o.reflect.Reflector">com.db4o.reflect.Reflector</seealso></member>
        <member name="M:com.db4o.reflect.ReflectClass.skipConstructor(System.Boolean)">
            <summary>
            instructs to install or uninstall a special constructor for the
            respective platform that avoids calling the constructor for the
            respective class
            </summary>
            <param name="flag">
            true to try to install a special constructor, false if
            such a constructor is to be removed if present
            </param>
            <returns>true if the special constructor is in place after the call</returns></member>
        <member name="T:com.db4o.ObjectContainer">
            <summary>the interface to a db4o database, stand-alone or client/server.</summary>
            <remarks>
            the interface to a db4o database, stand-alone or client/server.
            <br /><br />The ObjectContainer interface provides methods
            to store, query and delete objects and to commit and rollback
            transactions.<br /><br />
            An ObjectContainer can either represent a stand-alone database
            or a connection to a
            <see cref="M:com.db4o.Db4o.openServer">db4o server</see>
            .
            <br /><br />An ObjectContainer also represents a transaction. All work
            with db4o always is transactional. Both
            <see cref="M:com.db4o.ObjectContainer.commit">com.db4o.ObjectContainer.commit</see>
            and
            <see cref="M:com.db4o.ObjectContainer.rollback">com.db4o.ObjectContainer.rollback</see>
            start new transactions immediately. For working
            against the same database with multiple transactions, open a db4o server
            with
            <see cref="M:com.db4o.Db4o.openServer">com.db4o.Db4o.openServer</see>
            and
            <see cref="M:com.db4o.ObjectServer.openClient">connect locally</see>
            or
            <see cref="M:com.db4o.Db4o.openClient">over TCP</see>
            .
            </remarks>
            <seealso cref="T:com.db4o.ext.ExtObjectContainer">ExtObjectContainer for extended functionality.
            	</seealso></member>
        <member name="M:com.db4o.ObjectContainer.activate(System.Object,System.Int32)">
            <summary>activates all members on a stored object to the specified depth.</summary>
            <remarks>
            activates all members on a stored object to the specified depth.
            <br /><br />
            See
            <see cref="M:com.db4o.config.Configuration.activationDepth">"Why activation"</see>
            for an explanation why activation is necessary.<br /><br />
            The activate method activates a graph of persistent objects in memory.
            Only deactivated objects in the graph will be touched: their
            fields will be loaded from the database.
            The activate methods starts from a
            root object and traverses all member objects to the depth specified by the
            depth parameter. The depth parameter is the distance in "field hops"
            (object.field.field) away from the root object. The nodes at 'depth' level
            away from the root (for a depth of 3: object.member.member) will be instantiated
            but deactivated, their fields will be null.
            The activation depth of individual classes can be overruled
            with the methods
            <see cref="M:com.db4o.config.ObjectClass.maximumActivationDepth">maximumActivationDepth()
            	</see>
            and
            <see cref="M:com.db4o.config.ObjectClass.minimumActivationDepth">minimumActivationDepth()
            	</see>
            in the
            <see cref="T:com.db4o.config.ObjectClass">ObjectClass interface</see>
            .<br /><br />
            A successful call to activate triggers the callback method
            <see cref="M:com.db4o.ext.ObjectCallbacks.objectOnActivate">objectOnActivate</see>
            which can be used for cascaded activation.<br /><br /></remarks>
            <seealso cref="M:com.db4o.config.Configuration.activationDepth">Why activation?</seealso>
            <seealso cref="T:com.db4o.ext.ObjectCallbacks">Using callbacks</seealso>
            <param name="obj">the object to be activated.</param>
            <param name="depth">
            the member
            <see cref="M:com.db4o.config.Configuration.activationDepth">depth</see>
            to which activate is to cascade.
            </param></member>
        <member name="M:com.db4o.ObjectContainer.close">
            <summary>closes this ObjectContainer.</summary>
            <remarks>
            closes this ObjectContainer.
            <br /><br />A call to close() automatically performs a
            <see cref="M:com.db4o.ObjectContainer.commit">commit()</see>
            .
            <br /><br />Note that every session opened with Db4o.openFile() requires one
            close()call, even if the same filename was used multiple times.<br /><br />
            Use <code>while(!close()){}</code> to kill all sessions using this container.<br /><br /></remarks>
            <returns>
            success - true denotes that the last used instance of this container
            and the database file were closed.
            </returns></member>
        <member name="M:com.db4o.ObjectContainer.commit">
            <summary>commits the running transaction.</summary>
            <remarks>
            commits the running transaction.
            <br /><br />Transactions are back-to-back. A call to commit will starts
            a new transaction immedidately.
            </remarks></member>
        <member name="M:com.db4o.ObjectContainer.deactivate(System.Object,System.Int32)">
            <summary>deactivates a stored object by setting all members to <code>NULL</code>.
            	</summary>
            <remarks>
            deactivates a stored object by setting all members to <code>NULL</code>.
            <br />Primitive types will be set to their default values.
            <br /><br /><b>Examples: ../com/db4o/samples/activate.</b><br /><br />
            Calls to this method save memory.
            The method has no effect, if the passed object is not stored in the
            <code>ObjectContainer</code>.<br /><br /><code>deactivate()</code> triggers the callback method
            <see cref="M:com.db4o.ext.ObjectCallbacks.objectOnDeactivate">objectOnDeactivate</see>
            .
            <br /><br />
            Be aware that calling this method with a depth parameter greater than
            1 sets members on member objects to null. This may have side effects
            in other places of the application.<br /><br /></remarks>
            <seealso cref="T:com.db4o.ext.ObjectCallbacks">Using callbacks</seealso>
            <seealso cref="M:com.db4o.config.Configuration.activationDepth">Why activation?</seealso>
            <param name="obj">the object to be deactivated.</param>
            <param name="depth">
            the member
            <see cref="M:com.db4o.config.Configuration.activationDepth">depth</see>
            to which deactivate is to cascade.
            </param></member>
        <member name="M:com.db4o.ObjectContainer.delete(System.Object)">
            <summary>deletes a stored object permanently.</summary>
            <remarks>
            deletes a stored object permanently.
            <br /><br />Note that this method has to be called <b>for every single object
            individually</b>. Delete does not recurse to object members. Simple
            and array member types are destroyed.
            <br /><br />Object members of the passed object remain untouched, unless
            cascaded deletes are
            <see cref="M:com.db4o.config.ObjectClass.cascadeOnDelete">configured for the class</see>
            or for
            <see cref="M:com.db4o.config.ObjectField.cascadeOnDelete">one of the member fields</see>
            .
            <br /><br />The method has no effect, if
            the passed object is not stored in the <code>ObjectContainer</code>.
            <br /><br />A subsequent call to
            <code>set()</code> with the same object newly stores the object
            to the <code>ObjectContainer</code>.<br /><br /><code>delete()</code> triggers the callback method
            <see cref="M:com.db4o.ext.ObjectCallbacks.objectOnDelete">objectOnDelete</see>
            which can be also used for cascaded deletes.<br /><br /></remarks>
            <seealso cref="M:com.db4o.config.ObjectClass.cascadeOnDelete">com.db4o.config.ObjectClass.cascadeOnDelete
            	</seealso>
            <seealso cref="M:com.db4o.config.ObjectField.cascadeOnDelete">com.db4o.config.ObjectField.cascadeOnDelete
            	</seealso>
            <seealso cref="T:com.db4o.ext.ObjectCallbacks">Using callbacks</seealso>
            <param name="obj">
            the object to be deleted from the
            <code>ObjectContainer</code>.<br /></param></member>
        <member name="M:com.db4o.ObjectContainer.ext">
            <summary>returns an ObjectContainer with extended functionality.</summary>
            <remarks>
            returns an ObjectContainer with extended functionality.
            <br /><br />Every ObjectContainer that db4o provides can be casted to
            an ExtObjectContainer. This method is supplied for your convenience
            to work without a cast.
            <br /><br />The ObjectContainer functionality is split to two interfaces
            to allow newcomers to focus on the essential methods.<br /><br /></remarks>
            <returns>this, casted to ExtObjectContainer</returns></member>
        <member name="M:com.db4o.ObjectContainer.get(System.Object)">
            <summary>Query-By-Example interface to retrieve objects.</summary>
            <remarks>
            Query-By-Example interface to retrieve objects.
            <br /><br /><code>get()</code> creates an
            <see cref="T:com.db4o.ObjectSet">ObjectSet</see>
            containing
            all objects in the <code>ObjectContainer</code> that match the passed
            template object.<br /><br />
            Calling <code>get(NULL)</code> returns all objects stored in the
            <code>ObjectContainer</code>.<br /><br /><br /><b>Query Evaluation</b><br />All non-null members of the template object are compared against
            all stored objects of the same class.
            Primitive type members are ignored if they are 0 or false respectively.
            <br /><br />Arrays and all supported <code>Collection</code> classes are
            evaluated for containment. Differences in <code>length/size()</code> are
            ignored.
            <br /><br />Consult the documentation of the Configuration package to
            configure class-specific behaviour.<br /><br /><br /><b>Returned Objects</b><br />
            The objects returned in the
            <see cref="T:com.db4o.ObjectSet">ObjectSet</see>
            are instantiated
            and activated to the preconfigured depth of 5. The
            <see cref="M:com.db4o.config.Configuration.activationDepth">activation depth</see>
            may be configured
            <see cref="M:com.db4o.config.Configuration.activationDepth">globally</see>
            or
            <see cref="T:com.db4o.config.ObjectClass">individually for classes</see>
            .
            <br /><br />
            db4o keeps track of all instantiatied objects. Queries will return
            references to these objects instead of instantiating them a second time.
            <br /><br />
            Objects newly activated by <code>get()</code> can respond to the callback
            method
            <see cref="M:com.db4o.ext.ObjectCallbacks.objectOnActivate">objectOnActivate</see>
            .
            <br /><br /></remarks>
            <param name="template">object to be used as an example to find all matching objects.<br /><br /></param>
            <returns>
                <see cref="T:com.db4o.ObjectSet">ObjectSet</see>
            containing all found objects.<br /><br /></returns>
            <seealso cref="M:com.db4o.config.Configuration.activationDepth">Why activation?</seealso>
            <seealso cref="T:com.db4o.ext.ObjectCallbacks">Using callbacks</seealso></member>
        <member name="M:com.db4o.ObjectContainer.query">
            <summary>
            creates a new SODA
            <see cref="T:com.db4o.query.Query">Query</see>
            .
            <br /><br />
            Use
            <see cref="M:com.db4o.ObjectContainer.get">get(Object template)</see>
            for simple Query-By-Example.<br /><br /><see cref="M:com.db4o.ObjectContainer.query">Native queries</see>
            are the recommended main db4o query
            interface.
            <br /><br /></summary>
            <returns>a new Query object</returns></member>
        <member name="M:com.db4o.ObjectContainer.query(j4o.lang.Class)">
            <summary>queries for all instances of a class.</summary>
            <remarks>queries for all instances of a class.</remarks>
            <param name="clazz">the class to query for.</param>
            <returns>
            the
            <see cref="T:com.db4o.ObjectSet">com.db4o.ObjectSet</see>
            returned by the query.
            </returns></member>
        <member name="M:com.db4o.ObjectContainer.query(com.db4o.query.Predicate)">
            <summary>Native Query Interface.</summary>
            <remarks>
            Native Query Interface.
            <br /><br />Native Queries allow typesafe, compile-time checked and refactorable
            querying, following object-oriented principles. Native Queries expressions
            are written as if one or more lines of code would be run against all
            instances of a class. A Native Query expression should return true to mark
            specific instances as part of the result set.
            db4o will  attempt to optimize native query expressions and execute them
            against indexes and without instantiating actual objects, where this is
            possible.<br /><br />
            The syntax of the enclosing object for the native query expression varies,
            depending on the language version used. Here are some examples,
            how a simple native query will look like in some of the programming languages
            and dialects that db4o supports:<br /><br /><code>
                    <b>// C# .NET 2.0</b>
                    <br />
            IList &lt;Cat&gt; cats = db.Query &lt;Cat&gt; (delegate(Cat cat) {<br />
               return cat.Name == "Occam";<br />
            });<br /><br /><br /><b>// Java JDK 5</b><br />
            List &lt;Cat&gt; cats = db.query(new Predicate&lt;Cat&gt;() {<br />
               public boolean match(Cat cat) {<br />
                  return cat.getName().equals("Occam");<br />
               }<br />
            });<br /><br /><br /><b>// Java JDK 1.2 to 1.4</b><br />
            List cats = db.query(new Predicate() {<br />
               public boolean match(Cat cat) {<br />
                  return cat.getName().equals("Occam");<br />
               }<br />
            });<br /><br /><br /><b>// Java JDK 1.1</b><br />
            ObjectSet cats = db.query(new CatOccam());<br /><br />
            public static class CatOccam extends Predicate {<br />
               public boolean match(Cat cat) {<br />
                  return cat.getName().equals("Occam");<br />
               }<br />
            });<br /><br /><br /><b>// C# .NET 1.1</b><br />
            IList cats = db.Query(new CatOccam());<br /><br />
            public class CatOccam : Predicate {<br />
               public boolean Match(Cat cat) {<br />
                  return cat.Name == "Occam";<br />
               }<br />
            });<br /></code><br />
            Summing up the above:<br />
            In order to run a Native Query, you can<br />
            - use the delegate notation for .NET 2.0.<br />
            - extend the Predicate class for all other language dialects<br /><br />
            A class that extends Predicate is required to
            implement the #match() / #Match() method, following the native query
            conventions:<br />
            - The name of the method is "#match()" (Java) / "#Match()" (.NET).<br />
            - The method must be public public.<br />
            - The method returns a boolean.<br />
            - The method takes one parameter.<br />
            - The Type (.NET) / Class (Java) of the parameter specifies the extent.<br />
            - For all instances of the extent that are to be included into the
            resultset of the query, the match method should return true. For all
            instances that are not to be included, the match method should return
            false.<br /><br /></remarks>
            <param name="predicate">
            the
            <see cref="T:com.db4o.query.Predicate">com.db4o.query.Predicate</see>
            containing the native query expression.
            </param>
            <returns>
            the
            <see cref="T:com.db4o.ObjectSet">com.db4o.ObjectSet</see>
            returned by the query.
            </returns></member>
        <member name="M:com.db4o.ObjectContainer.rollback">
            <summary>rolls back the running transaction.</summary>
            <remarks>
            rolls back the running transaction.
            <br /><br />Transactions are back-to-back. A call to rollback will starts
            a new transaction immedidately.
            <br /><br />rollback will not restore modified objects in memory. They
            can be refreshed from the database by calling
            <see cref="M:com.db4o.ext.ExtObjectContainer.refresh">com.db4o.ext.ExtObjectContainer.refresh
            	</see>
            .
            </remarks></member>
        <member name="M:com.db4o.ObjectContainer.set(System.Object)">
            <summary>newly stores objects or updates stored objects.</summary>
            <remarks>
            newly stores objects or updates stored objects.
            <br /><br />An object not yet stored in the <code>ObjectContainer</code> will be
            stored when it is passed to <code>set()</code>. An object already stored
            in the <code>ObjectContainer</code> will be updated.
            <br /><br /><b>Updates</b><br />
            - will affect all simple type object members.<br />
            - links to object members that are already stored will be updated.<br />
            - new object members will be newly stored. The algorithm traverses down
            new members, as long as further new members are found.<br />
            - object members that are already stored will <b>not</b> be updated
            themselves.<br />Every object member needs to be updated individually with a
            call to <code>set()</code> unless a deep
            <see cref="M:com.db4o.config.Configuration.updateDepth">global</see>
            or
            <see cref="M:com.db4o.config.ObjectClass.updateDepth">class-specific</see>
            update depth was configured or cascaded updates were
            <see cref="M:com.db4o.config.ObjectClass.cascadeOnUpdate">defined in the class</see>
            or in
            <see cref="M:com.db4o.config.ObjectField.cascadeOnUpdate">one of the member fields</see>
            .
            <br /><br /><b>Examples: ../com/db4o/samples/update.</b><br /><br />
            Depending if the passed object is newly stored or updated, the
            callback method
            <see cref="M:com.db4o.ext.ObjectCallbacks.objectOnNew">objectOnNew</see>
            or
            <see cref="M:com.db4o.ext.ObjectCallbacks.objectOnUpdate">objectOnUpdate</see>
            is triggered.
            <see cref="M:com.db4o.ext.ObjectCallbacks.objectOnUpdate">objectOnUpdate</see>
            might also be used for cascaded updates.<br /><br /></remarks>
            <param name="obj">the object to be stored or updated.</param>
            <seealso cref="M:com.db4o.ext.ExtObjectContainer.set">ExtObjectContainer#set(object, depth)
            	</seealso>
            <seealso cref="M:com.db4o.config.Configuration.updateDepth">com.db4o.config.Configuration.updateDepth
            	</seealso>
            <seealso cref="M:com.db4o.config.ObjectClass.updateDepth">com.db4o.config.ObjectClass.updateDepth
            	</seealso>
            <seealso cref="M:com.db4o.config.ObjectClass.cascadeOnUpdate">com.db4o.config.ObjectClass.cascadeOnUpdate
            	</seealso>
            <seealso cref="M:com.db4o.config.ObjectField.cascadeOnUpdate">com.db4o.config.ObjectField.cascadeOnUpdate
            	</seealso>
            <seealso cref="T:com.db4o.ext.ObjectCallbacks">Using callbacks</seealso></member>
        <member name="T:com.db4o.foundation.Visitor4">
            <exclude></exclude></member>
        <member name="T:com.db4o.types.TransientClass">
            <summary>Marker interface to denote that a class should not be stored by db4o.</summary>
            <remarks>Marker interface to denote that a class should not be stored by db4o.</remarks></member>
        <member name="T:com.db4o.TransactionListener">
            <summary>
            allows registration with a transaction to be notified of
            commit and rollback
            </summary>
            <exclude></exclude></member>
        <member name="T:com.db4o.types.Db4oType">
            <summary>marker interface for all special db4o types.</summary>
            <remarks>marker interface for all special db4o types.</remarks></member>
        <member name="T:com.db4o.types.SecondClass">
            <summary>marks objects as second class objects.</summary>
            <remarks>
            marks objects as second class objects.
            <br /><br />Currently this interface is for internal use only
            to help discard com.db4o.config.Entry objects in the
            Defragment process.
            <br /><br />For future versions this interface is planned to
            mark objects that:<br />
            - are not to be held in the reference mechanism<br />
            - should always be activated with their parent objects<br />
            - should always be deleted with their parent objects<br />
            - should always be deleted if they are not referenced any
            longer.<br /></remarks></member>
        <member name="T:com.db4o.Internal4">
            <summary>Marker interface to denote that a class is used for db4o internals.</summary>
            <remarks>Marker interface to denote that a class is used for db4o internals.</remarks>
            <exclude></exclude></member>
        <member name="T:com.db4o.config.FreespaceConfiguration">
            <summary>interface to configure the freespace system to be used.</summary>
            <remarks>
            interface to configure the freespace system to be used.
            All methods should be called before opening database files.
            If db4o is instructed to exchange the system
            (
            <see cref="M:com.db4o.config.FreespaceConfiguration.useIndexSystem">com.db4o.config.FreespaceConfiguration.useIndexSystem
            	</see>
            ,
            <see cref="M:com.db4o.config.FreespaceConfiguration.useRamSystem">com.db4o.config.FreespaceConfiguration.useRamSystem
            	</see>
            )
            this will happen on opening the database file.<br /><br />
            By default the index-based system will be used.
            </remarks></member>
        <member name="M:com.db4o.config.FreespaceConfiguration.discardSmallerThan(System.Int32)">
            <summary>
            tuning feature: configures the minimum size of free space slots in the database file
            that are to be reused.
            </summary>
            <remarks>
            tuning feature: configures the minimum size of free space slots in the database file
            that are to be reused.
            <br /><br />When objects are updated or deleted, the space previously occupied in the
            database file is marked as "free", so it can be reused. db4o maintains two lists
            in RAM, sorted by address and by size. Adjacent entries are merged. After a large
            number of updates or deletes have been executed, the lists can become large, causing
            RAM consumption and performance loss for maintenance. With this method you can
            specify an upper bound for the byte slot size to discard.
            <br /><br />Pass <code>Integer.MAX_VALUE</code> to this method to discard all free slots for
            the best possible startup time.<br /><br />
            The downside of setting this value: Database files will necessarily grow faster.
            <br /><br />Default value:<br /><code>0</code> all space is reused
            </remarks>
            <param name="byteCount">Slots with this size or smaller will be lost.</param></member>
        <member name="M:com.db4o.config.FreespaceConfiguration.useIndexSystem">
            <summary>configures db4o to use an index-based freespace system.</summary>
            <remarks>
            configures db4o to use an index-based freespace system.
            <br /><br /><b>Advantages</b><br />
            - ACID, no freespace is lost on abnormal system termination<br />
            - low memory consumption<br /><br /><b>Disadvantages</b><br />
            - slower than the RAM-based system, since freespace information
            is written during every commit<br /></remarks></member>
        <member name="M:com.db4o.config.FreespaceConfiguration.useRamSystem">
            <summary>configures db4o to use a RAM-based freespace system.</summary>
            <remarks>
            configures db4o to use a RAM-based freespace system.
            <br /><br /><b>Advantages</b><br />
            - best performance<br /><br /><b>Disadvantages</b><br />
            - upon abnormal system termination all freespace is lost<br />
            - memory consumption<br /></remarks></member>
        <member name="T:com.db4o.ext.ObjectCallbacks">
            <summary>callback methods.</summary>
            <remarks>
            callback methods.
            <br /><br /><b>Examples: ../com/db4o/samples/callbacks.</b><br /><br />
            This interface only serves as a lists of all available callback methods.
            Every method is called individually, independant of implementing this interface.<br /><br /><b>Using callbacks</b><br />
            Simply implement one or more of the listed methods in your application classes to
            do tasks before activation, deactivation, delete, new or update, to cancel the
            action about to be performed and to respond to the performed task.
            <br /><br />Callback methods are typically used for:
            <br />- cascaded delete
            <br />- cascaded update
            <br />- cascaded activation
            <br />- restoring transient members on instantiation
            <br /><br />Callback methods follow regular calling conventions. Methods in superclasses
            need to be called explicitely.
            <br /><br />All method calls are implemented to occur only once, upon one event.
            </remarks></member>
        <member name="M:com.db4o.ext.ObjectCallbacks.objectCanActivate(com.db4o.ObjectContainer)">
            <summary>called before an Object is activated.</summary>
            <remarks>called before an Object is activated.</remarks>
            <param name="container">the <code>ObjectContainer</code> the object is stored in.
            	</param>
            <returns>false to prevent activation.</returns></member>
        <member name="M:com.db4o.ext.ObjectCallbacks.objectCanDeactivate(com.db4o.ObjectContainer)">
            <summary>called before an Object is deactivated.</summary>
            <remarks>called before an Object is deactivated.</remarks>
            <param name="container">the <code>ObjectContainer</code> the object is stored in.
            	</param>
            <returns>false to prevent deactivation.</returns></member>
        <member name="M:com.db4o.ext.ObjectCallbacks.objectCanDelete(com.db4o.ObjectContainer)">
            <summary>called before an Object is deleted.</summary>
            <remarks>
            called before an Object is deleted.
            <br /><br />In a client/server setup this callback method will be executed on
            the server.
            </remarks>
            <param name="container">the <code>ObjectContainer</code> the object is stored in.
            	</param>
            <returns>false to prevent the object from being deleted.</returns></member>
        <member name="M:com.db4o.ext.ObjectCallbacks.objectCanNew(com.db4o.ObjectContainer)">
            <summary>called before an Object is stored the first time.</summary>
            <remarks>called before an Object is stored the first time.</remarks>
            <param name="container">the <code>ObjectContainer</code> is about to be stored to.
            	</param>
            <returns>false to prevent the object from being stored.</returns></member>
        <member name="M:com.db4o.ext.ObjectCallbacks.objectCanUpdate(com.db4o.ObjectContainer)">
            <summary>called before a persisted Object is updated.</summary>
            <remarks>called before a persisted Object is updated.</remarks>
            <param name="container">the <code>ObjectContainer</code> the object is stored in.
            	</param>
            <returns>false to prevent the object from being updated.</returns></member>
        <member name="M:com.db4o.ext.ObjectCallbacks.objectOnActivate(com.db4o.ObjectContainer)">
            <summary>called upon activation of an object.</summary>
            <remarks>called upon activation of an object.</remarks>
            <param name="container">the <code>ObjectContainer</code> the object is stored in.
            	</param></member>
        <member name="M:com.db4o.ext.ObjectCallbacks.objectOnDeactivate(com.db4o.ObjectContainer)">
            <summary>called upon deactivation of an object.</summary>
            <remarks>called upon deactivation of an object.</remarks>
            <param name="container">the <code>ObjectContainer</code> the object is stored in.
            	</param></member>
        <member name="M:com.db4o.ext.ObjectCallbacks.objectOnDelete(com.db4o.ObjectContainer)">
            <summary>called after an object was deleted.</summary>
            <remarks>
            called after an object was deleted.
            <br /><br />In a client/server setup this callback method will be executed on
            the server.
            </remarks>
            <param name="container">the <code>ObjectContainer</code> the object was stored in.
            	</param></member>
        <member name="M:com.db4o.ext.ObjectCallbacks.objectOnNew(com.db4o.ObjectContainer)">
            <summary>called after a new object was stored.</summary>
            <remarks>called after a new object was stored.</remarks>
            <param name="container">the <code>ObjectContainer</code> the object is stored to.
            	</param></member>
        <member name="M:com.db4o.ext.ObjectCallbacks.objectOnUpdate(com.db4o.ObjectContainer)">
            <summary>called after an object was updated.</summary>
            <remarks>called after an object was updated.</remarks>
            <param name="container">the <code>ObjectContainer</code> the object is stored in.
            	</param></member>
        <member name="T:com.db4o.foundation.IntObjectVisitor">
            <exclude></exclude></member>
        <member name="T:com.db4o.TransactionAware">
            <exclude></exclude></member>
        <member name="T:com.db4o.config.ObjectField">
            <summary>configuration interface for fields of classes.</summary>
            <remarks>
            configuration interface for fields of classes.
            <br /><br /><b>Examples: ../com/db4o/samples/translators.</b><br /><br />
            Use the global Configuration object to configure db4o before opening an
            <see cref="T:com.db4o.ObjectContainer">ObjectContainer</see>
            .<br /><br /><b>Example:</b><br /><code>
            Configuration config = Db4o.configure();<br />
            ObjectClass oc = config.objectClass("package.className");<br />
            ObjectField of = oc.objectField("fieldName");
            of.rename("newFieldName");
            of.queryEvaluation(false);
            </code></remarks></member>
        <member name="M:com.db4o.config.ObjectField.cascadeOnActivate(System.Boolean)">
            <summary>sets cascaded activation behaviour.</summary>
            <remarks>
            sets cascaded activation behaviour.
            <br /><br />
            Setting cascadeOnActivate to true will result in the activation
            of the object attribute stored in this field if the parent object
            is activated.
            <br /><br />
            The default setting is <b>false</b>.<br /><br /></remarks>
            <param name="flag">whether activation is to be cascaded to the member object.</param>
            <seealso cref="M:com.db4o.config.Configuration.activationDepth">Why activation?</seealso>
            <seealso cref="M:com.db4o.config.ObjectClass.cascadeOnActivate">com.db4o.config.ObjectClass.cascadeOnActivate
            	</seealso>
            <seealso cref="M:com.db4o.ObjectContainer.activate">com.db4o.ObjectContainer.activate
            	</seealso>
            <seealso cref="T:com.db4o.ext.ObjectCallbacks">Using callbacks</seealso></member>
        <member name="M:com.db4o.config.ObjectField.cascadeOnDelete(System.Boolean)">
            <summary>sets cascaded delete behaviour.</summary>
            <remarks>
            sets cascaded delete behaviour.
            <br /><br />
            Setting cascadeOnDelete to true will result in the deletion of
            the object attribute stored in this field on the parent object
            if the parent object is passed to
            <see cref="M:com.db4o.ObjectContainer.delete">ObjectContainer#delete()</see>
            .
            <br /><br /><b>Caution !</b><br />
            This setting will also trigger deletion of the old member object, on
            calls to
            <see cref="M:com.db4o.ObjectContainer.set">ObjectContainer#set()</see>
            .
            An example of the behaviour can be found in
            <see cref="M:com.db4o.config.ObjectClass.cascadeOnDelete">ObjectClass#cascadeOnDelete()
            	</see><br /><br />
            The default setting is <b>false</b>.<br /><br /></remarks>
            <param name="flag">whether deletes are to be cascaded to the member object.</param>
            <seealso cref="M:com.db4o.config.ObjectClass.cascadeOnDelete">com.db4o.config.ObjectClass.cascadeOnDelete
            	</seealso>
            <seealso cref="M:com.db4o.ObjectContainer.delete">com.db4o.ObjectContainer.delete</seealso>
            <seealso cref="T:com.db4o.ext.ObjectCallbacks">Using callbacks</seealso></member>
        <member name="M:com.db4o.config.ObjectField.cascadeOnUpdate(System.Boolean)">
            <summary>sets cascaded update behaviour.</summary>
            <remarks>
            sets cascaded update behaviour.
            <br /><br />
            Setting cascadeOnUpdate to true will result in the update
            of the object attribute stored in this field if the parent object
            is passed to
            <see cref="M:com.db4o.ObjectContainer.set">ObjectContainer#set()</see>
            .
            <br /><br />
            The default setting is <b>false</b>.<br /><br /></remarks>
            <param name="flag">whether updates are to be cascaded to the member object.</param>
            <seealso cref="M:com.db4o.ObjectContainer.set">com.db4o.ObjectContainer.set</seealso>
            <seealso cref="M:com.db4o.config.ObjectClass.cascadeOnUpdate">com.db4o.config.ObjectClass.cascadeOnUpdate
            	</seealso>
            <seealso cref="M:com.db4o.config.ObjectClass.updateDepth">com.db4o.config.ObjectClass.updateDepth
            	</seealso>
            <seealso cref="T:com.db4o.ext.ObjectCallbacks">Using callbacks</seealso></member>
        <member name="M:com.db4o.config.ObjectField.indexed(System.Boolean)">
            <summary>turns indexing on or off.</summary>
            <remarks>
            turns indexing on or off.
            <br /><br />Field indices dramatically improve query performance but they may
            considerably reduce storage and update performance.<br />The best benchmark whether
            or not an index on a field achieves the desired result is the completed application
            - with a data load that is typical for it's use.<br /><br />This configuration setting
            is only checked when the
            <see cref="T:com.db4o.ObjectContainer">com.db4o.ObjectContainer</see>
            is opened. If the
            setting is set to <code>true</code> and an index does not exist, the index will be
            created. If the setting is set to <code>false</code> and an index does exist the
            index will be dropped.<br /><br /></remarks>
            <param name="flag">
            specify <code>true</code> or <code>false</code> to turn indexing on for
            this field
            </param></member>
        <member name="M:com.db4o.config.ObjectField.rename(System.String)">
            <summary>renames a field of a stored class.</summary>
            <remarks>
            renames a field of a stored class.
            <br /><br />Use this method to refactor classes.
            <br /><br /><b>Examples: ../com/db4o/samples/rename.</b><br /><br /></remarks>
            <param name="newName">the new fieldname.</param></member>
        <member name="M:com.db4o.config.ObjectField.queryEvaluation(System.Boolean)">
            <summary>toggles query evaluation.</summary>
            <remarks>
            toggles query evaluation.
            <br /><br />All fields are evaluated by default. Use this method to turn query
            evaluation of for specific fields.<br /><br /></remarks>
            <param name="flag">specify <code>false</code> to ignore this field during query evaluation.
            	</param></member>
        <member name="T:com.db4o.replication.ReplicationConflictHandler">
            <summary>
            will be called by a
            <see cref="T:com.db4o.replication.ReplicationProcess">com.db4o.replication.ReplicationProcess
            	</see>
            upon
            replication conflicts. Conflicts occur whenever
            <see cref="M:com.db4o.replication.ReplicationProcess.replicate">com.db4o.replication.ReplicationProcess.replicate
            	</see>
            is called with an object that
            was modified in both ObjectContainers since the last replication run between
            the two.
            </summary></member>
        <member name="M:com.db4o.replication.ReplicationConflictHandler.resolveConflict(com.db4o.replication.ReplicationProcess,System.Object,System.Object)">
            <summary>the callback method to be implemented to resolve a conflict.</summary>
            <remarks>
            the callback method to be implemented to resolve a conflict. <br /><br /></remarks>
            <param name="replicationProcess">
            the
            <see cref="T:com.db4o.replication.ReplicationProcess">com.db4o.replication.ReplicationProcess
            	</see>
            for which this
            ReplicationConflictHandler is registered
            </param>
            <param name="a">the object modified in the peerA ObjectContainer</param>
            <param name="b">the object modified in the peerB ObjectContainer</param>
            <returns>
            the object (a or b) that should prevail in the conflict or null,
            if no action is to be taken. If this would violate the direction
            set with
            <see cref="M:com.db4o.replication.ReplicationProcess.setDirection">com.db4o.replication.ReplicationProcess.setDirection
            	</see>
            no action will be taken.
            </returns>
            <seealso cref="M:com.db4o.replication.ReplicationProcess.peerA">com.db4o.replication.ReplicationProcess.peerA
            	</seealso>
            <seealso cref="M:com.db4o.replication.ReplicationProcess.peerB">com.db4o.replication.ReplicationProcess.peerB
            	</seealso></member>
        <member name="M:com.db4o.nativequery.expr.Expression.accept(com.db4o.nativequery.expr.ExpressionVisitor)">
            <summary>
                <a href="http://c2.com/cgi/wiki?AcyclicVisitor">Acyclic Visitor</a>
            </summary>
            <param name="visitor">
            must implement the visitor interface required
            by the concrete Expression implementation.
            </param></member>
        <member name="T:com.db4o.reflect.ReflectField">
            <summary>representation for java.lang.reflect.Field.</summary>
            <remarks>
            representation for java.lang.reflect.Field.
            <br /><br />See the respective documentation in the JDK API.
            </remarks>
            <seealso cref="T:com.db4o.reflect.Reflector">com.db4o.reflect.Reflector</seealso></member>
        <member name="T:com.db4o.inside.query.QueryResult">
            <exclude></exclude></member>
        <member name="T:com.db4o.config.Compare">
            <summary>allows special comparison behaviour during query evaluation.</summary>
            <remarks>
            allows special comparison behaviour during query evaluation.
            <br /><br />db4o will use the Object returned by the <code>compare()</code>
            method for all query comparisons.
            </remarks></member>
        <member name="M:com.db4o.config.Compare.compare">
            <summary>return the Object to be compared during query evaluation.</summary>
            <remarks>return the Object to be compared during query evaluation.</remarks></member>
        <member name="T:com.db4o.replication.ReplicationProcess">
            <summary>db4o replication interface.</summary>
            <remarks>db4o replication interface.</remarks>
            <seealso cref="M:com.db4o.ext.ExtObjectContainer.replicationBegin">com.db4o.ext.ExtObjectContainer.replicationBegin
            	</seealso></member>
        <member name="M:com.db4o.replication.ReplicationProcess.checkConflict(System.Object)">
            <summary>
            checks if an object has been modified in both ObjectContainers involved
            in the replication process since the last time the two ObjectContainers
            were replicated.
            </summary>
            <remarks>
            checks if an object has been modified in both ObjectContainers involved
            in the replication process since the last time the two ObjectContainers
            were replicated.
            </remarks>
            <param name="obj">- the object to check for a conflict.</param></member>
        <member name="M:com.db4o.replication.ReplicationProcess.commit">
            <summary>commits the replication task to both involved ObjectContainers.</summary>
            <remarks>
            commits the replication task to both involved ObjectContainers.
            <br /><br />Call this method after replication is completed to
            write all changes back to the database files. This method
            synchronizes both ObjectContainers by setting the transaction
            serial number (@link ExtObjectContainer#version()) on both
            ObjectContainers to be equal
            to the higher version number among the two. A record with
            information about this replication task, including the
            synchronized version number is stored to both ObjectContainers
            to allow future incremental replication.
            </remarks></member>
        <member name="M:com.db4o.replication.ReplicationProcess.peerA">
            <summary>returns the "peerA" ObjectContainer involved in this ReplicationProcess.
            	</summary>
            <remarks>returns the "peerA" ObjectContainer involved in this ReplicationProcess.
            	</remarks></member>
        <member name="M:com.db4o.replication.ReplicationProcess.peerB">
            <summary>returns the "peerB" ObjectContainer involved in this ReplicationProcess.
            	</summary>
            <remarks>returns the "peerB" ObjectContainer involved in this ReplicationProcess.
            	</remarks></member>
        <member name="M:com.db4o.replication.ReplicationProcess.replicate(System.Object)">
            <summary>replicates an object.</summary>
            <remarks>
            replicates an object.
            <br /><br />By default the version number of the object is checked in
            both ObjectContainers involved in the replication process. If the
            version number has not changed since the last time the two
            ObjectContainers were replicated
            </remarks>
            <param name="obj"></param></member>
        <member name="M:com.db4o.replication.ReplicationProcess.rollback">
            <summary>ends a replication task without committing any changes.</summary>
            <remarks>ends a replication task without committing any changes.</remarks></member>
        <member name="M:com.db4o.replication.ReplicationProcess.setDirection(com.db4o.ObjectContainer,com.db4o.ObjectContainer)">
            <summary>
            modifies the replication policy, what to do on a call to
            <see cref="M:com.db4o.replication.ReplicationProcess.replicate">com.db4o.replication.ReplicationProcess.replicate
            	</see>
            .
            <br /><br />If no direction is set, the replication process will be bidirectional by
            default.
            </summary>
            <param name="relicateFrom">the ObjectContainer to replicate from</param>
            <param name="replicateTo">the ObjectContainer to replicate to</param></member>
        <member name="M:com.db4o.replication.ReplicationProcess.whereModified(com.db4o.query.Query)">
            <summary>
            adds a constraint to the passed Query to query only for objects that
            were modified since the last replication process between the two
            ObjectContainers involved in this replication process.
            </summary>
            <remarks>
            adds a constraint to the passed Query to query only for objects that
            were modified since the last replication process between the two
            ObjectContainers involved in this replication process.
            </remarks>
            <param name="query">the Query to be constrained</param></member>
        <member name="T:com.db4o.ObjectSet">
            <summary>query resultset.</summary>
            <remarks>
            query resultset.
            <br /><br />An ObjectSet is a representation for a set of objects returned
            by a query.
            <br /><br />ObjectSet extends the system collection interfaces
            java.util.List/System.Collections.IList where they are available. It is
            recommended, never to reference ObjectSet directly in code but to use
            List / IList instead.
            <br /><br />Note that the underlying
            <see cref="T:com.db4o.ObjectContainer">ObjectContainer</see>
            of an ObjectSet
            needs to remain open as long as an ObjectSet is used. This is necessary
            for lazy instantiation. The objects in an ObjectSet are only instantiated
            when they are actually being used by the application.
            </remarks>
            <seealso cref="T:com.db4o.ext.ExtObjectSet">for extended functionality.</seealso></member>
        <member name="M:com.db4o.ObjectSet.ext">
            <summary>returns an ObjectSet with extended functionality.</summary>
            <remarks>
            returns an ObjectSet with extended functionality.
            <br /><br />Every ObjectSet that db4o provides can be casted to
            an ExtObjectSet. This method is supplied for your convenience
            to work without a cast.
            <br /><br />The ObjectSet functionality is split to two interfaces
            to allow newcomers to focus on the essential methods.
            </remarks></member>
        <member name="M:com.db4o.ObjectSet.hasNext">
            <summary>returns <code>true</code> if the <code>ObjectSet</code> has more elements.
            	</summary>
            <remarks>returns <code>true</code> if the <code>ObjectSet</code> has more elements.
            	</remarks>
            <returns>
            boolean - <code>true</code> if the <code>ObjectSet</code> has more
            elements.
            </returns></member>
        <member name="M:com.db4o.ObjectSet.next">
            <summary>returns the next object in the <code>ObjectSet</code>.</summary>
            <remarks>
            returns the next object in the <code>ObjectSet</code>.
            <br /><br />
            Before returning the Object, next() triggers automatic activation of the
            Object with the respective
            <see cref="M:com.db4o.config.Configuration.activationDepth">global</see>
            or
            <see cref="M:com.db4o.config.ObjectClass.maximumActivationDepth">class specific</see>
            setting.<br /><br /></remarks>
            <returns>the next object in the <code>ObjectSet</code>.</returns></member>
        <member name="M:com.db4o.ObjectSet.reset">
            <summary>resets the <code>ObjectSet</code> cursor before the first element.</summary>
            <remarks>
            resets the <code>ObjectSet</code> cursor before the first element.
            <br /><br />A subsequent call to <code>next()</code> will return the first element.
            </remarks></member>
        <member name="M:com.db4o.ObjectSet.size">
            <summary>returns the number of elements in the <code>ObjectSet</code>.</summary>
            <remarks>returns the number of elements in the <code>ObjectSet</code>.</remarks>
            <returns>the number of elements in the <code>ObjectSet</code>.</returns></member>
        <member name="T:com.db4o.reflect.generic.GenericConverter">
            <exclude></exclude></member>
        <member name="T:com.db4o.inside.replication.Db4oReplicationReference">
            <exclude></exclude></member>
        <member name="T:com.db4o.messaging.MessageSender">
            <summary>message sender for client/server messaging.</summary>
            <remarks>
            message sender for client/server messaging.
            <br /><br />db4o allows using the client/server TCP connection to send
            messages from the client to the server. Any object that can be
            stored to a db4o database file may be used as a message.<br /><br />
            See the sample in ../com/db4o/samples/messaging/ on how to
            use the messaging feature. It is also used to stop the server
            in ../com/db4o/samples/clientserver/StopServer.java<br /><br /><b>See Also:</b><br /><see cref="M:com.db4o.config.Configuration.getMessageSender">com.db4o.config.Configuration.getMessageSender
            	</see>
            ,<br /><see cref="T:com.db4o.messaging.MessageRecipient">com.db4o.messaging.MessageRecipient
            	</see>
            ,<br /><see cref="M:com.db4o.config.Configuration.setMessageRecipient">com.db4o.config.Configuration.setMessageRecipient
            	</see></remarks></member>
        <member name="M:com.db4o.messaging.MessageSender.send(System.Object)">
            <summary>sends a message to the server.</summary>
            <remarks>sends a message to the server.</remarks>
            <param name="obj">the message parameter, any object may be used.</param></member>
        <member name="T:com.db4o.YapComparable">
            <exclude></exclude></member>
        <member name="T:com.db4o.reflect.ReflectArray">
            <summary>representation for java.lang.reflect.Array.</summary>
            <remarks>
            representation for java.lang.reflect.Array.
            <br /><br />See the respective documentation in the JDK API.
            </remarks>
            <seealso cref="T:com.db4o.reflect.Reflector">com.db4o.reflect.Reflector</seealso></member>
        <member name="T:com.db4o.query.Constraint">
            <summary>
            constraint to limit the objects returned upon
            <see cref="M:com.db4o.query.Query.execute">query execution</see>
            .
            <br /><br />
            Constraints are constructed by calling
            <see cref="M:com.db4o.query.Query.constrain">Query.constrain()</see>
            .
            <br /><br />
            Constraints can be joined with the methods
            <see cref="M:com.db4o.query.Constraint.and">com.db4o.query.Constraint.and</see>
            and
            <see cref="M:com.db4o.query.Constraint.or">com.db4o.query.Constraint.or</see>
            .
            <br /><br />
            The methods to modify the constraint evaluation algorithm may
            be merged, to construct combined evaluation rules.
            Examples:
            <ul>
                    <li>
                        <code>Constraint#smaller().equal()</code> for "smaller or equal" </li>
                    <li>
                        <code>Constraint#not().like()</code> for "not like" </li>
                    <li>
                        <code>Constraint#not().greater().equal()</code> for "not greater or equal" </li>
                </ul></summary></member>
        <member name="M:com.db4o.query.Constraint.and(com.db4o.query.Constraint)">
            <summary>links two Constraints for AND evaluation.</summary>
            <remarks>links two Constraints for AND evaluation.</remarks>
            <param name="with">
            the other
            <see cref="T:com.db4o.query.Constraint">com.db4o.query.Constraint</see></param>
            <returns>
            a new
            <see cref="T:com.db4o.query.Constraint">com.db4o.query.Constraint</see>
            , that can be used for further calls
            to
            <see cref="M:com.db4o.query.Constraint.and">and()</see>
            and
            <see cref="M:com.db4o.query.Constraint.or">or()</see></returns></member>
        <member name="M:com.db4o.query.Constraint.or(com.db4o.query.Constraint)">
            <summary>links two Constraints for OR evaluation.</summary>
            <remarks>links two Constraints for OR evaluation.</remarks>
            <param name="with">
            the other
            <see cref="T:com.db4o.query.Constraint">com.db4o.query.Constraint</see></param>
            <returns>
            a new
            <see cref="T:com.db4o.query.Constraint">com.db4o.query.Constraint</see>
            , that can be used for further calls
            to
            <see cref="M:com.db4o.query.Constraint.and">and()</see>
            and
            <see cref="M:com.db4o.query.Constraint.or">or()</see></returns></member>
        <member name="M:com.db4o.query.Constraint.equal">
            <summary>sets the evaluation mode to <code>==</code>.</summary>
            <remarks>sets the evaluation mode to <code>==</code>.</remarks>
            <returns>
            this
            <see cref="T:com.db4o.query.Constraint">com.db4o.query.Constraint</see>
            to allow the chaining of method calls.
            </returns></member>
        <member name="M:com.db4o.query.Constraint.greater">
            <summary>sets the evaluation mode to <code>&gt;</code>.</summary>
            <remarks>sets the evaluation mode to <code>&gt;</code>.</remarks>
            <returns>
            this
            <see cref="T:com.db4o.query.Constraint">com.db4o.query.Constraint</see>
            to allow the chaining of method calls.
            </returns></member>
        <member name="M:com.db4o.query.Constraint.smaller">
            <summary>sets the evaluation mode to <code>&lt;</code>.</summary>
            <remarks>sets the evaluation mode to <code>&lt;</code>.</remarks>
            <returns>
            this
            <see cref="T:com.db4o.query.Constraint">com.db4o.query.Constraint</see>
            to allow the chaining of method calls.
            </returns></member>
        <member name="M:com.db4o.query.Constraint.identity">
            <summary>sets the evaluation mode to identity comparison.</summary>
            <remarks>sets the evaluation mode to identity comparison.</remarks>
            <returns>
            this
            <see cref="T:com.db4o.query.Constraint">com.db4o.query.Constraint</see>
            to allow the chaining of method calls.
            </returns></member>
        <member name="M:com.db4o.query.Constraint.like">
            <summary>sets the evaluation mode to "like" comparison.</summary>
            <remarks>
            sets the evaluation mode to "like" comparison.
            <br /><br />Constraints are compared to the first characters of a field.<br /><br /></remarks>
            <returns>
            this
            <see cref="T:com.db4o.query.Constraint">com.db4o.query.Constraint</see>
            to allow the chaining of method calls.
            </returns></member>
        <member name="M:com.db4o.query.Constraint.contains">
            <summary>sets the evaluation mode to containment comparison.</summary>
            <remarks>sets the evaluation mode to containment comparison.</remarks>
            <returns>
            this
            <see cref="T:com.db4o.query.Constraint">com.db4o.query.Constraint</see>
            to allow the chaining of method calls.
            </returns></member>
        <member name="M:com.db4o.query.Constraint.not">
            <summary>turns on not() comparison.</summary>
            <remarks>turns on not() comparison.</remarks>
            <returns>
            this
            <see cref="T:com.db4o.query.Constraint">com.db4o.query.Constraint</see>
            to allow the chaining of method calls.
            </returns></member>
        <member name="M:com.db4o.query.Constraint.getObject">
            <summary>
            returns the Object the query graph was constrained with to
            create this
            <see cref="T:com.db4o.query.Constraint">com.db4o.query.Constraint</see>
            .
            </summary>
            <returns>Object the constraining object.</returns></member>
        <member name="T:com.db4o.config.ObjectClass">
            <summary>configuration interface for classes.</summary>
            <remarks>
            configuration interface for classes.
            <br /><br /><b>Examples: ../com/db4o/samples/translators/Default.java.</b><br /><br />
            Use the global Configuration object to configure db4o before opening an
            <see cref="T:com.db4o.ObjectContainer">ObjectContainer</see>
            .<br /><br /><b>Example:</b><br /><code>
            Configuration config = Db4o.configure();<br />
            ObjectClass oc = config.objectClass("package.className");<br />
            oc.updateDepth(3);<br />
            oc.minimumActivationDepth(3);<br /></code></remarks></member>
        <member name="M:com.db4o.config.ObjectClass.callConstructor(System.Boolean)">
            <summary>
            advises db4o to try instantiating objects of this class with/without
            calling constructors.
            </summary>
            <remarks>
            advises db4o to try instantiating objects of this class with/without
            calling constructors.
            <br /><br />
            Not all JDKs / .NET-environments support this feature. db4o will
            attempt, to follow the setting as good as the enviroment supports.
            In doing so, it may call implementation-specific features like
            sun.reflect.ReflectionFactory#newConstructorForSerialization on the
            Sun Java 1.4.x/5 VM (not available on other VMs) and
            FormatterServices.GetUninitializedObject() on
            the .NET framework (not available on CompactFramework).<br /><br />
            This setting may also be set globally for all classes in
            <see cref="M:com.db4o.config.Configuration.callConstructors">com.db4o.config.Configuration.callConstructors
            	</see>
            .<br /><br /></remarks>
            <param name="flag">
            - specify true, to request calling constructors, specify
            false to request <b>not</b> calling constructors.
            </param>
            <seealso cref="M:com.db4o.config.Configuration.callConstructors">com.db4o.config.Configuration.callConstructors
            	</seealso></member>
        <member name="M:com.db4o.config.ObjectClass.cascadeOnActivate(System.Boolean)">
            <summary>sets cascaded activation behaviour.</summary>
            <remarks>
            sets cascaded activation behaviour.
            <br /><br />
            Setting cascadeOnActivate to true will result in the activation
            of all member objects if an instance of this class is activated.
            <br /><br />
            The default setting is <b>false</b>.<br /><br /></remarks>
            <param name="flag">whether activation is to be cascaded to member objects.</param>
            <seealso cref="M:com.db4o.config.ObjectField.cascadeOnActivate">com.db4o.config.ObjectField.cascadeOnActivate
            	</seealso>
            <seealso cref="M:com.db4o.ObjectContainer.activate">com.db4o.ObjectContainer.activate
            	</seealso>
            <seealso cref="T:com.db4o.ext.ObjectCallbacks">Using callbacks</seealso>
            <seealso cref="M:com.db4o.config.Configuration.activationDepth">Why activation?</seealso></member>
        <member name="M:com.db4o.config.ObjectClass.cascadeOnDelete(System.Boolean)">
            <summary>sets cascaded delete behaviour.</summary>
            <remarks>
            sets cascaded delete behaviour.
            <br /><br />
            Setting cascadeOnDelete to true will result in the deletion of
            all member objects of instances of this class, if they are
            passed to
            <see cref="M:com.db4o.ObjectContainer.delete">com.db4o.ObjectContainer.delete</see>
            .
            <br /><br /><b>Caution !</b><br />
            This setting will also trigger deletion of old member objects, on
            calls to
            <see cref="M:com.db4o.ObjectContainer.set">com.db4o.ObjectContainer.set</see>
            .<br /><br />
            An example of the behaviour:<br /><code>
            ObjectContainer con;<br />
            Bar bar1 = new Bar();<br />
            Bar bar2 = new Bar();<br />
            foo.bar = bar1;<br />
            con.set(foo);  // bar1 is stored as a member of foo<br />
            foo.bar = bar2;<br />
            con.set(foo);  // bar2 is stored as a member of foo
            </code><br />The last statement will <b>also</b> delete bar1 from the
            ObjectContainer, no matter how many other stored objects hold references
            to bar1.
            <br /><br />
            The default setting is <b>false</b>.<br /><br /></remarks>
            <param name="flag">whether deletes are to be cascaded to member objects.</param>
            <seealso cref="M:com.db4o.config.ObjectField.cascadeOnDelete">com.db4o.config.ObjectField.cascadeOnDelete
            	</seealso>
            <seealso cref="M:com.db4o.ObjectContainer.delete">com.db4o.ObjectContainer.delete</seealso>
            <seealso cref="T:com.db4o.ext.ObjectCallbacks">Using callbacks</seealso></member>
        <member name="M:com.db4o.config.ObjectClass.cascadeOnUpdate(System.Boolean)">
            <summary>sets cascaded update behaviour.</summary>
            <remarks>
            sets cascaded update behaviour.
            <br /><br />
            Setting cascadeOnUpdate to true will result in the update
            of all member objects if a stored instance of this class is passed
            to
            <see cref="M:com.db4o.ObjectContainer.set">com.db4o.ObjectContainer.set</see>
            .<br /><br />
            The default setting is <b>false</b>.<br /><br /></remarks>
            <param name="flag">whether updates are to be cascaded to member objects.</param>
            <seealso cref="M:com.db4o.config.ObjectField.cascadeOnUpdate">com.db4o.config.ObjectField.cascadeOnUpdate
            	</seealso>
            <seealso cref="M:com.db4o.ObjectContainer.set">com.db4o.ObjectContainer.set</seealso>
            <seealso cref="T:com.db4o.ext.ObjectCallbacks">Using callbacks</seealso></member>
        <member name="M:com.db4o.config.ObjectClass.compare(com.db4o.config.ObjectAttribute)">
            <summary>registers an attribute provider for special query behavior.</summary>
            <remarks>
            registers an attribute provider for special query behavior.
            <br /><br />The query processor will compare the object returned by the
            attribute provider instead of the actual object, both for the constraint
            and the candidate persistent object.<br /><br /> Preinstalled attribute
            providers are documented
            in the sourcecode of
            com.db4o.samples.translators.Default.java#defaultConfiguration().<br /><br /></remarks>
            <param name="attributeProvider">the attribute provider to be used</param></member>
        <member name="M:com.db4o.config.ObjectClass.enableReplication(System.Boolean)">
            <summary>
            Must be called before databases are created or opened
            so that db4o will control versions and generate UUIDs
            for objects of this class, which is required for using replication.
            </summary>
            <remarks>
            Must be called before databases are created or opened
            so that db4o will control versions and generate UUIDs
            for objects of this class, which is required for using replication.
            </remarks>
            <param name="setting"></param></member>
        <member name="M:com.db4o.config.ObjectClass.generateUUIDs(System.Boolean)">
            <summary>generate UUIDs for stored objects of this class.</summary>
            <remarks>generate UUIDs for stored objects of this class.</remarks>
            <param name="setting"></param></member>
        <member name="M:com.db4o.config.ObjectClass.generateVersionNumbers(System.Boolean)">
            <summary>generate version numbers for stored objects of this class.</summary>
            <remarks>generate version numbers for stored objects of this class.</remarks>
            <param name="setting"></param></member>
        <member name="M:com.db4o.config.ObjectClass.maximumActivationDepth(System.Int32)">
            <summary>sets the maximum activation depth to the desired value.</summary>
            <remarks>
            sets the maximum activation depth to the desired value.
            <br /><br />A class specific setting overrides the
            <see cref="M:com.db4o.config.Configuration.activationDepth">global setting</see><br /><br /></remarks>
            <param name="depth">the desired maximum activation depth</param>
            <seealso cref="M:com.db4o.config.Configuration.activationDepth">Why activation?</seealso>
            <seealso cref="M:com.db4o.config.ObjectClass.cascadeOnActivate">com.db4o.config.ObjectClass.cascadeOnActivate
            	</seealso></member>
        <member name="M:com.db4o.config.ObjectClass.minimumActivationDepth(System.Int32)">
            <summary>sets the minimum activation depth to the desired value.</summary>
            <remarks>
            sets the minimum activation depth to the desired value.
            <br /><br />A class specific setting overrides the
            <see cref="M:com.db4o.config.Configuration.activationDepth">global setting</see><br /><br /></remarks>
            <param name="depth">the desired minimum activation depth</param>
            <seealso cref="M:com.db4o.config.Configuration.activationDepth">Why activation?</seealso>
            <seealso cref="M:com.db4o.config.ObjectClass.cascadeOnActivate">com.db4o.config.ObjectClass.cascadeOnActivate
            	</seealso></member>
        <member name="M:com.db4o.config.ObjectClass.objectField(System.String)">
            <summary>
            returns an
            <see cref="T:com.db4o.config.ObjectField">ObjectField</see>
            object
            to configure the specified field.
            <br /><br /></summary>
            <param name="fieldName">the fieldname of the field to be configured.<br /><br /></param>
            <returns>
            an instance of an
            <see cref="T:com.db4o.config.ObjectField">ObjectField</see>
            object for configuration.
            </returns></member>
        <member name="M:com.db4o.config.ObjectClass.persistStaticFieldValues">
            <summary>turns on storing static field values for this class.</summary>
            <remarks>
            turns on storing static field values for this class.
            <br /><br />By default, static field values of classes are not stored
            to the database file. By turning the setting on for a specific class
            with this switch, all <b>non-simple-typed</b> static field values of this
            class are stored the first time an object of the class is stored, and
            restored, every time a database file is opened afterwards.
            <br /><br />The setting will be ignored for simple types.
            <br /><br />Use this setting for constant static object members.
            <br /><br />This option will slow down the process of opening database
            files and the stored objects will occupy space in the database file.
            </remarks></member>
        <member name="M:com.db4o.config.ObjectClass.readAs(System.Object)">
            <summary>creates a temporary mapping of a persistent class to a different class.</summary>
            <remarks>
            creates a temporary mapping of a persistent class to a different class.
            <br /><br />If meta information for this ObjectClass has been stored to
            the database file, it will be read from the database file as if it
            was representing the class specified by the clazz parameter passed to
            this method.
            The clazz parameter can be any of the following:<br />
            - a fully qualified classname as a String.<br />
            - a Class object.<br />
            - any other object to be used as a template.<br /><br />
            This method will be ignored if the database file already contains meta
            information for clazz.
            </remarks>
            <param name="clazz">class name, Class object, or example object.<br /><br /></param></member>
        <member name="M:com.db4o.config.ObjectClass.rename(System.String)">
            <summary>renames a stored class.</summary>
            <remarks>
            renames a stored class.
            <br /><br />Use this method to refactor classes.
            <br /><br /><b>Examples: ../com/db4o/samples/rename.</b><br /><br /></remarks>
            <param name="newName">the new fully qualified classname.</param></member>
        <member name="M:com.db4o.config.ObjectClass.storeTransientFields(System.Boolean)">
            <summary>allows to specify if transient fields are to be stored.</summary>
            <remarks>
            allows to specify if transient fields are to be stored.
            <br />The default for every class is <code>false</code>.<br /><br /></remarks>
            <param name="flag">whether or not transient fields are to be stored.</param></member>
        <member name="M:com.db4o.config.ObjectClass.translate(com.db4o.config.ObjectTranslator)">
            <summary>registers a translator for this class.</summary>
            <remarks>
            registers a translator for this class.
            <br /><br />
            Preinstalled translators are documented in the sourcecode of
            com.db4o.samples.translators.Default.java#defaultConfiguration().
            <br /><br />Example translators can also be found in this folder.<br /><br /></remarks>
            <param name="translator">
            this may be an
            <see cref="T:com.db4o.config.ObjectTranslator">ObjectTranslator</see>
            or an
            <see cref="T:com.db4o.config.ObjectConstructor">ObjectConstructor</see></param>
            <seealso cref="T:com.db4o.config.ObjectTranslator">com.db4o.config.ObjectTranslator
            	</seealso>
            <seealso cref="T:com.db4o.config.ObjectConstructor">com.db4o.config.ObjectConstructor
            	</seealso></member>
        <member name="M:com.db4o.config.ObjectClass.updateDepth(System.Int32)">
            <summary>specifies the updateDepth for this class.</summary>
            <remarks>
            specifies the updateDepth for this class.
            <br /><br />see the documentation of
            <see cref="M:com.db4o.ObjectContainer.set">com.db4o.ObjectContainer.set</see>
            for further details.<br /><br />
            The default setting is 0: Only the object passed to
            <see cref="M:com.db4o.ObjectContainer.set">com.db4o.ObjectContainer.set</see>
            will be updated.<br /><br /></remarks>
            <param name="depth">the depth of the desired update for this class.</param>
            <seealso cref="M:com.db4o.config.Configuration.updateDepth">com.db4o.config.Configuration.updateDepth
            	</seealso>
            <seealso cref="M:com.db4o.config.ObjectClass.cascadeOnUpdate">com.db4o.config.ObjectClass.cascadeOnUpdate
            	</seealso>
            <seealso cref="M:com.db4o.config.ObjectField.cascadeOnUpdate">com.db4o.config.ObjectField.cascadeOnUpdate
            	</seealso>
            <seealso cref="T:com.db4o.ext.ObjectCallbacks">Using callbacks</seealso></member>
        <member name="T:com.db4o.ext.StoredField">
            <summary>the internal representation of a field on a stored class.</summary>
            <remarks>the internal representation of a field on a stored class.</remarks></member>
        <member name="M:com.db4o.ext.StoredField.get(System.Object)">
            <summary>returns the field value on the passed object.</summary>
            <remarks>
            returns the field value on the passed object.
            <br /><br />This method will also work, if the field is not present in the current
            version of the class.
            <br /><br />It is recommended to use this method for refactoring purposes, if fields
            are removed and the field values need to be copied to other fields.
            </remarks></member>
        <member name="M:com.db4o.ext.StoredField.getName">
            <summary>returns the name of the field.</summary>
            <remarks>returns the name of the field.</remarks></member>
        <member name="M:com.db4o.ext.StoredField.getStoredType">
            <summary>returns the Class (Java) / Type (.NET) of the field.</summary>
            <remarks>
            returns the Class (Java) / Type (.NET) of the field.
            <br /><br />For array fields this method will return the type of the array.
            Use {link #isArray()} to detect arrays.
            </remarks></member>
        <member name="M:com.db4o.ext.StoredField.isArray">
            <summary>returns true if the field is an array.</summary>
            <remarks>returns true if the field is an array.</remarks></member>
        <member name="M:com.db4o.ext.StoredField.rename(System.String)">
            <summary>modifies the name of this stored field.</summary>
            <remarks>
            modifies the name of this stored field.
            <br /><br />After renaming one or multiple fields the ObjectContainer has
            to be closed and reopened to allow internal caches to be refreshed.<br /><br /></remarks>
            <param name="name">the new name</param></member>
        <member name="T:com.db4o.types.Db4oCollections">
            <summary>factory and other methods for database-aware collections.</summary>
            <remarks>factory and other methods for database-aware collections.</remarks></member>
        <member name="M:com.db4o.types.Db4oCollections.newLinkedList">
            <summary>creates a new database-aware linked list.</summary>
            <remarks>
            creates a new database-aware linked list.
            <br /><br />Usage:<br />
            - declare a <code>java.util.List</code> variable in your persistent class.<br />
            - fill this variable with this method.<br /><br /><b>Example:</b><br /><br /><code>
                    <pre>
            class MyClass{
            List myList;
            }
            MyClass myObject = new MyClass();
            myObject.myList = objectContainer.ext().collections().newLinkedList();</pre>
                </code><br /><br /></remarks>
            <returns>
                <see cref="T:com.db4o.types.Db4oList">com.db4o.types.Db4oList</see>
            </returns>
            <seealso cref="T:com.db4o.types.Db4oList">com.db4o.types.Db4oList</seealso></member>
        <member name="M:com.db4o.types.Db4oCollections.newHashMap(System.Int32)">
            <summary>creates a new database-aware HashMap.</summary>
            <remarks>
            creates a new database-aware HashMap.
            <br /><br />
            This map will call the hashCode() method on the key objects to calculate the
            hash value. Since the hash value is stored to the ObjectContainer, key objects
            will have to return the same hashCode() value in every VM session.
            <br /><br />
            Usage:<br />
            - declare a <code>java.util.Map</code> variable in your persistent class.<br />
            - fill the variable with this method.<br /><br /><b>Example:</b><br /><br /><code>
                    <pre>
            class MyClass{
            Map myMap;
            }
            MyClass myObject = new MyClass();
            myObject.myMap = objectContainer.ext().collections().newHashMap(0);</pre>
                </code><br /><br /></remarks>
            <param name="initialSize">the initial size of the HashMap</param>
            <returns>
                <see cref="T:com.db4o.types.Db4oMap">com.db4o.types.Db4oMap</see>
            </returns>
            <seealso cref="T:com.db4o.types.Db4oMap">com.db4o.types.Db4oMap</seealso></member>
        <member name="M:com.db4o.types.Db4oCollections.newIdentityHashMap(System.Int32)">
            <summary>creates a new database-aware IdentityHashMap.</summary>
            <remarks>
            creates a new database-aware IdentityHashMap.
            <br /><br />
            Only first class objects already stored to the ObjectContainer (Objects with a db4o ID)
            can be used as keys for this type of Map. The internal db4o ID will be used as
            the hash value.
            <br /><br />
            Usage:<br />
            - declare a <code>java.util.Map</code> variable in your persistent class.<br />
            - fill the variable with this method.<br /><br /><b>Example:</b><br /><br /><code>
                    <pre>
            class MyClass{
            Map myMap;
            }
            MyClass myObject = new MyClass();
            myObject.myMap = objectContainer.ext().collections().newIdentityMap(0);</pre>
                </code><br /><br /></remarks>
            <param name="initialSize">the initial size of the HashMap</param>
            <returns>
                <see cref="T:com.db4o.types.Db4oMap">com.db4o.types.Db4oMap</see>
            </returns>
            <seealso cref="T:com.db4o.types.Db4oMap">com.db4o.types.Db4oMap</seealso></member>
        <member name="T:com.db4o.config.ObjectTranslator">
            <summary>translator interface to translate objects on storage and activation.</summary>
            <remarks>
            translator interface to translate objects on storage and activation.
            <br /><br /><b>Examples: ../com/db4o/samples/translators.</b><br /><br />
            By writing classes that implement this interface, it is possible to
            define how application classes are to be converted to be stored more efficiently.
            <br /><br />
            Before starting a db4o session, translator classes need to be registered. An example:<br /><code>
            Configuration config = Db4o.configure();<br />
            ObjectClass oc = config.objectClass("package.className");<br />
            oc.translate(new FooTranslator());</code><br /><br /></remarks></member>
        <member name="M:com.db4o.config.ObjectTranslator.onStore(com.db4o.ObjectContainer,System.Object)">
            <summary>db4o calls this method during storage and query evaluation.</summary>
            <remarks>db4o calls this method during storage and query evaluation.</remarks>
            <param name="container">the ObjectContainer used</param>
            <param name="applicationObject">the Object to be translated</param>
            <returns>
            return the object to store.<br />It needs to be of the class
            <see cref="M:com.db4o.config.ObjectTranslator.storedClass">storedClass()</see>
            .
            </returns></member>
        <member name="M:com.db4o.config.ObjectTranslator.onActivate(com.db4o.ObjectContainer,System.Object,System.Object)">
            <summary>db4o calls this method during activation.</summary>
            <remarks>db4o calls this method during activation.</remarks>
            <param name="container">the ObjectContainer used</param>
            <param name="applicationObject">the object to set the members on</param>
            <param name="storedObject">the object that was stored</param></member>
        <member name="M:com.db4o.config.ObjectTranslator.storedClass">
            <summary>return the Class you are converting to.</summary>
            <remarks>return the Class you are converting to.</remarks>
            <returns>
            the Class of the object you are returning with the method
            <see cref="M:com.db4o.config.ObjectTranslator.onStore">onStore()</see></returns></member>
        <member name="T:com.db4o.query.Candidate">
            <summary>
            candidate for
            <see cref="T:com.db4o.query.Evaluation">com.db4o.query.Evaluation</see>
            callbacks.
            <br /><br />
            During
            <see cref="M:com.db4o.query.Query.execute">query execution</see>
            all registered
            <see cref="T:com.db4o.query.Evaluation">com.db4o.query.Evaluation</see>
            callback
            handlers are called with
            <see cref="T:com.db4o.query.Candidate">com.db4o.query.Candidate</see>
            proxies that represent the persistent objects that
            meet all other
            <see cref="T:com.db4o.query.Query">com.db4o.query.Query</see>
            criteria.
            <br /><br />
            A
            <see cref="T:com.db4o.query.Candidate">com.db4o.query.Candidate</see>
            provides access to the persistent object it
            represents and allows to specify, whether it is to be included in the
            <see cref="T:com.db4o.ObjectSet">com.db4o.ObjectSet</see>
            resultset.
            </summary></member>
        <member name="M:com.db4o.query.Candidate.getObject">
            <summary>
            returns the persistent object that is represented by this query
            <see cref="T:com.db4o.query.Candidate">com.db4o.query.Candidate</see>
            .
            </summary>
            <returns>Object the persistent object.</returns></member>
        <member name="M:com.db4o.query.Candidate.include(System.Boolean)">
            <summary>
            specify whether the Candidate is to be included in the
            <see cref="T:com.db4o.ObjectSet">com.db4o.ObjectSet</see>
            resultset.
            <br /><br />
            This method may be called multiple times. The last call prevails.
            </summary>
            <param name="flag">inclusion.</param></member>
        <member name="M:com.db4o.query.Candidate.objectContainer">
            <summary>
            returns the
            <see cref="T:com.db4o.ObjectContainer">com.db4o.ObjectContainer</see>
            the Candidate object is stored in.
            </summary>
            <returns>
            the
            <see cref="T:com.db4o.ObjectContainer">com.db4o.ObjectContainer</see></returns></member>
        <member name="T:com.db4o.ObjectServer">
            <summary>the db4o server interface.</summary>
            <remarks>
            the db4o server interface.
            <br /><br />- db4o servers can be opened with
            <see cref="M:com.db4o.Db4o.openServer">com.db4o.Db4o.openServer</see>
            .<br />
            - Direct in-memory connections to servers can be made with
            <see cref="M:com.db4o.ObjectServer.openClient">com.db4o.ObjectServer.openClient</see><br />
            - TCP connections are available through
            <see cref="M:com.db4o.Db4o.openClient">com.db4o.Db4o.openClient</see>
            .
            <br /><br />Before connecting clients over TCP, you have to
            <see cref="M:com.db4o.ObjectServer.grantAccess">com.db4o.ObjectServer.grantAccess</see>
            to the username and password combination
            that you want to use.
            </remarks>
            <seealso cref="M:com.db4o.Db4o.openServer">Db4o.openServer</seealso>
            <seealso cref="T:com.db4o.ext.ExtObjectServer">ExtObjectServer for extended functionality
            	</seealso></member>
        <member name="M:com.db4o.ObjectServer.close">
            <summary>closes the <code>ObjectServer</code> and writes all cached data.</summary>
            <remarks>
            closes the <code>ObjectServer</code> and writes all cached data.
            <br /><br /></remarks>
            <returns>
            true - denotes that the last instance connected to the
            used database file was closed.
            </returns></member>
        <member name="M:com.db4o.ObjectServer.ext">
            <summary>returns an ObjectServer with extended functionality.</summary>
            <remarks>
            returns an ObjectServer with extended functionality.
            <br /><br />Use this method as a convient accessor to extended methods.
            Every ObjectServer can be casted to an ExtObjectServer.
            <br /><br />The functionality is split to two interfaces to allow newcomers to
            focus on the essential methods.
            </remarks></member>
        <member name="M:com.db4o.ObjectServer.grantAccess(System.String,System.String)">
            <summary>grants client access to the specified user with the specified password.</summary>
            <remarks>
            grants client access to the specified user with the specified password.
            <br /><br />If the user already exists, the password is changed to
            the specified password.<br /><br /></remarks>
            <param name="userName">the name of the user</param>
            <param name="password">the password to be used</param></member>
        <member name="M:com.db4o.ObjectServer.openClient">
            <summary>opens a client against this server.</summary>
            <remarks>
            opens a client against this server.
            <br /><br />A client opened with this method operates within the same VM
            as the server. Since an embedded client can use direct communication, without
            an in-between socket connection, performance will be better than a client
            opened with
            <see cref="M:com.db4o.Db4o.openClient">com.db4o.Db4o.openClient</see><br /><br />Every client has it's own transaction and uses it's own cache
            for it's own version of all peristent objects.
            </remarks></member>
        <member name="T:com.db4o.ReadWriteable">
            <exclude></exclude></member>
        <member name="T:com.db4o.UseSystemTransaction">
            <summary>marker interface to distinguish, which transaction to use</summary></member>
        <member name="P:Cecil.FlowAnalysis.ControlFlow.IControlFlowGraph.MethodBody">
            <summary>
            The method body represented by this control flow graph.
            </summary></member>
        <member name="P:Cecil.FlowAnalysis.ControlFlow.IControlFlowGraph.Blocks">
            <summary>
            The blocks.
            </summary></member>
        <member name="M:Cecil.FlowAnalysis.ControlFlow.IControlFlowGraph.GetData(Mono.Cecil.Cil.IInstruction)">
            <summary>
            Retrieves data about a specific instruction.
            </summary>
            <param name="instruction"></param>
            <returns></returns></member>
        <member name="T:com.db4o.foundation.DeepClone">
            <summary>Deep clone</summary>
            <exclude></exclude></member>
        <member name="M:com.db4o.foundation.DeepClone.deepClone(System.Object)">
            <summary>
            The parameter allows passing one new object so parent
            references can be corrected on children.
            </summary>
            <remarks>
            The parameter allows passing one new object so parent
            references can be corrected on children.
            </remarks></member>
        <member name="T:com.db4o.types.Db4oCollection">
            <summary>base interface for db4o collections</summary></member>
        <member name="M:com.db4o.types.Db4oCollection.activationDepth(System.Int32)">
            <summary>configures the activation depth for objects returned from this collection.
            	</summary>
            <remarks>
            configures the activation depth for objects returned from this collection.
            <br /><br />Specify a value less than zero to use the default activation depth
            configured for the ObjectContainer or for individual objects.
            </remarks>
            <param name="depth">the desired depth</param></member>
        <member name="M:com.db4o.types.Db4oCollection.deleteRemoved(System.Boolean)">
            <summary>
            configures objects are to be deleted from the database file if they are
            removed from this collection.
            </summary>
            <remarks>
            configures objects are to be deleted from the database file if they are
            removed from this collection.
            <br /><br />Default value: <code>false</code></remarks>
            <param name="flag">the desired setting</param></member>
        <member name="T:com.db4o.ext.StoredClass">
            <summary>the internal representation of a stored class.</summary>
            <remarks>the internal representation of a stored class.</remarks></member>
        <member name="M:com.db4o.ext.StoredClass.getName">
            <summary>returns the name of this stored class.</summary>
            <remarks>returns the name of this stored class.</remarks></member>
        <member name="M:com.db4o.ext.StoredClass.getIDs">
            <summary>returns an array of IDs of all stored object instances of this stored class.
            	</summary>
            <remarks>returns an array of IDs of all stored object instances of this stored class.
            	</remarks></member>
        <member name="M:com.db4o.ext.StoredClass.getParentStoredClass">
            <summary>returns the StoredClass for the parent of the class, this StoredClass represents.
            	</summary>
            <remarks>returns the StoredClass for the parent of the class, this StoredClass represents.
            	</remarks></member>
        <member name="M:com.db4o.ext.StoredClass.getStoredFields">
            <summary>returns all stored fields of this stored class.</summary>
            <remarks>returns all stored fields of this stored class.</remarks></member>
        <member name="M:com.db4o.ext.StoredClass.rename(System.String)">
            <summary>renames this stored class.</summary>
            <remarks>
            renames this stored class.
            <br /><br />After renaming one or multiple classes the ObjectContainer has
            to be closed and reopened to allow internal caches to be refreshed.
            <br /><br />.NET: As the name you should provide [Classname, Assemblyname]<br /><br /></remarks>
            <param name="name">the new name</param></member>
        <member name="M:com.db4o.ext.StoredClass.storedField(System.String,System.Object)">
            <summary>returns an existing stored field of this stored class.</summary>
            <remarks>returns an existing stored field of this stored class.</remarks>
            <param name="name">the name of the field</param>
            <param name="type">
            the type of the field.
            There are four possibilities how to supply the type:<br />
            - a Class object.  (.NET: a Type object)<br />
            - a fully qualified classname.<br />
            - any object to be used as a template.<br /><br />
            - null, if the first found field should be returned.
            </param>
            <returns>
            the
            <see cref="T:com.db4o.ext.StoredField">com.db4o.ext.StoredField</see></returns></member>
        <member name="T:com.db4o.ext.ExtClient">
            <summary>
            extended client functionality for the
            <see cref="T:com.db4o.ext.ExtObjectContainer">ExtObjectContainer</see>
            interface.
            <br /><br />Both
            <see cref="M:com.db4o.Db4o.openClient">Db4o.openClient()</see>
            methods always
            return an <code>ExtClient</code> object so a cast is possible.<br /><br />
            The ObjectContainer functionality is split into multiple interfaces to allow newcomers to
            focus on the essential methods.
            </summary></member>
        <member name="M:com.db4o.ext.ExtClient.switchToFile(System.String)">
            <summary>requests opening a different server database file for this client session.
            	</summary>
            <remarks>
            requests opening a different server database file for this client session.
            <br /><br />
            This method can be used to switch between database files from the client
            side while not having to open a new socket connection or closing the
            current one.
            <br /><br />
            If the database file does not exist on the server, it will be created.
            <br /><br />
            A typical usecase:<br />
            The main database file is used for login, user and rights management only.
            Only one single db4o server session needs to be run. Multiple satellite
            database files are used for different applications or multiple user circles.
            Storing the data to multiple database files has the following advantages:<br />
            - easier rights management<br />
            - easier backup<br />
            - possible later load balancing to multiple servers<br />
            - better performance of smaller individual database files<br />
            - special debugging database files can be used
            <br /><br />
            User authorization to the alternative database file will not be checked.
            <br /><br />
            All persistent references to objects that are currently in memory
            are discarded during the switching process.<br /><br /></remarks>
            <param name="fileName">the fully qualified path of the requested database file.</param></member>
        <member name="M:com.db4o.ext.ExtClient.switchToMainFile">
            <summary>
            requests switching back to the main database file after a previous call
            to <code>switchToFile(String fileName)</code>.
            </summary>
            <remarks>
            requests switching back to the main database file after a previous call
            to <code>switchToFile(String fileName)</code>.
            <br /><br />
            All persistent references to objects that are currently in memory
            are discarded during the switching process.<br /><br /></remarks></member>
        <member name="T:com.db4o.query.Constraints">
            <summary>
            set of
            <see cref="T:com.db4o.query.Constraint">com.db4o.query.Constraint</see>
            objects.
            <br /><br />This extension of the
            <see cref="T:com.db4o.query.Constraint">com.db4o.query.Constraint</see>
            interface allows
            setting the evaluation mode of all contained
            <see cref="T:com.db4o.query.Constraint">com.db4o.query.Constraint</see>
            objects with single calls.
            <br /><br />
            See also
            <see cref="M:com.db4o.query.Query.constraints">com.db4o.query.Query.constraints</see>
            .
            </summary></member>
        <member name="M:com.db4o.query.Constraints.toArray">
            <summary>
            returns an array of the contained
            <see cref="T:com.db4o.query.Constraint">com.db4o.query.Constraint</see>
            objects.
            </summary>
            <returns>
            an array of the contained
            <see cref="T:com.db4o.query.Constraint">com.db4o.query.Constraint</see>
            objects.
            </returns></member>
        <member name="T:com.db4o.types.Blob">
            <summary>
            the db4o Blob type to store blobs independant of the main database
            file and allows to perform asynchronous upload and download operations.
            </summary>
            <remarks>
            the db4o Blob type to store blobs independant of the main database
            file and allows to perform asynchronous upload and download operations.
            <br /><br /><b>Usage:</b><br />
            - Define Blob fields on your user classes.<br />
            - As soon as an object of your class is stored, db4o automatically
            takes care that the Blob field is set.<br />
            - Call readFrom to read a blob file into the db4o system.<br />
            - Call writeTo to write a blob file from within the db4o system.<br />
            - getStatus may help you to determine, whether data has been
            previously stored. It may also help you to track the completion
            of the current process.
            <br /><br />
            db4o client/server carries out all blob operations in a seperate
            thread on a specially dedicated socket. One socket is used for
            all blob operations and operations are queued. Your application
            may continue to access db4o while a blob is transferred in the
            background.
            </remarks></member>
        <member name="M:com.db4o.types.Blob.getFileName">
            <summary>returns the name of the file the blob was stored to.</summary>
            <remarks>
            returns the name of the file the blob was stored to.
            <br /><br />The method may return null, if the file was never
            stored.
            </remarks>
            <returns>String the name of the file.</returns></member>
        <member name="M:com.db4o.types.Blob.getStatus">
            <summary>returns the status after the last read- or write-operation.</summary>
            <remarks>
            returns the status after the last read- or write-operation.
            <br /><br />The status value returned may be any of the following:<br />
            Status.UNUSED  no data was ever stored to the Blob field.<br />
            Status.AVAILABLE available data was previously stored to the Blob field.<br />
            Status.QUEUED an operation was triggered and is waiting for it's turn in the Blob queue.<br />
            Status.COMPLETED the last operation on this field was completed successfully.<br />
            Status.PROCESSING for internal use only.<br />
            Status.ERROR the last operation failed.<br />
            or a double between 0 and 1 that signifies the current completion percentage of the currently
            running operation.<br /><br /> the five STATUS constants defined in this interface or a double
            between 0 and 1 that signifies the completion of the currently running operation.<br /><br /></remarks>
            <returns>status - the current status</returns>
            <seealso cref="T:com.db4o.ext.Status">STATUS constants</seealso></member>
        <member name="M:com.db4o.types.Blob.readFrom(j4o.io.File)">
            <summary>reads a file into the db4o system and stores it as a blob.</summary>
            <remarks>
            reads a file into the db4o system and stores it as a blob.
            <br /><br />
            In Client/Server mode db4o will open an additional socket and
            process writing data in an additional thread.
            <br /><br /></remarks>
            <param name="file">the file the blob is to be read from.</param>
            <exception cref="T:System.IO.IOException">in case of errors</exception></member>
        <member name="M:com.db4o.types.Blob.readLocal(j4o.io.File)">
            <summary>reads a file into the db4o system and stores it as a blob.</summary>
            <remarks>
            reads a file into the db4o system and stores it as a blob.
            <br /><br />
            db4o will use the local file system in Client/Server mode also.
            <br /><br /></remarks>
            <param name="file">the file the blob is to be read from.</param>
            <exception cref="T:System.IO.IOException">in case of errors</exception></member>
        <member name="M:com.db4o.types.Blob.writeLocal(j4o.io.File)">
            <summary>writes stored blob data to a file.</summary>
            <remarks>
            writes stored blob data to a file.
            <br /><br />
            db4o will use the local file system in Client/Server mode also.
            <br /><br /></remarks>
            <exception cref="T:System.IO.IOException">
            in case of errors and in case no blob
            data was stored
            </exception>
            <param name="file">the file the blob is to be written to.</param></member>
        <member name="M:com.db4o.types.Blob.writeTo(j4o.io.File)">
            <summary>writes stored blob data to a file.</summary>
            <remarks>
            writes stored blob data to a file.
            <br /><br />
            In Client/Server mode db4o will open an additional socket and
            process writing data in an additional thread.
            <br /><br /></remarks>
            <exception cref="T:System.IO.IOException">
            in case of errors and in case no blob
            data was stored
            </exception>
            <param name="file">the file the blob is to be written to.</param></member>
        <member name="T:Cecil.FlowAnalysis.ActionFlow.IActionBlockCollection">
            <summary></summary></member>
        <member name="T:com.db4o.messaging.MessageRecipient">
            <summary>message recipient for client/server messaging.</summary>
            <remarks>
            message recipient for client/server messaging.
            <br /><br />db4o allows using the client/server TCP connection to send
            messages from the client to the server. Any object that can be
            stored to a db4o database file may be used as a message.<br /><br />
            See the sample in ../com/db4o/samples/messaging/ on how to
            use the messaging feature. It is also used to stop the server
            in ../com/db4o/samples/clientserver/StopServer.java<br /><br /><b>See Also:</b><br /><see cref="M:com.db4o.config.Configuration.setMessageRecipient">Configuration.setMessageRecipient(MessageRecipient)
            	</see>
            , <br /><see cref="T:com.db4o.messaging.MessageSender">com.db4o.messaging.MessageSender</see>
            ,<br /><see cref="M:com.db4o.config.Configuration.getMessageSender">com.db4o.config.Configuration.getMessageSender
            	</see>
            ,<br /></remarks></member>
        <member name="M:com.db4o.messaging.MessageRecipient.processMessage(com.db4o.ObjectContainer,System.Object)">
            <summary>the method called upon the arrival of messages.</summary>
            <remarks>the method called upon the arrival of messages.</remarks>
            <param name="con">the ObjectContainer the message was sent to.</param>
            <param name="message">the message received.</param></member>
        <member name="T:com.db4o.reflect.Reflector">
            <summary>root of the reflection implementation API.</summary>
            <remarks>
            root of the reflection implementation API.
            <br /><br />The open reflection interface is supplied to allow to implement
            reflection functionality on JDKs that do not come with the
            java.lang.reflect.* package.<br /><br />
            See the code in com.db4o.samples.reflect for a reference implementation
            that uses java.lang.reflect.*.
            <br /><br />
            Use
            <see cref="M:com.db4o.config.Configuration.reflectWith">Db4o.configure().reflectWith(IReflect reflector)
            	</see>
            to register the use of your implementation before opening database
            files.
            </remarks></member>
        <member name="M:com.db4o.reflect.Reflector.array">
            <summary>returns an IArray object, the equivalent to java.lang.reflect.Array.</summary>
            <remarks>returns an IArray object, the equivalent to java.lang.reflect.Array.</remarks></member>
        <member name="M:com.db4o.reflect.Reflector.constructorCallsSupported">
            <summary>specifiy whether parameterized Constructors are supported.</summary>
            <remarks>
            specifiy whether parameterized Constructors are supported.
            <br /><br />The support of Constructors is optional. If Constructors
            are not supported, every persistent class needs a public default
            constructor with zero parameters.
            </remarks></member>
        <member name="M:com.db4o.reflect.Reflector.forClass(j4o.lang.Class)">
            <summary>returns an IClass for a Class</summary></member>
        <member name="M:com.db4o.reflect.Reflector.forName(System.String)">
            <summary>
            returns an IClass class reflector for a class name or null
            if no such class is found
            </summary></member>
        <member name="M:com.db4o.reflect.Reflector.forObject(System.Object)">
            <summary>returns an IClass for an object or null if the passed object is null.</summary>
            <remarks>returns an IClass for an object or null if the passed object is null.</remarks></member>
        <member name="T:com.db4o.ext.ExtObjectServer">
            <summary>extended functionality for the ObjectServer interface.</summary>
            <remarks>
            extended functionality for the ObjectServer interface.
            <br /><br />Every ObjectServer also always is an ExtObjectServer
            so a cast is possible.<br /><br /><see cref="M:com.db4o.ObjectServer.ext">com.db4o.ObjectServer.ext</see>
            is a convenient method to perform the cast.<br /><br />
            The functionality is split to two interfaces to allow newcomers to
            focus on the essential methods.
            </remarks></member>
        <member name="M:com.db4o.ext.ExtObjectServer.backup(System.String)">
            <summary>backs up the database file used by the ObjectServer.</summary>
            <remarks>
            backs up the database file used by the ObjectServer.
            <br /><br />While the backup is running, the ObjectServer can continue to be
            used. Changes that are made while the backup is in progress, will be applied to
            the open ObjectServer and to the backup.<br /><br />
            While the backup is running, the ObjectContainer should not be closed.<br /><br />
            If a file already exists at the specified path, it will be overwritten.<br /><br /></remarks>
            <param name="path">a fully qualified path</param></member>
        <member name="M:com.db4o.ext.ExtObjectServer.configure">
            <summary>
            returns the
            <see cref="T:com.db4o.config.Configuration">com.db4o.config.Configuration</see>
            context for this ObjectServer.
            <br /><br />
            Upon opening an ObjectServer with any of the factory methods in the
            <see cref="T:com.db4o.Db4o">com.db4o.Db4o</see>
            class, the global
            <see cref="T:com.db4o.config.Configuration">com.db4o.config.Configuration</see>
            context
            is copied into the ObjectServer. The
            <see cref="T:com.db4o.config.Configuration">com.db4o.config.Configuration</see>
            can be modified individually for
            each ObjectServer without any effects on the global settings.<br /><br /></summary>
            <returns>the Configuration context for this ObjectServer</returns>
            <seealso cref="M:com.db4o.Db4o.configure">com.db4o.Db4o.configure</seealso></member>
        <member name="M:com.db4o.ext.ExtObjectServer.objectContainer">
            <summary>returns the ObjectContainer used by the server.</summary>
            <remarks>
            returns the ObjectContainer used by the server.
            <br /><br /></remarks>
            <returns>the ObjectContainer used by the server</returns></member>
        <member name="M:com.db4o.ext.ExtObjectServer.revokeAccess(System.String)">
            <summary>removes client access permissions for the specified user.</summary>
            <remarks>
            removes client access permissions for the specified user.
            <br /><br /></remarks>
            <param name="userName">the name of the user</param></member>
        <member name="T:com.db4o.reflect.generic.GenericObject">
            <exclude></exclude></member>
        <member name="T:com.db4o.config.TDictionary">
            <exclude /></member>
        <member name="T:com.db4o.inside.query.SingleItemCachingStrategy">
            <summary>
            A very simple caching strategy that caches only the last added item.
            </summary></member>
        <member name="T:com.db4o.YapRandomAccessFile">
            <exclude></exclude></member>
        <member name="T:com.db4o.inside.query.ObjectSetFacade">
            <summary>
            List based objectSet implementation
            </summary>
            <exclude /></member>
        <member name="T:com.db4o.reflect.net.NetConstructor">
            <remarks>Reflection implementation for Constructor to map to JDK reflection.</remarks></member>
        <member name="T:com.db4o.inside.ix.IxRemove">
            <summary>A node to represent an entry removed from an Index</summary></member>
        <member name="T:com.db4o.reflect.generic.GenericArray">
            <exclude></exclude></member>
        <member name="T:com.db4o.QEContains">
            <exclude></exclude></member>
        <member name="T:com.db4o.inside.ix.Index4">
            <exclude></exclude></member>
        <member name="M:com.db4o.inside.ix.Index4.commitFreeSpace(com.db4o.inside.ix.Index4)">
            <summary>
            solving a hen-egg problem: commit itself works with freespace
            so we have to do this all sequentially in the right way, working
            with with both indexes at the same time.
            </summary>
            <remarks>
            solving a hen-egg problem: commit itself works with freespace
            so we have to do this all sequentially in the right way, working
            with with both indexes at the same time.
            </remarks></member>
        <member name="T:com.db4o.Db4o">
            <summary>factory class to start db4o database engines.</summary>
            <remarks>
            factory class to start db4o database engines.
            <br /><br />This class provides static methods to<br />
            - open single-user databases
            <see cref="M:com.db4o.Db4o.openFile">com.db4o.Db4o.openFile</see><br />
            - open db4o servers
            <see cref="M:com.db4o.Db4o.openServer">com.db4o.Db4o.openServer</see><br />
            - connect to db4o servers
            <see cref="M:com.db4o.Db4o.openClient">com.db4o.Db4o.openClient</see><br />
            - provide access to the global configuration context
            <see cref="M:com.db4o.Db4o.configure">com.db4o.Db4o.configure</see><br />
            - print the version number of this db4o version
            <see cref="M:com.db4o.Db4o.Main">com.db4o.Db4o.Main</see></remarks>
            <seealso cref="T:com.db4o.ext.ExtDb4o">ExtDb4o for extended functionality.</seealso></member>
        <member name="M:com.db4o.Db4o.Main(System.String)">
            <summary>prints the version name of this version to <code>System.out</code>.</summary>
            <remarks>prints the version name of this version to <code>System.out</code>.</remarks></member>
        <member name="M:com.db4o.Db4o.configure">
            <summary>
            returns the global db4o
            <see cref="T:com.db4o.config.Configuration">Configuration</see>
            context
            for the running JVM session.
            <br /><br />
            The
            <see cref="T:com.db4o.config.Configuration">Configuration</see>
            can be overriden in each
            <see cref="M:com.db4o.ext.ExtObjectContainer.configure">ObjectContainer</see>
            .<br /><br /></summary>
            <returns>
            the global
            <see cref="T:com.db4o.config.Configuration">configuration</see>
            context
            </returns></member>
        <member name="M:com.db4o.Db4o.licensedTo(System.String)">
            <summary>enters the licensing information into licensed versions.</summary>
            <remarks>enters the licensing information into licensed versions.</remarks></member>
        <member name="M:com.db4o.Db4o.openClient(System.String,System.Int32,System.String,System.String)">
            <summary>
            opens an
            <see cref="T:com.db4o.ObjectContainer">ObjectContainer</see>
            client and connects it to the specified named server and port.
            <br /><br />
            The server needs to
            <see cref="M:com.db4o.ObjectServer.grantAccess">allow access</see>
            for the specified user and password.
            <br /><br />
            A client
            <see cref="T:com.db4o.ObjectContainer">ObjectContainer</see>
            can be cast to
            <see cref="T:com.db4o.ext.ExtClient">ExtClient</see>
            to use extended
            <see cref="T:com.db4o.ext.ExtObjectContainer">ExtObjectContainer</see>
            and
            <see cref="T:com.db4o.ext.ExtClient">ExtClient</see>
            methods.
            <br /><br /></summary>
            <param name="hostName">the host name</param>
            <param name="port">the port the server is using</param>
            <param name="user">the user name</param>
            <param name="password">the user password</param>
            <returns>
            an open
            <see cref="T:com.db4o.ObjectContainer">ObjectContainer</see></returns>
            <seealso cref="M:com.db4o.ObjectServer.grantAccess">com.db4o.ObjectServer.grantAccess
            	</seealso></member>
        <member name="M:com.db4o.Db4o.openFile(System.String)">
            <summary>
            opens an
            <see cref="T:com.db4o.ObjectContainer">ObjectContainer</see>
            on the specified database file for local use.
            <br /><br />Subsidiary calls with the same database file name will return the same
            <see cref="T:com.db4o.ObjectContainer">ObjectContainer</see>
            object.<br /><br />
            Every call to <code>openFile()</code> requires a corresponding
            <see cref="M:com.db4o.ObjectContainer.close">ObjectContainer.close</see>
            .<br /><br />
            Database files can only be accessed for readwrite access from one process
            (one Java VM) at one time. All versions except for db4o mobile edition use an
            internal mechanism to lock the database file for other processes.
            <br /><br /></summary>
            <param name="databaseFileName">the full path to the database file</param>
            <returns>
            an open
            <see cref="T:com.db4o.ObjectContainer">ObjectContainer</see></returns>
            <seealso cref="M:com.db4o.config.Configuration.readOnly">com.db4o.config.Configuration.readOnly
            	</seealso>
            <seealso cref="M:com.db4o.config.Configuration.encrypt">com.db4o.config.Configuration.encrypt
            	</seealso>
            <seealso cref="M:com.db4o.config.Configuration.password">com.db4o.config.Configuration.password
            	</seealso></member>
        <member name="M:com.db4o.Db4o.openServer(System.String,System.Int32)">
            <summary>
            opens an
            <see cref="T:com.db4o.ObjectServer">ObjectServer</see>
            on the specified database file and port.
            <br /><br />
            If the server does not need to listen on a port because it will only be used
            in embedded mode with
            <see cref="M:com.db4o.ObjectServer.openClient">com.db4o.ObjectServer.openClient</see>
            , specify '0' as the
            port number.
            </summary>
            <param name="databaseFileName">the full path to the database file</param>
            <param name="port">
            the port to be used, or 0, if the server should not open a port,
            because it will only be used with
            <see cref="M:com.db4o.ObjectServer.openClient">com.db4o.ObjectServer.openClient</see></param>
            <returns>
            an
            <see cref="T:com.db4o.ObjectServer">ObjectServer</see>
            listening
            on the specified port.
            </returns>
            <seealso cref="M:com.db4o.config.Configuration.readOnly">com.db4o.config.Configuration.readOnly
            	</seealso>
            <seealso cref="M:com.db4o.config.Configuration.encrypt">com.db4o.config.Configuration.encrypt
            	</seealso>
            <seealso cref="M:com.db4o.config.Configuration.password">com.db4o.config.Configuration.password
            	</seealso></member>
        <member name="M:com.db4o.Db4o.version">
            <summary>returns the version name of the used db4o version.</summary>
            <remarks>
            returns the version name of the used db4o version.
            <br /><br /></remarks>
            <returns>version information as a <code>String</code>.</returns></member>
        <member name="M:com.db4o.Session.closeInstance">
            <summary>returns true, if session is to be closed completely</summary></member>
        <member name="T:com.db4o.MetaField">
            <summary>Field MetaData to be stored to the database file.</summary>
            <remarks>
            Field MetaData to be stored to the database file.
            Don't obfuscate.
            </remarks>
            <exclude></exclude>
            <persistent></persistent></member>
        <member name="T:com.db4o.io.MemoryIoAdapter">
            <summary>IoAdapter for in-memory operation.</summary>
            <remarks>
            IoAdapter for in-memory operation.
            <br /><br />Configure db4o to operate with this in-memory IoAdapter with
            <code>MemoryIoAdapter memoryIoAdapter = new MemoryIoAdapter();<br />
            Db4o.configure().io(memoryIoAdapter);</code><br /><br /><br />Use the normal #openFile() and #openServer() commands to
            open ObjectContainers and ObjectServers. The names specified as
            file names will be used to identify the
            <code>byte[]</code> content of the in-memory files in
            the _memoryFiles Hashtable in the adapter. After working with an
            in-memory ObjectContainer/ObjectServer the <code>byte[]</code> content
            is available in the MemoryIoAdapter by using
            <see cref="M:com.db4o.io.MemoryIoAdapter.get">com.db4o.io.MemoryIoAdapter.get</see>
            . To add old existing database
            <code>byte[]</code> content to a MemoryIoAdapter use
            <see cref="M:com.db4o.io.MemoryIoAdapter.put">com.db4o.io.MemoryIoAdapter.put</see>
            . To reduce memory consumption of memory
            file names that will no longer be used call
            <see cref="M:com.db4o.io.MemoryIoAdapter.put">com.db4o.io.MemoryIoAdapter.put</see>
            and pass an empty byte array.
            <seealso>com.db4o.io.IoAdapter</seealso>
            for a documentation of the methods
            </remarks></member>
        <member name="M:com.db4o.io.MemoryIoAdapter.put(System.String,System.Byte[])">
            <summary>
            creates an in-memory database with the passed content bytes and
            adds it to the adapter for the specified name.
            </summary>
            <remarks>
            creates an in-memory database with the passed content bytes and
            adds it to the adapter for the specified name.
            </remarks>
            <param name="name">the name to be use for #openFile() or #openServer() calls</param>
            <param name="bytes">the database content</param></member>
        <member name="M:com.db4o.io.MemoryIoAdapter.get(System.String)">
            <summary>returns the content bytes for a database with the given name.</summary>
            <remarks>returns the content bytes for a database with the given name.</remarks>
            <param name="name">the name to be use for #openFile() or #openServer() calls</param>
            <returns>the content bytes</returns></member>
        <member name="M:com.db4o.io.MemoryIoAdapter.growBy(System.Int32)">
            <summary>
            configures the length a memory file should grow, if no more
            free slots are found within.
            </summary>
            <remarks>
            configures the length a memory file should grow, if no more
            free slots are found within.
            <br /><br />Specify a large value (100,000 or more) for best performance.
            Specify a small value (100) for the smallest memory consumption. The
            default setting is 10,000.
            </remarks>
            <param name="length">the length in bytes</param></member>
        <member name="M:com.db4o.io.MemoryIoAdapter.close">
            <summary>for internal processing only.</summary>
            <remarks>for internal processing only.</remarks></member>
        <member name="M:com.db4o.io.MemoryIoAdapter.exists(System.String)">
            <summary>for internal processing only.</summary>
            <remarks>for internal processing only.</remarks></member>
        <member name="M:com.db4o.io.MemoryIoAdapter.getLength">
            <summary>for internal processing only.</summary>
            <remarks>for internal processing only.</remarks></member>
        <member name="M:com.db4o.io.MemoryIoAdapter.open(System.String,System.Boolean,System.Int64)">
            <summary>for internal processing only.</summary>
            <remarks>for internal processing only.</remarks></member>
        <member name="M:com.db4o.io.MemoryIoAdapter.read(System.Byte[],System.Int32)">
            <summary>for internal processing only.</summary>
            <remarks>for internal processing only.</remarks></member>
        <member name="M:com.db4o.io.MemoryIoAdapter.seek(System.Int64)">
            <summary>for internal processing only.</summary>
            <remarks>for internal processing only.</remarks></member>
        <member name="M:com.db4o.io.MemoryIoAdapter.sync">
            <summary>for internal processing only.</summary>
            <remarks>for internal processing only.</remarks></member>
        <member name="M:com.db4o.io.MemoryIoAdapter.write(System.Byte[],System.Int32)">
            <summary>for internal processing only.</summary>
            <remarks>for internal processing only.</remarks></member>
        <member name="T:com.db4o.YapArrayN">
            <summary>n-dimensional array</summary></member>
        <member name="T:com.db4o.Messages">
            <exclude></exclude></member>
        <member name="T:com.db4o.reflect.generic.GenericReflector">
            <exclude></exclude></member>
        <member name="T:com.db4o.inside.cluster.ClusterQuery">
            <exclude></exclude></member>
        <member name="T:com.db4o.YapField">
            <exclude></exclude></member>
        <member name="M:com.db4o.YapField.getOrCreate(com.db4o.Transaction,System.Object)">
            <summary>
            dirty hack for com.db4o.types some of them need to be set automatically
            TODO: Derive from YapField for Db4oTypes
            </summary></member>
        <member name="T:com.db4o.Msg">
            <summary>Messages for Client/Server Communication</summary></member>
        <member name="M:com.db4o.Msg.getByteLoad">
            <summary>
            dummy method to allow clean override handling
            without casting
            </summary></member>
        <member name="M:com.db4o.Msg.processMessageAtServer(com.db4o.foundation.network.YapSocket)">
            <summary>server side execution</summary></member>
        <member name="T:com.db4o.TNull">
            <exclude /></member>
        <member name="T:com.db4o.Transient">
            <summary>
            Marks a field as transient.
            </summary>
            <remarks>
            Transient fields are not stored by db4o.
            <br />
            If you don't want a field to be stored by db4o,
            simply mark it with this attribute.
            </remarks>
            <exclude /></member>
        <member name="T:com.db4o.io.IoAdapter">
            <summary>
            Base class for database file adapters, both for file and memory
            databases.
            </summary>
            <remarks>
            Base class for database file adapters, both for file and memory
            databases.
            </remarks></member>
        <member name="M:com.db4o.io.IoAdapter.regularAddress(System.Int32,System.Int32)">
            <summary>converts address and address offset to an absolute address</summary></member>
        <member name="M:com.db4o.io.IoAdapter.blockCopy(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)">
            <summary>copies a block within a file in block mode</summary></member>
        <member name="M:com.db4o.io.IoAdapter.blockSeek(System.Int32)">
            <summary>sets the read/write pointer in the file using block mode</summary></member>
        <member name="M:com.db4o.io.IoAdapter.blockSeek(System.Int32,System.Int32)">
            <summary>sets the read/write pointer in the file using block mode</summary></member>
        <member name="M:com.db4o.io.IoAdapter.blockSize(System.Int32)">
            <summary>outside call to set the block size of this adapter</summary></member>
        <member name="M:com.db4o.io.IoAdapter.close">
            <summary>implement to close the adapter</summary></member>
        <member name="M:com.db4o.io.IoAdapter.copy(System.Int64,System.Int64,System.Int32)">
            <summary>copies a block within a file in absolute mode</summary></member>
        <member name="M:com.db4o.io.IoAdapter.exists(System.String)">
            <summary>checks whether a file exists</summary></member>
        <member name="M:com.db4o.io.IoAdapter.getLength">
            <summary>implement to return the absolute length of the file</summary></member>
        <member name="M:com.db4o.io.IoAdapter.open(System.String,System.Boolean,System.Int64)">
            <summary>implement to open the file</summary></member>
        <member name="M:com.db4o.io.IoAdapter.read(System.Byte[])">
            <summary>reads a buffer at the seeked address</summary></member>
        <member name="M:com.db4o.io.IoAdapter.read(System.Byte[],System.Int32)">
            <summary>implement to read a buffer at the seeked address</summary></member>
        <member name="M:com.db4o.io.IoAdapter.seek(System.Int64)">
            <summary>implement to set the read/write pointer in the file, absolute mode</summary></member>
        <member name="M:com.db4o.io.IoAdapter.sync">
            <summary>implement to flush the file contents to storage</summary></member>
        <member name="M:com.db4o.io.IoAdapter.write(System.Byte[])">
            <summary>writes a buffer to the seeked address</summary></member>
        <member name="M:com.db4o.io.IoAdapter.write(System.Byte[],System.Int32)">
            <summary>implement to write a buffer at the seeked address</summary></member>
        <member name="M:com.db4o.io.IoAdapter.blockSize">
            <summary>returns the block size currently used</summary></member>
        <member name="T:com.db4o.inside.cluster.ClusterConstraints">
            <exclude></exclude></member>
        <member name="T:com.db4o.foundation.Collection4">
            <summary>Fast linked list for all usecases.</summary>
            <remarks>Fast linked list for all usecases.</remarks>
            <exclude></exclude></member>
        <member name="F:com.db4o.foundation.Collection4._first">
            <summary>first element of the linked list</summary></member>
        <member name="F:com.db4o.foundation.Collection4._size">
            <summary>number of elements collected</summary></member>
        <member name="M:com.db4o.foundation.Collection4.add(System.Object)">
            <summary>Adds an element to the beginning of this collection.</summary>
            <remarks>Adds an element to the beginning of this collection.</remarks>
            <param name="element"></param></member>
        <member name="M:com.db4o.foundation.Collection4.containsByIdentity(System.Object)">
            <summary>tests if the object is in the Collection.</summary>
            <remarks>
            tests if the object is in the Collection.
            == comparison.
            </remarks></member>
        <member name="M:com.db4o.foundation.Collection4.get(System.Object)">
            <summary>
            returns the first object found in the Collections
            that equals() the passed object
            </summary></member>
        <member name="M:com.db4o.foundation.Collection4.ensure(System.Object)">
            <summary>makes sure the passed object is in the Collection.</summary>
            <remarks>
            makes sure the passed object is in the Collection.
            equals() comparison.
            </remarks></member>
        <member name="M:com.db4o.foundation.Collection4.iterator">
            <summary>
            Iterates through the collection in
            reversed insertion order which happens
            to be the fastest.
            </summary>
            <remarks>
            Iterates through the collection in
            reversed insertion order which happens
            to be the fastest.
            </remarks>
            <returns></returns></member>
        <member name="M:com.db4o.foundation.Collection4.strictIterator">
            <summary>
            Iterates through the collection in the correct
            order (the insertion order).
            </summary>
            <remarks>
            Iterates through the collection in the correct
            order (the insertion order).
            </remarks>
            <returns></returns></member>
        <member name="M:com.db4o.foundation.Collection4.remove(System.Object)">
            <summary>
            removes an object from the Collection
            equals() comparison
            returns the removed object or null, if none found
            </summary></member>
        <member name="M:com.db4o.foundation.Collection4.toArray(System.Object[])">
            <summary>This is a non reflection implementation for more speed.</summary>
            <remarks>
            This is a non reflection implementation for more speed.
            In contrast to the JDK behaviour, the passed array has
            to be initialized to the right length.
            </remarks></member>
        <member name="T:com.db4o.inside.query.PredicateEvaluation">
            <exclude></exclude></member>
        <member name="T:com.db4o.YapMemoryFile">
            <exclude></exclude></member>
        <member name="T:com.db4o.inside.ix.IxFileRange">
            <summary>A range of index entries in the database file.</summary>
            <remarks>A range of index entries in the database file.</remarks></member>
        <member name="T:com.db4o.cluster.Cluster">
            <summary>allows running Queries against multiple ObjectContainers.</summary>
            <remarks>allows running Queries against multiple ObjectContainers.</remarks>
            <exclude></exclude></member>
        <member name="M:com.db4o.cluster.Cluster.query">
            <summary>
            starts a query against all ObjectContainers in
            this Cluster.
            </summary>
            <remarks>
            starts a query against all ObjectContainers in
            this Cluster.
            </remarks>
            <returns>the Query</returns></member>
        <member name="M:com.db4o.cluster.Cluster.objectContainerFor(System.Object)">
            <summary>
            returns the ObjectContainer in this cluster where the passed object
            is stored or null, if the object is not stored to any ObjectContainer
            in this cluster
            </summary>
            <param name="obj">the object</param>
            <returns>the ObjectContainer</returns></member>
        <member name="T:com.db4o.MsgD">
            <summary>Messages with Data for Client/Server Communication</summary></member>
        <member name="T:Cecil.FlowAnalysis.CodeStructure.ExpressionPrinter">
            <summary></summary></member>
        <member name="T:com.db4o.inside.ix.NIxPathNode">
            <exclude></exclude></member>
        <member name="M:com.db4o.inside.ix.NIxPathNode.compare(com.db4o.inside.ix.NIxPathNode,System.Int32,System.Int32)">
            <summary>
            returns 0, if keys are equal
            uses this - other
            returns positive if this is greater than a_to
            returns negative if this is smaller than a_to
            </summary></member>
        <member name="T:com.db4o.YapBit">
            <exclude></exclude></member>
        <member name="T:com.db4o.YapClient">
            <exclude></exclude></member>
        <member name="M:com.db4o.YapClient.getResponse">
            <summary>may return null, if no message is returned.</summary>
            <remarks>
            may return null, if no message is returned. Error handling is weak and
            should ideally be able to trigger some sort of state listener
            (connection dead) on the client.
            </remarks></member>
        <member name="T:com.db4o.YapClassCollection">
            <exclude></exclude></member>
        <member name="T:com.db4o.QueryResultImpl">
            <exclude></exclude></member>
        <member name="T:com.db4o.YapWriter">
            <summary>public for .NET conversion reasons</summary>
            <exclude></exclude></member>
        <member name="T:com.db4o.QPending">
            <exclude></exclude></member>
        <member name="T:com.db4o.inside.replication.MigrationConnection">
            <exclude></exclude></member>
        <member name="T:com.db4o.Platform4">
            <exclude /></member>
        <member name="T:com.db4o.config.TTransient">
            <exclude /></member>
        <member name="T:com.db4o.Tuning">
            <summary>Tuning switches for customized versions.</summary>
            <remarks>Tuning switches for customized versions.</remarks>
            <exclude></exclude></member>
        <member name="F:com.db4o.Tuning.symbianSeek">
            <deprecated>Use Db4o.configure().io(new com.db4o.io.SymbianIoAdapter()) instead</deprecated></member>
        <member name="T:com.db4o.io.RandomAccessFileAdapter">
            <summary>IO adapter for random access files.</summary>
            <remarks>IO adapter for random access files.</remarks></member>
        <member name="T:com.db4o.QELike">
            <exclude></exclude></member>
        <member name="T:com.db4o.QEIdentity">
            <exclude></exclude></member>
        <member name="T:com.db4o.QEAbstract">
            <exclude></exclude></member>
        <member name="T:com.db4o.ReplicationImpl">
            <exclude></exclude></member>
        <member name="M:com.db4o.ReplicationImpl.tryToHandle(com.db4o.YapStream,System.Object)">
            <summary>called by YapStream.set()</summary>
            <returns>
            id of reference in caller or 0 if not handled or -1
            if #set() should stop processing because of a direction
            setting.
            </returns></member>
        <member name="T:com.db4o.Unobfuscated">
            <exclude></exclude></member>
        <member name="T:com.db4o.JDKReflect">
            <summary>
            package and class name are hard-referenced in JavaOnly#jdk()
            TODO: may need to use this on instead of JDK on .NET.
            </summary>
            <remarks>
            package and class name are hard-referenced in JavaOnly#jdk()
            TODO: may need to use this on instead of JDK on .NET. Check!
            </remarks></member>
        <member name="M:com.db4o.JDKReflect.methodIsAvailable(System.String,System.String,j4o.lang.Class[])">
            <summary>
            use for system classes only, since not ClassLoader
            or Reflector-aware
            </summary></member>
        <member name="M:com.db4o.JDKReflect.invoke(System.Object,System.String,j4o.lang.Class[],System.Object[])">
            <summary>
            use for system classes only, since not ClassLoader
            or Reflector-aware
            </summary></member>
        <member name="M:com.db4o.JDKReflect.invoke(System.String,System.String,j4o.lang.Class[],System.Object[],System.Object)">
            <summary>
            use for system classes only, since not ClassLoader
            or Reflector-aware
            </summary></member>
        <member name="M:com.db4o.JDKReflect.getMethod(System.String,System.String,j4o.lang.Class[])">
            <summary>
            calling this "method" will break C# conversion with the old converter
            use for system classes only, since not ClassLoader
            or Reflector-aware
            </summary></member>
        <member name="T:com.db4o.config.TQueue">
            <exclude /></member>
        <member name="T:com.db4o.YapIndependantType">
            <summary>
            Common base class for YapString and YapArray:
            There is one indirection in the database file to this.
            </summary>
            <remarks>
            Common base class for YapString and YapArray:
            There is one indirection in the database file to this.
            </remarks>
            <exclude></exclude></member>
        <member name="M:com.db4o.YapIndependantType.deleteEmbedded(com.db4o.YapWriter)">
            <summary>overriden in YapArray</summary></member>
        <member name="T:com.db4o.Deploy">
            <exclude></exclude></member>
        <member name="T:com.db4o.inside.Exceptions4">
            <exclude></exclude></member>
        <member name="T:com.db4o.YapStringIO">
            <exclude></exclude></member>
        <member name="T:com.db4o.YapString">
            <summary>
            YapString
            Legacy rename for C# obfuscator production trouble
            </summary>
            <exclude></exclude></member>
        <member name="M:com.db4o.YapString.compare(com.db4o.YapReader,com.db4o.YapReader)">
            <summary>
            returns: -x for left is greater and +x for right is greater
            TODO: You will need collators here for different languages.
            </summary>
            <remarks>
            returns: -x for left is greater and +x for right is greater
            TODO: You will need collators here for different languages.
            </remarks></member>
        <member name="T:com.db4o.QConEvaluation">
            <exclude></exclude></member>
        <member name="T:com.db4o.DTrace">
            <exclude></exclude></member>
        <member name="M:com.db4o.nativequery.expr.build.ExpressionBuilder.not(com.db4o.nativequery.expr.Expression)">
            <summary>Optimizations: !(Bool)-&gt;(!Bool), !!X-&gt;X</summary></member>
        <!--FIXME: Invalid documentation markup was found for member M:com.db4o.nativequery.expr.build.ExpressionBuilder.and(com.db4o.nativequery.expr.Expression,com.db4o.nativequery.expr.Expression)-->
        <member name="M:com.db4o.nativequery.expr.build.ExpressionBuilder.or(com.db4o.nativequery.expr.Expression,com.db4o.nativequery.expr.Expression)">
            <summary>Optimizations: X||t-&gt;t, f||X-&gt;X, X||X-&gt;X, X||!X-&gt;t</summary></member>
        <member name="M:com.db4o.nativequery.expr.build.ExpressionBuilder.constant(System.Boolean)">
            <summary>Optimizations: static bool roots</summary></member>
        <member name="T:com.db4o.foundation.Hashtable4">
            <exclude></exclude></member>
        <member name="T:com.db4o.reflect.net.NetArray">
            <remarks>Reflection implementation for Array to map to .NET reflection.</remarks></member>
        <member name="T:com.db4o.P1Object">
            <summary>base class for all database aware objects</summary>
            <exclude></exclude>
            <persistent></persistent></member>
        <member name="T:com.db4o.JDK">
            <exclude></exclude></member>
        <member name="M:com.db4o.JDK.methodIsAvailable(System.String,System.String,j4o.lang.Class[])">
            <summary>
            use for system classes only, since not ClassLoader
            or Reflector-aware
            </summary></member>
        <member name="T:com.db4o.foundation.Visitor4Dispatch">
            <exclude></exclude></member>
        <member name="T:com.db4o.TreeStringObject">
            <exclude></exclude></member>
        <member name="T:com.db4o.config.TList">
            <exclude /></member>
        <member name="T:com.db4o.io.SymbianIoAdapter">
            <summary>
            Workaround for two Symbian/Epoc I/O bugs:
            - seek() cannot move beyond the current file length.
            </summary>
            <remarks>
            Workaround for two Symbian/Epoc I/O bugs:
            - seek() cannot move beyond the current file length.
            Fix: Write padding bytes up to the seek target if necessary
            - Under certain (rare) conditions, calls to RAF.length() seems
            to garble up following reads.
            Fix: Use a second RAF handle to the file for length() calls
            only.
            TODO:
            - BasicClusterTest C/S fails (in AllTests context only)
            </remarks>
            <exclude></exclude></member>
        <member name="T:com.db4o.config.TClass">
            <exclude /></member>
        <member name="T:com.db4o.YInt">
            <exclude></exclude></member>
        <member name="T:com.db4o.TransactionObjectCarrier">
            <summary>TODO: Check if all time-consuming stuff is overridden!</summary></member>
        <member name="T:com.db4o.YapFile">
            <exclude></exclude></member>
        <member name="T:com.db4o.inside.ix.IxTree">
            <exclude></exclude></member>
        <member name="M:com.db4o.inside.ix.IxTree.lowerAndUpperMatch">
            <summary>
            Overridden in IxFileRange
            Only call directly after compare()
            </summary></member>
        <member name="T:com.db4o.inside.cluster.ClusterQueryResult">
            <exclude></exclude></member>
        <member name="T:com.db4o.reflect.net.NetClass">
            <summary>Reflection implementation for Class to map to .NET reflection.</summary>
            <remarks>Reflection implementation for Class to map to .NET reflection.</remarks></member>
        <member name="T:com.db4o.foundation.SimpleTimer">
            <exclude></exclude></member>
        <member name="T:com.db4o.inside.ix.QxPath">
            <summary>Query Index Path</summary></member>
        <member name="T:com.db4o.reflect.generic.GenericArrayReflector">
            <exclude></exclude></member>
        <member name="T:com.db4o.inside.ix.NIxPaths">
            <summary>
            A note on the logic of #count() and #traverse():
            Within the visitor we are always looking at two NIxPath: last[0] and current.
            </summary>
            <remarks>
            A note on the logic of #count() and #traverse():
            Within the visitor we are always looking at two NIxPath: last[0] and current.
            Each run of the visitor takes care of all nodes:
            - smaller than last[0] for the first run only
            - equal to last[0]
            - between last[0] and current
            - but *NOT* equal to current, which is handled in the next run.
            </remarks>
            <exclude></exclude></member>
        <member name="M:com.db4o.inside.ix.NIxPaths.countSpan(com.db4o.inside.ix.NIxPath,com.db4o.inside.ix.NIxPath,com.db4o.inside.ix.NIxPathNode,com.db4o.inside.ix.NIxPathNode,com.db4o.inside.ix.NIxPathNode,com.db4o.inside.ix.NIxPathNode,System.Int32)">
            <summary>see documentation to this class for behaviour *</summary></member>
        <member name="M:com.db4o.inside.ix.NIxPaths.traverseSpan(com.db4o.inside.ix.NIxPath,com.db4o.inside.ix.NIxPath,com.db4o.inside.ix.NIxPathNode,com.db4o.inside.ix.NIxPathNode,com.db4o.inside.ix.NIxPathNode,com.db4o.inside.ix.NIxPathNode,com.db4o.foundation.Visitor4Dispatch)">
            <summary>see documentation to this class for behaviour *</summary></member>
        <member name="T:com.db4o.inside.query.QueryExpressionBuilder">
            <summary>
            Build a com.db4o.nativequery.expr tree out of
            a predicate method definition.
            </summary></member>
        <member name="M:com.db4o.inside.query.QueryExpressionBuilder.Visitor.RegisterAssembly(Mono.Cecil.IAssemblyDefinition)">
            <summary>
            Registers an assembly so it can be looked up by its assembly name
            string later.
            </summary>
            <param name="assembly"></param></member>
        <member name="T:com.db4o.YapObject">
            <exclude></exclude></member>
        <member name="M:com.db4o.YapObject.continueSet(com.db4o.Transaction,System.Int32)">
            <summary>return false if class not completely initialized, otherwise true *</summary></member>
        <member name="M:com.db4o.YapObject.store(com.db4o.Transaction,com.db4o.YapClass,System.Object,System.Int32)">
            <summary>
            return true for complex objects to instruct YapStream to add to lookup trees
            and to perform delayed storage through call to continueset further up the stack.
            </summary>
            <remarks>
            return true for complex objects to instruct YapStream to add to lookup trees
            and to perform delayed storage through call to continueset further up the stack.
            </remarks></member>
        <member name="M:com.db4o.YapObject.hc_add(com.db4o.YapObject)">
            <summary>HCTREE ****</summary></member>
        <member name="M:com.db4o.YapObject.id_add(com.db4o.YapObject)">
            <summary>IDTREE ****</summary></member>
        <member name="T:com.db4o.TreeString">
            <exclude></exclude></member>
        <member name="T:com.db4o.QConObject">
            <summary>Object constraint on queries</summary>
            <exclude></exclude></member>
        <member name="T:com.db4o.P1ListElement">
            <summary>element of linked lists</summary>
            <exclude></exclude>
            <persistent></persistent></member>
        <member name="T:com.db4o.QEMulti">
            <exclude></exclude></member>
        <member name="T:com.db4o.Debug">
            <exclude></exclude></member>
        <member name="T:Cecil.FlowAnalysis.CecilUtilities.CecilFormatter">
            <summary></summary></member>
        <member name="T:com.db4o.inside.ix.IxAdd">
            <summary>An addition to a field index.</summary>
            <remarks>An addition to a field index.</remarks></member>
        <member name="T:com.db4o.QConPath">
            <summary>
            Placeholder for a constraint, only necessary to attach children
            to the query graph.
            </summary>
            <remarks>
            Placeholder for a constraint, only necessary to attach children
            to the query graph.
            Added upon a call to Query#descend(), if there is no
            other place to hook up a new constraint.
            </remarks>
            <exclude></exclude></member>
        <member name="T:com.db4o.io.SafeSyncIoAdapter">
            <summary>Debug IoAdapter syncing to drive after every write call.</summary>
            <remarks>Debug IoAdapter syncing to drive after every write call.</remarks></member>
        <member name="T:com.db4o.QCandidate">
            <summary>Represents an actual object in the database.</summary>
            <remarks>
            Represents an actual object in the database. Forms a tree structure,
            indexed by id. Can have dependents that are doNotInclude'd in the
            query result when this is doNotInclude'd.
            </remarks>
            <exclude></exclude></member>
        <member name="M:com.db4o.QCandidate.include(System.Boolean)">
            <summary>For external interface use only.</summary>
            <remarks>
            For external interface use only. Call doNotInclude() internally so
            dependancies can be checked.
            </remarks></member>
        <member name="T:com.db4o.QENot">
            <exclude></exclude></member>
        <member name="T:com.db4o.MetaClass">
            <summary>
            Class metadata to be stored to the database file
            Don't obfuscate.
            </summary>
            <remarks>
            Class metadata to be stored to the database file
            Don't obfuscate.
            </remarks>
            <exclude></exclude>
            <persistent></persistent></member>
        <member name="T:com.db4o.reflect.generic.GenericClass">
            <exclude></exclude></member>
        <member name="T:com.db4o.YapTypeAbstract">
            <exclude></exclude></member>
        <member name="T:com.db4o.TreeIntObject">
            <exclude></exclude></member>
        <member name="T:com.db4o.BlobImpl">
            <summary>
            Transfer of blobs to and from the db4o system,
            if users use the Blob Db4oType.
            </summary>
            <remarks>
            Transfer of blobs to and from the db4o system,
            if users use the Blob Db4oType.
            </remarks>
            <exclude></exclude></member>
        <member name="T:com.db4o.QEEqual">
            <exclude></exclude></member>
        <member name="T:com.db4o.QConJoin">
            <summary>Join constraint on queries</summary>
            <exclude></exclude></member>
        <member name="T:com.db4o.Rename">
            <summary>
            Renaming actions are stored to the database file to make
            sure that they are only performed once.
            </summary>
            <remarks>
            Renaming actions are stored to the database file to make
            sure that they are only performed once.
            </remarks>
            <exclude></exclude>
            <persistent></persistent></member>
        <member name="T:Cecil.FlowAnalysis.Impl.ActionFlow.ActionGraphBuilder">
            <summary></summary></member>
        <member name="M:Cecil.FlowAnalysis.Impl.ActionFlow.ActionGraphBuilder.IsLogicalExpression(Cecil.FlowAnalysis.ControlFlow.IInstructionBlock)">
            <summary>
            Checks if the subgraph starting at block represents
            a logical expression.
            </summary>
            <param name="block"></param>
            <returns></returns></member>
        <member name="T:com.db4o.inside.cluster.ClusterConstraint">
            <exclude></exclude></member>
        <member name="T:com.db4o.foundation.network.YapSocketFake">
            <summary>Fakes a socket connection for an embedded client.</summary>
            <remarks>Fakes a socket connection for an embedded client.</remarks></member>
        <member name="T:com.db4o.config.TType">
            <exclude /></member>
        <member name="T:Cecil.FlowAnalysis.Impl.ControlFlow.FlowGraphBuilder">
            <summary></summary></member>
        <member name="T:com.db4o.ClassIndexClient">
            <summary>client class index.</summary>
            <remarks>
            client class index. Largly intended to do nothing or
            redirect functionality to the server.
            </remarks></member>
        <member name="T:Cecil.FlowAnalysis.Impl.ActionFlow.ConditionalBranchActionBlock">
            <summary></summary></member>
        <member name="T:com.db4o.Db4oVersion">
            <exclude></exclude></member>
        <member name="T:com.db4o.ext.Db4oDatabase">
            <summary>Class to identify a database by it's signature.</summary>
            <remarks>
            Class to identify a database by it's signature.
            <br /><br />db4o UUID handling uses a reference to the Db4oDatabase object, that
            represents the database an object was created on.
            </remarks>
            <persistent></persistent>
            <exclude></exclude></member>
        <member name="F:com.db4o.ext.Db4oDatabase.i_signature">
            <summary>Field is public for implementation reasons, DO NOT TOUCH!</summary></member>
        <member name="F:com.db4o.ext.Db4oDatabase.i_uuid">
            <summary>
            Field is public for implementation reasons, DO NOT TOUCH!
            This field is badly named, it really is the creation time.
            </summary>
            <remarks>
            Field is public for implementation reasons, DO NOT TOUCH!
            This field is badly named, it really is the creation time.
            </remarks></member>
        <member name="F:com.db4o.ext.Db4oDatabase.i_stream">
            <summary>cached ObjectContainer for getting the own ID.</summary>
            <remarks>cached ObjectContainer for getting the own ID.</remarks></member>
        <member name="F:com.db4o.ext.Db4oDatabase.i_id">
            <summary>cached ID, only valid in combination with i_objectContainer</summary></member>
        <member name="M:com.db4o.ext.Db4oDatabase.generate">
            <summary>generates a new Db4oDatabase object with a unique signature.</summary>
            <remarks>generates a new Db4oDatabase object with a unique signature.</remarks></member>
        <member name="M:com.db4o.ext.Db4oDatabase.Equals(System.Object)">
            <summary>comparison by signature.</summary>
            <remarks>comparison by signature.</remarks></member>
        <member name="M:com.db4o.ext.Db4oDatabase.getID(com.db4o.Transaction)">
            <summary>gets the db4o ID, and may cache it for performance reasons.</summary>
            <remarks>gets the db4o ID, and may cache it for performance reasons.</remarks>
            <param name="a_oc">the ObjectContainer</param>
            <returns>the db4o ID for the ObjectContainer</returns></member>
        <member name="M:com.db4o.ext.Db4oDatabase.getSignature">
            <summary>returns the unique signature</summary></member>
        <member name="M:com.db4o.ext.Db4oDatabase.bind(com.db4o.Transaction)">
            <summary>make sure this Db4oDatabase is stored.</summary>
            <remarks>make sure this Db4oDatabase is stored. Return the ID.</remarks></member>
        <member name="M:com.db4o.ext.Db4oDatabase.query(com.db4o.Transaction)">
            <summary>find a Db4oDatabase with the same signature as this one</summary></member>
        <member name="T:com.db4o.YapConfigBlock">
            <summary>
            configuration and agent to write the configuration block
            The configuration block also contains the timer lock and
            a pointer to the running transaction.
            </summary>
            <remarks>
            configuration and agent to write the configuration block
            The configuration block also contains the timer lock and
            a pointer to the running transaction.
            </remarks>
            <exclude></exclude></member>
        <member name="T:com.db4o.reflect.net.SerializationConstructor">
            <summary>Constructs objects by using System.Runtime.Serialization.FormatterServices.GetUninitializedObject
            and bypasses calls to user contructors this way. Not available on CompactFramework
            </summary></member>
        <member name="T:com.db4o.QEGreater">
            <exclude></exclude></member>
        <member name="T:com.db4o.StaticField">
            <exclude></exclude>
            <persistent></persistent></member>
        <member name="T:com.db4o.foundation.network.ByteBuffer4">
            <summary>
            Transport buffer for C/S mode to simulate a
            socket connection in memory.
            </summary>
            <remarks>
            Transport buffer for C/S mode to simulate a
            socket connection in memory.
            </remarks></member>
        <member name="T:com.db4o.foundation.Cool">
            <summary>A collection of cool static methods that should be part of the runtime environment but are not.
            	</summary>
            <remarks>A collection of cool static methods that should be part of the runtime environment but are not.
            	</remarks>
            <exclude></exclude></member>
        <member name="T:com.db4o.PBootRecord">
            <summary>database boot record.</summary>
            <remarks>
            database boot record. Responsible for ID generation, version generation and
            holding a reference to the Db4oDatabase object of the ObjectContainer
            </remarks>
            <exclude></exclude>
            <persistent></persistent></member>
        <member name="T:com.db4o.ext.MemoryFile">
            <summary>carries in-memory data for db4o in-memory operation.</summary>
            <remarks>
            carries in-memory data for db4o in-memory operation.
            <br /><br />In-memory ObjectContainers are useful for maximum performance
            on small databases, for swapping objects or for storing db4o format data
            to other media or other databases.<br /><br />Be aware of the danger of running
            into OutOfMemory problems or complete loss of all data, in case of hardware
            or JVM failures.
            <br /><br /></remarks>
            <seealso cref="M:com.db4o.ext.ExtDb4o.openMemoryFile">com.db4o.ext.ExtDb4o.openMemoryFile
            	</seealso></member>
        <member name="M:com.db4o.ext.MemoryFile.getBytes">
            <summary>returns the raw byte data.</summary>
            <remarks>
            returns the raw byte data.
            <br /><br />Use this method to get the byte data from the MemoryFile
            to store it to other media or databases, for backup purposes or
            to create other MemoryFile sessions.
            <br /><br />The byte data from a MemoryFile should only be used
            after it is closed.<br /><br /></remarks>
            <returns>bytes the raw byte data.</returns></member>
        <member name="M:com.db4o.ext.MemoryFile.getIncrementSizeBy">
            <summary>
            returns the size the MemoryFile is to be enlarged, if it grows beyond
            the current size.
            </summary>
            <remarks>
            returns the size the MemoryFile is to be enlarged, if it grows beyond
            the current size.
            </remarks>
            <returns>size in bytes</returns></member>
        <member name="M:com.db4o.ext.MemoryFile.getInitialSize">
            <summary>returns the initial size of the MemoryFile.</summary>
            <remarks>returns the initial size of the MemoryFile.</remarks>
            <returns>size in bytes</returns></member>
        <member name="M:com.db4o.ext.MemoryFile.setBytes(System.Byte[])">
            <summary>sets the raw byte data.</summary>
            <remarks>
            sets the raw byte data.
            <br /><br /><b>Caution!</b><br />Calling this method during a running
            Memory File session may produce unpreditable results.
            </remarks>
            <param name="bytes">the raw byte data.</param></member>
        <member name="M:com.db4o.ext.MemoryFile.setIncrementSizeBy(System.Int32)">
            <summary>
            configures the size the MemoryFile is to be enlarged by, if it grows
            beyond the current size.
            </summary>
            <remarks>
            configures the size the MemoryFile is to be enlarged by, if it grows
            beyond the current size.
            <br /><br />Call this method before passing the MemoryFile to
            <see cref="M:com.db4o.ext.ExtDb4o.openMemoryFile">ExtDb4o#openMemoryFile(MemoryFile)
            	</see>
            .
            <br /><br />
            This parameter can be modified to tune the maximum performance of
            a MemoryFile for a specific usecase. To produce the best results,
            test the speed of your application with real data.<br /><br /></remarks>
            <param name="byteCount">the desired size in bytes</param></member>
        <member name="M:com.db4o.ext.MemoryFile.setInitialSize(System.Int32)">
            <summary>configures the initial size of the MemoryFile.</summary>
            <remarks>
            configures the initial size of the MemoryFile.
            <br /><br />Call this method before passing the MemoryFile to
            <see cref="M:com.db4o.ext.ExtDb4o.openMemoryFile">ExtDb4o#openMemoryFile(MemoryFile)
            	</see>
            .
            <br /><br />
            This parameter can be modified to tune the maximum performance of
            a MemoryFile for a specific usecase. To produce the best results,
            test speed and memory consumption of your application with
            real data.<br /><br /></remarks>
            <param name="byteCount">the desired size in bytes</param></member>
        <member name="T:com.db4o.YapMeta">
            <exclude></exclude></member>
        <member name="T:com.db4o.QConFalse">
            <exclude></exclude></member>
        <member name="T:Cecil.FlowAnalysis.Impl.ActionFlow.AbstractActionBlock">
            <summary></summary></member>
        <member name="T:com.db4o.foundation.Iterator4Impl">
            <exclude></exclude></member>
        <member name="T:com.db4o.query.Predicate">
            <summary>Base class for native queries.</summary>
            <remarks>
            Base class for native queries.
            <br /><br />Native Queries allow typesafe, compile-time checked and refactorable
            querying, following object-oriented principles. Native Queries expressions
            are written as if one or more lines of code would be run against all
            instances of a class. A Native Query expression should return true to mark
            specific instances as part of the result set.
            db4o will  attempt to optimize native query expressions and execute them
            against indexes and without instantiating actual objects, where this is
            possible.<br /><br />
            The syntax of the enclosing object for the native query expression varies,
            depending on the language version used. Here are some examples,
            how a simple native query will look like in some of the programming languages
            and dialects that db4o supports:<br /><br /><code>
                    <b>// C# .NET 2.0</b>
                    <br />
            IList &lt;Cat&gt; cats = db.Query &lt;Cat&gt; (delegate(Cat cat) {<br />
               return cat.Name == "Occam";<br />
            });<br /><br /><br /><b>// Java JDK 5</b><br />
            List &lt;Cat&gt; cats = db.query(new Predicate&lt;Cat&gt;() {<br />
               public boolean match(Cat cat) {<br />
                  return cat.getName().equals("Occam");<br />
               }<br />
            });<br /><br /><br /><b>// Java JDK 1.2 to 1.4</b><br />
            List cats = db.query(new Predicate() {<br />
               public boolean match(Cat cat) {<br />
                  return cat.getName().equals("Occam");<br />
               }<br />
            });<br /><br /><br /><b>// Java JDK 1.1</b><br />
            ObjectSet cats = db.query(new CatOccam());<br /><br />
            public static class CatOccam extends Predicate {<br />
               public boolean match(Cat cat) {<br />
                  return cat.getName().equals("Occam");<br />
               }<br />
            });<br /><br /><br /><b>// C# .NET 1.1</b><br />
            IList cats = db.Query(new CatOccam());<br /><br />
            public class CatOccam : Predicate {<br />
               public boolean Match(Cat cat) {<br />
                  return cat.Name == "Occam";<br />
               }<br />
            });<br /></code><br />
            Summing up the above:<br />
            In order to run a Native Query, you can<br />
            - use the delegate notation for .NET 2.0.<br />
            - extend the Predicate class for all other language dialects<br /><br />
            A class that extends Predicate is required to
            implement the #match() / #Match() method, following the native query
            conventions:<br />
            - The name of the method is "#match()" (Java) / "#Match()" (.NET).<br />
            - The method must be public public.<br />
            - The method returns a boolean.<br />
            - The method takes one parameter.<br />
            - The Type (.NET) / Class (Java) of the parameter specifies the extent.<br />
            - For all instances of the extent that are to be included into the
            resultset of the query, the match method should return true. For all
            instances that are not to be included, the match method should return
            false.<br /><br /></remarks></member>
        <member name="F:com.db4o.query.Predicate.PREDICATEMETHOD_NAME">
            <summary>public for implementation reasons, please ignore.</summary>
            <remarks>public for implementation reasons, please ignore.</remarks></member>
        <member name="M:com.db4o.query.Predicate.extentType">
            <summary>public for implementation reasons, please ignore.</summary>
            <remarks>public for implementation reasons, please ignore.</remarks></member>
        <member name="M:com.db4o.query.Predicate.appliesTo(System.Object)">
            <summary>public for implementation reasons, please ignore.</summary>
            <remarks>public for implementation reasons, please ignore.</remarks></member>
        <member name="T:com.db4o.TreeReader">
            <exclude></exclude></member>
        <member name="T:com.db4o.QCon">
            <summary>Base class for all constraints on queries.</summary>
            <remarks>Base class for all constraints on queries.</remarks>
            <exclude></exclude></member>
        <member name="T:com.db4o.inside.ix.IndexTransaction">
            <summary>Index root holder for a field and a transaction.</summary>
            <remarks>Index root holder for a field and a transaction.</remarks>
            <exclude></exclude></member>
        <member name="M:com.db4o.inside.ix.IndexTransaction.visit(System.Object)">
            <summary>
            Visitor functionality for merge:<br />
            Add
            </summary></member>
        <member name="T:com.db4o.YapHandlers">
            <exclude></exclude></member>
        <member name="M:com.db4o.YapHandlers.handlerForClass(com.db4o.YapStream,com.db4o.reflect.ReflectClass)">
            <summary>
            Can't return ANY class for interfaces, since that would kill the
            translators built into the architecture.
            </summary>
            <remarks>
            Can't return ANY class for interfaces, since that would kill the
            translators built into the architecture.
            </remarks></member>
        <member name="T:com.db4o.YapStream">
            <exclude></exclude></member>
        <member name="M:com.db4o.YapStream.activate2(com.db4o.Transaction,System.Object,System.Int32)">
            <summary>internal call interface, does not reset i_justActivated</summary></member>
        <member name="M:com.db4o.YapStream.bind1(com.db4o.Transaction,System.Object,System.Int64)">
            <summary>TODO: This is not transactional yet.</summary>
            <remarks>TODO: This is not transactional yet.</remarks></member>
        <member name="M:com.db4o.YapStream.db4oTypeStored(com.db4o.Transaction,System.Object)">
            <summary>allows special handling for all Db4oType objects.</summary>
            <remarks>
            allows special handling for all Db4oType objects.
            Redirected here from #set() so only instanceof check is necessary
            in the #set() method.
            </remarks>
            <returns>object if handled here and #set() should not continue processing</returns></member>
        <member name="M:com.db4o.YapStream.initialize2">
            <summary>before file is open</summary></member>
        <member name="M:com.db4o.YapStream.initialize2NObjectCarrier">
            <summary>overridden in YapObjectCarrier</summary></member>
        <member name="M:com.db4o.YapStream.isClient">
            <summary>
            overridden in YapClient
            This method will make it easier to refactor than
            an "instanceof YapClient" check.
            </summary>
            <remarks>
            overridden in YapClient
            This method will make it easier to refactor than
            an "instanceof YapClient" check.
            </remarks></member>
        <member name="M:com.db4o.YapStream.showInternalClasses(System.Boolean)">
            <summary>
            Objects implementing the "Internal" marker interface are
            not visible to queries, unless this flag is set to true.
            </summary>
            <remarks>
            Objects implementing the "Internal" marker interface are
            not visible to queries, unless this flag is set to true.
            The caller should reset the flag after the call.
            </remarks></member>
        <member name="M:com.db4o.YapStream.stillTo1(com.db4o.foundation.List4,com.db4o.Tree[],System.Object,System.Int32,System.Boolean)">
            <summary>
            returns true in case an unknown single object is passed
            This allows deactivating objects before queries are called.
            </summary>
            <remarks>
            returns true in case an unknown single object is passed
            This allows deactivating objects before queries are called.
            </remarks></member>
        <member name="T:com.db4o.QField">
            <exclude></exclude></member>
        <member name="T:com.db4o.inside.freespace.FreeSlotNode">
            <exclude></exclude></member>
        <member name="T:com.db4o.config.TSerializable">
            <summary>
            translator for types that are marked with the Serializable attribute.
            The Serializable translator is provided to allow persisting objects that
            do not supply a convenient constructor. The use of this translator is
            recommended only if:<br />
            - the persistent type will never be refactored<br />
            - querying for type members is not necessary<br /></summary></member>
        <member name="T:com.db4o.QE">
            <summary>Query Evaluator - Represents such things as &gt;, &gt;=, &lt;, &lt;=, EQUAL, LIKE, etc.
            	</summary>
            <remarks>Query Evaluator - Represents such things as &gt;, &gt;=, &lt;, &lt;=, EQUAL, LIKE, etc.
            	</remarks>
            <exclude></exclude></member>
        <member name="M:com.db4o.QE.indexBitMap(System.Boolean[])">
            <summary>Specifies which part of the index to take.</summary>
            <remarks>
            Specifies which part of the index to take.
            Array elements:
            [0] - smaller
            [1] - equal
            [2] - greater
            [3] - nulls
            </remarks>
            <param name="bits"></param></member>
        <member name="T:com.db4o.ext.Status">
            <summary>Static constants to describe the status of objects.</summary>
            <remarks>Static constants to describe the status of objects.</remarks></member>
        <member name="T:com.db4o.P1HashElement">
            <exclude></exclude>
            <persistent></persistent></member>
        <member name="T:com.db4o.io.crypt.XTEA">
            <exclude></exclude></member>
        <member name="T:com.db4o.io.crypt.XTEA.IterationSpec">
            <exclude></exclude></member>
        <member name="M:com.db4o.io.crypt.XTEA.byte2int(System.Byte[],System.Int32,System.Int32[])">
            <summary>
            converts incoming array of eight bytes from offset to array of two
            integer values.<br />
            (An Integer is represented in memory as four bytes.)
            </summary></member>
        <member name="M:com.db4o.io.crypt.XTEA.int2byte(System.Int32[],System.Int32,System.Byte[])">
            <summary>
            converts incoming array of two integers from offset to array of eight
            bytes.<br />
            (An Integer is represented in memory as four bytes.)
            </summary></member>
        <!--FIXME: Invalid documentation markup was found for member M:com.db4o.io.crypt.XTEA.encipher(System.Int32[])-->
        <!--FIXME: Invalid documentation markup was found for member M:com.db4o.io.crypt.XTEA.decipher(System.Int32[])-->
        <member name="M:com.db4o.io.crypt.XTEA.encrypt(System.Byte[])">
            <summary>encrypts incoming byte array according XTEA</summary>
            <param name="buffer">
            -
            incoming byte array to be encrypted
            </param></member>
        <member name="M:com.db4o.io.crypt.XTEA.decrypt(System.Byte[])">
            <summary>decrypts incoming byte array according XTEA</summary>
            <param name="buffer">
            -
            incoming byte array to be decrypted
            </param></member>
        <member name="T:com.db4o.reflect.generic.GenericField">
            <exclude></exclude></member>
        <member name="T:com.db4o.TreeInt">
            <summary>Base class for balanced trees.</summary>
            <remarks>Base class for balanced trees.</remarks>
            <exclude></exclude></member>
        <member name="T:com.db4o.ext.DatabaseFileLockedException">
            <summary>
            this Exception is thrown during any of the db4o open calls
            if the database file is locked by another process.
            </summary>
            <remarks>
            this Exception is thrown during any of the db4o open calls
            if the database file is locked by another process.
            </remarks>
            <seealso cref="M:com.db4o.Db4o.openFile">com.db4o.Db4o.openFile</seealso></member>
        <member name="T:com.db4o.QConClass">
            <summary>Class constraint on queries</summary>
            <exclude></exclude></member>
        <member name="T:com.db4o.inside.ix.IxTraverser">
            <exclude></exclude></member>
        <member name="T:com.db4o.Config4Impl">
            <summary>Configuration template for creating new db4o files</summary>
            <exclude></exclude></member>
        <member name="M:com.db4o.Config4Impl.send(System.Object)">
            <summary>The ConfigImpl also is our messageSender</summary></member>
        <member name="T:com.db4o.VirtualAttributes">
            <exclude></exclude></member>
        <member name="T:com.db4o.Tree">
            <exclude></exclude></member>
        <member name="M:com.db4o.Tree.compare(com.db4o.Tree)">
            <summary>
            returns 0, if keys are equal
            uses this - other
            returns positive if this is greater than a_to
            returns negative if this is smaller than a_to
            </summary></member>
        <member name="M:com.db4o.Tree.nodes">
            <returns>the number of nodes in this tree for balancing</returns></member>
        <member name="M:com.db4o.Tree.size">
            <returns>the number of objects represented.</returns></member>
        <member name="T:com.db4o.inside.ix.QxProcessor">
            <exclude></exclude></member>
        <member name="T:com.db4o.inside.ix.NIxPath">
            <exclude></exclude></member>
        <member name="T:com.db4o.MetaIndex">
            <summary>The index record that is written to the database file.</summary>
            <remarks>
            The index record that is written to the database file.
            Don't obfuscate.
            </remarks>
            <exclude></exclude>
            <persistent></persistent></member>
        <member name="T:com.db4o.config.TStack">
            <exclude /></member>
        <member name="T:com.db4o.UserException">
            <summary>
            TODO: Do we need this class? Possibly it's initialized by reflection
            during a license check to bypass hacks.
            </summary>
            <remarks>
            TODO: Do we need this class? Possibly it's initialized by reflection
            during a license check to bypass hacks.
            </remarks></member>
        <member name="T:com.db4o.Dynamic">
            <exclude /></member>
        <member name="T:com.db4o.ext.ObjectNotStorableException">
            <summary>
            this Exception is thrown, if objects can not be stored and if
            db4o is configured to throw Exceptions on storage failures.
            </summary>
            <remarks>
            this Exception is thrown, if objects can not be stored and if
            db4o is configured to throw Exceptions on storage failures.
            </remarks>
            <seealso cref="M:com.db4o.config.Configuration.exceptionsOnNotStorable">com.db4o.config.Configuration.exceptionsOnNotStorable
            	</seealso></member>
        <member name="T:com.db4o.YapObjectCarrier">
            <summary>
            no reading
            no writing
            no updates
            no weak references
            navigation by ID only both sides need synchronised ClassCollections and
            MetaInformationCaches
            </summary>
            <exclude></exclude></member>
        <member name="T:com.db4o.QQuery">
            <summary>QQuery is the users hook on our graph.</summary>
            <remarks>
            QQuery is the users hook on our graph.
            A QQuery is defined by it's constraints.
            </remarks>
            <exclude></exclude></member>
        <member name="M:com.db4o.QQuery.constrain(System.Object)">
            <summary>Search for slot that corresponds to class.</summary>
            <remarks>
            Search for slot that corresponds to class. <br />If not found add it.
            <br />Constrain it. <br /></remarks></member>
        <member name="T:com.db4o.ext.ExtDb4o">
            <summary>extended factory class with static methods to open special db4o sessions.
            	</summary>
            <remarks>extended factory class with static methods to open special db4o sessions.
            	</remarks></member>
        <member name="M:com.db4o.ext.ExtDb4o.openMemoryFile(com.db4o.ext.MemoryFile)">
            <summary>
            opens an
            <see cref="T:com.db4o.ObjectContainer">com.db4o.ObjectContainer</see>
            for in-memory use .
            <br /><br />In-memory ObjectContainers are useful for maximum performance
            on small databases, for swapping objects or for storing db4o format data
            to other media or other databases.<br /><br />Be aware of the danger of running
            into OutOfMemory problems or complete loss of all data, in case of hardware
            or JVM failures.<br /><br /></summary>
            <param name="memoryFile">
            a
            <see cref="T:com.db4o.ext.MemoryFile">MemoryFile</see>
            to store the raw byte data.
            </param>
            <returns>
            an open
            <see cref="T:com.db4o.ObjectContainer">ObjectContainer</see></returns>
            <seealso cref="T:com.db4o.ext.MemoryFile">com.db4o.ext.MemoryFile</seealso></member>
        <member name="F:com.db4o.Config4Class._maintainMetaClass">
            <summary>
            We are running into cyclic dependancies on reading the PBootRecord
            object, if we maintain MetaClass information there
            </summary></member>
        <member name="T:com.db4o.io.VanillaIoAdapter">
            <summary>base class for IoAdapters that delegate to other IoAdapters (decorator pattern)
            	</summary></member>
        <member name="T:Cecil.FlowAnalysis.FlowGraphFactory">
            <summary>
            Creates the specific graphs.
            </summary></member>
        <member name="T:com.db4o.inside.ix.IxPatch">
            <summary>Node for index tree, can be addition or removal node</summary></member>
        <member name="T:com.db4o.foundation.Queue4">
            <summary>
            Using the CollectionElement the other way around:
            CollectionElement.i_next points to the previous element
            </summary>
            <exclude></exclude></member>
        <member name="T:com.db4o.Transaction">
            <exclude></exclude></member>
        <member name="T:com.db4o.inside.ix.IxPath">
            <summary>
            Index Path to represent a list of traversed index tree entries,
            used by IxTraverser
            </summary></member>
        <member name="T:com.db4o.io.crypt.KeyGenerator">
            <exclude></exclude></member>
        <member name="M:com.db4o.io.crypt.KeyGenerator.core(System.String)">
            <summary>
            generates an int[] array which has length four and produced according
            MD5 Message Digest Algorithm, as defined in RFC 1321.
            </summary>
            <remarks>
            generates an int[] array which has length four and produced according
            MD5 Message Digest Algorithm, as defined in RFC 1321.
            </remarks>
            <param name="message">
            -
            represents key to be converted as integer 128-bits<br />
            (will be used in XTEA encryption algorithm as key.)
            </param>
            <returns>int array of size 128-bit.</returns></member>
        <member name="M:com.db4o.io.crypt.KeyGenerator.core_operation(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)">
            <summary>core operation of MD5 Message Digest Algorithm</summary></member>
        <member name="M:com.db4o.io.crypt.KeyGenerator.f(System.Int32,System.Int32,System.Int32)">
            <summary>nonlinear function, used in each round</summary></member>
        <member name="M:com.db4o.io.crypt.KeyGenerator.g(System.Int32,System.Int32,System.Int32)">
            <summary>nonlinear function, used in each round</summary></member>
        <member name="M:com.db4o.io.crypt.KeyGenerator.h(System.Int32,System.Int32,System.Int32)">
            <summary>nonlinear function, used in each round</summary></member>
        <member name="M:com.db4o.io.crypt.KeyGenerator.i(System.Int32,System.Int32,System.Int32)">
            <summary>nonlinear function, used in each round</summary></member>
        <member name="M:com.db4o.io.crypt.KeyGenerator.string2integer_padding(System.String)">
            <summary>converts incoming padded String to an int array of size 128-bit.</summary>
            <remarks>converts incoming padded String to an int array of size 128-bit.</remarks>
            <param name="incomingString">
            -
            String to be converted to an int array of size 128-bit.
            </param>
            <returns>128-bit int array</returns></member>
        <member name="T:com.db4o.ext.Db4oUUID">
            <summary>a unique universal identify for an object.</summary>
            <remarks>
            a unique universal identify for an object. <br /><br />The db4o UUID consists of
            two parts:<br /> - an indexed long for fast access,<br /> - the signature of the
            <see cref="T:com.db4o.ObjectContainer">ObjectContainer</see>
            the object was created with.
            <br /><br />Db4oUUIDs are valid representations of objects over multiple
            ObjectContainers
            </remarks></member>
        <member name="M:com.db4o.ext.Db4oUUID.getLongPart">
            <summary>returns the long part of this UUID.</summary>
            <remarks>
            returns the long part of this UUID. <br /><br />To uniquely identify an object
            universally, db4o uses an indexed long and a reference to the
            <see cref="T:com.db4o.ext.Db4oDatabase">com.db4o.ext.Db4oDatabase</see>
            object it was created on.
            </remarks>
            <returns>the long part of this UUID.</returns></member>
        <member name="M:com.db4o.ext.Db4oUUID.getSignaturePart">
            <summary>returns the signature part of this UUID.</summary>
            <remarks>
            returns the signature part of this UUID. <br /><br /><br /><br />To uniquely
            identify an object universally, db4o uses an indexed long and a reference to
            the
            <see cref="T:com.db4o.ext.Db4oDatabase">com.db4o.ext.Db4oDatabase</see>
            singleton object of the
            <see cref="T:com.db4o.ObjectContainer">ObjectContainer</see>
            it was created on. This method
            returns the signature of the Db4oDatabase object of the ObjectContainer: the
            signature of the origin ObjectContainer.
            </remarks>
            <returns>the signature of the Db4oDatabase for this UUID.</returns></member>
        <member name="T:com.db4o.ReplicationRecord">
            <summary>
            tracks the version of the last replication between
            two Objectcontainers.
            </summary>
            <remarks>
            tracks the version of the last replication between
            two Objectcontainers.
            </remarks>
            <exclude></exclude>
            <persistent></persistent></member>
        <member name="T:com.db4o.Compat">
            <exclude /></member>
        <member name="T:com.db4o.YapStringIOUnicode">
            <exclude></exclude></member>
        <member name="T:com.db4o.YapJavaClass">
            <exclude></exclude></member>
        <member name="M:com.db4o.YapJavaClass.primitiveClassReflector">
            <summary>classReflector() has to be called first, before this returns a value</summary></member>
        <member name="T:com.db4o.reflect.generic.GenericVirtualField">
            <exclude></exclude></member>
        <member name="T:com.db4o.YapClass">
            <exclude></exclude></member>
        <member name="M:com.db4o.YapClass.isStrongTyped">
            <summary>no any, primitive, array or other tricks.</summary>
            <remarks>
            no any, primitive, array or other tricks. overriden in YapClassAny and
            YapClassPrimitive
            </remarks></member>
        <member name="T:com.db4o.User">
            <exclude></exclude>
            <persistent></persistent></member>
        <member name="T:com.db4o.foundation.List4">
            <summary>elements in linked list Collection4</summary>
            <exclude></exclude></member>
        <member name="F:com.db4o.foundation.List4._next">
            <summary>next element in list</summary></member>
        <member name="F:com.db4o.foundation.List4._element">
            <summary>carried object</summary></member>
        <member name="T:com.db4o.ClassIndex">
            <summary>representation to collect and hold all IDs of one class</summary></member>
        <member name="F:com.db4o.ClassIndex.i_root">
            <summary>contains TreeInt with object IDs</summary></member>
        <member name="T:com.db4o.QESmaller">
            <exclude></exclude></member>
        <member name="T:com.db4o.StaticClass">
            <exclude></exclude>
            <persistent></persistent></member>
        <member name="T:com.db4o.IntArrayList">
            <exclude></exclude></member>
        <member name="T:com.db4o.QOrder">
            <exclude></exclude></member>
        <member name="T:com.db4o.YapReader">
            <summary>public for .NET conversion reasons.</summary>
            <remarks>public for .NET conversion reasons.</remarks>
            <exclude></exclude></member>
        <member name="M:com.db4o.YapReader.read(com.db4o.YapStream,System.Int32,System.Int32)">
            <summary>non-encrypted read, used for indexes</summary>
            <param name="a_stream"></param>
            <param name="a_address"></param></member>
        <member name="T:com.db4o.io.crypt.XTeaEncryptionFileAdapter">
            <summary>
            XTeaEncryptionFileAdapter is an encryption IoAdapter plugin for db4o file IO
            <br />
            that realized XTEA encryption algorithm.
            </summary>
            <remarks>
            XTeaEncryptionFileAdapter is an encryption IoAdapter plugin for db4o file IO
            <br />
            that realized XTEA encryption algorithm. <br /><br />
            Configure db4o to add this encryption mechanism:<br /><code>Db4o.configure().io(new XTeaEncryptionFileAdapter("password"));
            </code><br />
            Any changes must be taken with the same password.<br /><br />
            Remember that any configuration settings must be set before opening
            ObjectContainer.
            </remarks></member>
        <member name="M:com.db4o.io.crypt.XTeaEncryptionFileAdapter.close">
            <summary>implement to close the adapter</summary></member>
        <member name="M:com.db4o.io.crypt.XTeaEncryptionFileAdapter.getLength">
            <summary>implement to return the absolute length of the file</summary></member>
        <member name="M:com.db4o.io.crypt.XTeaEncryptionFileAdapter.open(System.String,System.Boolean,System.Int64)">
            <summary>implement to open the file</summary></member>
        <member name="M:com.db4o.io.crypt.XTeaEncryptionFileAdapter.read(System.Byte[],System.Int32)">
            <summary>implement to read and decrypt a buffer</summary></member>
        <member name="M:com.db4o.io.crypt.XTeaEncryptionFileAdapter.seek(System.Int64)">
            <summary>implement to set the read/write pointer in the file</summary></member>
        <member name="M:com.db4o.io.crypt.XTeaEncryptionFileAdapter.sync">
            <summary>implement to flush the file contents to storage</summary></member>
        <member name="M:com.db4o.io.crypt.XTeaEncryptionFileAdapter.write(System.Byte[],System.Int32)">
            <summary>implement to write and encrypt a buffer</summary></member>
        <member name="T:Cecil.FlowAnalysis.Impl.ActionFlow.ActionBlockCollection">
            <summary></summary></member>
        <member name="T:com.db4o.MClassNameForID">
            <summary>get the classname for an internal ID</summary></member>
        <member name="T:com.db4o.QCandidates">
            <summary>Holds the tree of QCandidate objects and the list of QContraints during query evaluation.
            	</summary>
            <remarks>
            Holds the tree of QCandidate objects and the list of QContraints during query evaluation.
            The query work (adding and removing nodes) happens here.
            Candidates during query evaluation. QCandidate objects are stored in i_root
            </remarks>
            <exclude></exclude></member>
        <member name="T:com.db4o.config.Entry">
            <exclude></exclude></member>
        <member name="T:com.db4o.YapClassAny">
            <summary>Undefined YapClass used for members of type Object.</summary>
            <remarks>Undefined YapClass used for members of type Object.</remarks></member>
        <member name="T:com.db4o.QConstraints">
            <summary>Array of constraints for queries.</summary>
            <remarks>
            Array of constraints for queries.
            Necessary to be returned to Query#constraints()
            </remarks>
            <exclude></exclude></member>
        <member name="T:com.db4o.YapConst">
            <exclude></exclude></member>
        <member name="T:com.db4o.reflect.generic.GenericArrayClass">
            <exclude></exclude></member>
        <member name="T:com.db4o.ext.VirtualField">
            <summary>intended for future virtual fields on classes.</summary>
            <remarks>
            intended for future virtual fields on classes. Currently only
            the constant for the virtual version field is found here.
            </remarks>
            <exclude></exclude></member>
        <member name="F:com.db4o.ext.VirtualField.VERSION">
            <summary>
            the field name of the virtual version field, to be used
            for querying.
            </summary>
            <remarks>
            the field name of the virtual version field, to be used
            for querying.
            </remarks></member>
        <member name="T:com.db4o.SerializedRoot">
            <exclude></exclude></member>
        <member name="T:com.db4o.QResultClient">
            <exclude></exclude></member>
    </members>
</doc>
