<?xml version="1.0"?>
<doc>
    <assembly>
        <name>Perst.NET</name>
    </assembly>
    <members>
        <member name="T:Perst.PersistentCollection">
            <summary>
            Base class for all persistent collections
            </summary>
        </member>
        <member name="T:Perst.PersistentResource">
            <summary>Base class for persistent capable objects supporting locking
            </summary>
        </member>
        <member name="T:Perst.Persistent">
            <summary> Base class for all persistent capable objects
            </summary>
        </member>
        <member name="T:Perst.IPersistent">
            <summary> Interface of all persistent capable objects
            </summary>
        </member>
        <member name="M:Perst.IPersistent.Load">
            <summary> Load object from the database (if needed)
            </summary>
        </member>
        <member name="M:Perst.IPersistent.IsRaw">
            
            <summary> Check if object is stub and has to be loaded from the database
            </summary>
            <returns><code>true</code> if object has to be loaded from the database
            </returns>
        </member>
        <member name="M:Perst.IPersistent.IsPersistent">
            <summary> Check if object is persistent 
            </summary>
            <returns><code>true</code> if object has assigned OID
            
            </returns>
        </member>
        <member name="M:Perst.IPersistent.IsDeleted">
            <summary>  Check if object is deleted by GC from process memory
            </summary>
            <returns> <code>true</code> if object is deleted by GC
            </returns>
        </member>
        <member name="M:Perst.IPersistent.IsModified">
            <summary> Check if object was modified within current transaction
            </summary>
            <returns><code>true</code> if object is persistent and was modified within current transaction
            
            </returns>
        </member>
        <member name="M:Perst.IPersistent.MakePersistent(Perst.Storage)">
            <summary> Explicitely make object peristent. Usually objects are made persistent
            implicitlely using "persistency on reachability apporach", but this
            method allows to do it explicitly 
            </summary>
            <param name="storage">storage in which object should be stored 
            </param>
            <returns>OID assigned to the object</returns>
        </member>
        <member name="M:Perst.IPersistent.Store">
            <summary> Save object in the database
            </summary>
        </member>
        <member name="M:Perst.IPersistent.Modify">
            <summary>
            Mark object as modified. Object will be saved to the database during transaction commit.
            </summary>
        </member>
        <member name="M:Perst.IPersistent.Deallocate">
            <summary> Deallocate persistent object from the database
            </summary>
        </member>
        <member name="M:Perst.IPersistent.RecursiveLoading">
            <summary> Specified whether object should be automatically loaded when it is referenced
            by other loaded peristent object. Default implementation of this method
            returns <code>true</code> making all cluster of referenced objects loaded together. 
            To avoid main memory overflow you should stop recursive loading of all objects
            from the database to main memory by redefining this method in some classes and returing
            <code>false</code> in it. In this case object has to be loaded explicitely 
            using Persistent.load method.
            </summary>
            <returns><code>true</code> if object is automatically loaded
            
            </returns>
        </member>
        <member name="M:Perst.IPersistent.OnLoad">
            <summary> This method is  called by the database after loading of the object.
            It can be used to initialize transient fields of the object. 
            Default implementation of this method do nothing 
            </summary>
        </member>
        <member name="M:Perst.IPersistent.OnStore">
            <summary> This method is  called by the database befire storing of the object.
            It can be used to initialize transient fields of the object. 
            Default implementation of this method do nothing 
            </summary>
        </member>
        <member name="M:Perst.IPersistent.Invalidate">
            <summary>
            Invalidate object. Invalidated object has to be explicitly
            reloaded using load() method. Attempt to store invalidated object
            will cause StoraegError exception.
            </summary>
        </member>
        <member name="M:Perst.IPersistent.AssignOid(Perst.Storage,System.Int32,System.Boolean)">
            <summary>
            Method used to associate object with storage.
            This method is used by Storage class and you should not use it explicitly.
            </summary>
            <param name="storage">storage to be assigned to</param>
            <param name="oid">assigned OID</param>
            <param name="raw">if object is already loaded</param>
        </member>
        <member name="P:Perst.IPersistent.Oid">
            <summary> Get object identifier (OID)
            </summary>
        </member>
        <member name="P:Perst.IPersistent.Storage">
            <summary> Get storage in which this object is stored
            </summary>
        </member>
        <member name="T:Perst.IResource">
            <summary>
             Interface of object supporting locking
             </summary>
        </member>
        <member name="M:Perst.IResource.SharedLock">
            <summary>
            Lock persistent object in shared mode. Other threads will be able to set their
            shared locks on this objects, but not exclusive lock can be set until this lock is released.
            
            Upgrading of the lock is not possible (thread having read lock can not upgrade it to exclusive lock).
            It is done to prevent possible deadlocks caused by lock updates. 
            But locks are reentrant - so thread can request the same lock many times (and correspondent 
            number of unlocks is needed to release the lock).
            
            Locking the object doesn't prevent other threads from accessing the object - 
            it only has influence on <code>sharedLock</code> and <code>exclusiveLock</code> methods.
            So programmer should set proper lock before accessing the object in multithreaded application.
            
            If object is concurrently accessed by several threads in read-only mode, then explicit locking
            of this object is not needed, because language API provides consistent retrieving of objects itself.
            
            Only persistent object (object which were assigned to the the storage either implicitly by
            saving some other persistent object referencing this object, either explicitly by 
            <code>Storage.makeObjectPersistent</code> method.
            </summary>
        </member>
        <member name="M:Perst.IResource.ExclusiveLock">
            <summary>
            Lock persistent object in exclusive mode. Only one thread can lock object in exclusive mode at each
            moment of time. Shared or exclusive lock requests of other threads will be blocked until
            this lock is released.
            shared locks on this objects, but not exclusive lock can be set until this lock is released.
            
            This lock is reentrant, so thread owning the lock can successfully retrieve the lock many times
            (and correspondent number of unlocks is needed to release the lock).
            
            Locking the object doesn't prevent other threads from accessing the object - 
            it only has influence on <code>sharedLock</code> and <code>exclusiveLock</code> methods.
            So programmer should set proper lock before accessing the object in multithreaded application.
                        Only persistent object (object which were assigned to the the storage either implicitly by
            saving some other persistent object referencing this object, either explicitly by 
            <code>Storage.makeObjectPersistent</code> method.   
            </summary>
        </member>
        <member name="M:Perst.IResource.SharedLock(System.Int64)">
            <summary>
            Lock persistent object in shared mode. Other threads will be able to set their
            shared locks on this objects, but not exclusive lock can be set until this lock is released.
            
            Upgrading of the lock is not possible (thread having read lock can not upgrade it to exclusive lock).
            It is done to prevent possible deadlocks caused by lock updates. 
            But locks are reentrant - so thread can request the same lock many times (and correspondent 
            number of unlocks is needed to release the lock).
             
            Locking the object doesn't prevent other threads from accessing the object - 
            it only has influence on <code>sharedLock</code> and <code>exclusiveLock</code> methods.
            So programmer should set proper lock before accessing the object in multithreaded application.
            
            If object is concurrently accessed by several threads in read-only mode, then explicit locking
            of this object is not needed, because language API provides consistent retrieving of objects itself.
            
            Only persistent object (object which were assigned to the the storage either implicitly by
            saving some other persistent object referencing this object, either explicitly by 
            <code>Storage.makeObjectPersistent</code> method.
            </summary>
            <param name="timeout">timeout of operation in milliseconds. If timeout is 0 and
            lock can not be granted, the request will fail immediately. Otherwise the system will try
            to grant lock within specified amount of time.
            </param>
            <returns>
            <DL>
            <DT><code>true</code> if lock is successfully granted</DT>
            <DT><code>false</code> if lock can not be granted within specified time</DT> 
            </DL>
            </returns>
        </member>
        <member name="M:Perst.IResource.ExclusiveLock(System.Int64)">
             <summary>
             Lock persistent object in exclusive mode. Only one thread can lock object in exclusive mode at each
             moment of time. Shared or exclusive lock requests of other threads will be blocked until
             this lock is released.
             shared locks on this objects, but not exclusive lock can be set until this lock is released.
             
             This lock is reentrant, so thread owning the lock can successfully retrieve the lock many times
             (and correspondent number of unlocks is needed to release the lock).
             
             Locking the object doesn't prevent other threads from accessing the object - 
             it only has influence on <code>sharedLock</code> and <code>exclusiveLock</code> methods.
            So programmer should set proper lock before accessing the object in multithreaded application.
            
             Only persistent object (object which were assigned to the the storage either implicitly by
             saving some other persistent object referencing this object, either explicitly by 
             <code>Storage.makeObjectPersistent</code> method.   
             </summary>
             <param name="timeout">timeout of operation in milliseconds. If timeout is 0 and
             lock can not be granted, the request will fail immediately. Otherwise the system will try
             to grant lock within specified amount of time.
             </param>
             <returns>
             <DL>
             <DT><code>true</code> if lock is successfully granted</DT>
             <DT><code>false</code> if lock can not be granted within specified time</DT>
             </DL>
             </returns>
        </member>
        <member name="M:Perst.IResource.Unlock">
            <summary>
            Remove granted lock. If lock was requested several times by one thread, then correspondent number
            of unlocks is needed to release the lock.
            </summary>
        </member>
        <member name="M:Perst.IResource.Reset">
            <summary>
            Reset resource to original state.
            Wakrup all threads waiting for this resource.
            </summary>
        </member>
        <member name="T:Perst.ITable">
            <summary> Interface of selectable collection.
            Selectable collections allows to selct its memebers using JSQL query
            </summary>